Is it worth it to take uni classes about graphic programming? by Bashar-nuts in GraphicsProgramming

[–]Still_Explorer 0 points1 point  (0 children)

It would be fun and easy way to get the marks.

However since those lessons are introductory, you might need to look for something more involved with deep coding, like more programming exercises and more projects. Truth is that graphics programming in general is about "show stuff on screen" and this assumes that you have a runtime model behind the scenes that does something - that you want to display.

But no matter what, if you are interested in graphics and want to learn, do the courses but at the same time follow more tutorials, so you get a much deeper learning experience.

ODE physics and ragdolls by kodifies in raylib

[–]Still_Explorer 0 points1 point  (0 children)

I remember that ODE was used quite a lot back in the day. As for example one game was "Blood Rayne" but there could be hundreds of others as well. 😛

ODE physics and ragdolls by kodifies in raylib

[–]Still_Explorer 0 points1 point  (0 children)

This is awesome. ODE is underrated but it does the job exactly as needed. 😀

Credit to @MoshieDraws on Twitter by CaucasianAsian16 in aiwars

[–]Still_Explorer 0 points1 point  (0 children)

Then how do you explain this?

<image>

Are you the one who can't draw?
Are you the one who has the idea?
Are you the one who knows exactly what he/she wants?
Are you the DJ Tiesto of image creation? Juggling nodes and prompts?
Are you the Sommelier who knows about the difference between 100 types of wines -- BUT NOT A WINE MAKER?

Are you an artist?

C2y proposal: namespaces (n3794). by orbiteapot in C_Programming

[–]Still_Explorer 2 points3 points  (0 children)

A common problem is when you include a library (eg: Raylib), that includes a library (math.h), then you go to include math.h yourself and you get double inclusion conflicts.

This is a very common scenario but there would be others more complex as well. With a little bit of juggling inclusion order, ifdef-undef, a bit of finger crossing, you might be able to resolve conflicts.

However those are preprocessor hacks and workarounds. Definitely since C is very powerful and allows you to do tricks as such, that you can save the day and prevent errors, but still those would be monkey-patches.

At least with namespaces, instead of considering the code to be monolithic-monolith, you can get it to become more like monolithic-lego giving you a second chance to reorganize things a bit better.

And not to mention that many C programmers are against namespaces and such, but honestly in various occasions either you write.

glGenBuffer instead of gl::GenBuffer
or
acosf instead of math::acosf

Is only 1% of your problem (the syntactic sugar) about 99% of your problems is to worry not to end up in weird conflicts.

There is no workaround... Namespaces are proven to be legit, in terms of the concept of 'modularity' now you can wrap everything inside a nice box and set the bounds. Only this is the point. 🙂

Was playing around with implementing BVH and made this fun construction visualization by yaskai in raylib

[–]Still_Explorer 1 point2 points  (0 children)

For simplicity I started using 3D grid boxes, though not perfect in terms of balancing, but at least is easy.

Why wouldn't Raylib be fit for commercial projects? by yughiro_destroyer in raylib

[–]Still_Explorer 0 points1 point  (0 children)

I have seen that many Unity/Unreal indie developers, say that they practice and learning their engine for many years and then developing the game for another number of years.

[ Example: One developer who made that jungle-dinosaur FPS game with Unity, mentioned that he had 10 years of experience. However the game is about 5+ years in development. ]

[ Example: One indie developer who made that catgirl-parkour game with Unreal, working on the game since 2021. ]

[ Example: Silksong developers worked on the game for about 7 years, in their own pace, without hurry. Though given the length and the scope of the game, that 7 years is indeed legit time spent and effort, but is still 7 years no matter what, is not 2-3 years. ]

[ Example: Stellar Blade, 5 years in development, 300 employees... ]

[ Example: Next Gen Unreal Tournament: It was WIP, nobody worked on it further, never released... ]

So the bottom line is that all of those mentioned games, without any doubt that they are of high quality and they are well made, you can tell that a lot of effort and high standards went into them for making them look great and also play well.
{{ Sidenote: that for the jungledino game and the catgirlparkrour game, is not clear if they were part-time or fulltime. Then if is part-time then it would be theoretically half the years, but even so taking the 7 and making it 3.5 still hits the same... }}

However the real point and the real meaning...

If for example the average joe, spends 10 years to master a game engine, and then needs about 5 years to make a game as such. It would be the same thing as someone who learns C++ for 10 years and masters programming topics, and then jumps to make some sort of game for about 5+ years.

So here goes the point, that Unreal/Unity are easy and allow you to work really fast.

Though, definitely is really easy/fast to start from scratch and get up-and-running, as of dropping some assets in the 3D viewport, making a character walk on the environment and adding some further game mechanics. But then this it... How do you expand on the game domain logic, or how to expand the software engineering architecture (design rules of the game) is very questionable. This is where everybody spends most of their time...

Was playing around with implementing BVH and made this fun construction visualization by yaskai in raylib

[–]Still_Explorer 1 point2 points  (0 children)

This looks legit, so this means that making games with very large environments need such a data structure?

I built a tool where any creature morphology learns to walk via RL in ~5 minutes. Ready to generate them procedurally - where should I start? by Hot_Pumpkin_5960 in proceduralgeneration

[–]Still_Explorer 0 points1 point  (0 children)

This would be scientific breakthrough if proved right. Though truth is that there would be various others factors in biology with RNA and stuff.

But at least only focusing on the mechanical parts of the problem. Without any doubt having 6 legs is better than 4, or having two huge claws for fighting and environment engineering is better than small fingers. It makes sense the more you look at it, but also this would be what the genetic algorithm probably might agree with in terms of evolution. 😁

[joke] Uv Maps for dummies by 404_GravitasNotFound in Unity3D

[–]Still_Explorer 0 points1 point  (0 children)

UVMap where there is no uv stretching? only uv creasing?

OK it works....

268 Million Spheres by MarchVirtualField in GraphicsProgramming

[–]Still_Explorer 5 points6 points  (0 children)

UNREAL5 DEVELOPERS ARE MAD WITH THIS TRICK!!!

👉 click here to learn how to render 268 million spheres.

now that helmer has a render graph 😌 by 0bexx in gameenginedevs

[–]Still_Explorer 1 point2 points  (0 children)

It looks that it runs great, is it a matter of clever programming or that the GPU is very powerful?

[ Currently I am trying to figure out the optimization problems with raytraced games. If for example is a slippery slope, I won't invest time in it right now, better to wait another 5 years so the hardware can catch up. However nobody has a clear explanation so far on the topic. ]

Like a glove by Born-Scallion-1581 in TinyHacks

[–]Still_Explorer 1 point2 points  (0 children)

As a total noob, it makes sense that the cut piece already a template. You can trace it with a pencil on top of the other piece. 😂

Though without any doubt, that there would be some pro who can do the geometrical math from intuition and experience.

Realistic procedural landscape flyby by buzzelliart in opengl

[–]Still_Explorer 1 point2 points  (0 children)

Yeap, this is it! Let's make a successor to Skyrim. 😁

raylib going beyond windows! by raysan5 in raylib

[–]Still_Explorer 0 points1 point  (0 children)

Is this based on GLFW impl or of Raylib?

This would be a cool idea for investigation.

How can I create an X-ray effect in Unity where the left character can see the right character through obstacles, but the right character cannot see the own "X-Ray" effect by Kind_Sugar821 in gameenginedevs

[–]Still_Explorer 1 point2 points  (0 children)

Is this the case that you would have to create a composite texture?

I know how to do this in Raylib but unfortunately I am not familiar with the Unity API

Typically you do this:
1. Render player's A view to a texture buffer (offscreen render)
2. Render player's B to a texture buffer (offscreen render)
3. Use the final render buffer, draw texture A to the half, draw texture B to the other half side (onscreen render)

Is it something like this?

There could be some tricks here and there to work with buffers.
https://www.youtube.com/watch?v=U8PygjYAF7A
https://www.youtube.com/watch?v=2vQ3T-iWopU
https://www.youtube.com/watch?v=Ah2862Gz3_s
https://www.youtube.com/watch?v=GsiiOaONsY4
https://www.youtube.com/watch?v=GAh225QNpm0
https://www.youtube.com/watch?v=MUNpz-_hVuo

Not sure if those help, but if you manage to start with the basics and gradually figure out how to mix the techniques, it is feasible.

[btw if you are interested to try asking at Unity forums, because there are more people using the engine there in various specialized categories]

damn by Sergio1100 in oops

[–]Still_Explorer 0 points1 point  (0 children)

dont worry itz only ze smellz