the second approach is specifically using sin/cos frequency encoding with 6 octaves, 128 quantisation bins for my 384x384x8 latent texture, 32x2 MLP (saved as FP16), and training for about an hour and a half.

still have a long way to go... maybe a latent pyramid is next?

this one is a comparison between the original and a much
smaller version (~12x smaller than ref, ~4-5x smaller than BC7)

ideally, id like the quality level of the first approach with the compression levels of the second. continuing to look into ways of making this feasible

been taking a break from the traditional graphics stuff to look into neural rendering, below is the results of my pytorch implementation of NTC, the left is the original, the right is the compressed version (~4x smaller than ref, ~25% smaller than BC7)

shoutout bluesky for the worst looking video compression ever, here's a nicer screenshot

been continuin to work on neki !!
on the graphics side ive added full pbr+ibl, depth of field, render graphs, directional spot and point lights (all shadow casting), gpu-driven streaming, and probs more that im forgetting...
other than that, ive got physics, an editor, scene serialisation, etc. etc.

right as you walk in, kick your feet up on the interviewer's desk and say "enough about me, why should i work for you?"

if the universe turns out to be deterministic im making all my objects constexpr

((((and out-of-core rendering with HLODs if i have time........ i just think it'd be cool........))))

might be shooting myself in the foot here by saying my plans before ive actually figured out if it'll be possible (this is for a school project so due in a couple months), but id like to try and get 3d physics, networking, and serialisation for saving/loading in before submission....
wish me luck :>

and it is indeed up-to-date with the graphics samples

here's a lil sample of the ECS in action, first in the user's code and second in the backend RenderSystem :>

the entrypoint is owned by the engine, and it gets linked to the user's code through those function declarations that the user is expected to define

been a lil while since the last update, but ive been busy converting my render engine to a fully fledged game engine !!

this has involved writing my own ECS framework which has taken up most of my time asdfjfhkdsj but it's done now :>

details below !

am i a graphics programmer yet ?

(ignore overwatch in my taskbar that's not relevant to the demonstration)

just got done adding MSAA and SSAA support to the vulkan side of things :>

the 1st image is with no anti aliasing, the 2nd image is with 8x MSAA (notice how the geometry edges are anti aliased but the textures are still jaggy, classic MSAA 🙄), and the 3rd is 4x SSAA

video in replies !!

is it IBL time chat?

fixed the lighting !! looks a lot better now (had many issues with my tbn matrix n whatnot, classic tbn matrix amirite)

testing this sample on my laptop running d3d12 at 4k did actually reveal some weird screen tearing issues so ill have to do some investigating there, doesn't happen on vulkan or 1080p dx12 though so probably just some weird dx12 quirk im not familiar with sdfjkhfsd

day 1 of PBR, this is just copied over from my old vulkan framework so it doesn't look great but it's a start !! and i can confirm all the textures (albedo, normal, roughness, metallic, ambient occlusion, and emissive) are being loaded correctly :>

also this is working on dx12 and vulkan

gonna take a break now from the backend stuff so i can spend a while doing fun shading i think :>

took a full day of locking tf in but textured models are finally implemented, works on both d3d12 and vulkan

camera camera camera camera !!!!

cube cube cube cube !!!!

comms open

surprise !! if you made it this far, you get to see the Neki logo with the proper colours after my dumbass remembered to use srgb format for the swapchain

the GPUUploader class also has a EnqueueBufferDataUpload() function which is the same thing but for buffers instead of textures, so in the Texture sample, im batching my texture upload alongside the vertex and index buffer uploads

yap session concluded, thanks for reading :))

i make it sound more complicated than it is i think sdfjhkfsd
this is it !!

synchronisation is also handled quite nicely i think. when you call Flush() you pass in true/false depending on if you want to stall the calling thread until the flush is finished. If you set it to false, the function returns a fence that will be signalled when it's done so you know when to Reset()

this means that a bunch of uploads (like if you had 1000 textures to upload) would all get batched together into a single staging buffer and the transfer commands submitted all at once

once it's done flushing, you call Reset() to clear the staging buffer and reset the command buffer

more below :>