MehdiNS

Writing a modern rendering engine

Designing a Modern GPU Interface by @BrookeHodgman
Optimizing the Graphics Pipeline with Compute by @gwihlidal
GPU Driven Rendering Pipelines by @SebAaltonen
Destiny’s Multi-threaded Renderer Architecture by @Mirror2Mask
Stingray Renderer Walkthrough by @tobias_persson

In order to effectively use a multi-core CPU, a decomposition of code into tasks must be made. By decomposing code into tasks, the tasks can be distributed among CPU cores by a scheduler. Tasks can have dependencies on other tasks, meaning that the tasks execute in a partial order. This partial order can be represented as a graph, where each task has predecessors and successors. A task can only execute when all its predecessors have completed.

To implement this, we can explicitly create a graph of tasks, with edges between tasks to identify predecessor/successor relationships. The problem with a general task graph system is that it's not productive to work with. Maybe it's okay for some purposes to have a GUI interface to build a task graph, but that's too tedious for everyday code. Imagine if you had to explicitly create nodes and edges when implementing a single-threaded function call graph, it would be so tedious!

https://www.khronos.org/vulkan/
http://renderdoc.org/vulkan-in-30-minutes.html
https://developer.nvidia.com/Vulkan
https://developer.nvidia.com/opengl-vulkan
http://gpuopen.com/say-hello/
https://github.com/SaschaWillems/Vulkan (examples)
https://www.khronos.org/files/vulkan10-reference-guide.pdf
https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html (specs)
http://gpuopen.com/using-the-vulkan-validation-layers/ (using validation layers)
https://github.com/nvpro-pipeline/vkcpp (vkcpp, c++, safe vulkan)

	analytic

	# variables go here...
	# only floats supported right now.
	# [type] [name] [min val] [max val] [default val]

	::begin parameters
	float albedo 0 1 1
	float roughness 0 1 1
	::end parameters

	This turned into a random walk through some linear algebra topics that are near and dear
	to my heart. The initial stimulus was to give my preferred mathematician's explanation of
	why the inverse transpose shows up when transforming normal vectors. I've never seen an
	explanation in the computer graphics literature I found completely satisfactory.

	Notation:

	V -> W is the type of a function from V to W.
	A^t is the transpose of A.
	A^(-1) is the inverse of A.

	#include <stdio.h>

	// #define CLANG_EXTENSION
	// Clang compile with -O3

	#define VS_EXTENSION
	// https://godbolt.org/z/sVWrF4
	// Clang compile with -O3 -fms-compatibility
	// VS2017 compile with /O3

	#pragma once

	#include <limits>
	#define _USE_MATH_DEFINES
	#include <math.h>

	namespace framework {
	namespace math_constexpr {

	int constexpr abs(int x) {

	struct Data
	{
	Data()
	{
	}

	~Data()
	{
	}