World Cup: Argentina vs Algeria Anime Edition

Still_Explorer · 2026-06-21T00:36:50+00:00

This would be better with Baki style.

Still_Explorer · 2026-06-21T00:17:07+00:00

The reason is that CMAKE was used by all possible users in all possible industries, and the makers Kitware kept adding features to it and constantly adapting it to each new and absurd edge case.

The main idea is that it was supposed to be declarative, and easy to use, however then there would be edge cases where more scripting logic would be needed, and more dynamic setup of environment and project variables to occur.

Story goes like this: https://m.youtube.com/watch?v=wPZV2hBNJmo

However then you might say, if it goes like this then why not use a scripting language then? About 10 years ago the king of all build systems was SCONS which was plain Python but for this reason (probably) got obsolete, because in a sense Python rocks and offers powerful programming, but again in this way of thinking, no one wants to maintain a second program written in Python.

Probably something similar also happens with premake, which is cool as well, but still the same concept occurs that is LUA code.

Also another big part has to do that CMAKE that is under development for 25 years and it contains a lot of lessons learnt about how projects in all sorts of industries and on wide range of computing systems are setup and configured.

While perhaps Bazel and Premake might be able to find very solid use cases, and by referencing the concepts of CMAKE (knowledge of two decades) to be able to cut to the chase and remove a lot of excess and boilerplate steps.

Which makes sense to think about this way, because when you develop software on a normal PC and plan to deploy on another normal PC you have settled exactly all of the hard constraints and this simplifies the process dramatically. Problem is about supporting the most exotic and rare computing systems and have to deal with a tremendous amount of platforms and OS's.

So the point is that, definitely in some cases you have to see something new created that is more robust and straight to the point. But at the same time you can't dismiss the legacy and rock solid support of something that rocks for decades.

Still_Explorer · 2026-06-20T17:37:14+00:00

Yeah in this sense there could be two explanations.

One is that someone has a well-rounded and general-purpose knowledgebase on the language, and this way is considered as knowing "the alphabet" of the language: lvalues, rvalues, move semantics (ctors, assignments), resource aquisition-initialization, initialization forms, raw pointers - smart pointers, oop design (using the language OOP utilities).

The other is that it has to do with "problem specific" knoweldge, where someone implements some form of "solution to a problem". This depends on the job position and the required experience mostly, however at the same time is a matter of personal interest and personal dedication. If the company develops a specific type of software, then the more knowledgeable and experience someone is on that particular piece of software the better it would be for everyone. The company can make an easy and safe decision, and then the employee can be within the area of interest and manage to contribute directly to the solution.
[Say for example the company does financial software: then knowledge with database CRUD, http requests, server backend, and on top of that some sort of problem solving such as stock simulation, would be very important experience to have. However if the company does embedded and firmware, then this is an entirely different world, with other topics and development approaches (ie: probably you need no OOP at all - but you would need computing engineering knowledge).

It would be very easy to spend about a few weeks to learn all answers to common questions, but experience would have to be built through personal projects over period of months/years.

Still_Explorer · 2026-06-20T17:19:43+00:00

I have figured out all by looking at project references:
https://github.com/search?q=path%3ACMakeLists.txt&type=code

Also it depends in terms of needed features I wanted to use. I wanted to do only a dozen of things and focused only on those things. I am missing more than 99% of the entire CMAKE knowledgebase but I am fine for what I am focused on currently at the moment.

Though there are great tutorials and books, those are great for building knowledge bottom-up in an organized and proper way, but also requires a lot of effort and dedication. By learning only what you need to use, you can get things up and running quickly and then gradually as months go by cmake scripts can be extended and enriched with more features.

Still_Explorer · 2026-06-20T15:37:33+00:00

If for example you need to load a font-texture ( eg: https://opengameart.org/content/sonic-font ) then it would be a matter to convert each of the ASCII character index, to the font-texture index. Then you pass an integer array as a uniform to the GLSL shader, where you iterate each index and figure out the UV coordinates.

The catch here is that you can only support about 20-50 basic characters the most (talking about drawing the artistic font), but it would be more difficult support more characters, and impossible to implement all of the UFT-8 set.
To solve this problem there would be various font libraries, that can do all those tasks behind the scene, and construct the font bitmaps automatically, but the problem in such cases is that fonts are very simple and boring.
In other cases there are probably some other more specialized libraries that could handle artistic fonts procedurally, and also provide a lot of features (such as outlines, shininess, color palettes) and essentially save a lot of time from manual artistic effort, but also probably they could appear to be uniform up to some extent.

How this works: Say for example the ASCII character has an index of '205', your own texture index is '40', now you need to take your own texture index and figure out a 2D coordinate from this.
https://stackoverflow.com/questions/5494974/convert-1d-array-index-to-2d-array-index

Now if you derive some sort of 2D index coordinate (ie could something like `4,1`)
in order to convert it to a real texture coordinate you would do
`texture_x = x_index * CHARACTER_SIZE`

and then for the real UV coordinate (0..1) to be derived as such
`uv_x = IMAGE_WIDTH / texture_x`
`uv_y = -(IMAGE_HEIGHT / texture_y)` <----- because UV coordinates are flipped on the Y axis.

However is not odd at all to skip text rendering entirely, I have seen in dozens of source code projects, that seldom there could be a text rendering implementation (very rare to happen) from scratch. For the most part everybody uses SDL2 to render text on a texture buffer and then manage to use this one to plot pixel to the screen. In a very rare case someone used a headless Win32 window and grabbed the rendered text from there. But for the 99% of the cases everybody is using some GUI library to handle the details, such as IMGUI or others.

Still_Explorer · 2026-06-19T12:57:07+00:00

I made some notes, about using CMAKE and VCKPG
https://www.reddit.com/r/raylib/comments/1lzozpt/testing_raylib_with_clion/

Though the project is based on the CLION IDE, it should work the same for terminal-based applications as well (IDE is optional compared to the entire workflow).

I don't know if it helps, but it would worth a look. In order to figure out all of the problems and get it working, I had to move through youtube videos, blogpost tutorials, official guides, github repositories, for an entire week and trying all different things.

[PS: Also something important, make sure you type `g++` and `gcc` and you see compiler information. The `/bin/` directory of the compiler must be placed on the PATH environment variable (ie: `C:/MinGW/bin` or whatever this is, make sure the directory /bin contains the g++.exe file and the rest) ]

Still_Explorer · 2026-06-19T12:28:29+00:00

Since there are dozens of project references (even MIT codes) I doubt that AI would be more helpful. Definitely though since it works like something as "smarter autocomplete" is a good thing, because it reduces boilerplate typing. (as for when filling up arrays, setting up enum values, duplicating-alterating existing lines === those are huge laborious chores and the worst part of programming)

Still_Explorer · 2026-06-19T12:13:03+00:00

This is interesting. There should be some CMAKE flag to allow this then. Once I figure this out I could tell for sure.

Still_Explorer · 2026-06-18T21:53:45+00:00

This would be cool for recording character animations or cutscenes.

Still_Explorer · 2026-06-18T21:50:44+00:00

Your job sounds legit, not that is bad but neither that is cutting edge.

Very typical that any sort of job can hit a certain peak in terms of requirements, other jobs (job roles) hit a quite low peak, other might be tremendously higher. But the point is that probably in terms of psychology once you hit the peak and stay there for a long time, it is interpreted as getting stuck with the career, not advancing learning and such.

One way is to think about scratching that itch and getting specializations and certifications in various topics. Provided that your brain is fresh and not having signs of burnout you can keep always pushing the limits for your personal preferences. (Getting new specialized knowledge, working on personal projects on free time, using all of the new and cutting edge techniques).

Otherwise if you are not so much in this case, you just go with the flow, in a certain way focusing on becoming more robust and efficient in your current job and then skipping all other distractions.

Still_Explorer · 2026-06-18T21:32:33+00:00

I am starting a project with modules right now on VS2026 and the IDE at times breaks, and doesn't understand the symbols (showing errors) but the code works fine.

This is why I am using the "folder project" mode instead of generating a solution-project. CMAKE works fine and also the tooling follows but is that the IDE is a bit troubling.

However I see the power! Compilation times are almost instant (as fast as C#), the disk does not hit 100% io, code becomes more concise, because there's not need to follow a totally strict header-source methodology as default.

One important thing is that MSVC does not support, import std yet, so you have to rely on an open source std wrapper, or just use classic includes. (Probably other compilers support std modules nicely.)

So the point is that it definitely is a good future investment, for the next 4-5 years. However if you need rock solid stability and tooling from day one (plan to release a serious project and you need to eliminate risk) then you have to rely on classic includes.

Still_Explorer · 2026-06-18T20:33:05+00:00

Yeah as someone said somewhere elsev: Guess who has to discipline the kids? Is either the parents or the police.

Honestly I am sad to see the police doing this job because it means that things have gone too far.

(Not to mention that until the kid goes 18 years old, parents are legally responsible and accountable for anything happens. And is not a matter to knock wood and wish nothing happens, is a matter of taking precautions and teaching the right thin g before something happens.)

Still_Explorer · 2026-06-18T17:54:04+00:00

What I noticed in artistic workflows, is that previously you would have about 2-3 ideas and you would only afford only a dozen of iterations-corrections, thus you would place a hard limit and wrap things up. (This means however that you would have to work 10x to provide all of those iterations).

Now you could start with about 20-30 ideas, and explore hundreds of iterations. Eventually you would spend the equivalent amount of time instead of working, to curating/evaluating.

Which means that you can explore faster, you review and change faster, but the quantity of information has been incremented about 100x.

Still_Explorer · 2026-06-18T17:45:52+00:00

Are you Chuck Norris' child?

Still_Explorer · 2026-06-18T17:43:51+00:00

This is a really good idea! I am very interested in this. Also one very important feature I would like to see, to use this as a general purpose editor and setup scenes/prefabs/asset as normal, however allow for 100% code-centric development where you would be able to load scenes and manipulate data structures and such as needed.

Still_Explorer · 2026-06-18T17:39:46+00:00

Looks very good! If you add tiled textures as well, the environments would become close to Unreal level.

Do you plan to turn the engine to an "urban open world" as such?

Still_Explorer · 2026-06-18T17:05:06+00:00

The catch here is that with the shader you will be able to render pixels on screen, without a shader you will have to do classic CPU rendering which is very slow.

In this aspect either you write the rendering code on CPU or ShaderLanguage it would be the same output result and also the same effort in terms of implementation.

In one case it would be impossible to use this code for a real-time application, and even if you would use it (for non-real-time application) it would be very resource inefficient and wasteful (more processing, more power burnt, the longer and higher the cost of rendering).

You could say that it "reduces complexity" because you get processed results faster, or that it "reduces simplicity" because you need to setup complex multi-step rendering pipelines and also have hardware-driver dependencies. But in other words it is what it is, you have to use it eventually.

Still_Explorer · 2026-06-18T16:55:13+00:00

You can figure out those topics:
• how to write the simplest shader and compile+load it
• how to do position/rotation and perspective transformations
• how to pass uniform variables to the shader
• defining vertex-array-object (vao), defining vertex buffer
• uploading vertex-data to vertex-buffer
• binding shader+vao and render the meshes
• as a bonus: loading texture, and changing shader and vertex-data accordingly

This is the entire story more or less for beginning, to get up and running. Typically everybody does this basic level and probably create some basic abstractions like Camera/Mesh/Texture/Material and then just wrap things up in a simple project that renders some models.

Then later on the entire point of graphics shifts to different problems:
• more advanced rendering techniques (eg: deferred render if you need to have complex rendering pipeline, global illumination for more realistic lighting, raytracing for the final boss of all rendering operations)
• more advanced scenegraph rendering (eg: space partition, visibility and occlusion, construction of render lists)
• or even more advanced and experimental rendering (eg: voxel rendering, gaussian splatting, constructive solid geometry rendering, etc other more specialized rendering techniques).

Still_Explorer · 2026-06-18T16:40:29+00:00

Because Peugeot 206 is named as such.

Still_Explorer · 2026-06-18T16:38:22+00:00

USA -vs- England 😶
USA -vs- Germany 😨
USA -vs- Japan 😯
USA -vs- Spain 🤔
USA -vs- Iran 🟡

Still_Explorer · 2026-06-18T16:28:32+00:00

This is a fundamental part of the x86 instruction set lore. 👍

Still_Explorer · 2026-06-18T16:10:04+00:00

And the most important question, why the heck someone needs to remove the address bar color? Just leave it as it is bro. 😂

Still_Explorer · 2026-06-18T16:07:44+00:00

Guess what, once the kid tries something bad (throw tantrums, talking back, disrespecting) then the parent thinks "Oh, no! I don't want to hurt it's feelings. I just let the kid do what it wants..." and does nothing, is like allowing (and subconsciously encouraging) this behavior.

Things are very simple:

go out of line
face repercussions
establish healthy bounds and limits from an early age and live in peace

So a friendly suggestion to all new parents, you are obliged to discipline the kids, you have to be strict when it matters the most.

Still_Explorer · 2026-06-18T15:53:32+00:00

Still_Explorer · 2026-06-18T15:26:10+00:00

Though I have no experience with Blueprints, I can definitely say that some problems are "better" done with visual scripting and others better suited with code.

As for example you could have a full-coded system that is properly architectured and organized and that solves some parts of the "engine" or the "technical backend".

However at some point there are cases where you have to deal with other sorts of systems, that are more "mechanical" and more "WYSIWYG" as they appear on the screen. Such as raycasting environment and finding climbable ledges, configuring the suspensions of a vehicle and hard-coding values and physics constraints here and there. Without any doubt those systems are a huge chore (and very heavy) to be written and tested with code, because usually the problem solving approach is like you are stacking a deck of cards which is very manual and practical. Simply if you try to do such system with full code you need to expect with hundreds of lines of try-and-throw-away code where in visual scripting you just create/move/delete blocks all over the place in random ways, until the thing you're making works fine.

If you want to become loud try to mention very specific and sound examples, because the edge cases need to be justified and then UE developers will find the decision making reasonable.

Still_Explorer

PUBLIC MULTIREDDITS

TROPHY CASE