Andromeda - Terrain/Landscape editor using Vulkan and Rust | Graphics Programming | Page 3

potent quest Apr 25, 2023, 9:11 PM

#

seems like my gltf extension died thanks to the update

#

you rec some for clion?

shadow trench Apr 25, 2023, 9:12 PM

#

i dont use any

potent quest Apr 25, 2023, 9:13 PM

#

🗿

#

alr thank you

livid geode Apr 25, 2023, 9:41 PM

#

its incredibly useful tho

#

rebind without changing mutability

shadow trench Apr 25, 2023, 9:44 PM

#

i dont use it a whole lot but when I do its a lot nicer than the alternative

shadow trench Apr 25, 2023, 10:03 PM

#

Im heading to bed @potent quest, if you have any questions you can just leave them here and I’ll answer in the morning

shadow trench Apr 26, 2023, 9:11 AM

#

3 left to fix compilation of

#

app, renderer and gui are all broken

livid geode Apr 26, 2023, 9:46 AM

#

why

#

what yu doin

shadow trench Apr 26, 2023, 9:47 AM

#

moving everything into subcrates instead of submodules

#

also switching to the event bus thingy where possible

#

but one thing at a time

livid geode Apr 26, 2023, 9:49 AM

#

send repo when you push those changes

shadow trench Apr 26, 2023, 9:50 AM

#

sure

shadow trench Apr 26, 2023, 10:36 AM

#

the renderer compiles

#

now to glue it all together again

shadow trench Apr 26, 2023, 11:18 AM

#

It all compiles

#

I fully expect it to come crashing down when I run it

#

actually not that bad

#

one deadlock on the input system

#

https://github.com/NotAPenguin0/andromeda-rs/tree/master still need to switch some stuff to using the new event system ofc

potent quest Apr 26, 2023, 11:29 AM

#

Wha subcrates?

shadow trench Apr 26, 2023, 11:29 AM

#

yeah

#

better compile time and code separation

#

this is a nasty deadlock though

#

let input = input.write();
input.process_event(event) {
  bus.publish(event) {
    camera_handler(event) {
      let input = input.read(); // DEADLOCK
    }
  }
}

potent quest Apr 26, 2023, 11:45 AM

#

What why

#

Uh

shadow trench Apr 26, 2023, 11:59 AM

#

i fixed it by pushing events to a buffer and flushing them after

#

i have another issue to fix now :P

shadow trench Apr 28, 2023, 6:07 PM

#

https://cdn.discordapp.com/attachments/760083323904196620/1101568938019672184/IMG_5481.jpg

#

not really related to my project

#

but my little embedded journey for school is making progress

livid geode Apr 28, 2023, 6:14 PM

#

thats awesome

#

@shadow trench is that a regular lcd w a reflective panel?

shadow trench Apr 28, 2023, 6:14 PM

#

its a memory in pixel display thingy

#

its kinda cool, if you cut off the power it keeps the image for a good 20 seconds

wispy ore Apr 28, 2023, 8:56 PM

#

shadow trench https://cdn.discordapp.com/attachments/760083323904196620/1101568938019672184/IM...

at this point idk what this post is about anymore KEKW

shadow trench Apr 28, 2023, 8:56 PM

#

just my various ramblings KEKW

potent quest Apr 28, 2023, 11:53 PM

#

holy shit

#

they werent kidding when they said

#

the rust compiler teaches you rust

young oar Apr 29, 2023, 4:34 AM

#

shadow trench ```rs let input = input.write(); input.process_event(event) { bus.publish(even...

Oh yea I had deadlocks happen in those types of situations before

#

At least we got fallible functions for that (I think?)

shadow trench Apr 29, 2023, 3:54 PM

#

https://cdn.discordapp.com/attachments/905143356919779368/1101889279506002010/IMG_5483.mov

▶ Play video

#

scrolling and keyboard input is working too now :)

#

all in rust btw

potent quest Apr 30, 2023, 1:15 PM

#

Bad apple when

shadow trench Apr 30, 2023, 3:11 PM

#

funnily enough, the site where they sell these shows bad apple running as a demo

potent quest Apr 30, 2023, 3:17 PM

#

💀 LMAOOO

#

bad apple is the universal bench mark

shrewd lynx Apr 30, 2023, 3:29 PM

#

sure a good way to entice weebs to buy it

#

good marketing strategy

shadow trench Apr 30, 2023, 3:46 PM

#

kekw

potent quest May 1, 2023, 11:02 PM

#

Penguin sorry to turn this channel in rust, but

#

did learning rust make you a "better" c++ developer?

wise viper May 2, 2023, 12:15 AM

#

Im not penguin but it made me a better c++ dev

shadow trench May 2, 2023, 7:01 AM

#

I agree yeah

spare bay May 2, 2023, 8:50 AM

#

I mean, the more language you know the better you become at you favourite

potent quest May 2, 2023, 9:42 PM

#

step 2: how to borrow checker

shadow trench May 2, 2023, 9:56 PM

#

You do what the compiler says

#

But it comes down to

#

don’t use after free (I mean, obviously)
never have more than one mutable reference to the same thing

potent quest May 2, 2023, 9:59 PM

#

ok so brain dead moment

#

I'm not getting the difference between move vs copy

#

so move is taking the pointer, length, and etc. and copying it and invalidating the pervious pointer

#

but a copy copies both and redirects the pointer to the new copy

#

oh ownership is pretty easy it's unique_ptrs

shadow trench May 2, 2023, 10:06 PM

#

a move is like std::move

#

There’s not necessarily a pointer

#

Also, a move in rust is a bit more than in C++

#

It leaves the old object destroyed and fully relocates it somewhere else

#

Then there’s Clone which makes a deep copy (for example cloning a Vec allocates a new vector and clones each element into the new vec)

#

Then Copy is a trait that allows a type to do a bitwise copy and still be valid

#

A Vec or obviously not Copy, but u32 is

#

Copy types are not moved either

potent quest May 2, 2023, 10:09 PM

#

ok i think i get it

#

thank you!

shadow trench May 2, 2023, 10:09 PM

#

habibi_pray anytime

#

Typically Clone is an “expensive copy” while Copy is just a memcpy

potent quest May 2, 2023, 10:16 PM

#

https://tenor.com/view/always-sunny-frank-oh-my-god-i-get-it-gif-22328165

Tenor

#

they literally forced you to follow RAII

shadow trench May 2, 2023, 10:16 PM

#

Yes

#

Without unsafe you cannot possibly leak memory

potent quest May 2, 2023, 10:17 PM

#

mfw all the rust code ive seen using vulkan wraps vk functions with unsafe

shadow trench May 2, 2023, 10:17 PM

#

Thats because vulkan functions are inherently unsafe

#

The safety of the call is determined by whether the input parameters were valid

#

You could pass in an invalid pNext pointer for example

potent quest May 2, 2023, 10:32 PM

#

ohh i see

#

but the returned data is safe from the call*

shadow trench May 2, 2023, 10:33 PM

#

In theory any unsafe block could cause UB

#

But using unsafe for vk calls is no big deal

potent quest May 2, 2023, 10:38 PM

#

ok so we're back to: i dont know cpp

#

so rust tutorial is saying data races can also be caused by
2+ pointers accessing the data at the same time

#

but they proceed to do

#

let mut s = String::from("hello");

let r1 = &s; // no problem
let r2 = &s; // no problem

println!("{}, {}, and {}", r1, r2);

#

oh wait

#

is it because r1 and r2 are accessed non-concurrently of each other

#

or whatever it's called i.e. println!() accesses r1 first then r2 after it finished r1

shadow trench May 2, 2023, 10:41 PM

#

potent quest ```rust let mut s = String::from("hello"); let r1 = &s; // no problem let r2 = ...

This isn’t an issue because both r1 and r2 are immutable references

#

But suppose you would send r2 to another thread and then proceed to try to modify s

#

This won’t compile at all

shadow trench May 2, 2023, 10:42 PM

#

potent quest so rust tutorial is saying data races can **also** be caused by 2+ pointers acc...

This should say two mutable references really

#

many immutable shared references is fine

#

But from the moment you want mutability, it’s a data race

potent quest May 2, 2023, 10:43 PM

#

note to self: make my pointer faster to win the race 😄

shadow trench May 2, 2023, 10:43 PM

#

kek

#

In rust thread safety is done using two traits

#

Send and Sync

#

They’re automatically implemented where applicable

#

Send means: “you can send this to another thread and the data it accesses will still be valid”

#

Sync means multiple threads can safely use this concurrently

#

Mutex<T> is Sync

#

&T is not Send because the thing it references could be dropped before the thread exits

#

&'static T is Send because of the static lifetime

potent quest May 2, 2023, 10:48 PM

#

fun fact: i have yet to learn multithreading 💀

#

most ive done was slap openmp onto my math project

potent quest May 2, 2023, 10:49 PM

#

shadow trench `&'static T` is `Send` because of the static lifetime

lifetime?

#

eh rust tutorial said that was a later me problem

#

so ill leave it like that

#

KEKW

wise viper May 2, 2023, 10:52 PM

#

shadow trench Without `unsafe` you cannot possibly leak memory

yes you can

#

you can make cyclic references with ref countes ptrs in rust like arc or rc

#

then cut off all access to them except the refs they have to each other

#

that just leaks

#

its considered safe to leak in rust

shadow trench May 2, 2023, 10:53 PM

#

Ooh yeah true I guess

#

Seems unlikely to actually run into tbh

wise viper May 2, 2023, 10:54 PM

#

yea it is

shadow trench May 2, 2023, 10:54 PM

#

potent quest eh rust tutorial said that was a later me problem

Yeah dw about it too much yet

wise viper May 2, 2023, 10:54 PM

#

i dont think this ever happened to me

potent quest May 2, 2023, 10:58 PM

#

ok so rust slices are like memory safe buffer slices

shadow trench May 2, 2023, 11:02 PM

#

they’re like a std::span

#

They refer to some contiguous range of items, for example a subslice of a vec

#

Except the validity of what they point to is checked at compile time

potent quest May 2, 2023, 11:06 PM

#

ohh ic

potent quest May 2, 2023, 11:57 PM

#

hmhmh

#

so i finished

#

learning move semantics

#

should i yolo

#

and jump into phobos

#

the answer: yes

#

error[E0554]: `#![feature]` may not be used on the stable release channel

#

uh penguin do i have to switch over to the unstable?

#

kinda would like to just stay in stable

potent quest May 3, 2023, 12:36 AM

#

also i think

#

the example given

#

https://docs.rs/phobos/latest/phobos/

phobos - Rust

Fast, powerful Vulkan abstraction library

#

does not compile?

#

use winit::window::WindowBuilder;
use winit::event_loop::EventLoopBuilder;
use phobos::prelude::*;

fn main() {
    let event_loop = EventLoopBuilder::new().build();
    let window = WindowBuilder::new()
        .with_title("Hello, Phobos!")
        .build(&event_loop)
        .unwrap();

    let settings = AppBuilder::new()
        .version((1, 0, 0))
        .name("Phobos demo app")
        .validation(true)
        .window(&window)
        .present_mode(vk::PresentModeKHR::MAILBOX)
        .scratch_size(1 * 1024u64) // 1 KiB scratch memory per buffer type per frame
        .gpu(GPURequirements {
            dedicated: true,
            min_video_memory: 1 * 1024 * 1024 * 1024, // 1 GiB.
            min_dedicated_video_memory: 1 * 1024 * 1024 * 1024,
            queues: vec![
                QueueRequest { dedicated: false, queue_type: QueueType::Graphics },
                QueueRequest { dedicated: true, queue_type: QueueType::Transfer },
                QueueRequest { dedicated: true, queue_type: QueueType::Compute }
            ],
            ..Default::default()
        })
        .build();

    let (
        instance,
        physical_device,
        surface,
        allocator,
        exec,
        frame,
        Some(debug_messenger)
    ) = WindowedContext::init(&settings)? else {
        panic!("Asked for debug messenger but didn't get one.")
    };


    println!("Hello, world!");
}

#

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src\main.rs:40:41
   |
5  | fn main() {
   | --------- this function should return `Result` or `Option` to accept `?`
...
40 |     ) = WindowedContext::init(&settings)? else {
   |                                         ^ cannot use the `?` operator in a function that returns `()`
   |
   = help: the trait `FromResidual<std::result::Result<Infallible, anyhow::Error>>` is not implemented for `()`


error[E0308]: mismatched types
  --> src\main.rs:32:9
   |
32 |       let (
   |  _________^
33 | |         instance,
34 | |         physical_device,
35 | |         surface,
...  |
39 | |         Some(debug_messenger)
40 | |     ) = WindowedContext::init(&settings)? else {
   | |     ^   --------------------------------- this expression has type `(VkInstance, phobos::PhysicalDevice, Surface, phobos::Device, DefaultAllocator, ExecutionManager, FrameManager, Option<DebugMessenger>)`
   | |_____|
   |       expected a tuple with 8 elements, found one with 7 elements
   |
   = note: expected tuple `(VkInstance, phobos::PhysicalDevice, Surface, phobos::Device, DefaultAllocator, ExecutionManager, FrameManager, Option<DebugMessenger>)`
              found tuple `(_, _, _, _, _, _, _)`

shadow trench May 3, 2023, 3:58 AM

#

potent quest uh penguin do i have to switch over to the unstable?

Yea it requires nightly unfortunately

shadow trench May 3, 2023, 3:59 AM

#

potent quest ``` error[E0277]: the `?` operator can only be used in a function that returns `...

Make your main return a Result<()> (anyhow::Result is good)

#

But generally nightly isn’t that “unstable”

#

I can maybe cut down on the features used though, I’ll try to remove them

potent quest May 3, 2023, 4:08 AM

#

Yeah its just I wanna code and not accidentally end up getting used to some experimental feature

shadow trench May 3, 2023, 4:09 AM

#

The feature flags are not transitive luckily

#

So it doesn’t apply to your app, they’re only used when compiling the phobos dependency

#

And all unstable features require such a flag to be added

potent quest May 3, 2023, 4:26 AM

#

Ohh okay I see

shadow trench May 3, 2023, 4:29 AM

#

If you want to switch in the meantime, it’s as simple as rustup default nightly (or stable to go back)

shadow trench May 3, 2023, 8:37 AM

#

potent quest ``` error[E0277]: the `?` operator can only be used in a function that returns `...

Ah, the example was also missing one tuple element for the device

#

i got rid of all but one unstable feature

#

i cant seem to get around using min_specialization for the Fence<T> Future<T> implementation

#

I recommend doing ```toml
phobos = { git = "https://github.com/NotAPenguin0/phobos-rs", rev = "bd0ea43" }

btw

#

this way you can easily stay on the git branch instead of waiting for releases, but the commit is fixed

potent quest May 3, 2023, 4:39 PM

#

ohh alright i see

potent quest May 3, 2023, 4:39 PM

#

shadow trench Ah, the example was also missing one tuple element for the device

Ohh what is the right version then?

shadow trench May 3, 2023, 4:39 PM

#

its fixed in latest

potent quest May 3, 2023, 4:40 PM

#

huh

#

it's still complaining about the tuples

shadow trench May 3, 2023, 4:41 PM

#

you need to add a device after the surface

potent quest May 3, 2023, 4:41 PM

#

ohh that's it

shadow trench May 3, 2023, 4:41 PM

#

yeah i just forgot one element in the example

#

some example code i tend to forget to update

#

most up to date one youll find is the raytracing sample

potent quest May 3, 2023, 4:43 PM

#

ohh yeah seems like there's an issue with how you're also handling

#

WindowContext::init()

#

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src\main.rs:43:41
   |
7  | fn main() {
   | --------- this function should return `Result` or `Option` to accept `?`
...
43 |     ) = WindowedContext::init(&settings)? else {
   |                                         ^ cannot use the `?` operator in a function that returns `()`
   |
   = help: the trait `FromResidual<std::result::Result<Infallible, anyhow::Error>>` is not implemented for `()`

shadow trench May 3, 2023, 4:43 PM

#

you can only use ? in a function that returns a result

#

do cargo add anyhow, use anyhow::Result; and make main fn main() -> Result<()>

potent quest May 3, 2023, 4:44 PM

#

ohh alright

#

im so sorry for making you teach me rust 💀

shadow trench May 3, 2023, 4:44 PM

#

all good

#

anyhow is a crate that implements an error type that works for any library's error type

#

So it converts between them

potent quest May 3, 2023, 4:46 PM

#

ohh a compat layer

shadow trench May 3, 2023, 4:46 PM

#

kind of

#

its really convenient for applications

#

i might move ph over to its own error type so it doesnt depend on anyhow

#

we'll see

potent quest May 3, 2023, 4:47 PM

#

oh wait

#

what do i return in main?

shadow trench May 3, 2023, 4:48 PM

#

Ok(())

#

() is the unit type, its the same as void really

#

except you can construct it

potent quest May 3, 2023, 4:48 PM

#

i got a window to open for 0.01 seconds before the program closed
BUT LETS GOOOOOO

shadow trench May 3, 2023, 4:48 PM

#

kek

#

Do you have a main loop

potent quest May 3, 2023, 4:48 PM

#

no i literally just took the code from the examples

#

to make sure my pc is chill it vuk

#

i meant

#

phobos*

#

shhh

shadow trench May 3, 2023, 4:49 PM

#

https://github.com/NotAPenguin0/phobos-rs/blob/5a444e4f9a3ff607c37894e5e2d39eaee876668c/examples/example_runner/lib.rs#L213

#

the example runner might help

potent quest May 3, 2023, 4:49 PM

#

oooh alright

#

so i gotta guess the examples are reliable*

shadow trench May 3, 2023, 4:50 PM

#

it does the boilerplate for the provided examples

#

03_raytracing is

#

02_headless_compute maybe

potent quest May 3, 2023, 4:50 PM

#

ohh okay. maybe add like test cases for them?

shadow trench May 3, 2023, 4:50 PM

#

the basic one i gotta fix

#

Yeah

potent quest May 3, 2023, 4:50 PM

#

wtf cargo has testing tooling

#

bro what

shadow trench May 3, 2023, 4:50 PM

#

it has everything kek

potent quest May 3, 2023, 4:51 PM

#

bro i feel like a cavemen exiting into the modern world

shadow trench May 3, 2023, 4:51 PM

#

c++ developer discovers rust

potent quest May 3, 2023, 4:51 PM

#

KEKW

#

i should probably finish learning rust

#

especially lifetimes

shadow trench May 3, 2023, 4:52 PM

#

eh lifetimes you learn as you go

#

in the end they do make a lot of sense tbh

potent quest May 3, 2023, 4:53 PM

#

ok so pub makes stuff public

shadow trench May 3, 2023, 4:53 PM

#

yep

potent quest May 3, 2023, 4:53 PM

#

struct is like a bluepritn

#

then impl is like the .cpp file to the .h

shadow trench May 3, 2023, 4:53 PM

#

sure

#

in the end structs are like classes

potent quest May 3, 2023, 4:54 PM

#

wait what is
.scratch_size(1 * 1024u64) // 1 KiB scratch memory per buffer type per frame
?

#

wait you allocate scratch for rasterization too?

shadow trench May 3, 2023, 4:55 PM

#

currently you get a scratch allocator provided yeah

#

you can use it for quick uniform data for example

#

but its a bit different from staging buffers

potent quest May 3, 2023, 4:56 PM

#

iirc scratch memory is temp memory of sorts?

shadow trench May 3, 2023, 4:56 PM

#

yeah

#

in this case its cleared every frame

potent quest May 3, 2023, 4:56 PM

#

like it's the spot where if you need to work on some uniform or data on the gpu, you put it there

shadow trench May 3, 2023, 4:56 PM

#

yeah

potent quest May 3, 2023, 4:56 PM

#

ohh alright

#

thank you

shadow trench May 3, 2023, 4:57 PM

#

uniform buffers, a storage buffer thats updated each frame

#

or a small vertex buffer for gui for example

#

https://docs.rs/phobos/latest/phobos/allocator/scratch_allocator/struct.ScratchAllocator.html
and https://docs.rs/phobos/latest/phobos/wsi/frame/struct.InFlightContext.html

potent quest May 3, 2023, 4:59 PM

#

ohh alright thank you

shadow trench May 3, 2023, 4:59 PM

#

you get this InFlightContext each frame in the new_frame() callback

potent quest May 3, 2023, 5:00 PM

#

oh yeah dumb question
I never understood the differnece between CpuToGpu and GPUOnly
Don't you either way have to transfer memory from the cpu to gpu? i.e. uploading vertex data from gltf

shadow trench May 3, 2023, 5:01 PM

#

CpuToGpu is ideally DEVICE_LOCAL| HOST_VISIBLE, GpuOnly is HOST_VISIBLE

#

CpuToGpu is perfect for uploading

#

the name CpuToGpu comes from the fact that you can easily write to it from the Cpu (its mappable), and the gpu can easily read from it

potent quest May 3, 2023, 5:05 PM

#

OHHH
Make buffer for CpuToGpu then have a the GPU read it and make a GpuOnly buffer

#

? iirc that was in vkguide or smth

shadow trench May 3, 2023, 5:05 PM

#

Thats for uploads with a staging buffer

#

These scratch buffers for example are also CpuToGpu

potent quest May 3, 2023, 5:07 PM

#

ohh\

#

wait i might need to redo my buffers then KEKW

shadow trench May 3, 2023, 5:08 PM

#

what do you have rn

potent quest May 3, 2023, 5:08 PM

#

im talking about my vuk rt project i kinda just assumd everything was GpuOnly unless vuk's examples told me otherwise

shadow trench May 3, 2023, 5:08 PM

#

ahh

#

i mean, GpuOnly is best for performance

#

Stuff that you dont need to constantly write from the cpu is best to have GpuOnly

potent quest May 3, 2023, 5:10 PM

#

ohh okay

#

i might be fine then since i only write my blas and tlas once

shadow trench May 3, 2023, 5:11 PM

#

yeah then gpuonly is best

shadow trench May 3, 2023, 6:33 PM

#

MonkaS my dev folder is 90 gb

haughty valley May 3, 2023, 6:36 PM

#

rookie numbers

#

193GB

shadow trench May 3, 2023, 6:38 PM

#

nervous

#

I deleted a couple gb of random assets and .vs folders

haughty valley May 3, 2023, 6:39 PM

#

ah just that one project

#

that is quite big

#

or all projects?

shadow trench May 3, 2023, 6:40 PM

#

nah all projects

haughty valley May 3, 2023, 6:41 PM

#

ah

#

yeah my biggest 3 are kernel, CTS and the amdvlk driver 🐸

shadow trench May 3, 2023, 6:41 PM

#

froge makes sense

shrewd lynx May 3, 2023, 6:41 PM

#

Mine was around 200gb bc it includes projects I cloned but have forgotten to try out

haughty valley May 3, 2023, 6:41 PM

#

each >25gb frog_sweat

shadow trench May 3, 2023, 6:42 PM

#

cleaning out build folders always helps

shrewd lynx May 3, 2023, 6:42 PM

#

Doesn't help either if said projects have assets

shadow trench May 3, 2023, 6:42 PM

#

yeah

livid geode May 3, 2023, 6:47 PM

#

you know you're using rust when your project's folder is 13gb

#

shadow trench May 3, 2023, 6:49 PM

#

yep

#

300 dependencies

livid geode May 3, 2023, 6:52 PM

#

that's actually much less than i expected

shadow trench May 3, 2023, 6:53 PM

#

that is not a lot

livid geode May 3, 2023, 6:53 PM

#

taking into account it uses vk, winit and whatnot

shadow trench May 3, 2023, 6:53 PM

#

yeah

livid geode May 3, 2023, 6:53 PM

#

what about andromeda

shadow trench May 3, 2023, 6:53 PM

#

lets see

#

cargo tree lists 405 lines of output but theres a lot of duplicates, since its split up in multiple crates

#

using cargo-deps-list

shadow trench May 3, 2023, 7:45 PM

#

oh no

#

im only crashing in release

#

dread_cat

potent quest May 3, 2023, 8:04 PM

#

not even rust is safe

shadow trench May 3, 2023, 8:05 PM

#

happens

#

hows progress on your end

potent quest May 3, 2023, 8:12 PM

#

i forgot that my math exams

#

are soon

#

so gotta study

#

tbh i just need to past 💀 since universities only look at your mid terms for admission

shadow trench May 3, 2023, 8:17 PM

#

potent quest are soon

kekw woops

#

happens

#

gl

potent quest May 4, 2023, 12:36 AM

#

damn so this "exam" has zero problem solving whatsoever

#

the calculator part is so broken too 💀 You can use the graphing calculator to more or less get one line solutions and say GCD

wispy ore May 4, 2023, 2:05 AM

#

potent quest the calculator part is so broken too 💀 You can use the graphing calculator to m...

I've only had one exam where a calculator was allowed

#

and there really wasn't anything you needed a calculator for in the first place

#

lmfao

potent quest May 4, 2023, 2:06 AM

#

ohh nono im prepping for my last high school exam

#

and yeah nothing reall

#

yits just that theyll make you calculate something stupid like normalcdf but it also means when they ask you to ingrate anything it's one liners 💀 or solve

potent quest May 4, 2023, 4:55 AM

#

Yo dumb question penguin

#

I hesrd that zig is good for unsafe messiness

#

Why hasn’t gp clung on that much to zig compared to rust?

shadow trench May 4, 2023, 7:36 AM

#

Because zig is a meme lang KEKW

#

Its a lot closer to C really

livid geode May 4, 2023, 8:38 AM

#

zig is not safe

#

or rather does not prevent any unsafe operations

#

also meme lang too

hot yarrow May 4, 2023, 10:20 AM

#

dont tell herald

potent quest May 4, 2023, 5:58 PM

#

LMAO I thought it was serious KEKW

shadow trench May 4, 2023, 6:07 PM

#

funny part is they think they are too

shadow trench May 4, 2023, 7:22 PM

#

heh i broke camera rotation

#

but not movement

#

CatStare

#

hmm probably has to do with the way input events are triggering new input events

hot yarrow May 4, 2023, 7:28 PM

#

heh

shadow trench May 4, 2023, 7:40 PM

#

ah

#

i do not register the input system lmao

#

as an added bonus fixing that once again deadlocked my program

#

cant publish the same event type from within its own handler

#

these chains can get pretty long but i do think its a bit nicer than passing everything around all the time

hot yarrow May 4, 2023, 7:51 PM

#

i broke my framebuffer scaling

shadow trench May 4, 2023, 7:51 PM

#

Especially when adding multithreading into the mix later

shadow trench May 4, 2023, 7:51 PM

#

hot yarrow i broke my framebuffer scaling

I just fixed that 😄

hot yarrow May 4, 2023, 7:51 PM

#

this .unwrap()...unwrap() looks super cursed

#

but its what its in rust i guess

shadow trench May 4, 2023, 7:52 PM

#

That's rust yeah

#

I could maybe use ? here actually

#

The first unwrap() is needed because the lock could be poisoned

#

The second is needed because the dependency might not exist in the registry, and theres no meaningful way to continue if it isnt (its just an initialization error)

#

And I have to handle these errors to access the value so unwrap it is 🤷

#

In a lot of cases you can just let value = may_fail()?;

hot yarrow May 4, 2023, 7:56 PM

#

: )

livid geode May 4, 2023, 8:06 PM

#

use ? 😭

#

unwrap is nasty

shadow trench May 4, 2023, 8:16 PM

#

I know unwrap sucks

#

But this TryLockResult doesnt implement Send so I can't use ? on it

#

Maybe I should fix that

livid geode May 4, 2023, 8:53 PM

#

how are you gonna fix it

shadow trench May 4, 2023, 9:15 PM

#

Im not sure actually

#

Maybe I can make the inner T Send safely but I don’t even know if that would be sound and if it would help

livid geode May 4, 2023, 9:30 PM

#

changing the compiler?

#

if the result is not send there must be a good reason for it

#

or something else

shadow trench May 4, 2023, 9:43 PM

#

Probably

potent quest May 5, 2023, 12:47 AM

#

yo penguin

#

how would you uh make a private member in a struct

livid geode May 5, 2023, 5:49 AM

#

its private by default if you don't put pub on it

shadow trench May 5, 2023, 12:49 PM

#

pub enum AssetRef<'a, A: Send + 'static> {
    Pending,
    Invalid,
    Failed(anyhow::Error),
    Ready(&'a A),
}

I hope this is not too annoying to work with if I return this from my asset get() function

#

Maybe if I add some helper functions

shadow trench May 5, 2023, 1:46 PM

#

Ok one thing I am always struggling with is getting around the following problem

#

I need some struct like the following

#

struct RefToInnerLock<'a, T> {
   lock: RwReadLockGuard<'a, T>,
   value: &'a SomeTypeInT
}

#

Now this won’t ever compile because it’s a self-referential type which would never work

#

Currently I’m trying to make something like ```rs

pub struct AssetReadLock<'a, A: Send + 'static> {
lock: RwLockReadGuard<'a, AssetContainer<A>>,
asset: RefCell<Option<AssetRef<'a, A>>>,
}

Where the option inside the `RefCell` is lazily filled in `Deref`

#

But it stinks and I don’t even know if it’ll work

shadow trench May 5, 2023, 5:41 PM

#

seems like this isnt possible either

livid geode May 5, 2023, 7:00 PM

#

shadow trench ```rs struct RefToInnerLock<'a, T> { lock: RwReadLockGuard<'a, T>, value: ...

Can't you create a RwReadLockGuard from the member value?

#

Or wait

shadow trench May 5, 2023, 7:00 PM

#

i dont think so

livid geode May 5, 2023, 7:01 PM

#

Why are you passing the lock around in the first place

shadow trench May 5, 2023, 7:01 PM

#

because if i drop the lock the reference to the inner value is invalidated

#

i may have an unsafe workaround

livid geode May 5, 2023, 7:01 PM

#

shadow trench because if i drop the lock the reference to the inner value is invalidated

Yes, Rust takes care of that

livid geode May 5, 2023, 7:01 PM

#

shadow trench i may have an unsafe workaround

No

#

Use the power of lifetimes

shadow trench May 5, 2023, 7:01 PM

#

the public interface does

livid geode May 5, 2023, 7:01 PM

#

*lock is valid for 'a

#

or at least you can force it to be afaik

shadow trench May 5, 2023, 7:02 PM

#

i have a RwLock<HashMap<K, V>> and I need a &V

livid geode May 5, 2023, 7:02 PM

#

okay

#

How about (*lock).get(key)

shadow trench May 5, 2023, 7:03 PM

#

returning that drops the lock

#

so i need to also return the lock somehow

livid geode May 5, 2023, 7:03 PM

#

Can you pass the lock from outside the fn?

#

May I have some context

shadow trench May 5, 2023, 7:04 PM

#

not really

livid geode May 5, 2023, 7:04 PM

#

So you have something like

member fn {
  let lock = self.get_map();
  return &lock.get(key);
}```

shadow trench May 5, 2023, 7:04 PM

#

Yeah

livid geode May 5, 2023, 7:05 PM

#

the cleanest way to handle this is by passing a lambda

shadow trench May 5, 2023, 7:05 PM

#

Yeah I know thats possible but it gets really messy with many asset lookups

#

Also I feel like since I only need immutable access I can do this cleaner

livid geode May 5, 2023, 7:06 PM

#

No I don't think having it immutable makes anything much easier

#

The issue is that the lock must stay inside

#

So you can only use it inside

#

So

member fn(do_fn: impl FnOnce(&V) -> T) -> T {
  let lock = self.get_map();
  do_fn(&lock.get(key))
}```

#

a lot of crates do this btw

#

including std

shadow trench May 5, 2023, 7:07 PM

#

enum AssetPtr<A> {
    Invalid,
    Failed(*const anyhow::Error),
    Pending,
    Ready(*const A),
}

impl<A> AssetPtr<A> {
    unsafe fn as_ref<'a>(&self) -> AssetRef<'a, A> {
        match self {
            AssetPtr::Invalid => AssetRef::Invalid,
            AssetPtr::Failed(err) => AssetRef::Failed(&**err),
            AssetPtr::Pending => AssetRef::Pending,
            AssetPtr::Ready(ptr) => AssetRef::Ready(&**ptr),
        }
    }
}

pub enum AssetRef<'a, A> {
    Invalid,
    Failed(&'a anyhow::Error),
    Pending,
    Ready(&'a A),
}

pub struct AssetReadLock<'a, A: Send + 'static> {
    lock: RwLockReadGuard<'a, AssetContainer<A>>,
    asset: AssetRef<'a, A>,
}

impl<'a, A: Send + 'static> AssetReadLock<'a, A> {
    pub(crate) fn new(lock: RwLockReadGuard<'a, AssetContainer<A>>, ptr: AssetPtr<A>) -> Self {
        Self {
            lock,
            // SAFETY: We immediately dereference the pointer we just got
            asset: unsafe { ptr.as_ref() },
        }
    }
}

This is my current (unsafe) approach

livid geode May 5, 2023, 7:07 PM

#

bleakekw

shadow trench May 5, 2023, 7:07 PM

#

livid geode So ```rs member fn(do_fn: impl FnOnce(&V) -> T) -> T { let lock = self.get_map...

Yeah I dont mind this for a lot of things but I feel like this would get really annoying with many assets

livid geode May 5, 2023, 7:08 PM

#

// SAFETY: We immediately dereference the pointer we just got
this does not say much

shadow trench May 5, 2023, 7:08 PM

#

yeh true

livid geode May 5, 2023, 7:08 PM

#

in fact i have no idea whether that is ub or not

shadow trench May 5, 2023, 7:08 PM

#

idk either

livid geode May 5, 2023, 7:12 PM

#

i wouldn't risk it, but if you think it's really really really worth it

#

normally when i reach situations like this i step back and see what i've done to get to there instead of forcing the decision

shadow trench May 5, 2023, 7:14 PM

#

yeah probably not a bad idea

#

maybe the callback approach is fine

livid geode May 5, 2023, 7:14 PM

#

callbacks are annoying

#

i understand you

#

but i wouldn't risk ub

shadow trench May 5, 2023, 7:15 PM

#

yeah

hot yarrow May 5, 2023, 8:02 PM

#

it feels absolutely overengineered what you guys do here for some reason

#

getting lost in rustisms 😄

shadow trench May 5, 2023, 8:09 PM

#

well this is kinda not amazing

#

ill rework it to callback isms

shadow trench May 5, 2023, 8:25 PM

#

pub fn with<A, R, F>(&self, handle: Handle<A>, f: F) -> Option<R>
where
    A: Asset + Send + 'static,
    F: FnOnce(AssetRef<A>) -> R, {
    let lock = self.inner.read().unwrap();
    lock.with_container(|container| {
        let entry = container.items.get(handle);
        entry.map(|entry| {
            let asset = Self::poll_entry(entry);
            f(asset)
        })
    })
}

#

let assets = di.get::<AssetStorage>();
assets.with(my_handle, |asset| {
  // do something with asset if it existed
});

hot yarrow May 5, 2023, 8:26 PM

#

ARF 🙂

shadow trench May 5, 2023, 8:27 PM

#

kek

#

should try to get a B in there

hot yarrow May 5, 2023, 8:27 PM

#

yeah Handle Aff is also not bad

#

FnOnce reads as Fucking Once

#

hehe

shadow trench May 5, 2023, 8:27 PM

#

kekw

hot yarrow May 5, 2023, 8:27 PM

#

what is R and what is F?

shadow trench May 5, 2023, 8:27 PM

#

ill also add with_if_ready that only calls f if the asset was in the ready state

hot yarrow May 5, 2023, 8:28 PM

#

i get A is Asset

shadow trench May 5, 2023, 8:28 PM

#

F is a function that is called with the asset if it was found

#

R is the return value of that function

hot yarrow May 5, 2023, 8:28 PM

#

can you not name those things like that then? 🙂

shadow trench May 5, 2023, 8:28 PM

#

I suppose

hot yarrow May 5, 2023, 8:28 PM

#

WhenAssetFound instead of F

#

ReturnValue instead of R or TReturn at least dunno if rust peeps use T... for generic paramaters

shadow trench May 5, 2023, 8:29 PM

#

I tend to use single letter generics too much kekw

#

there is one caveat with this

#

if you call with before loading an asset of that type there wont be a container for that asset

#

Which right now results in a panic

hot yarrow May 5, 2023, 8:31 PM

#

return a NullAsset/Unit then

#

since this is functional inspired stuff it seems

#

or rather dysfunctional 😛

shadow trench May 5, 2023, 8:33 PM

#

hot yarrow return a NullAsset/Unit then

i want to but i dont know how kekw

#

I mean, I know a way but it involves a lot of redundant locking

#

get read lock, check if container exists, if not release read lock and get write lock, insert it, release write lock, get new read lock, continue as if nothing happened

#

hmm

hot yarrow May 5, 2023, 8:43 PM

#

: D

shadow trench May 5, 2023, 8:44 PM

#

fn with_container<'a, A, F, R>(&'a self, f: F) -> R
where
    A: Send + 'static,
    F: FnOnce(RwLockReadGuard<'a, AssetContainer<A>>) -> R, {
    let lock = self.inner.read().unwrap();
    let maybe_container = lock.containers.read_sync::<AssetContainer<A>>();
    match maybe_container {
        None => {
            drop(maybe_container);
            drop(lock);
            let mut lock = self.inner.write().unwrap();
            lock.with_new_container(f)
        }
        Some(container) => {
            f(container)
        }
    }
}

unfortunately this pattern doesnt compile

hot yarrow May 5, 2023, 8:44 PM

#

why not check if container exists before

#

before locking it for reading

shadow trench May 5, 2023, 8:44 PM

#

The read lock is on the container list yeah

hot yarrow May 5, 2023, 8:45 PM

#

i can read other languages usually, but this code is 100% unreadable

shadow trench May 5, 2023, 8:45 PM

#

kekw

hot yarrow May 5, 2023, 8:45 PM

#

and it is 0 clear what its intent is or w🇹🇫 it is supposed to do

shadow trench May 5, 2023, 8:45 PM

#

its mostly internal but i should go around my codebase clarifying things for future me

#

because i will forget

hot yarrow May 5, 2023, 8:46 PM

#

dont get me wrong

shadow trench May 5, 2023, 8:46 PM

#

Well this doesnt work anyway

hot yarrow May 5, 2023, 8:46 PM

#

its mostly just me being an idiot especially when it comes to rust

shadow trench May 5, 2023, 8:46 PM

#

I mean I was going to do that anyway tbh

#

Though you are right its not very obvious

hot yarrow May 5, 2023, 8:46 PM

#

im not 17 anymore

shadow trench May 5, 2023, 8:47 PM

#

oh it compiles if i remove the lifetime lol

#

that shouldnt have been there

#

okay that fixes the load before get issue

#

Okay heres a design question

#

Querying an asset gives this

pub enum AssetRef<'a, A> {
    Failed(&'a anyhow::Error),
    Pending,
    Ready(&'a A),
}

#

Basically either a failure during load, its still loading, or a ready asset

#

with(handle, callback) lets you handle these cases yourself

#

Now I probably want to add a with_if_ready that only calls the callback if the asset is ready

#

But I wonder if that should also call the callback if it is ready but with an error status

#

So basically

with_if_ready(handle, |asset| {
  // can assume asset loaded successfully
});

vs

with_if_ready(handle, |asset| {
  // must handle error case
});

#

I like the former because its simple, but this error must be reported at some point so maybe the latter is better

#

Alternatively I use the first and periodically check all assets for errors and report/remove failed ones

hot yarrow May 5, 2023, 8:55 PM

#

hmm so you basically want your whole api to be "fluent"

shadow trench May 5, 2023, 8:55 PM

#

Yeah ideally

hot yarrow May 5, 2023, 8:55 PM

#

thats quite the brainworm

shadow trench May 5, 2023, 8:55 PM

#

it really is 😄

hot yarrow May 5, 2023, 8:56 PM

#

i get fluid api for builder pattern

shadow trench May 5, 2023, 8:56 PM

#

I cant just ignore the error indefinitely but handling it on each access is wasteful and annoying

hot yarrow May 5, 2023, 8:56 PM

#

or unit tests

#

or otherwise smaller things where you need/want to - well - build something

#

but keep the rest "ordinary"

#

ifs and elses and otherwise conditional blocks

#

unless, its yet another thing amongst rustaceans 🙂

#

to make everything fluent

shadow trench May 5, 2023, 8:57 PM

#

The thing is this needs to be a callback because of rust isms kek

#

in monke words: do not return reference to local variable

hot yarrow May 5, 2023, 8:57 PM

#

callback itself is probably not a bad thing

#

idk what that means "in monke words"

shadow trench May 5, 2023, 8:58 PM

#

other way to say shrimple

hot yarrow May 5, 2023, 8:58 PM

#

monke was a gorilla who killed someone?

shadow trench May 5, 2023, 8:58 PM

#

no no thats a different monkey

hot yarrow May 5, 2023, 8:58 PM

#

then i dont get that monke nonsense at all 😄

#

anyway

shadow trench May 5, 2023, 9:00 PM

#

I think some sort of "asset garbage collector" might not be awful

hot yarrow May 5, 2023, 9:01 PM

#

which is more or less just a List<IDisposable> (a list of disposables, a thing which has a Dispose method)

shadow trench May 5, 2023, 9:01 PM

#

yeah it would just go over all assets, check which ones failed to load, report their errors and remove them

hot yarrow May 5, 2023, 9:01 PM

#

yeah

shadow trench May 5, 2023, 9:01 PM

#

and do that every now and then

hot yarrow May 5, 2023, 9:01 PM

#

reasonable

#

like an AssetCache

shadow trench May 5, 2023, 9:01 PM

#

Yeah

#

I mean this thing is named AssetStorage for a reason :P

hot yarrow May 5, 2023, 9:02 PM

#

😛

shadow trench May 5, 2023, 9:19 PM

#

and im going to need another one of those tasks to resolve pending promises when they are ready

#

I was going to do that in with originally but that wont work because it needs mutable access

shadow trench May 5, 2023, 9:38 PM

#

I guess that also means its a good idea to use a HopSlotMap over SlotMap, if I'm going to be iterating over all assets somewhat frequently

hot yarrow May 5, 2023, 11:04 PM

#

i read HopSlob 😄

shadow trench May 6, 2023, 12:29 PM

#

im sneaking an el_rubio in my paper

#

livid geode May 6, 2023, 1:29 PM

#

shadow trench im sneaking an `el_rubio` in my paper

what is it a reference to? freya's bot is also called that

shadow trench May 6, 2023, 1:29 PM

#

i have no idea

livid geode May 6, 2023, 1:29 PM

#

also you usin latex or typst?

shadow trench May 6, 2023, 1:29 PM

#

latex

#

i havent really checked out typst yet

livid geode May 6, 2023, 1:29 PM

#

i recommend it fully

shadow trench May 6, 2023, 1:30 PM

#

it does look pretty good tbh

livid geode May 6, 2023, 1:31 PM

#

the most useful feature it has is that you can code in it

#

but the new syntax is appreciated too (although it takes a while to get used to)

shadow trench May 6, 2023, 1:31 PM

#

I mean latex syntax kinda sucks ngl

#

also this just happened

#

dread_cat

livid geode May 6, 2023, 1:32 PM

#

What happened

#

Columns?

shadow trench May 6, 2023, 1:33 PM

#

a lot of whitespace

livid geode May 6, 2023, 1:33 PM

#

Or that your whole paper got turned into gibberish

#

Ah

shadow trench May 6, 2023, 1:33 PM

#

the columns are intentional but uh

#

I added some text above and now the whitespace is all messed up

livid geode May 6, 2023, 1:34 PM

#

maybe it's trying to place something but it don't fit

shadow trench May 6, 2023, 1:35 PM

#

Yeah we have some very bad code to put a table somewhere

#

this table

#

spans both columns

#

ah, making some random image a bit smaller works kek

livid geode May 6, 2023, 1:36 PM

#

bruh literally microsoft word

shadow trench May 6, 2023, 1:36 PM

#

literally

shadow trench May 7, 2023, 11:58 AM

#

tokio::time::sleep(Duration::from_secs(RESOLVE_INTERVAL_MS)).await;

#

oops

#

Accidentally running the asset gc every 500 seconds instead of ms

hot yarrow May 7, 2023, 12:06 PM

#

https://tenor.com/view/kid-run-hallway-oops-walking-back-gif-12263463

Tenor

shadow trench May 8, 2023, 12:01 PM

#

i may come to regret doing this

#

pub struct Texture<F: TextureFormat> {
    pub image: PairedImageView,
    marker: PhantomData<F>,
}

making textures typed over their format

livid geode May 8, 2023, 12:12 PM

#

wtf why did you do that

#

actually there's a fix

#

introduce a dynamically formatted texture type and add a conversion method from the typed one

shadow trench May 8, 2023, 12:14 PM

#

im just working on it to see if its viable

#

generally you dont want random dynamic image types: a heightmap is always expected to have a single-channel f16 texture for example

shadow trench May 8, 2023, 1:02 PM

#

contributed to rust: ✅

livid geode May 8, 2023, 2:03 PM

#

shadow trench generally you dont want random dynamic image types: a heightmap is always expect...

yes but for e.g. assets you do not know the image format

#

cause not everything is hardcoded

shadow trench May 8, 2023, 2:04 PM

#

yeah but every asset needs to be in a finalized consistent format after loading

#

color textures must be srgba8

#

so the impl can do a conversion to that on load

livid geode May 8, 2023, 2:05 PM

#

you don't allow other formats other than srgb8 for color textures?

shadow trench May 8, 2023, 2:05 PM

#

i dont plan to without a conversion

#

the conversion happens automatically anyway

#

like you can load anything from disk

shadow trench May 8, 2023, 3:36 PM

#

I ditched the asset GC

#

It was smelly

#

Now the asset task removes itself from the storage if it fails

shadow trench May 8, 2023, 6:08 PM

#

I have a minor issue with the way my asset system works but its not big deal

#

pub struct Heightmap {
    pub image: Handle<Texture<HeightmapFormat>>,
}

I have this asset type for example

#

If I want to do something when this is ready, I need to write

#

let handle: Handle<Heightmap> = ... ;
assets.with_if_ready(handle, |heightmap| {
   assets.with_if_ready(heigtmap.image, |image| {
      // done
   });
});

#

Though maybe in this case I can store a texture directly actually

#

but this wont work when I have multiple sub-assets inside

#

pub type HeightmapFormat = Grayscale<f16>;

#[derive(Debug)]
pub struct Heightmap {
    pub image: Texture<HeightmapFormat>,
}

pub struct HeightmapLoadInfo {
    pub path: PathBuf,
}

impl Asset for Heightmap {
    type LoadInfo = HeightmapLoadInfo;

    fn load(info: Self::LoadInfo, bus: EventBus<DI>) -> Result<Self>
    where
        Self: Sized, {
        load_from_image(info, bus)
    }
}

// Normalizes height values in the height map to [-1, 1] based on the most extreme value
fn normalize_height(width: u32, height: u32, data: &mut [LumaPixel<f16>]) -> Result<()> {
    trace!("Normalizing heightmap data");
    // Find the largest absolute value in the dataset, and take the absolute value of it.
    let extreme_val = data
        .par_iter()
        .max_by(|lhs, rhs| lhs.to_f32().abs().total_cmp(&rhs.to_f32().abs()))
        .unwrap();
    let extreme_val = f16::from_f32(extreme_val.to_f32().abs());
    let extreme_val_inverse = f16::ONE / extreme_val;
    // Now divide every height value by this extreme value
    data.par_iter_mut().for_each(|value| {
        **value *= extreme_val_inverse;
    });

    Ok(())
}

fn load_from_image(info: HeightmapLoadInfo, bus: EventBus<DI>) -> Result<Heightmap> {
    let tex_info = TextureLoadInfo::FromPath {
        path: info.path,
        cpu_postprocess: Some(normalize_height),
    };
    // Because we only load one image, we can get away with not doing this in another
    // async task through the asset system. This also makes it a bit more ergonomic to
    // access the image inside the heightmap because we don't need to go through two layers of
    // handles.
    let image = Texture::load(tex_info, bus)?;
    Ok(Heightmap {
        image,
    })
}

This entire file got so much simpler now after the asset system rework, it's so nice

shadow trench May 8, 2023, 6:32 PM

#

nervous

#

I guess if its in wrapper its not so bad

hot yarrow May 8, 2023, 6:51 PM

#

assets.assets.assets.assets 😛

shadow trench May 8, 2023, 6:51 PM

#

kek

#

It is a lot less code than before though, I used to handle all the task spawning and joining inside each asset load function which was really messy

#

now I just ask for a handle and its done

hot yarrow May 8, 2023, 6:54 PM

#

THandle GetHandle<THandle>() why not 😛

livid geode May 8, 2023, 6:56 PM

#

shadow trench <:nervous:836935166437883934>

cant you do this stuff with async instead?

shadow trench May 8, 2023, 6:58 PM

#

im not sure, its kinda hard because of the locking involved

#

thats how I ended up with this callback approach

shadow trench May 8, 2023, 9:39 PM

#

shadow trench ```rs pub struct Texture<F: TextureFormat> { pub image: PairedImageView, ...

ngl compiler errors on using a wrong color space is kinda nice to have

shadow trench May 9, 2023, 8:17 AM

#

i may have impulsively bought a domain name

#

it was cheap

livid geode May 9, 2023, 8:20 AM

#

what lol

#

which one

shadow trench May 9, 2023, 8:27 AM

#

notapenguin.blog

#

i can do structured rambling on the internet now

wispy ore May 9, 2023, 8:28 AM

#

I, too, should do structured rambling on the internet

#

although you were always able to do that before

#

just host with github KEKW

shadow trench May 9, 2023, 8:30 AM

#

im still going to host with github

#

but a custom domain is kinda nice

wispy ore May 9, 2023, 8:30 AM

#

yeah can set a custom domain

#

how much was it / is it

shadow trench May 9, 2023, 8:30 AM

#

9 eur for the first year

wispy ore May 9, 2023, 8:30 AM

#

that's actually fair

shadow trench May 9, 2023, 8:30 AM

#

30/year or so after that

#

i need to figure out how to set up https

#

but its not that big of a deal

short surge May 9, 2023, 9:55 AM

#

they always get you with the renewals

shadow trench May 9, 2023, 10:12 AM

#

true

#

https://www.notapenguin.blog/ got an empty jekyll site running now

NotAPenguin’s ramblings

Welcome to my page, where I ramble about various things, usually related to computer graphics or Rust.

#

i quite like this theme

#

i still need a better name tho, this is boring

#

I wonder if my asset system is interesting enough to write something about

livid geode May 9, 2023, 10:29 AM

#

doxxed

#

sending a linkedin invite your way right now

#

NOOOOOO

shadow trench May 9, 2023, 10:32 AM

#

I don’t think I have a linkedin profile

#

Do I??

#

KEKW

livid geode May 9, 2023, 10:33 AM

#

There's a single result for your name

#

There could be another person with your exact same name lol

shadow trench May 9, 2023, 10:33 AM

#

No I think that’s me

#

Wtf when did I make that

short surge May 9, 2023, 10:34 AM

#

that theme is nice

shadow trench May 9, 2023, 10:34 AM

#

It says 5th place in some regional coding contest when I was in hs

short surge May 9, 2023, 10:34 AM

#

i think mine is still default theme

shadow trench May 9, 2023, 10:34 AM

#

But I got 2nd the year after KEKW

livid geode May 9, 2023, 10:35 AM

#

only 5th??? smh smh smh

shadow trench May 9, 2023, 10:35 AM

#

Yeah I know

#

The second time I got 2nd without my team

#

It was like a cp contest except you have 3 people on 1 laptop

#

Or 4 i think

#

Except my teammates didn’t rly do anything and I did everything that year

#

livid geode May 9, 2023, 10:36 AM

#

like a what contest

shadow trench May 9, 2023, 10:37 AM

#

Competitive programming

livid geode May 9, 2023, 10:40 AM

#

Ahhh

livid geode May 9, 2023, 12:47 PM

#

@shadow trench Nice copypaste of martty's blog KEKW

shadow trench May 9, 2023, 12:47 PM

#

is it the same theme?

livid geode May 9, 2023, 12:47 PM

#

ye

shadow trench May 9, 2023, 12:47 PM

#

oh lmfao

#

that was not intentional kekw

livid geode May 9, 2023, 12:48 PM

#

https://martty.github.io/posts/radbg_part_1/

Pain au GPU

Making an AMDGPU debugger part I - The Plan

Intro GPUs are complex beasts - and certainly more mysterious in some ways than CPUs which come with ample amounts of documentation and manuals. Aspiring graphics programmers (too insignificant to have a devrel contact to give insight) are sometimes left to scrounge old GDC presentations on performance tips, with very little known about the inne...

shadow trench May 9, 2023, 12:48 PM

#

dammit now I need a different theme

#

its on the front page of the jekyll theme list

livid geode May 9, 2023, 12:49 PM

#

also i hadn't seen this lmfao

shadow trench May 9, 2023, 12:49 PM

#

kekw

#

well its fine, im sure there are hundreds of blogs with this theme

livid geode May 9, 2023, 12:51 PM

#

its not the only theme by far, there are lots, i'm sure you can find one that you like more

#

but otherwise you can ofc stay with this one

shadow trench May 9, 2023, 12:52 PM

#

yeah ill look a little further

livid geode May 9, 2023, 12:52 PM

#

i should post something on my blog again, i posted a single article and nothing more since 2021

#

mewby hardware stuff

shadow trench May 9, 2023, 12:52 PM

#

why not post about the thingy thats secret

livid geode May 9, 2023, 12:54 PM

#

thats actually kinda secret

shadow trench May 9, 2023, 12:54 PM

#

ahh

livid geode May 9, 2023, 12:54 PM

#

:p

shadow trench May 9, 2023, 12:54 PM

#

my bad

#

incredible

livid geode May 9, 2023, 12:54 PM

#

lmao

haughty valley May 9, 2023, 12:56 PM

#

pRoJeCt vExEd

shadow trench May 9, 2023, 1:00 PM

#

This isnt too bad but I really dont have a good image to put there

#

most screenshots from renders just arent vertical like that

livid geode May 9, 2023, 1:19 PM

#

Cant you change your renderer resolution?

shadow trench May 9, 2023, 1:28 PM

#

Yeah I can but it would look kinda weird probably

shrewd lynx May 9, 2023, 4:08 PM

#

i want to be able to do structured rambling aswell

#

damn cool though

wispy ore May 9, 2023, 4:14 PM

#

shrewd lynx i want to be able to do structured rambling aswell

literally pick any jekyll theme, fork it and call the repo githubname.github.io

#

https://sfreytag.github.io/friday-theme/ is the theme I am using. Need to modify the scss though for dark mode

Welcome to Friday Theme · Friday Theme ...

shadow trench May 9, 2023, 4:20 PM

#

Yeah it's super simple to set up

shadow trench May 9, 2023, 4:40 PM

#

sneak peak time

livid geode May 9, 2023, 5:19 PM

#

bruhhhhw hat you doin

#

transmuting a dyn T to an impl T

#

that doesn't work like that, dyn objects are completely different types of pointers

#

they're fat pointers

#

you cannot cast that at all

#

you can downcast tho

shadow trench May 9, 2023, 5:23 PM

#

I know that doesn’t work kekw

#

It does work with ThinBox

#

That’s the point I’m trying to make

shadow trench May 9, 2023, 5:24 PM

#

livid geode transmuting a dyn T to an impl T

dyn Any to dyn T

livid geode May 9, 2023, 5:26 PM

#

ah i see

shadow trench May 9, 2023, 5:34 PM

#

Its UB because the vtables don’t match

#

But with ThinBox the vtable is on the heap so you can “safely” transmute

hot yarrow May 9, 2023, 6:47 PM

#

when is this rustism over and we can finally see some terrainisms again? 🙂

shadow trench May 9, 2023, 7:00 PM

#

Soon ™️

shadow trench May 9, 2023, 7:25 PM

#

Sometimes I have to set up some infrastructure to continue

shadow trench May 9, 2023, 8:25 PM

#

While writing the post I realized theres an easy way to allow for recursively publishing the same event type without deadlocking

#

Easy fix

#

Actually it might still deadlock, just later down the line

#

Oh well

livid geode May 9, 2023, 8:31 PM

#

shadow trench But with ThinBox the vtable is on the heap so you can “safely” transmute

so thinbox is like regular c++ oop?

shadow trench May 9, 2023, 8:31 PM

#

yea

#

but its unstable

livid geode May 9, 2023, 8:32 PM

#

yeye

shadow trench May 9, 2023, 8:33 PM

#

also comes with the Unsize trait

#

T: Unsize<dyn Foo> if T: Foo

shadow trench May 9, 2023, 9:52 PM

#

ive written a first draft of a post https://www.notapenguin.blog/posts/rust-event-systems/

NotAPenguin’s ramblings

Writing an event system in Rust

Disclaimer

#

this one is very rust-focused i suppose

wispy ore May 9, 2023, 10:32 PM

#

shadow trench this one is very rust-focused i suppose

if you only suppose it is rust focused KEKW

shadow trench May 9, 2023, 10:32 PM

#

kekw

#

It won’t always be like that

hot yarrow May 9, 2023, 10:38 PM

#

said no one ever

potent quest May 10, 2023, 2:58 AM

#

exams are finally over

#

so what didi miss

shadow trench May 10, 2023, 7:45 AM

#

I wrote a blog post

#

That’s about it from me

young oar May 10, 2023, 2:30 PM

#

shadow trench ive written a first draft of a post https://www.notapenguin.blog/posts/rust-even...

W

shadow trench May 10, 2023, 2:31 PM

#

the design is somewhat inspired by yours actually

young oar May 10, 2023, 2:31 PM

#

Yea lol I noticed some similarities here and there

#

Yours seems tk be more focused on actual proper events though

shadow trench May 10, 2023, 2:32 PM

#

Yeah I wanted no hardcoded event types

young oar May 10, 2023, 2:32 PM

#

Yeap

#

I wanted to implement such a thing when writing my event system but I found it not too rewarding

#

So in your game/game engine you can have custom user events?

shadow trench May 10, 2023, 2:35 PM

#

I'm not making a game engine, but yeah that's definitely possible

#

I liked this because it allows me to add new event types easily

young oar May 10, 2023, 2:36 PM

#

Yea

livid geode May 10, 2023, 3:15 PM

#

@shadow trench considering using phobos for rex

#

maintaining a nih graphics backend is hard work

shadow trench May 10, 2023, 3:15 PM

#

it do be

livid geode May 10, 2023, 3:15 PM

#

and i kinda need just something done for the editor

shadow trench May 10, 2023, 3:16 PM

#

i have an egui backend too

livid geode May 10, 2023, 3:22 PM

#

yup i do need that too

#

was it trivial to make?

shadow trench May 10, 2023, 3:22 PM

#

yeah it was pretty easy

#

just porting the existing one

young oar May 10, 2023, 5:24 PM

#

I'm also thinking of using egui for my game engine editor

#

Idk how to handle reflection though

#

Probably through bevy_reflect

shadow trench May 10, 2023, 5:30 PM

#

or a simple handrolled proc macro

#

tho i assume thats pretty much exactly what bevy_reflect does

livid geode May 10, 2023, 5:59 PM

#

yeah except good

#

use bevy_reflect, don't bother nihing your own solution, it ain't worth it

shadow trench May 10, 2023, 5:59 PM

#

didnt you try that at some point

livid geode May 10, 2023, 5:59 PM

#

(says the person that did a nihed solution)

#

yes

shadow trench May 10, 2023, 5:59 PM

#

kekw

livid geode May 10, 2023, 5:59 PM

#

that is why i say that its not worth it

shadow trench May 10, 2023, 6:10 PM

#

maybe, but it looks like a fun challenge to solve kek

shadow trench May 10, 2023, 6:56 PM

#

debugging deadlocks dread_cat

shadow trench May 10, 2023, 7:22 PM

#

time to add a wrapper around RwLock that logs everything it does

hot yarrow May 10, 2023, 7:23 PM

#

Wrap<RwLock<Wrap<RwLock<X>>>>

shadow trench May 10, 2023, 7:25 PM

#

I'll just name it RwLock too and make sure to import the right one

#

They have the same API anyway

#

The other name I came up with was InstrumentedRwLock<T> but that feels a bit verbose

hot yarrow May 10, 2023, 7:27 PM

#

Instrumented suggests it contains instrumentation

shadow trench May 10, 2023, 7:28 PM

#

Yeah I don't really know what else to call it

hot yarrow May 10, 2023, 7:28 PM

#

i mean why not

#

LoggedRwLock perhaps

#

to be more specific

shadow trench May 10, 2023, 7:28 PM

#

It should log its acquires, possibly throw a warn if its held for too long, stuff like that

#

things i can toggle off for release builds ofc

hot yarrow May 10, 2023, 7:28 PM

#

intrumentation is more like collecting shrimples

shadow trench May 10, 2023, 7:29 PM

#

true

shadow trench May 10, 2023, 8:19 PM

#

hm alright I fixed my deadlock

#

im not sure I like the fix a lot tbh

#

The problem is I have this with_when_ready() method on my asset system which blocks the caller until an asset load is completed

#

But its implemented as a dumb polling loop

livid geode May 10, 2023, 9:23 PM

#

make it async orsomethin

shadow trench May 10, 2023, 9:27 PM

#

I need to think about it yeah

hot yarrow May 10, 2023, 9:29 PM

#

await await it();

shadow trench May 10, 2023, 9:30 PM

#

I think I can maybe use a channel instead and yeet a message through it when load completes

#

Then I can just wait on the channel instead which doesn’t need a polling loop

livid geode May 10, 2023, 9:31 PM

#

it doesn't?

#

you can recv but i think that just busyloops inside

shadow trench May 10, 2023, 9:32 PM

#

I assume it uses some unsafe state internally to wake the future on send() no?

livid geode May 10, 2023, 9:33 PM

#

how

#

no i dont think so

shadow trench May 10, 2023, 9:33 PM

#

Idk honestly

#

But it would hide that loop into the runtime

#

And I can use something like a broadcast channel to only have to lock the asset system shortly to retrieve a copy of the receiver and await it after

#

That might work

shadow trench May 11, 2023, 9:23 AM

#

/// Calls the provided callback with the given asset, blocking the calling thread until it is ready.
pub fn with_when_ready<A, R, F>(&self, handle: Handle<A>, f: F) -> Option<R>
where
    A: Asset + Send + 'static,
    F: FnOnce(&A) -> R, {
    // Poll the asset system once for the current status of the asset.
    // * If the asset doesn't exist, don't call `f`
    // * If the asset load completed, call `f` if it was successful
    // * If the asset load is still pending, we get a broadcast channel that we can wait on
    let poll = self.poll_asset(handle);
    match poll {
        // Wait for the broadcast message and call `f` if we receive a `Success` message.
        PollResult::Pending(mut rx) => {
            let message = tokio::runtime::Handle::current().block_on(rx.recv()).ok()?;
            match message {
                AssetLoadMessage::Success => self.with_if_ready(handle, f),
                AssetLoadMessage::Fail => None,
            }
        }
        PollResult::Failed => None,
        PollResult::Ready => {
            // We know the asset is ready, so this will always call `f`.
            self.with_if_ready(handle, f)
        }
    }
}

this works yeah, and it holds the lock only for a short time

#

And it's not a dumb polling loop, I get to use whatever smart tricks tokio uses to optimize scheduling broadcast channels

shadow trench May 11, 2023, 11:34 AM

#

uh oh

#

somewhere down the line half my mesh disapeared

#

Well, not destroying staging buffers before uploading would be helpful

#

nervous

#

lets check out release mode first

#

much better

#

Even better, my program keeps running fine even if an asset loader panics due to a library bug

livid geode May 11, 2023, 11:56 AM

#

shadow trench somewhere down the line half my mesh disapeared

Looks either distorted or maybe half is being culled

shadow trench May 11, 2023, 11:57 AM

#

shadow trench Well, not destroying staging buffers before uploading would be helpful

this kek

livid geode May 11, 2023, 11:58 AM

#

oh lmao

shadow trench May 11, 2023, 11:59 AM

#

I had this code

struct BufferCopyResult<'a, D: ExecutionDomain> {
    pub cmd: IncompleteCommandBuffer<'a, D>,
    pub buffer: Buffer,
    pub staging: StagingBuffer,
}

... 

let BufferCopyResult {
        cmd,
        buffer: vertices,
        ..
    } = copy_buffer( ... );

which apparently drops the staging buffer

livid geode May 11, 2023, 12:01 PM

#

oh ofc lol

#

you're not binding it

#

that's actually a problem there

shadow trench May 11, 2023, 12:02 PM

#

yeah I fixed it, I thought it would just keep it floating around somehow kek

#

which i realize now doesnt make sense

livid geode May 11, 2023, 12:02 PM

#

for a quick api fix you could make it private and introduce a getter

#

thats just a hack tho

shadow trench May 11, 2023, 12:02 PM

#

I just gave it a name for now

young oar May 11, 2023, 12:21 PM

#

livid geode yeah except good

I was thinking of writing my own reflect macro as well lol but then realized that bevy reflect isn't so bad

hot yarrow May 11, 2023, 4:59 PM

#

shadow trench uh oh

looks like a star destroyer

shadow trench May 11, 2023, 5:00 PM

#

i kinda see it

young oar May 11, 2023, 5:30 PM

#

Oh yep lol

#

"It's not a bug it's a feature"

hot yarrow May 11, 2023, 8:41 PM

#

@shadow trench sorry for this OT question, but do you remember the gl validation layer nonsense jaker you and tried to toy with?

#

i cant find it in the projects posts or did we remove it somehow or was that just a thread somewhere?

shadow trench May 11, 2023, 8:51 PM

#

I don’t know if we had a fred

#

Not sure

hot yarrow May 11, 2023, 8:51 PM

#

yeah, i dont rember either

#

but you know what i mean, neh?

#

https://github.com/GraphicsProgramming/gl-validation-layer

shadow trench May 11, 2023, 9:10 PM

#

Yeah that project

shadow trench May 11, 2023, 11:09 PM

#

@hot yarrow you thinking of reviving it?

#

maybe we used the fwog thread?

#

#opengl message

#

I found this message which has a link I don't have access to

hot yarrow May 11, 2023, 11:18 PM

#

i was trying to remember what and where it was for LVSTRI to perhaps have a go at it 🙂 since he just started with gl and is neck deep into MDI/compute/hiZ and whatnot already and complains about opengl not providing proper yelling at him hehe

shadow trench May 11, 2023, 11:18 PM

#

nervous

#

Does that message link work for you?

hot yarrow May 11, 2023, 11:19 PM

#

yes

shadow trench May 11, 2023, 11:19 PM

#

What mysterious lands does it lead to

hot yarrow May 11, 2023, 11:19 PM

#

gets me here

shadow trench May 11, 2023, 11:19 PM

#

Yeah I meant the one in that message

hot yarrow May 11, 2023, 11:19 PM

#

ah

shadow trench May 11, 2023, 11:19 PM

#

Though considering it says Unknown for you too I guess it maybe got deleted

hot yarrow May 11, 2023, 11:20 PM

#

ah

#

yes

#

thats from the retired yourprojects channel

shadow trench May 11, 2023, 11:20 PM

#

Ahh I see

#

Unfortunate

hot yarrow May 11, 2023, 11:20 PM

#

when we recreated the forum channel

#

maybe i can resurrect the messages from it somehow into a new post in #1019722539116802068

shadow trench May 11, 2023, 11:22 PM

#

Mayhaps

hot yarrow May 11, 2023, 11:22 PM

#

will take a looksie over the weekend

shadow trench May 11, 2023, 11:22 PM

#

frogapprove

shadow trench May 12, 2023, 11:29 AM

#

new warnings added

#

these should help track down deadlocks

#

I also added a similar one that checks if a lock is blocking for over 100ms

#

Quick test shows it working nicely for a simple deadlock

let _lock = lock.read();
let lock = lock.write();

young oar May 12, 2023, 12:56 PM

#

Or you can try and use a try_read try_write system

#

That would return an error of the lock was already locked

#

That's how I do things (though instead of using RwLock I use a refcell)

shadow trench May 12, 2023, 1:03 PM

#

Yeah that's possible but it's a lot more annoying to use

#

Also inside like a renderer hot path there's really not much room to keep retrying

#

but these logs are mostly just for debugging in case of deadlocks

#

the last one was a huge pain to track down so

shadow trench May 15, 2023, 9:06 AM

#

Ok I think it's time to work on the first major terrain editor feature

#

@hot yarrow you're going to like this

#

I'm going to make the first brush tools

#

That said I don't really know where to begin

#

Perhaps getting mouse click positions in worldspace isn't a bad start

shadow trench May 15, 2023, 9:26 AM

#

I made a little list of tasks

hot yarrow May 15, 2023, 10:10 AM

#

https://tenor.com/view/this-shouldve-happened-a-long-time-ago-reggie-bush-cold-as-balls-about-time-finally-gif-19800325

Tenor

shadow trench May 15, 2023, 10:33 AM

#

Well it's not very easy

#

I need to figure out how to insert arbitrary graphics work but not every frame

hot yarrow May 15, 2023, 10:44 AM

#

: ) no rush

shadow trench May 15, 2023, 10:45 AM

#

I have an idea but it got interrupted by the fire alarm

#

dread_cat

hot yarrow May 15, 2023, 10:45 AM

#

siren_blue

shadow trench May 15, 2023, 10:45 AM

#

Happens like every other week here

hot yarrow May 15, 2023, 10:46 AM

#

oof

shadow trench May 15, 2023, 10:48 AM

#

Most of the time we can stay inside but this time we had to evacuate

hot yarrow May 15, 2023, 10:49 AM

#

skool? or home?

shadow trench May 15, 2023, 10:49 AM

#

Student dorm thingy

#

Probably someone messed up while cooking again

hot yarrow May 15, 2023, 11:00 AM

#

ah

livid geode May 15, 2023, 12:36 PM

#

lmao

shadow trench May 15, 2023, 1:19 PM

#

NanaStare someone opened an issue on my repo

shadow trench May 15, 2023, 4:48 PM

#

kinda?

#

im not sure why it reports zero every other frame

shadow trench May 15, 2023, 6:38 PM

#

once again another reason to never use vec3s on the gpu

#

i frogor the alignment rules again

livid geode May 15, 2023, 6:51 PM

#

you got to use lfs @shadow trench

#

ppl are complainin

shadow trench May 15, 2023, 6:51 PM

#

yeah i saw lol

#

for now i fixed

#

but lfs sucks too

livid geode May 15, 2023, 6:51 PM

#

yeah it does

#

maybe you could just host the assets elsewhere and download them at startup

shadow trench May 15, 2023, 6:52 PM

#

thats what i was thinking too yeah

#

tho eventually you provide your own assets to use

livid geode May 15, 2023, 6:52 PM

#

andromeda launcher lol

shadow trench May 15, 2023, 6:52 PM

#

kekw

livid geode May 15, 2023, 6:52 PM

#

that could work

shadow trench May 15, 2023, 6:52 PM

#

if needed yeah

shadow trench May 15, 2023, 8:08 PM

#

im trying to figure out why debug builds are so slow and this is the top function catHUH

#

wat it doin

#

it creating backtraces everywhere

#

watbulb

#

should it not only do that on error

#

oh wtf i get it

#

I have a bunch of ok_or(anyhow!(...)) calls

#

which always constructs the error case

#

and captures a backtrace and everything

#

i assume thats optimized out in release but not in debug

livid geode May 15, 2023, 8:19 PM

#

bruh!!!!

livid geode May 15, 2023, 8:19 PM

#

shadow trench I have a bunch of `ok_or(anyhow!(...))` calls

ok_or_else

shadow trench May 15, 2023, 8:20 PM

#

that is a good idea

livid geode May 15, 2023, 8:20 PM

#

clippy should notify you of that iirc

shadow trench May 15, 2023, 8:20 PM

#

not in its default config I think

livid geode May 15, 2023, 8:20 PM

#

theres a lint to use ok_or_else for anything that requires computation

livid geode May 15, 2023, 8:20 PM

#

shadow trench not in its default config I think

maybe its getting confused by the macro

shadow trench May 15, 2023, 8:20 PM

#

Yeah maybe

#

Yeah I didn't know that was such a huge deal lol

#

holy shit thats so much better lmao

livid geode May 15, 2023, 8:22 PM

#

its a heap alloc + backtrace if enabled vs a branch predicted jump

#

you should search for other ok_or usages

shadow trench May 15, 2023, 8:23 PM

#

frametime with debugger went from 70ms to 20ms lmao

#

Yeah I did project-wide already

#

ill check phobos too

livid geode May 15, 2023, 8:23 PM

#

lmao

#

rip

shadow trench May 15, 2023, 9:06 PM

#

now time to figure out how to map world position to uv

#

should not be too difficult to figure out

shadow trench May 15, 2023, 9:40 PM

#

Step 1 complete

potent quest May 16, 2023, 4:39 AM

#

why cant i find motivation to learn any gp 💀 i'll phobos soon

shadow trench May 16, 2023, 6:10 AM

#

GP is hard

#

I just improved perf by a lot lmao

livid geode May 16, 2023, 6:27 AM

#

What'd you do

shadow trench May 16, 2023, 7:03 AM

#

The err thing lol

shadow trench May 16, 2023, 11:14 AM

#

@potent quest im reworking frame submissions a little so its more in line with out of frame submits and also allows submitting multiple command buffers

shadow trench May 16, 2023, 11:34 AM

#

wtf my frame sync was overly complicated lol

#

i still blame vulkan-tutorial

potent quest May 16, 2023, 12:57 PM

#

Yoooooi

#

that’s awesome

shadow trench May 16, 2023, 12:58 PM

#

I've had this SubmitBatch thingy for a while to get multiple command buffers and semaphores between them

#

Im going to try to make it so that to submit frame commands you just return that struct instead of a single command buffer

#

Seems to work nicely

#

let cmd = cmd.finish()?;
let mut batch = ctx.exec.start_submit_batch()?;
batch.submit_for_present(cmd, &ifc)?;
Ok(batch)

#

Should also be able to submit any amount of command buffers in a frame, and have sync applied nicely

#

(and its all batched in one VkQueueSubmit

#

The only drawback is they must be on the same queue for now

#

It might be possible to get around that later

shadow trench May 16, 2023, 3:10 PM

#

alright I can now add a command buffer to the next running frame from anywhere on any thread

#

this is mostly useful for commands that have to be synchronized to resources that are also used in the frame

shadow trench May 16, 2023, 3:39 PM

#

something is happening

#

im only updating one pixel in the heightmap but

#

it very delayed for some reason

#

im guessing the brush event arrives way after the click for some reason

#

no thats not it

#

hmmm

livid geode May 16, 2023, 4:25 PM

#

shadow trench something is happening

shadow trench May 16, 2023, 4:52 PM

#

time to pull out the lock timers again and see if its not stuck waiting on one

shadow trench May 16, 2023, 6:30 PM

#

i think the delay is fixed, its just kinda putting the pillars not at the right place

#

terrain editing 101

hot yarrow May 16, 2023, 6:40 PM

#

looks fine to me

#

ogldev is working on terrain as well and his current series is quite great on geomipmapping+lod isms

shadow trench May 16, 2023, 6:46 PM

#

hot yarrow looks fine to me

theyre slightly offset from where im clicking froge_sad

hot yarrow May 16, 2023, 6:48 PM

#

ah those are the locations where you clicked?

shadow trench May 16, 2023, 6:48 PM

#

Should be

#

It always appears a little shifted in some direction

hot yarrow May 16, 2023, 6:49 PM

#

hmm is this raytracing the position?

shadow trench May 16, 2023, 6:49 PM

#

I get the position from the depth boofer

#

unproject isms

hot yarrow May 16, 2023, 6:49 PM

#

ah

shadow trench May 16, 2023, 6:49 PM

#

It lags one frame behind but that shouldnt matter

hot yarrow May 16, 2023, 6:49 PM

#

are you including some non client area isms perhaps

shadow trench May 16, 2023, 6:49 PM

#

not sure

#

ill log everything and see what comes up

#

fn height_uv_at(world_pos: Vec3, options: &TerrainOptions) -> Vec2 {
    // First compute outer bounds of the terrain mesh
    let min_x = options.min_x();
    let min_y = options.min_y();
    let max_x = options.max_x();
    let max_y = options.max_y();
    // Then we get the length of the terrain in each dimension
    let dx = (max_x - min_x).abs();
    let dy = (max_y - min_y).abs();
    // Now we can simple calculate the ratio between world_pos and the length in each dimension
    // to get the uvs.
    // Note that we use the z coordinate since y is up, and our terrain is in the flat plane.
    // We will assume our terrain is properly centered. In this case, the uvs we get are
    // in the [-0.5, 0.5] range, so we need to remap them to [0, 1]. Since this range is
    // of the same size, we can just add 0.5
    let uv = Vec2::new(world_pos.x / dx, world_pos.z / dy);
    uv + 0.5
}

This is what im doing to get the uv from the position

#

Clicking a corner seems about right though

#

Same with the opposite corner 🤷

hot yarrow May 16, 2023, 6:54 PM

#

no "return"?

#

that looks cursed

shadow trench May 16, 2023, 6:54 PM

#

implicit return

hot yarrow May 16, 2023, 6:55 PM

#

sheesh

shadow trench May 16, 2023, 6:55 PM

#

you get used to it kek

#

Its really nice for expression blocks and stuff

hot yarrow May 16, 2023, 6:55 PM

#

i think that would drive me crazy lol

shadow trench May 16, 2023, 6:55 PM

#

not when remapping position to uv

livid geode May 16, 2023, 6:55 PM

#

fuck you discord for not scrolling me to the bottom

hot yarrow May 16, 2023, 6:55 PM

#

but im sorry, i didnt mean to start a language war now

shadow trench May 16, 2023, 6:59 PM

#

float calculate_weight(float distance) {
    float max_distance = sqrt(2) * pc.size / 2.0;
    float distance_ratio = distance / max_distance;
    return exp(-distance_ratio);
}

[numthreads(16, 16, 1)]
void main(uint3 GlobalInvocationID : SV_DispatchThreadID) {
    uint w, h;
    heights.GetDimensions(w, h);
    int2 texels = int2(float2(w, h) * pc.uv);
    int2 offset = int2(GlobalInvocationID.xy) - int(pc.size / 2);
    texels = texels + offset;
    if (texels.x < 0 || texels.y < 0 || texels.x >= w || texels.y >= h)
        return;
    float dist = length(float2(offset));
    float weight = calculate_weight(dist);
    float height = heights.Load(int3(texels, 0)) + 0.1 * weight;
    heights[texels] = height;
}

#

this is my komput shader for editing the heightmap

#

its supposed to grab a size range around the clicked pixel and update the heights around it

#

It may be bugged but it's still fun to play around with

hot yarrow May 16, 2023, 7:13 PM

#

i like it anyway, although your fov looks fucked

shadow trench May 16, 2023, 7:13 PM

#

thats just the screenshot

#

Looks fine if I take a shot of the entire program

hot yarrow May 16, 2023, 7:14 PM

#

ah

#

i like the sky 🙂

shadow trench May 16, 2023, 7:15 PM

#

~~adapted~~ stolen from lvutner

hot yarrow May 16, 2023, 7:15 PM

#

and that rough/powderesqe finish on that terrain

shadow trench May 16, 2023, 7:15 PM

#

froge

#

its uh

hot yarrow May 16, 2023, 7:15 PM

#

just phong?

shadow trench May 16, 2023, 7:15 PM

#

very bad shading kekw

#

Yeah

hot yarrow May 16, 2023, 7:15 PM

#

lol

#

must be the many looking tringles then

shadow trench May 16, 2023, 7:15 PM

#

there are quite a lot yeah

#

32x32x128x128 points

#

so like 32 million tris

hot yarrow May 16, 2023, 7:16 PM

#

are terrains not some special kind of kind with uneven dimensions

#

129x129 etc

shadow trench May 16, 2023, 7:17 PM

#

I think @wispy ore did something with that to stitch them together

#

but im not doing that yet

#

ah I have an idea to debug this

#

I can try to color the area around where it thinks the mouse is

hot yarrow May 16, 2023, 7:18 PM

#

good idea

shadow trench May 16, 2023, 7:19 PM

#

that should be fairly easy to do too

#

actually I want to do that eventually anyway to have some kind of decal that shows where youre brushing

hot yarrow May 16, 2023, 7:20 PM

#

i think almost exactly 20 years ago was the last time i fiddled with terrain :C

shadow trench May 16, 2023, 7:20 PM

#

:o

hot yarrow May 16, 2023, 7:21 PM

#

had a little world editor for maps for Ultima Online freeshards

#Andromeda - Terrain/Landscape editor using Vulkan and Rust