Nick Aversano nickav

This downloads standalone MSVC compiler, linker & other tools, also headers/libraries from Windows SDK into portable folder, without installing Visual Studio. Has bare minimum components - no UWP/Store/WindowsRT stuff, just files & tools for native desktop app development.

Run py.exe portable-msvc.py and it will download output into msvc folder. By default it will download latest available MSVC & Windows SDK from newest Visual Studio.

You can list available versions with py.exe portable-msvc.py --show-versions and then pass versions you want with --msvc-version and --sdk-version arguments.

To use cl.exe/link.exe first run setup_TARGET.bat - after that PATH/INCLUDE/LIB env variables will be updated to use all the tools as usual. You can also use clang-cl.exe with these includes & libraries.

To use clang-cl.exe without running setup.bat, pass extra /winsysroot msvc argument (msvc is folder name where output is stored).

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.

Minimal D3D11 elaborations I

A spin-off from the mainline Minimal D3D11 series, adding two-lane instanced rendering. As before: 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. No modern C++ / OOP / obscuring cruft.

The main difference here is that the hollow cube itself is rendered using instancing (which saves a lot of vertices compared to the original, so geometry data is now small enough to be included in the source without being too much in the way), but also all trigonometry and matrix math is moved to the vertex shader, simplifying the main code (and not needing math.h).

In this case, each instance is mere

A traditional table-based DFA implementation looks like this:

uint8_t table[NUM_STATES][256]

uint8_t run(const uint8_t *start, const uint8_t *end, uint8_t state) {
    for (const uint8_t *s = start; s != end; s++)
        state = table[state][*s];
    return state;
}

A half-hour to learn Zig

This is inspired by https://fasterthanli.me/blog/2020/a-half-hour-to-learn-rust/

Basics

the command zig run my_code.zig will compile and immediately run your Zig program. Each of these cells contains a zig program that you can try to run (some of them contain compile-time errors that you can comment out to play with)

	// =============================================================================
	// XNU kperf/kpc demo
	// Available for 64-bit Intel/Apple Silicon, macOS/iOS, with root privileges
	//
	//
	// Demo 1 (profile a function in current thread):
	// 1. Open directory '/usr/share/kpep/', find your CPU PMC database.
	// M1 (Pro/Max/Ultra): /usr/share/kpep/a14.plist
	// M2 (Pro/Max): /usr/share/kpep/a15.plist
	// M3: /usr/share/kpep/as1.plist

	// Estimating CPU frequency...
	// CPU frequency: 4.52 GHz
	// sum1: value = 15182118497126522709, 0.31 secs, 5.14 cycles/elem
	// sum2: value = 15182118497126522709, 0.17 secs, 2.93 cycles/elem

	#define RW(x) asm("" : "+r"(x))

	typedef struct Node {
	u64 value;
	struct Node *next;

	#define COBJMACROS
	#define NOMINMAX
	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>
	#include <d3d11.h>

	#include <stdint.h>
	#include <string.h>
	#include <intrin.h>

	@echo off
	setlocal enabledelayedexpansion

	rem !!! build requirements !!!
	rem Visual Studio 2022 - https://visualstudio.microsoft.com/vs/
	rem 7-Zip - https://www.7-zip.org/download.html
	rem Python - https://www.python.org/downloads/
	rem CMake - http://www.cmake.org/download/
	rem ninja.exe - https://github.com/ninja-build/ninja/releases/latest

	#pragma once

	namespace YourNamespace
	{
	struct Routine
	{
	// Current "waiting time" before we run the next block
	float wait_for = 0;

	// Used during `rt_for`, which repeats the given block for X time