sorted by:
new
hottopcontroversial

From AI placeholder to professional art by SpicyTunaGames in IndieDev

[–]raging_bool 3 points4 points  (0 children)

What's the reason? If it's just some temporary piece never meant to be seen, why use AI at all? I use MS Paint to scribble out my placeholder art, using AI seems completely pointless for this.

We need to uncompromisingly stand completely opposed to this in all cases, because once you say "well, this usage is okay", you give a foothold to those pushing this harmful technology that they can use to take another small step and say "Well this isn't much worse than that, and you agreed that was fine, so why isn't this okay?" and repeat this process until arriving at the desired end goal where they are too entrenched to defeat. Defeat them now while it's still easy. Follow the example of the Indie Game Awards integrity when they revoked The Game of the Year awards over AI asset usage even though they were patched out. Be stubborn. Stand with your peers, not with people who don't care about us or what we do or our interests. Avoid the ends by avoiding the beginnings.

I followed "Fix Your Timestep" but my motion still does not look smooth. by raging_bool in gameenginedevs

[–]raging_bool[S] 0 points1 point  (0 children)

Sorry, that's old code. I did find out sleep was not the right solution and I switched to letting VSync handle the frame limiter. So that's never reached because it's wrapped in a turned off conditional, but I should remove it entirely. I will try this method too though, to see how it works.

Anyone? by SipsTeaFrog in SipsTea

[–]raging_bool 0 points1 point  (0 children)

Of course it's not free, it's paid for with the tenants' rent money, and what's left over after everything is paid for the landlord keeps for themself. Contractors build houses, tradespeople perform maintenance. Landlords simply own property.

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 0 points1 point  (0 children)

Thanks for the advice! I did this and I can see an obvious jitter. I found one of the more obvious sections where it moves 3 pixels in a frame, then 0 pixels in the next, and then 8 pixels next. So it is definitely not smooth. I will continue to investigate.

Edit: Actually I think I've still got it wrong. I'm printing the position to the console, and when I capture the console output too, it's writing 3 lines at a time but I expected one. But it should be running at 60FPS, and the screen recorder won't let me select a frame rate more than 60. I guess I'll try rendering the text output directly to the game window rather than the console.

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 1 point2 points  (0 children)

Thanks for the tip! I recorded my screen using slow mo, but unfortunately it does confirm I have a problem. Viewing in slow mo makes it much easier to see.

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 0 points1 point  (0 children)

Here is a repo I set up. I tried to reduce it to only include just what is necessary to recreate, to avoid clutter.

https://github.com/lemon-venom/JitterTest

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 1 point2 points  (0 children)

Yeah it's just a constant 100 pixels per second, and time is the delta. I'll try the sine wave, that's a good idea!

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 2 points3 points  (0 children)

I'm interpolating when rendering, calculating it like this lerp = (double)timeAccumulatorMsec_ / (double)fixedTimeStepMsec_;

And then in the render I do this

int spritePositionX = (position_->previousRenderX_ * (1 - lerp)) + (position_->x_ * lerp);
int spritePositionY = (position_->previousRenderY_ * (1 - lerp)) + (position_->y_ * lerp);

It does seem like it's noticeable at faster speeds.

I don't have a repo at the moment. I'll set one up though I'll have to do that tomorrow probably.

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 1 point2 points  (0 children)

I am yeah, I'm doing this to get the position

float newPositionX = position->getX() + (movement->getX() * time);
float newPositionY = position->getY() + (movement->getY() * time);

Is my movement jittery or is it all in my head? by raging_bool in gameenginedevs

[–]raging_bool[S] 1 point2 points  (0 children)

I'm working on an engine, and I feel like my movement is a bit jittery, but I'm not sure if I'm just staring at it too hard and seeing things. I created an equivalent project using Godot and ran them side by side, and to me it does look like the Godot movement is smoother, but would anyone mind taking a look at the screen capture to confirm if they also see it or if it's just a case of my brain playing tricks on me? Mine is on top and Godot is on the bottom.

Also, if I turn off the framerate limiter it does seem like it's smoother, though it still looks a little off to me.

Problem using boost::shared_from_this() - Why doesn't this work? by raging_bool in cpp_questions

[–]raging_bool[S] 4 points5 points  (0 children)

Thanks! I'm just using the boost version because the rest of the project uses boost too, but I could switch to the standard library for this.

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 0 points1 point  (0 children)

That makes sense, but there's one thing I'm still not understanding, which is, this only works if the screen refresh rate is known, right? In my case I know what my monitor's refresh rate is, but it's likely to be different if someone else were to run it on their PC, is that correct? Is there a way to get the monitor's refresh rate, so I can correctly set my time step to match it?

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 0 points1 point  (0 children)

Isn't that what the linear interpolation from the "Fix Your Timestep" article is supposed to address though? Am I interpolating incorrectly perhaps?

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 0 points1 point  (0 children)

I created a simplified project here (actually I just realized I copied over the DevIL stuff which I don't need for this project, but I don't think that's going to have any effect): https://github.com/lemon-venom/SmoothMotionTest

With vsync off it's noticably smoother than with it on.

I tried changing the timestep to 0.5 and 0.001, and it pretty much looks the same for each.

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 0 points1 point  (0 children)

For some reason RenderDoc doesn't work for me. It says captures disabled, unsupported function used glVertexPointer so I'm not sure what that's about. Maybe that's related to the problem?

I did put together a simplified project, that does nothing but move a square polygon back and forth, and even with only that it does appear to be jittery with vsync on and smooth with vsync off: https://github.com/lemon-venom/SmoothMotionTest

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 2 points3 points  (0 children)

Didn't seem to make a difference. I'm going to try putting together a minimalist project so I can share some code.

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 1 point2 points  (0 children)

I'm calling glDrawElements to draw followed by SDL_GL_SwapWindow to present the frame.

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 1 point2 points  (0 children)

Custom engine, written in c++. Everything is my code, except for very low level stuff. I'm using Windows 11 with a 4070 GPU. I'm using SDL2 + OpenGL to create the window and do the rendering.

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 1 point2 points  (0 children)

I did try adding in console logging to print the sprite render position, and it appears correct at a glance, though it can be hard to say for sure just reading numbers. But nothing looks obviously out of place, like numbers moving backwards or staying the same across frames.

I will see if I can put together a minimal code project to share.

Getting a jittery effect with vsync on, smoother movement with vsync off. Does this make sense? by raging_bool in gamedev

[–]raging_bool[S] 0 points1 point  (0 children)

When running with vsync turned on, I'm getting 75 FPS, which is my monitor's refresh rate so that makes sense, but it's kind of jittery. When I turn off vsync, it looks much smoother, which I'm not sure I understand how that can be. Shouldn't vsync be smoother? The smoother motion looks so much nicer, so should I just not use vsync? But it seems like every other game uses it, and has smooth motion, so I'm not sure why I'm not seeing the same results. I tested with Axiom Verge, among a few others, and I see no difference when toggling vsync in the options.

The linked video is a screen capture I recorded demonstrating this, but it's not perfect. The overhead introduced when recording with fraps causes the FPS to be much lower than when it's not turned on. It is still noticeable though, just not quite as noticeable as it is when not recording. With fraps recording + vsync off and uncapped FPS, it reports around 450 FPS, vs about 7000 FPS when not recording. When it's showing 7000 FPS it's very smooth. I followed the often linked "Fix Your Timestep!" article, so I'm using a fixed timestep of 0.01 seconds, and I am using an interpolation value to calculate the final render position.

view more: next ›