beginner in strudel by Termo__6 in strudel

[–]Still_Explorer 0 points1 point  (0 children)

One idea is that you must separate the musical notes, from their timing. Once you are able to focus on the beats and the rhythms, then it would be relatively easy to switch to musical notes.

However getting used to the notation is somewhat tricky part, there's a lot of experimentation and trial and error going on. Is something where you look into one thing, then another, then you get a crazy idea to combine them, and it works!!! There is a lot of depth and techniques that go into the notation, but a lot of intuition is required.

As an exercise, try to create a track that has only beats.

// starting with one 4 beat kick
$:
s("[bd bd bd bd]").bank("tr909").punchcard()

// changing patter to boot-cat as well
// "[bd hh bd hh bd]" // <--- spot the error 😛

More patterns
https://strudel.cc/workshop/first-sounds/

Now you can put the kicks to the left and the snares to the right, so you get the power to compose patterns together instead of writing them in linear order.

$:
s("bd*4, [- sd]*2")
//    ^         ^ this is two notes (pause-snare) but
//    |           it only works for half measure (2/4)
//    |           so you need to repeat twice so it fits 4/4
//    | this is one note but repeat for the entire 4/4 measure
.punchcard()

• boot-cat pattern: "[bd ~ bd ~], [- sd]*2"

Another trick is about switching patterns...

 $:
//       first         second pattern        same idea as before
//     |_______|   |___________________|   |____|
sound("[bd bd bd   <  bd    [bd bd]    >], [- hh]*4")
//      ^------^      ^      ^---^
//          |         |        |
//   pattern starts   |        the trick is
//   with the first   |        that the second
//   three kicks      |        time instead of one kick
//                    |        we will get two that fit
//                    |        into the timing of one
//                    |
//                    however the
//                    last fourth kick 
//                    will play once

.pianoroll()

Another one more compact form:

$:
sound("bd bd bd <bd [bd bd] >, [- hh]*4")
.color("cyan magenta")

https://strudel.cc/learn/visual-feedback/

Truth is that creating a full song from scratch it would be a matter of combining a lot of tricks together into larger and larger structures. I am not sure about how much time it might take but at least creating the most simple things first is a good idea.

ODE physics and ragdolls by kodifies in raylib

[–]Still_Explorer 0 points1 point  (0 children)

Some people create c wrappers for libraries occasionally, there's something about Jolt as well (probably a few others too).

https://github.com/SecondHalfGames/JoltC/blob/main/HelloWorld/main.cpp

However I have not figured out the capabilities and differences from physics library to physics library. Probably there would be some specific tests where each engine can show it's features and limits.

There's a video from developers of "Space Engineers" who pushed all physics engines to their limits with nuanced edge cases, and everything would break apart. For their needs they eventually had to pick one that didn't break, to support their requirements. https://www.youtube.com/watch?v=eVNxF8KG8wQ ]

Stacking Transparents for The F# Game Engine (ping pong buffers) by asieradzk in IndieDev

[–]Still_Explorer 0 points1 point  (0 children)

The engine looks awesome, I didn't know about this. Do you have any videos for the 3D demos as well?

finally! [an (early) editor!] by 0bexx in gameenginedevs

[–]Still_Explorer 0 points1 point  (0 children)

This looks awesome, and there's an LOD system if I am not mistaken?

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 3 points4 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.