I'm having trouble creating a solid game engine for my OpenGL application. It's a game which consists of several sprites with a lot of action.
I created objects which are basically all of my sprites. Another object called "gameEngine" loops through a set of calculations every something of a second (a timer), resulting in new game variables. After that, the sprite objects now know their drawing data.
The problem is, that after collecting all of my drawing data, the drawing should take place at exactly the right moment in time, resulting in a steady animation. Depending on the complexity of the current scene, the game calculations take an undetermined amount of time. So, the actual drawing takes place at different moments in time. How would I prevent that from happening?
To clarify, my approach goes something like:
// Every something of a second I call tick
-(void)tick
{
drawingData = gameEngine();
draw(drawingData);
}
There must be a best practice for building game engines like this I'm not aware of?
Game loops come in many varieties but the better ones separate the animation from the drawing or in more classic terminology model and view. Basically you want to construct a model of your game where you can establish the passing of time and update the model (physics framerate) and then independently render a snapshot of the model at consecutive moments in time (rendering framerate).
Here are a couple of articles which give a more detailed explanation of some of the variations on game loops and their pros and cons. There is source code too. I hope it helps.
Fix Your Timestep! and
deWiTTERS Game Loop Article
This really isn't about OpenGL; it's more to do with the operating system or system APIs you're using (i.e. Carbon/Cocoa/Win32). But the really, really simple case is this (pseudocode):
checkTime = currentTime
while not exitCondition
if currentTime - checkTime >= 50 milliseconds
checkTime = checkTime + 50 milliseconds
updateScene
else drawScene
You are drawing as often as you can, but only doing the updates every 50 milliseconds (i.e. 20 times per second). There are obviously a lot of other things to think about, especially in terms of what you do when you fall behind (skipping frames).
The best place to get into OpenGL stuff is Nehe's lessons:
http://nehe.gamedev.net/lesson.asp?index=01
They're getting a little dated, but the sample code at the bottom of each lesson is a great place to start, and it's available in many languages and for many operating systems.
The best solution would be a multi threaded application - one thread calculating the drawing data into a buffer and one rendering the data.
If you are looking for a realy simple solution, just invert the order of calculation and rendering.
void Initialize()
{
DrawingData = GameEngine();
}
void Tick()
{
Draw(DrawingData);
DrawingData = GameEngine();
}
You calculate the first drawing data on application start up and when the timer fires you just draw it. After that you have all the time up to the next timer event to calculate the drawing data again.
But in general it may be a better solution to render at a variable frame rate - you avoid the problems if the machine is to slow for your desired frame rate and you provide high frame rates on fast machines.
void Main()
{
StartTime = Now();
while (!ExitRequested)
{
DrawingData = GameEngine(Now() - StartTime);
Draw(DrawingData);
}
}
You render frames as fast as possible - not with a fixed interval between each frame but instead with the real time the application is running. That means do not advance your objects by 20 milliseconds every frame, just move them to the position the current running time says.
It's somewhat platform dependent, but one basic approach that usually works is to use a high performance timer in your render loop, and use it to help you sleep between frames in order to have a stable, steady framerate.
You can time your frame's rendering, and then sleep by the amount to maintain a stable framerate.
However, if your platform can't keep up with the framerate you want to achieve, you'll need to start looking at ways to optimize your game engine. This only works to slow down things to make them consistent and smooth - not to speed it up.
--- Clarification ----
-(void)tick
{
time = now() // from high perf. timer
drawingData = gameEngine();
newTime = now()
// pause for the time required to make the framerate consistent
Sleep(totalTimeForTickToBeStable - newTime + time)
draw(drawingData);
}
Related
The speed value which i get from the location object is always negative (-1). From Apples blog
A negative value indicates an invalid speed.
My code is
CLLocationManager iPhoneLocationManager = new CLLocationManager ();
iPhoneLocationManager.RequestAlwaysAuthorization ();
iPhoneLocationManager.PausesLocationUpdatesAutomatically = false;
iPhoneLocationManager.DesiredAccuracy = 100;
iPhoneLocationManager.DistanceFilter = 5;
if (CLLocationManager.LocationServicesEnabled) {
iPhoneLocationManager.StartUpdatingLocation ();
}
Even though it gives correct location, the speed is always negative.
Speed
This value reflects the instantaneous speed of the device in the
direction of its current heading. A negative value indicates an
invalid speed. Because the actual speed can change many times between
the delivery of subsequent location events, you should use this
property for informational purposes only.
Unless you are constantly moving at a fairly constant rate directly away from the last sampling point, i.e. a linear vector based calculation and not running around in a tight circle, instantaneous speed is somewhat worthless. Now riding a bike and driving in a car at a constant velocity, instantaneous speed can be fairly valid...
Most real-time mobile mapping systems use some type of a speed sampling algorithm; i.e. distance moved over X samples using a moving average calculation divided by your sampling time interval is one way to get your 'current' speed.
Each app has a different use-case, so your algorithm would need to be adjusted, like if you have a hiking application and are showing the user his avg. speed on a trail and how long it will take to complete the trail would have a different algorithm from a public transportation app that calculates your arrival time based on current speed of the bus but factoring in traffic conditions, time of day, passenger stops, red lights, etc...
A blog post showing a simple sampling technique (in obj-c, but easy to translate his idea to c#): http://www.perspecdev.com/blog/2012/02/22/using-corelocation-on-ios-to-track-a-users-distance-and-speed/
I'm trying to convert some Java2D code to JavaFX and I'm stuck with an issue regarding the performance of the JavaFX Canvas. At some point, I'll have to draw thousands of small circles on the screen.
My problem is that in the first drawing, my code takes a lot of time to execute. But if I have to perform a second drawing, it takes only a fraction of the time to draw (it is at least 10 times faster).
Is there anything I'm doing wrong? Is there any way to prevent that initial delay?
I wrote this code to test it. In this code I draw 500,000 circles at random positions on a 1000 x 1000 canvas (built previously). I linked this code to a button click event, and on the first time I click it takes 10 seconds to execute. But if I just click again, it takes only 0.025 seconds.
private void paintCanvas() {
long initTime = System.currentTimeMillis();
GraphicsContext cg = canvas.getGraphicsContext2D();
cg.setFill(Color.WHITE);
cg.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
cg.setFill(Color.rgb(0, 0, 0, 0.1));
Random rand = new Random();
for (int i = 0; i < 500000; i++) {
cg.fillOval(1000 * rand.nextFloat(), 1000 * rand.nextFloat(), 2, 2);
}
long endTime = System.currentTimeMillis();
System.out.println("Time spent on drawing:" + (endTime - initTime)/1000.0f);
}
Actually there is no max number of new elements. It can vary from some hundreds to hundreds of thousands, depending of the users needs. And yes, it is ok if some elements pop in over time.
Guys I thank you for all help. I sent the same question to the OpenJFX mailing list and one of the developers answered. It seems that my JavaFX 2.2 version still use a old model for growing the command buffer. The new version, JavaFX 8, uses a more efficient model which makes the first painting as fast as the subsequent ones.
Here is the answer I got:
Jim Graham (james.graham at oracle.com)
Mon May 12 21:17:19 UTC 2014
This is likely due to growing the command buffer which was done
linearly at one point (probably still done that way in 2.2), but is
now exponential in 8.0. The first render time is nearly
instantaneous in
8.0, but takes a long time as you found when I try it with one of my old
2.x builds...
...jim
I can think of a couple things but let's start with one:
It could be that the JVM Just in Time compiler is hitting your execution. Depends on your JVM option (Whether it is client or server JIT, and whether you are using AggresiveOpts or not).
Remember, the JVM is smart enough to perform optimizations on that loop. In my opinion you can start there, put this on your JVM options when executing this: -XX:+PrintCompilation, and look at the output on console, your method should be compiled during the first execution and then you should not observe any compilations during the second. If this is so, then you know that this piece of code was compiled and stored in the CodeCache, and execution is not happening through the interpreter but through straight natively compiled code, which will have better performance.
Let us know your findings!
JVM options reference (might need to find your specific JVM doc):
http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html
P.S. can you try lowering the start time get right before you instantiate random?, it would be nice to be able to take two times, one at the beggining and right before the random, and the second, right after this last time and finally when the loop finished, the idea is to try and get a break down on where your code it's spending its time when you observe this (the loop, or the canvas instantiation).
I'd like to a counter to run in the background while my game is being played so that when the player survives for say 1 minute, something happens.
Currently, I'm thinking of doing this by getting the system time at start (say in surfaceCreated) and then in my physics update method, getting the current time and comparing the two. When 60,000 ms have passed then I know obviously 1 minute has passed.
Is this the best way to do this? Or is there another/better/simpler way.
Thanks all
That's a good way to go about it.
There's not many other options. In my game, I have a stopwatch that stops resets right before the frame update, so I can determine the amount of time spent doing other things. Then, each object is stepped with this amount of time.
It's good because it allows me to move each object at a speed relative to time rather than framerate, so if framerate differs on a different device, things still move at the same speed.
If you're not doing this, you really should be. If your step function looks something like
object.x += speed.x;
then it really should be
object.x += speed.x (in units/s) * step_time (in ms) / 1000.0
If you are doing this, it's probably best just to make a timer object that runs a Runnable when the timer expires (i.e it sums up the step-times and fires when it reaches 60sec).
Would you, dear all, suggest me best practices to get constant animation speed not depending on computer's real speed? Frames may be skipped.
There are two types of animation - frame based and time based and the names suggest the obvious.
What you are looking for is time-based where you call the display() function (the function which draws frames) is called continuously. Within the display function you set a global variable or a static variable(depends on language) to store the TIME(preferably in micro or milliseconds) when the previous occurrence to this call was made. We compare the current time and the saved time to find difference in time, dt, and the function must draw based on dt(time elapsed).
How can you make the display frames per second be independent from the game logic? That is so the game logic runs the same speed no matter how fast the video card can render.
I think the question reveals a bit of misunderstanding of how game engines should be designed. Which is perfectly ok, because they are damn complex things that are difficult to get right ;)
You are under the correct impression that you want what is called Frame Rate Independence. But this does not only refer to Rendering Frames.
A Frame in single threaded game engines is commonly referred to as a Tick. Every Tick you process input, process game logic, and render a frame based off of the results of the processing.
What you want to do is be able to process your game logic at any FPS (Frames Per Second) and have a deterministic result.
This becomes a problem in the following case:
Check input:
- Input is key: 'W' which means we move the player character forward 10 units:
playerPosition += 10;
Now since you are doing this every frame, if you are running at 30 FPS you will move 300 units per second.
But if you are instead running at 10 FPS, you will only move 100 units per second. And thus your game logic is not Frame Rate Independent.
Happily, to solve this problem and make your game play logic Frame Rate Independent is a rather simple task.
First, you need a timer which will count the time each frame takes to render. This number in terms of seconds (so 0.001 seconds to complete a Tick) is then multiplied by what ever it is that you want to be Frame Rate Independent. So in this case:
When holding 'W'
playerPosition += 10 * frameTimeDelta;
(Delta is a fancy word for "Change In Something")
So your player will move some fraction of 10 in a single Tick, and after a full second of Ticks, you will have moved the full 10 units.
However, this will fall down when it comes to properties where the rate of change also changes over time, for example an accelerating vehicle. This can be resolved by using a more advanced integrator, such as "Verlet".
Multithreaded Approach
If you are still interested in an answer to your question (since I didn't answer it but presented an alternative), here it is. Separating Game Logic and Rendering into different threads. It has it's draw backs though. Enough so that the vast majority of Game Engines remain single threaded.
That's not to say there is only ever one thread running in so called single threaded engines. But all significant tasks are usually in one central thread. Some things like Collision Detection may be multithreaded, but generally the Collision phase of a Tick blocks until all the threads have returned, and the engine is back to a single thread of execution.
Multithreading presents a whole, very large class of issues, even some performance ones since everything, even containers, must be thread safe. And Game Engines are very complex programs to begin with, so it is rarely worth the added complication of multithreading them.
Fixed Time Step Approach
Lastly, as another commenter noted, having a Fixed size time step, and controlling how often you "step" the game logic can also be a very effective way of handling this with many benefits.
Linked here for completeness, but the other commenter also links to it:
Fix Your Time Step
Koen Witters has a very detailed article about different game loop setups.
He covers:
FPS dependent on Constant Game Speed
Game Speed dependent on Variable FPS
Constant Game Speed with Maximum FPS
Constant Game Speed independent of Variable FPS
(These are the headings pulled from the article, in order of desirability.)
You could make your game loop look like:
int lastTime = GetCurrentTime();
while(1) {
// how long is it since we last updated?
int currentTime = GetCurrentTime();
int dt = currentTime - lastTime;
lastTime = currentTime;
// now do the game logic
Update(dt);
// and you can render
Draw();
}
Then you just have to write your Update() function to take into account the time differential; e.g., if you've got an object moving at some speed v, then update its position by v * dt every frame.
There was an excellent article on flipcode about this back in the day. I would like to dig it up and present it for you.
http://www.flipcode.com/archives/Main_Loop_with_Fixed_Time_Steps.shtml
It's a nicely thought out loop for running a game:
Single threaded
At a fixed game clock
With graphics as fast as possible using an interpolated clock
Well, at least that's what I think it is. :-) Too bad the discussion that pursued after this posting is harder to find. Perhaps the wayback machine can help there.
time0 = getTickCount();
do
{
time1 = getTickCount();
frameTime = 0;
int numLoops = 0;
while ((time1 - time0) TICK_TIME && numLoops < MAX_LOOPS)
{
GameTickRun();
time0 += TICK_TIME;
frameTime += TICK_TIME;
numLoops++;
// Could this be a good idea? We're not doing it, anyway.
// time1 = getTickCount();
}
IndependentTickRun(frameTime);
// If playing solo and game logic takes way too long, discard pending
time.
if (!bNetworkGame && (time1 - time0) TICK_TIME)
time0 = time1 - TICK_TIME;
if (canRender)
{
// Account for numLoops overflow causing percent 1.
float percentWithinTick = Min(1.f, float(time1 - time0)/TICK_TIME);
GameDrawWithInterpolation(percentWithinTick);
}
}
while (!bGameDone);
Enginuity has a slightly different, but interesting approach: the Task Pool.
Single-threaded solutions with time delays before displaying graphics are fine, but I think the progressive way is to run game logic in one thread, and displaying in other thread.
But you should synchronize threads right way ;) It'll take a long time to implement, so if your game is not too big, single-threaded solution will be fine.
Also, extracting GUI into separate thread seems to be great approach. Have you ever seen "Mission complete" pop-up message while units are moving around in RTS games? That's what I'm talking about :)
This doesn' cover the higher program abstraction stuff, i.e. state machines etc.
It's fine to control movement and acceleration by adjusting those with your frame time lapse.
But how about stuff like triggering a sound 2.55 seconds after this or that, or changing
game level 18.25 secs later, etc.
That can be tied up to an elapsed frame time accumulator (counter), BUT these timings can
get screwed up if your frame rate falls below your state script resolution
i.e if your higher logic needs 0.05 sec granularity and you fall below 20fps.
Determinism can be kept if the game logic is run on a separate "thread"
(at the software level, which I would prefer for this, or OS level) with a fixed time-slice, independent of fps.
The penalty might be that you might waste cpu time in-between frames if not much is happening,
but I think it's probably worth it.
From my experience (not much) Jesse and Adam's answers should put you on the right track.
If you are after further information and insight into how this works, i found that the sample applications for TrueVision 3D were very useful.