How can I re-arrange my stack levels so they aren't based alphabetically?
Click the small cogwheel in the upper right corner
Related
I'm looking for a (preferably free) lib for the following:
I want to do a Trace Ray through my scene, but not for a single starting point, but rather a starting shape.
So instead of having the origin being a point and the trace a line, I want the origin to be a shape (say, circle) and the trace a cylinder.
I found this page here: https://github.com/jslee02/awesome-collision-detection , but I still could not find this feature.
Unreal has UWorld::SweepMultiByChannel, which is pretty much what I want (but I'm not in UE...)
Thanks in advance!
NVIDIAGameWorks PhysX seems to have all the answers that I need.
When working with a large LiveCode stack (e.g. 2048 x 1536), the stack take up more screen space than is available (monitor resolution is 1368 x 768).
I can somewhat work around this by programatically positioning the stack.g.
set the loc of this stack to 1000,500
but this is pretty time consuming and awkward.
Is there any solutions to this that I am missing?
As of the latest stable release, 6.6.1, there is a scaleFactor property that you can use to scale the visual size of the stack to a percentage of its actual size.
set the scaleFactor of stack "hugeStack" to .75
Have you tried
set the fullscreenmode of this stack to “exactFit”
on the stack? That should activate the new scaling stuff that was added in 6.5.
(See here: http://livecode.com/livecode-6-5/)
See this post download shuffleAbout and download the stack that you can use as plugin.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question appears to be off-topic because it lacks sufficient information to diagnose the problem. Describe your problem in more detail or include a minimal example in the question itself.
Closed 8 years ago.
Improve this question
I am interested in LiveCodes Resolution Independence feature as, in the past, I have programatically had to resized my stack via the resizeStack handler.
I believe that you have to set the fullScreenMode with a given parameter e.g.
set the fullScreenMode of this stack to "exactFit"
Is this really all you have to do?
You will be able to use fullScreenMode when you want your stack resized or scaled to take full advantage of the available screen that its been deployed too.
What this means is that, you create a stack at any size that you want, and then LiveCode automatically adjusts this to a given screen.
The main reason for the resolution independence feature is so you do not need to worry about the various sizes/dimensions of every mobile device that is available. This is especially useful when it comes to Android-
http://en.wikipedia.org/wiki/Comparison_of_Android_devices
An example of this in action is, when you deploy and non-retina iPhone sized stack (320 x 480 (3:2 aspect ratio) to a Galaxy S3 (1280 x 720) (16:9 aspect ratio).
As the aspect ratios do not match, then using “exactFit” will cause some elements to appear stretched/skewed, “letterBox” will add small black bars to top and bottom of screen, but aspect ratio will be kept in tact, “noBorder” will crop the stack and maintain aspect ratio however as cropping occurs some elements may be slightly cut and finally “noScale” centres the stack on screen with no scaling occurring.
The following is a great site for calculating the aspect ratios of a given resolution-
http://andrew.hedges.name/experiments/aspect_ratio/
and we also have a tutorial which explains how to use implement resolution independence here-
http://lessons.runrev.com/s/lessons/m/15262/l/156477-how-do-i-make-my-app-scale-to-fit-the-screen-on-all-devices
There are also the LiveCode release notes which explains the Resolution Independence features in more detail-
http://downloads.livecode.com/livecode/6_5_0/LiveCodeNotes-6_5_0.pdf
http://downloads.livecode.com/livecode/6_5_1/LiveCodeNotes-6_5_1.pdf
http://downloads.livecode.com/livecode/6_6_0/LiveCodeNotes-6_6_0_dp_1.pdf
The easiest way to use this feature is add it to your preOpenStack handler on your stack script:
on preOpenStack
set the fullScreenMode of this stack to "exactFit"
end preOpenStack
The fullscreenmode can be set to any of the following values (taken straight from the LiveCode dictionary/API):
empty - The stack is resized (not scaled) to fit the screen. (default) This is the existing behavior.
exactFit - Scale the stack to fill the screen. This stretches the stack if the aspect ratio of the screen does not match that of the stack.
letterbox - Scale the stack, preserving the aspect ratio, so all content is visible. Some blank space may remain if the screen and stack aspect ratios do not match.
noBorder - Scale the stack to fill the screen, preserving the aspect ratio. If the stack and screen aspect ratios do not match, the left / right or top / bottom extremes of the stack are not visible.
noScale - The stack is not scaled, but is centered on the screen instead.
showAll - Scale the stack preserving aspect ratio so all content within the stack rect is visible. Portions of the stack outside the stack rect will be visible if the scaled stack does not fit the screen exactly.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 9 years ago.
Improve this question
I'm currently writing a software application which creates notes on a staff, when a piano key is pressed. Unfortunately I have no background in music, and thus am finding it quite hard to get started.
Could someone kindly tell me if the following screenshot represents what it would look like on the staff (approximately) if someone presses all the white keys on a 25-key keyboard (15 white, 10 black) from left to right, and then from right to left?
Am I on the right track, or is this completely wrong? (The notes are just displayed as circles for now - im trying to get the positioning right).
Almost. You need a few extra things. (NB. This is a simplified list just to get you going. Music notation is a complex beast that can take years of study to master)
A Clef. Presumably in this instance you're looking for a treble clef.
You need to imagine that there are invisible lines (ledger lines) above and below the 5 you can see. In your example, the very first note played is immediately below the first of the invisible lines at the bottom, so you need to draw that as part of the note. (See the example on the wikipedia page I linked to.)
Obviously, note duration is required, but you mention you're already on that so I won't talk about it here.
A Key signature to tell the player what key the music is in, and therefore what sharps and flats to expect
There's a lot more to drawing music on a stave than meets the eye, I'm afraid, but these should point you in the right direction.
Try looking at examples of sheet music. That may be helpful.
For instance: http://en.wikipedia.org/wiki/Sheet_music
I think so..
But what I'm missing at the most left side of the staff is the 'key'. This is pretty important.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 5 years ago.
Improve this question
I am looking for a tool / standard / concept / convention that would improved the communications between a designer and a developer for describing UI elements and their layout.
I will try to explain by example:
consider a design that shows a 200 by 200 pixels red box with a 100 by 100 pixels green box centered within it.
This is very clear as long as nothing is dynamic,
but the moment you want to account for any dynamic change this is not enough any more.
just consider what should be happen to this design if the size of the device turns out to be 300 by 400 pixels... instead of 200 by 200.
It can be interpreted as:
Keeping the 200 by 200 square pinned to any of the corners of the 300 by 400 area leaving unbalanced white margins.
Keeping the 200 by 200 square centered with respect to the 300 by 400 are leaving balanced white margins.
stretching the red area to fit the new available area but leaving the internal square the same original size.
And so on.
This is not some theoretical Q, This is a real problem with designing UIs for applications that need to support more then a single language.
the dimensions of a button can change due to text contained within it changing as a different language is used.
I am looking for a (graphic?) standard for showing anchors / margins / minimum or maximum sizes, relative positioning and so on.
Something that can easily convey a message such as:
Those two buttons should have margins of 5px on each side, and a middle area that is at least 80px or bigger if so required to accommodate their texts. both buttons should eventually have the same size (by increasing them all to the size required by the largest of them).
I manage developers and designers at an agency. We make sure our designers design for every possible (device) screen. If the UI is designed for a PC, the developers will have questions about how the layout changes from PC to mobile to tablet. Most designers are aware of this and design for all screens from the beginning.
For a specific answer to your hypothetical question, using percentages for dimensions would help translate a design from large to small screens and keep the design aesthetic better than using absolute pixel sizes.