randallrvr

There are two types of rays being traced: shadow and "gbuffer". The latter return gbuffer-style information from hit points, and don't recursively launch more rays. Lighting is done in a deferred way. There is just one light: the sun.

irradiance cache: usually fewer than 16k cache entries:
- main trace: 4/entry * (1 gbuffer ray + 1 shadow ray for the sun)
- restir validation trace: 4/entry * (1 gbuffer ray + 1 shadow ray for the sun)
- accessibility check: 16/entry short shadow rays
sun shadow pass: 1/pixel shadow ray
final gather done at half-res; every third frame is a ReSTIR validation frame, and instead of tracing new candidates, it checks the old ones, and updates their radiance. in addition to that, the validation frame also traces very short contact rays; on paper it seems like it would be doing more work, but it's actually slightly cheaper, so I'm counting conservatively here:

Realtime Fluid Simulation: Projection

The core of most real-time fluid simulators, like the one in EmberGen, are based on the "Stable Fluids" algorithm by Jos Stam, which to my knowledge was first presented at SIGGRAPH '99. This is a post about one part of this algorithm that's often underestimated: Projection

MG4_F32.mp4

Stable Fluids

The Stable Fluids algorithm solves a subset of the famous "Navier Stokes equations", which describe how fluids interact and move. In particular, it typically solves what's called the "incompressible Euler equations", where viscous forces are often ignored.

Specific Papers

https://arxiv.org/abs/1505.07376

Texture Synthesis Using Convolutional Neural Networks
https://arxiv.org/abs/1508.06576

A Neural Algorithm of Artistic Style
https://arxiv.org/abs/1603.03417

Texture Networks: Feed-forward Synthesis of Textures and Stylized Images
https://arxiv.org/abs/1701.02096

Improved Texture Networks: Maximizing Quality and Diversity in Feed-forward Texture Synthesis

Volumetric Clouds Resources List

A. Schneider, "Real-Time Volumetric Cloudscapes," in GPU Pro 7: Advanced Rendering Techniques, 2016, pp. 97-127. (Follow up presentations here, and here.)
S. Hillaire, "Physically Based Sky, Atmosphere and Cloud Rendering in Frostbite" in Physically Based Shading in Theory and Practice course, SIGGRAPH 2016. [video] [course notes] [scatter integral shadertoy]
[R. Högfeldt, "Convincing Cloud Rendering – An Implementation of Real-Time Dynamic Volumetric Clouds in Frostbite"](https://odr.chalmers.se/hand

	// Copyright 2024, Benjamin 'BeRo' Rosseaux - zlib licensed

	////////////////////////////
	// QTangent based variant //
	////////////////////////////

	// The qtangent based variant has a better precision than the octahedron/diamond based variant below.

	// 10bit 10bit 9bit for the 3 smaller components of the quaternion and 1bit for the sign of the bitangent and 2bit for the
	// largest component index for the reconstruction of the largest component of the quaternion.

	// Copyright (c) 2023 Tomasz Stachowiak
	//
	// This contribution is dual licensed under EITHER OF
	//
	// Apache License, Version 2.0, (http://www.apache.org/licenses/LICENSE-2.0)
	// MIT license (http://opensource.org/licenses/MIT)
	//
	// at your option.

	#include "/inc/frame_constants.hlsl"

	const std = @import("std");

	pub fn build(b: *std.Build) void {
	// Standard target options allows the person running `zig build` to choose
	// what target to build for. Here we do not override the defaults, which
	// means any target is allowed, and the default is native. Other options
	// for restricting supported target set are available.
	const target = b.standardTargetOptions(.{});

	// Standard optimization options allow the person running `zig build` to select

	// Public Domain under http://unlicense.org, see link for details.
	// except:
	// * core-math function `cr_cbrtf` (see license below)
	// * musl flavored fdlib function `fdlibm_cbrtf` (see license below)

	// code and test driver for cube root and it's reciprocal based on:
	// "Fast Calculation of Cube and Inverse Cube Roots Using
	// a Magic Constant and Its Implementation on Microcontrollers"
	// Moroz, Samotyy, Walczyk, Cieslinski, 2021
	// (PDF: https://www.mdpi.com/1996-1073/14/4/1058)

	uint16_t encode16_morton2(uint8_t x_, uint8_t y_)
	{
	uint32_t res=x_\|(uint32_t(y_)<<16);
	res=(res\|(res<<4))&0x0f0f0f0f;
	res=(res\|(res<<2))&0x33333333;
	res=(res\|(res<<1))&0x55555555;
	return uint16_t(res\|(res>>15));
	}
	//----

	Pretty print tables summarizing properties of tensor arrays in numpy, pytorch, jax, etc.

	Now on pip! `pip install arrgh` https://github.com/nmwsharp/arrgh