Minimal D3D11 reference implementation: An uncluttered Direct3D 11 setup & basic rendering primer / API familiarizer. Complete, runnable Windows application contained in a single function and laid out in a linear, step-by-step fashion that should be easy to follow from the code alone. ~215 LOC. No modern C++ / OOP / obscuring cruft. View on YouTube
// -*- compile-command: "nvcc -m 32 -arch sm_50 -Xptxas=-v,-abi=no -cubin lop3.cu"; -*- | |
#define KERNEL_QUALIFIERS extern "C" __global__ | |
// | |
// Bit hack: "Conditionally set or clear bits without branching" | |
// http://graphics.stanford.edu/~seander/bithacks.html#ConditionalSetOrClearBitsWithoutBranching | |
// | |
// This bit hack *should* map to a single LOP3.LUT opcode: | |
// |
Buffer<uint> Input; | |
RWBuffer<uint> Output; | |
//returns the index that this value should be moved to to sort the array | |
uint CuteSort(uint value, uint laneIndex) | |
{ | |
uint smallerValuesMask = 0; | |
uint equalValuesMask = ~0; | |
//don't need to test every bit if your value is constrained to a smaller range |
uint32_t NextPow2(uint32_t v) | |
{ | |
v--; | |
v |= (v >> 1); | |
v |= (v >> 2); | |
v |= (v >> 4); | |
v |= (v >> 8); | |
v |= (v >> 16); | |
v++; |
#pragma use_dxc //enable SM 6.0 features, in Unity this is only supported on version 2020.2.0a8 or later with D3D12 enabled | |
#pragma kernel CountTotalsInBlock | |
#pragma kernel BlockCountPostfixSum | |
#pragma kernel CalculateOffsetsForEachKey | |
#pragma kernel FinalSort | |
uint _FirstBitToSort; | |
int _NumElements; | |
int _NumBlocks; | |
bool _ShouldSortPayload; |
Shader "Unlit/MatCap Techniques" | |
{ | |
Properties | |
{ | |
[NoScaleOffset] _MatCap ("MatCap", 2D) = "white" {} | |
[KeywordEnum(ViewSpaceNormal, ViewDirectionCross, ViewDirectionAligned)] _MatCapType ("Matcap UV Type", Float) = 2 | |
} | |
SubShader | |
{ | |
Tags { "RenderType"="Opaque" } |
import os | |
import bpy | |
import sys | |
import typing | |
import inspect | |
import pkgutil | |
import importlib | |
from pathlib import Path | |
__all__ = ( |
// 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" |
Coding practices are a source of a lot of arguments among programmers. Coding standards, to some degree, help us to put certain questions to bed and resolve stylistic debates. No coding standard makes everyone happy. (And even their existence is sure to make some unhappy.) What follows are the standards we put together on the Core team, which have become the general coding standard for all programming teams on new code development. We’ve tried to balance the need for creating a common, recognizable and readable code base with not unduly burdening the programmer with minor code formatting concerns.
From time to time I receive questions on the depth aware upsampling mentioned in the INSIDE-rendering presentation: https://loopit.dk/rendering_inside.pdf#page=39
The goal of this technique is to take the texture-output from a half-resolution pass, containing the results of sampling volumetric fog - and scale it up to full resolution. This presents two challenges:
- Making sure samples from the low-resolution buffer, do not spill on top of foreground objects in the high-resolution buffer
- Making sure the samples in the volumetric fog can be properly accumulated by TAA after upsampling