74 posts
Posted 09 December 2014 - 01:57 AM
I'm working with a project that's going to use a lot of animations. The speed, or sleep(), seems to stop getting quicker at 0.1 and won't go any faster (For example, 0.05). This makes the graphics pretty slow and more annoying than cool. Is there any way to do a sleep that's quicker than 0.1 seconds?
Edited on 09 December 2014 - 12:57 AM
59 posts
Posted 09 December 2014 - 02:08 AM
You will not be able to go any faster then a minecraft tick which is .05 seconds. Sleep should work when set at 1 tick or .05 seconds.
os.sleep()Edited on 09 December 2014 - 01:10 AM
7083 posts
Location
Tasmania (AU)
Posted 09 December 2014 - 02:18 AM
Indeed, you can't slice time any smaller than a twentieth of a second (and even
that assumes that you aren't running lots of other computers at the same time, which'll slow things down further). Be it via timer events (as used by sleep) or via os.clock(), increments of 0.05 seconds are as good as it gets.
If you don't want to "pause" so much as "yield", then you can always
queue then immediately
pull an event.
74 posts
Posted 09 December 2014 - 03:12 AM
You will not be able to go any faster then a minecraft tick which is .05 seconds. Sleep should work when set at 1 tick or .05 seconds.
os.sleep()
This explains why no one really does animations. They're painfully slow.
Indeed, you can't slice time any smaller than a twentieth of a second (and even
that assumes that you aren't running lots of other computers at the same time, which'll slow things down further). Be it via timer events (as used by sleep) or via os.clock(), increments of 0.05 seconds are as good as it gets.
If you don't want to "pause" so much as "yield", then you can always
queue then immediately
pull an event.
If this dosen't load the animations any quicker, then I'm not interested. Thanks though.
2151 posts
Location
Auckland, New Zealand
Posted 09 December 2014 - 03:36 AM
I've found with intensive animations, depending on how much calculation is done over pure drawing, that you can pretty much just let it go as fast as possible without any delays.
For example, in this animation in OneOS to keep it fast and smooth there's not a single sleep or yield call. It calculates what the preview should look like and just draws it. I haven't really found a case where it's too fast, it is a reasonably intensive draw process.
Now, I'm not really sure how intensive your animation is. I doubt it'll take long that that one because everything being run through a buffer and it's a somewhat complicated drawing process to shrink the images. I'd stick with sleep(0) or see how this works.
You could (although shouldn't) put a for loop that does math.sqrt tons of times or something. I've found also making animations larger than 5 steps just doesn't work.
Edited on 09 December 2014 - 02:37 AM
808 posts
Posted 09 December 2014 - 06:35 AM
-snip-
Surely there must be a yield in there somewhere, even if you're not calling it yourself. Otherwise an animation would pause all other computers for the duration of the animation, wouldn't it?
1080 posts
Location
In the Matrix
Posted 09 December 2014 - 04:46 PM
Surely there must be a yield in there somewhere, even if you're not calling it yourself. Otherwise an animation would pause all other computers for the duration of the animation, wouldn't it?
I think he's saying that for the animation itself, since it shouldn't ever take more than 10 seconds, it doesn't yield until AFTER it's done, so that it runs through quickly.
This was towards his own.
Otherwise for a lot longer animation, there will need to be yielding yeah.
Edited on 09 December 2014 - 03:47 PM
1852 posts
Location
Sweden
Posted 09 December 2014 - 08:23 PM
Well have you tried doing this?
local function yield()
os.queueEvent( "sleep" )
coroutine.yield( "sleep" )
end
This basically queues an event and pulls it directly by using corotine.yield( which is used by os.pullEvent ). I believe this takes 0.02 seconds or something.
1023 posts
Posted 09 December 2014 - 08:55 PM
Well have you tried doing this?
local function yield()
os.queueEvent( "sleep" )
coroutine.yield( "sleep" )
end
This basically queues an event and pulls it directly by using corotine.yield( which is used by os.pullEvent ). I believe this takes 0.02 seconds or something.
I believe that using any method of yielding in CC takes a minimum .05 seconds, which is the length of a minecraft tick. So this would take .05 seconds, which is the same as using sleep(0)
1852 posts
Location
Sweden
Posted 09 December 2014 - 09:40 PM
Well have you tried doing this?
local function yield()
os.queueEvent( "sleep" )
coroutine.yield( "sleep" )
end
This basically queues an event and pulls it directly by using corotine.yield( which is used by os.pullEvent ). I believe this takes 0.02 seconds or something.
I believe that using any method of yielding in CC takes a minimum .05 seconds, which is the length of a minecraft tick. So this would take .05 seconds, which is the same as using sleep(0)
Have you even tried this? I'm pretty sure this is faster than sleep
Proof that it's faster
local w, h = term.getSize()
local function yield()
os.queueEvent( "sleep" )
coroutine.yield( "sleep" )
end
local start = os.clock()
for x = 1, w do
for y = 1, h do
term.setCursorPos( x, y )
term.write( "0" )
end
yield()
end
local _end = os.clock()
term.clear() term.setCursorPos( 1, 1 )
print( _end - start ) -- Got the result 0,05 here
os.pullEvent( "key" )
start = os.clock()
for x = 1, w do
for y = 1, h do
term.setCursorPos( x, y )
term.write( "0" )
end
sleep( 0 )
end
_end = os.clock()
term.clear() term.setCursorPos( 1, 1 )
print( _end - start ) -- Got the result 2,25 here
Edited on 09 December 2014 - 08:55 PM
1023 posts
Posted 09 December 2014 - 09:59 PM
-snip
I did my own test, and found that you can run your yield function around 10,000 times in the amount of time it takes to do sleep(0) 100 times. This is honestly suprising to me. I was under the impression from other things that I had read that yielding required at least a mc tick, which it obviously does not.
I was unable to test it when I posted that. Was on a computer that refuses to run cc emulators, or mc.
edit:
The only problem with using this function, is there is no way to specify how long to yield for (the entire problem op is facing). He is wanting animations, but that requires a very short amount of time to go by between updating each frame in the animation. He never said he was having problems with to long without yielding, which is what that function would be useful for fixing. Without a specifiable amount of time the animation would probably be too fast, however, you could likely make the function accept a argument which it would use to loop through a number of times to get the amount of time wanted. Although this would likely slow any other computers in the world.edit2: Just noticed your original post was in reponse to dragon not the op.
Edited on 09 December 2014 - 09:16 PM