paultag

/*
 * "Throb" effect ( Part Deux )
 *
 * Paul Tagliamonte, 2010. ( Peace, Love and C++, baby )
 *
 *  This code is released under the Bacon license.
 *  If you like this code enough, consider sending me bacon.
 *
 *  That or GPL-3+. 
 *

bert

Some possible implementations of the Bresenham Algorithms in C.

The Bresenham line algorithm is an algorithm which determines which points in an
n-dimensional raster should be plotted in order to form a close approximation
to a straight line between two given points.
It is commonly used to draw lines on a computer screen, as it uses only integer
addition, subtraction and bit shifting, all of which are very cheap operations
in standard computer architectures.
It is one of the earliest algorithms developed in the field of computer graphics.
A minor extension to the original algorithm also deals with drawing circles.

p01

            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                    Version 2, December 2004

 Copyright (C) 2011 Mathieu 'p01' Henri - http://www.p01.org/releases/

 Everyone is permitted to copy and distribute verbatim or modified
 copies of this license document, and changing it is allowed as long
 as the name is changed.

            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE

rygorous

// float->half variants.
// by Fabian "ryg" Giesen.
//
// I hereby place this code in the public domain, as per the terms of the
// CC0 license:
//
//   https://creativecommons.org/publicdomain/zero/1.0/
//
// float_to_half_full: This is basically the ISPC stdlib code, except
// I preserve the sign of NaNs (any good reason not to?)

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

preshing

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef unsigned int u32;
typedef unsigned long long u64;

//-------------------------------------------------------------------------
// WorkArea
//-------------------------------------------------------------------------

rygorous

#include <immintrin.h>
#include <intrin.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

union Mat44 {
    float m[4][4];
    __m128 row[4];
};

transitive-bullshit

// total number of samples at each fragment
#define NUM_SAMPLES           {{ numSamples }}

#define NUM_SPIRAL_TURNS      {{ numSpiralTurns }}

#define USE_ACTUAL_NORMALS    {{ useActualNormals }}

#define VARIATION             {{ variation }}

uniform sampler2D sGBuffer;

vl4dimir

public Vector3 VectorAt(float x, float y, float z) {
	if (x < 0f) x = Mathf.Abs(x);
	if (y < 0f) y = Mathf.Abs(y);
	if (z < 0f) z = Mathf.Abs(z);

	int floorX = Mathf.FloorToInt(x);
	float tx = x - floorX;
	floorX %= Dimension;
	int ceilX = Mathf.CeilToInt(x) % Dimension;

ForNeVeR

#define WIN32_LEAN_AND_MEAN  // just say no to MFC

#define INIT_GUID

#include "hge.h"
#include <hgesprite.h>
#include <hgefont.h>
#include <hgecolor.h>