CynicatPro

vec1.up = 1, purely on vibes because when graphing a function higher values are upwards.

Personally, I'd undefine vec1.up since it doesn't simplify or clarify the code at all. But I'm very much in the pragmatist and minimalist camp of code, so mileage may vary.

Finally building my own UI system for my engine. I really should have done this earlier X3.

Having a viewer for all loaded textures is awesome btw. No secrets, I see all O_O

My father died about 5 years ago. We had a distant relationship, but I still wish I could have shown him some of my work.

Feels like missing a step. A habit made for a reality that no longer exists. =<

I second this, it’s the worst X<

Honestly, stylized proportions are hard to do in 3d, you’re doing great so far!

Yep, that’s an Anton design alright. X3

My favorite cursed fact is that unity originally imported HDR images as SRGB, and didn't fix it for so long that they decided not to fix it at all. Claiming it would break too many existing projects.

Huh, fascinating! Can i ask how the material properties are handled for these voxels, how do you convert from a 4x4x4 bit brick to an index for the voxel?

I'd say fight me, but my sword is too large and I'll be too slow to fight back

We're so cooked

This is hiding some tiny little pinhole artifacts they couldn't figure out how to fix.

I need to remember to practice animation more, it's fun =3

manually modifying an obj file is a true right of passage for any artist X3

Speaking from the highpoly side, it's not great for that either. Skinning is just a bad technique honestly.

I 100% understand how the flow went originally. "Hey, we use matrices for objects, lets allow vertices to be parented to multiple objects!"

But in practice, the quality and workflow suck.

This sounds like a really rad game concept honestly, there's a lot of room for cool aesthetics and neat game design cause and effect in this.

I've had a similar vampire concept in my back pocket about seeing the long term consequences of actions over decades.

Long time periods are under-explored.

What your describing there is already how input prediction works. It works well, but at 60fps, small errors accumulate very fast.

It's usually a combination of game state and controller based prediction, since that works extremely well.

Also the DNN itself adds latency.

You have the normal input->gameframe->renderframe->gpu->present delay, then on top of that add a whole extra frame and readback before that input can even hit the cpu to be used. so your having to predict quite far ahead.

Yes, this actually works ok in the tests i've seen, but evaluating a neural network is sadly extremely gpu memory bandwidth intensive, especially if you're processing images as input.

And if your having to render an camera for every single player you run into cpu draw call overhead. =/

Yooo this is such a good idea

I've had this decision before(though on a smaller scale) and it sucks. I feel for ya.

A pile of lessons learned, even if it's a bunch of broken pieces.

I do this by dumping screenshots into my work WIPs folder so I run into them while working. A+ highly recommended

this is so fuckin pretty i love it

oooooh, I love this!

Oooh i love the chunky pixel art dithering, that's clever!

These are all insanely creative and i love them

Shocked! Shocked I say!

I was sick, so I decided to make myself ramen. But I kept smelling soap while eating it, turns out I didn't rinse the pan enough, so I had made soap ramen.

It did not make me feel better.

oooh I love the runescape vibes of this, that's gorgeous

Yep, also frankly the instruction sets are usually proprietary not publicly documented so you couldn't generate them even if you wanted to.

We could theoretically move to public instruction sets like CPU's have, but that would take lot of political will to get stuff standardized.

Drivers could simply convert from bytecode to machine code, but then if the bytecode was unoptimized, they would look worse in benchmarks than a driver that does optimization passes.

So drivers do incredibly heavy optimization passes when a shader gets compiled... like running LLVM... big spikes.