Constantine Galkin wiseConst

How do you descriptor set?

Descriptor sets have vexed me at every step of development. They're new and different and they have a lot of rules which aren't all that obvious. This document will hopefully lay out everything in one convenient place that I - and also you - can refer to

First, let's talk about what we're trying to do

Use Case

Most renderers need some way for shaders to access resources like textures, buffers, etc. For the Vulkan API, this way is the almighty descriptor set. Descriptors, as I understand them, are essentially a pointer to a resource. You update your descriptor sets with your resources, then you bind the descriptor sets to your command buffer, then shaders involved in subsequent drawcalls can look at the descriptors to know what resources they should actually read from. I'm not entirely sure why there's this indirection - and in fact, on AMD GPUs descriptor sets are actually just pointers - but the indirection exists, and we all have to find a way to deal with it

gathering of links 2019

http://lousodrome.net/blog/light/tag/furnace-test/

Real Shading in Unreal Engine

https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf

"A Multiple-Scattering Microfacet Model for Real-Time Image-based Lighting"

http://jcgt.org/published/0008/01/03/

CUSTOM GAME ENGINES: A Small Study

WARNING: Article moved to separate repo to allow users contributions: https://github.com/raysan5/custom_game_engines

A couple of weeks ago I played (and finished) A Plague Tale, a game by Asobo Studio. I was really captivated by the game, not only by the beautiful graphics but also by the story and the locations in the game. I decided to investigate a bit about the game tech and I was surprised to see it was developed with a custom engine by a relatively small studio. I know there are some companies using custom engines but it's very difficult to find a detailed market study with that kind of information curated and updated. So this article.

Nowadays lots of companies choose engines like [Unreal](https:

GPU Optimization for GameDev

Graphics Pipeline / GPU Architecture Overview

2011 - A trip through the Graphics Pipeline 2011
2013 - Performance Optimization Guidelines and the GPU Architecture behind them
2015 - Life of a triangle - NVIDIA's logical pipeline
2015 - Render Hell 2.0
2016 - How bad are small triangles on GPU and why?
2017 - GPU Performance for Game Artists
2019 - Understanding the anatomy of GPUs using Pokémon

Adding extra probes around walls (detroit become human)

https://twvideo01.ubm-us.net/o1/vault/gdc2018/presentations/CAURANT_GUILLAUME_The_Lighting_Technology.pdf#page=64

Offset along "bent normal"

https://www.youtube.com/watch?v=ERlcRbRoJF0&t=34m35s

Approximate probe-visibility with cubemap (causes "shadowmap"-like artefacts), DDGI, McGuire

2020

2019

https://developer.download.nvidia.com/video/GDC-19/NSIGHT_GPU_TRACE_Bavoil.pdf (video)

2018

https://anteru.net/blog/2018/intro-to-compute-shaders/index.html

	// these matrices are for left-handed coordinate systems, with depth mapped to [1;0]
	// the derivation for other matrices is analogous

	// to get a perspective matrix with reversed z, simply swap the near and far plane
	glm::mat4 perspectiveFovReverseZLH_ZO(float fov, float width, float height, float zNear, float zFar) {
	return glm::perspectiveFovLH_ZO(fov, width, height, zFar, zNear);
	};

	// now let zFar go towards infinity
	glm::mat4 infinitePerspectiveFovReverseZLH_ZO(float fov, float width, float height, float zNear) {

	struct vec3f {float x, y, z;};
	struct vec4f {float x, y, z, w;};
	struct mat44f {vec4f x, y, z, w;};

	//============================================================================
	// sphere_screen_extents
	//============================================================================
	// Calculates the exact screen extents xyzw=[left, bottom, right, top] in
	// normalized screen coordinates [-1, 1] for a sphere in view space. For
	// performance, the projection matrix (v2p) is assumed to be setup so that

	// cofactor matrix. drop-in replacement for the traditional transpose(inverse(m)) normal matrix calculation.
	// this is a substantial performance improvement.
	// short form found via shadertoy: https://www.shadertoy.com/view/3s33z
	mat3 cofactor(mat4 m) {
	return mat3(
	cross(m[1].xyz, m[2].xyz),
	cross(m[2].xyz, m[0].xyz),
	cross(m[0].xyz, m[1].xyz)
	);
	}

	#pragma once

	#include <limits>
	#include <cassert>
	#include <stdexcept>

	#define MORTON_CODE_MAX_LEVEL 32

	#define UINT8 unsigned char
	#define UINT32 unsigned int