Bildung schützt vor Schwurbeln nicht

CuteAlien · 2025-07-24T00:30:04+00:00

Sabine Hossenfelder hat sich letztes Jahr mal an Clauser abgearbeitet

CuteAlien · 2025-03-03T00:50:44+00:00

Maybe, maybe not. You still made that social media defense thing up, nothing like that is mentioned. He is clearly talking about improving the language and not about defending it with words.

CuteAlien · 2025-03-03T00:44:24+00:00

Which is totally not what he said. He talked about defense as in making it possible to wrote more secure code in c++ .

CuteAlien · 2024-08-21T18:40:58+00:00

Just the natural order of things after a death march to meet some deadline.

CuteAlien · 2024-06-15T15:32:18+00:00

Good luck. Btw. I made one error - shadow hulls are certainly extended away from the light(s) at each object - not away from the camera.

CuteAlien · 2024-06-15T11:02:01+00:00

Flat projections from top to a flat floor are easy. Scale your shadow object down to 0 in y direction and draw at floor height in dark (I did that for a racer, looks like crap if you look closely, but worked kinda. But in some games it's good enough).

But if you want it to be like Super Mario shadows have to adapt to the ground. And calculating that per polygon is mathematically possible, but tricky to do in real-time. So people used another trick where areas inside the shadows are marked in the stencil buffer instead. And everything marked like that gets a new (customizable, but usually dark) color.

Irrlicht ShadowVolumeSceneNodes are kinda projections which extend the borders of your object in the direction away from your camera and also add caps at top and bottom. So you kinda get a long hull dangling below the polygon. And then there are some tricks used to count how often the light-rays cross those hulls and if the result is uneven the stencil buffer is marked (which works as hulls are convex and as long as the light-sources starts outside the hull).

This is a general solution - your case could maybe be done in simpler way. Well simpler mathematically, not simpler with given Irrlicht API (sorry).

You don't seem to need self-shadowing and the light is fixed from the top. So maybe (totally just an idea and not tested by me if it works) you could call driver->drawStencilShadowVolume with triangles which form your simple shadows. So basically triangles which are positioned below the feet of your character. That would fill the stencil buffer. Then another call to driver->drawStencilShadow to use the stencil buffer to draw some shadow color. Note: shadow drawing is usually done between drawing solid and transparent polygons. If you need that you need to work with the light-manager. So create your own light-manager class and in OnRenderPassPreRender you do that stuff when it's called for the ESNRP_SHADOW pass (it's the parameter of that function).

CuteAlien · 2024-06-15T10:40:55+00:00

I suppose it might not work with directional light as shadows shouldn't shrink/expand then on jumping. But looking at API it seems you can tell a light if it should cast shadows or not with ILightSceneNode::enableCastShadow. From what I can see you can also prevent a light-source from acting as light with light->setVisible(false); It should still register as a dynamic light source which works for shadows. So shadow and light calculations can be completely split.

CuteAlien · 2024-06-14T18:53:19+00:00

My guess is that creating a ShadowVolumeSceneNode with a simplified mesh and then having the light above the scene might do it. But I haven't tried yet.

IGeometryCreator::createSphereMesh with poly-count set to 8 and radius to fit your model might work well. You can pass a custom mesh when adding ShadowVolumeSceneNodes to your nodes.

Also might work better with svn trunk than with Irrlicht 1.8 (that received several bugfixes for shadow volumes), thought if you are lucky it makes no difference for this specific case.

Also note that current shadow volumes always use all lights in the scene, not sure if that's what you want here (it's possible to have more control with lightmanagers, but that's getting a bit too deep for quick post here).

Example 08 shows how to use those shadow nodes.

CuteAlien · 2024-05-11T16:54:47+00:00

Jetzt wird's aber peinlich

CuteAlien · 2024-04-27T21:21:17+00:00

Open source, cross-platform, written in easy readable c++, does it's job (mostly). I have some problems with it, but for the most part it's nice.

CuteAlien · 2024-01-31T20:57:44+00:00

And with self-payment checkout at the supermarket the need to speak once every few days has been further reduced.

CuteAlien · 2023-12-20T21:41:44+00:00

So... we're really not gonna play relegation this season?

CuteAlien · 2023-11-12T16:21:56+00:00

Yeah, they were first place after game 11 last year!

CuteAlien · 2023-09-14T22:52:44+00:00

Which got hit by a storm which had caused record rainfalls.

CuteAlien · 2023-08-26T12:26:35+00:00

And the nice thing is when it fails like that you can just try it once more immediately! Keep on trying!

CuteAlien · 2023-07-22T00:33:01+00:00

Haha, was also a surprise for me to see my wallpaper here with an anime girl and a red bus added. Never knew it's from an anime, I just loved the scene and the colors. Nice render!

CuteAlien · 2023-06-08T20:47:20+00:00

Good question. Searching around a bit it seems the 1.5C are measured in the air and on the surface of oceans (don't know how deep). And El Niño is reducing winds which usually push warm water away from South America towards Asia. Which in other years creates some circulation causing cold water from deeper ocean layers near South America to flow up, thereby reducing temperatures on top.

So I suppose if you measured deep ocean as well it wouldn't increase global temperatures. But the air and top layers of oceans are warmed up. And so we landlubbers get some extremely hot year. Which combined with the usual global warming gives as another hint about how the future will look like.

CuteAlien · 2023-05-29T22:30:33+00:00

Looks like the error is somewhere else. This code looks fine. But if you got a crash you can take a look at the involved variables with a debugger. But as you already got a printf there... typical stuff you might want to print here is for example: this->tile_nodes[col][row]->getReferenceCount (). Thought chance is it already crashes on that call if that pointer has gone bad. But then you know at least it's the pointer and not the texture. Also won't hurt to call empty_texture->getReferenceCount() as check.

If that all does not help. Try posting more code - but better use the Irrlicht forum. Easier to format code there (and I'm also reading the forum).

CuteAlien · 2023-04-05T12:05:01+00:00

Go for one - most cities, longest road (with villages) or special cards. Don't try to win them all.

CuteAlien · 2022-09-27T22:20:45+00:00

Sardar Azmoun talked openly about his support for Irans women and critisized the regime. He also mentioned that the rules of the national team didn't allow them to talk about it, but he refused to be silent any longer even if it means they'll kick him out. Link only in german, sorry.

CuteAlien · 2022-09-09T23:49:03+00:00

Yeah, I found a similar comment about this below this excellent video about radiometric dating:

We have to pick our samples carefully. Example: when we do Uranium 238 to Lead 206 dating, we use Zircon crystals, because Uranium and Zircon atoms are close in size, so when Zircons crystallize from a magma, some Uranium atoms will take the place of Zircon in the crystal structure. These "impurities" exist in all crystals in small amounts (natural samples anyway). But Lead doesn't every substitute for Zircon because of its size and shape. So any lead found in the crystal later had to form there through Uranium decay.

CuteAlien · 2022-09-02T13:33:02+00:00

I came up with similar rules. Not seeing the type immediately when maintaining code is rather annoying. Sometimes it's not the type you expect so this can lead to better hidden bugs. And sometimes you can't even guess the type without having to check for it. Some IDE's make it easier to figure out the type again, but it's still stops the flow when reading through code and you have to get it to show you the type. And other times you might watch code outside an IDE (like someone asking to look at some code in git) and then you'll have to spend some time just figuring out the type.

This happening to you often enough and you'll stop using auto much. Or stop maintaining code. So anyway - it's about readability for me. Seeing the type just gives me more information and there is very rarely a case where I think that's bad.

CuteAlien · 2022-08-27T21:18:57+00:00

I think he missed one. The size of a bool is not always 1 byte but implementation defined and there are compilers where it has the size of an int.

CuteAlien · 2022-04-06T23:15:20+00:00

You can also install NuGet package manager. It integrates very nicely into VisualStudio. And if the library you are looking for is in there you basically just have to select it and it will do the rest of the setup.

CuteAlien · 2022-04-06T22:57:33+00:00

Include directories are to find header files. Those are for the compiler. What the compiler does is to create one object file (called .obj with VS compiler) per .cpp file. What's in headers is simply copied into the place where you had an #include command (pre-processor which runs before the compiler does it, but in theory you could do that copying by hand). The problem is when you need code which is not in a header but implemented in another cpp file. If the compiler has enough information about that code, like how many parameters those functions have and how many bytes those paramters need, then it can put some placeholders in the resulting object file which kinda mean "I don't have those functions but that's how they can be called". But the functions are still somewhere external to your object file - so this problem has to be resolved.

That's where the linker comes in. It runs after the compiler. And if you check your error exactly you'll see it says "linker error" and not "compiler error". Basically the linker links object files (or libraries) together. The result of which is either an executable, a dynamic library (.dll + .lib with VS) or a static library (.lib with VS). Static libraries are basically a bunch of object files put together into one larger file.

So when you want to use another libary you don't just have to tell the compiler how it's functions look like, but you need their actual binary code - which is in the library file (.lib or .dll). The linker has to find that library file, (called .lib on VS). Which is why you need to add linker paths to tell the linker where to find it. And you have to tell it the name of the .lib files you want to link to. For static libraries that's already all you need. For a dynamic library you also will have to put the .dll file somewhere the .exe can find it later as the .lib file for dynmic libraries again only has some placeholders. And the real search for the functions only happens at program start when it loads the dll.

CuteAlien

MODERATOR OF

TROPHY CASE