Luxko DaseinPhaos

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).


	static void gi_on_gpu(u8* in_bitmap, int w, int h) {
	#define num_cascades 7
	static bool initialized;
	static gpu_bindgroup_t texture_bindgroup[2];
	static gpu_bindgroup_t cascade_uniform_bindgroup[num_cascades];
	static gpu_bindgroup_t render_uniform_bindgroup;
	static gpu_buffer_t vertex_buffer;
	static gpu_buffer_t uniform_buffer;
	static gpu_pipeline_t pipeline;

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

	package block_allocator

	// Allocator based on Sebastian Aaltonen's Offset Allocator:
	// https://github.com/sebbbi/OffsetAllocator/blob/main/offsetAllocator.cpp

	import "core:fmt"
	import "core:math/bits"
	import "core:math/rand"

	assert_allocator_layout_good :: proc(allocator: ^Block_Allocator) {

	// D3D12 single-function triangle sample.
	//
	// Usage:
	// - copy SDL2.dll from Odin/vendor/sdl2 to your project directory
	// - odin run .
	//
	// Contributors:
	// - Karl Zylinski <[email protected]> (version 1, version 3)
	// - Jakub Tomšů (version 2)
	//

	// Copyright 2021 Johan Rade ([email protected])
	// Distributed under the MIT license (https://opensource.org/licenses/MIT)

	#ifndef FAST_EXP_H
	#define FAST_EXP_H

	#include <cstdint>
	#include <cstring>

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

	# Here's a probably-not-new data structure I discovered after implementing weight-balanced trees with
	# amortized subtree rebuilds (e.g. http://jeffe.cs.illinois.edu/teaching/algorithms/notes/10-scapegoat-splay.pdf)
	# and realizing it was silly to turn a subtree into a sorted array with an in-order traversal only as an
	# aid in constructing a balanced subtree in linear time. Why not replace the subtree by the sorted array and
	# use binary search when hitting that leaf array? Then you'd defer any splitting of the array until inserts and
	# deletes hit that leaf array. Only in hindsight did I realize this is similar to the rope data structure for strings.
	# Unlike ropes, it's a key-value search tree for arbitrary ordered keys.
	#
	# The main attraction of this data structure is its simplicity (on par with a standard weight-balanced tree) and that it
	# coalesces subtrees into contiguous arrays, which reduces memory overhead and boosts the performance of in-order traversals

	// cl.exe xbox_test.c /link setupapi.lib user32.lib

	#include <windows.h>
	#include <setupapi.h>
	#include <dbt.h>
	#include <stdio.h>

	/// interface

	#define XBOX_MAX_CONTROLLERS 16

	// Copyright 2019 Google LLC.
	// SPDX-License-Identifier: Apache-2.0

	// Polynomial approximation in GLSL for the Turbo colormap
	// Original LUT: https://gist.github.com/mikhailov-work/ee72ba4191942acecc03fe6da94fc73f

	// Authors:
	// Colormap Design: Anton Mikhailov ([email protected])
	// GLSL Approximation: Ruofei Du ([email protected])