tcantenot

// -*- 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:
//

tcantenot

// Store tile values (w/ border) in shared memory:
//  - first compute and store the "border" values (by a subset of the threads of the block)
//  - then compute the "center" values (the one corresponding to each thread that will be used afterwards).
//
// "Center" values: o
// "Border" values: c, h, v
//
// The "borders" values are classified in 3 groups:
//  - The first tile row + the left border of the 2nd row (range end: r0)
//  - The left and right borders values + the border and the last row (range end: r1)

tcantenot

Minimal D3D11

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

tcantenot

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

tcantenot

uint32_t NextPow2(uint32_t v)
{
    v--;
    v |= (v >> 1);
    v |= (v >> 2);
    v |= (v >> 4);
    v |= (v >> 8);
    v |= (v >> 16);
    v++;

tcantenot

#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;

tcantenot

Shader "Unlit/MatCap Techniques"
{
    Properties
    {
        [NoScaleOffset] _MatCap ("MatCap", 2D) = "white" {}
        [KeywordEnum(ViewSpaceNormal, ViewDirectionCross, ViewDirectionAligned)] _MatCapType ("Matcap UV Type", Float) = 2
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

tcantenot

import os
import bpy
import sys
import typing
import inspect
import pkgutil
import importlib
from pathlib import Path

__all__ = (

tcantenot

// 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"

tcantenot

Core Coding Standard

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.

Table Of Contents

• Why we need Coding Standards
• Context is Important
• Stylistic Standards

• Namespaces