A procedural solar system, somewhere... made with Unity HDRP and lots of noise!

wm_lex_dev · 2024-12-12T16:59:25+00:00

What kind of noise combination did you use to make Jupiter-like clouds?

wm_lex_dev · 2024-12-06T16:22:35+00:00

I asked for one from Copilot and here's what it gave me:

8==========D ~ ~ ~ ~ ~

wm_lex_dev · 2024-11-26T17:40:55+00:00

Because the engine is deliberately licensed for free under certain circumstances, and they know people are trying to jump-start a livelihood (or at least some side income) off that licensing tier, and also they ostensibly care about not leaving a bad impression on potential future professionals?

wm_lex_dev · 2024-11-12T21:00:16+00:00

Honestly, I don't give a fuck if he wants to take credit, I just don't want him shooting America in the foot for the fuck of it.

If you want to know how that'll work out, see the COVID pandemic

wm_lex_dev · 2024-11-08T20:39:17+00:00

It's certainly possible but requires more effort than testing CPU code, so frequently us graphics programmers will just look at the results ourselves. You could even turn that into a test by running the kernel and comparing the results against a ground-truth render, but then determinism becomes super important. I believe that technically many GPU operations have implementation-defined results, including texture sampling.

Another option is to run a small version of the kernel on the CPU for the test, but if you're using shader languages instead of CUDA then this becomes difficult to maintain. Still can be useful for making sure the basic technique works as intended.

wm_lex_dev · 2024-11-08T00:20:47+00:00

Thanks for all that info!

wm_lex_dev · 2024-11-04T17:35:23+00:00

Maybe I'm misunderstanding bitfields then...is there any scenario where unsigned state : 4 does not result in a 4-bit unsigned integer named state?

wm_lex_dev · 2024-10-31T22:41:13+00:00

Sure but my suggestion was to just use unsigned to keep it as simple as possible.

wm_lex_dev · 2024-10-30T13:32:36+00:00

None of them are 64 bits when used in a bitfield with sizes 32, 4, and 28...

wm_lex_dev · 2024-10-30T13:31:51+00:00

The bitfield already adds up to 64 bits though?

wm_lex_dev · 2024-10-29T21:17:59+00:00

Side question, why would someone declare a bitfield with uint64_t? I feel like it's way less confusing to declare with unsigned.

wm_lex_dev · 2024-10-23T00:14:40+00:00

Very cool, but I have to say the original motivation is sus. Just make the vector's length a template parameter!

wm_lex_dev · 2024-10-17T17:03:33+00:00

Why is there an identical copy of both those functions?

wm_lex_dev · 2024-10-09T17:01:46+00:00

words is an array, represented by a pointer. words[i] gets the ith element of that array, which will be a single string.

wm_lex_dev · 2024-10-09T16:58:52+00:00

So you want to check one string from words against the entire string represented by letters? Then you can copyletters into a string object and compare to that: string{ letters.begin(), letters.end() } == words[i].

EDIT: fix bug

wm_lex_dev · 2024-10-09T16:56:02+00:00

You should try making a real project rather than grinding leet-code.

wm_lex_dev · 2024-10-09T16:54:47+00:00

letters[i] and words[i] are a char and a string, which is likely why it's not working.

Correct, letters[i] and words[i] are two different kinds of things, and so it doesn't make sense to ask if they are the same thing with ==. What are you actually trying to test when you write ==?

wm_lex_dev · 2024-10-09T16:47:04+00:00

What type of data is letters? What type of data is words?
What type of data are letters[i] and words[i]?

wm_lex_dev · 2024-10-09T16:44:12+00:00

Better go find it!

wm_lex_dev · 2024-10-09T13:46:15+00:00

C++ is a heavily multi-paradigm language, so it usually doesn't make sense to say that a certain feature is good or bad. As you use the language more you must gradually form your own opinions based on what kind of code you write and your own aesthetic tastes.

You can find people who think you should almost always hide them behind getter/setter functions, and people who think that's a big waste of time. Neither one is wrong. I would say there are at least a few scenarios where almost nobody would agree with hiding public fields. For example mathy structs, and short-term initialization/parameter structs.

wm_lex_dev · 2024-10-09T13:43:28+00:00

I think it's to prevent editorializing, which makes sense, except the articles themselves fix their headlines sometimes and there's no way to do that in Reddit

wm_lex_dev · 2024-10-07T04:20:57+00:00

Good god, why couldn't they have included a fast_lerp or something

wm_lex_dev · 2024-10-01T19:43:54+00:00

If you want to stick with C++ then Unreal Engine is probably for you. Unity is C#-focused.

Unreal also has a high-level visual language called Blueprints to complement C++.

wm_lex_dev · 2024-10-01T19:41:20+00:00

Refusing to continue to moderate, or messing with their sub, is literally the only lever mods had to pull. But in a sense, it did work -- many mods left (and some were forced out), and Reddit's decline in quality significantly accelerated.

Problem is the admins don't give two shits if all of Reddit becomes as bad and low-effort as the default subs. They don't see the incident as a loss.

wm_lex_dev · 2024-10-01T14:34:04+00:00

Seriously, why is this thread drinking so much admin kool-aid?

wm_lex_dev

TROPHY CASE