jcrussell/libsst
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
James Russell
2026-04-03 00:22:39 -05:00
commit eca1e8c458
945 changed files with 218160 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
libsst-random/Makefile Normal file
View File

@@ -0,0 +1,44 @@
# libsst-random/Makefile
# Author: Patrick Baggett <ptbaggett@762studios.com>
# Created: 2/26/2012
#
# Purpose:
#
# Makefile for libsst-random
#
# License:
#
# This program is free software. It comes without any warranty, to
# the extent permitted by applicable law. You can redistribute it
# and/or modify it under the terms of the Do What The Fuck You Want
# To Public License, Version 2, as published by Sam Hocevar. See
# http://sam.zoy.org/wtfpl/COPYING for more details.
BINNAME := $(DIST)/libsst-random.a
ifeq ($(TARGET),debug)
BINNAME := $(subst .a,_d.a, $(BINNAME))
endif
SRC := SST_CMWC.c \
SST_Mersenne.c \
SST_SimplexNoise.c \
SST_PRNG.c \
SST_SimplexNoise.c \
SST_SmallPRNG.c
OBJ := $(addprefix obj/$(ARCH)/$(TARGET)/,$(subst .c,.o,$(SRC)) )
$(shell mkdir -p obj/$(ARCH)/$(TARGET))
$(BINNAME): $(OBJ)
$(AR) cru $@ $+
$(RANLIB) $@
# CLEAN
clean:
@-rm -r -f obj $(DIST)/libsst-random*.a
# *.c files to *.o files
obj/$(ARCH)/$(TARGET)/%.o: %.c
@echo CC $@
@$(CC) $(CFLAGS) -c $*.c -o obj/$(ARCH)/$(TARGET)/$*.o

87
libsst-random/RandomFuncTbl.h Normal file
View File

@@ -0,0 +1,87 @@
/*
RandomFuncTbl.h
Author: James Russell <jcrussell@762studios.com>, Patrick Baggett <@762studios.com>
Created: 5/1/2012
Purpose:
Private header for libsst-random function table
License:
This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#pragma once
#ifndef _SST_RANDOMFUNCTBL_H
#define _SST_RANDOMFUNCTBL_H
#include <SST/SST_PRNG.h>
#include <SST/SST_Build.h>
#include <stdlib.h> /* size_t */
/*
The following typedefs are used to set function pointer types.
*/
typedef void (*SST_Random_InitFromSeedFunc)(void*, uint32_t);
typedef void (*SST_Random_GetFloatArrayFunc)(void*, float*, size_t, float, float);
typedef int (*SST_Random_GetIntFunc)(void*);
typedef void (*SST_Random_GetIntArrayFunc)(void*, int*, size_t, int, int);
/*
Struct used to contain the necessary function pointers for a given PRNG.
See SST_PRNG.c for explanation of non-orthogonality.
*/
typedef struct SST_PRNG_FuncTable
{
SST_Random_InitFromSeedFunc initFromSeed;
SST_Random_GetFloatArrayFunc getFloatArray;
SST_Random_GetIntFunc getInt;
SST_Random_GetIntArrayFunc getIntArray;
size_t privateSize;
} SST_PRNG_FuncTable;
#define SST_RAND_FLOATBITS_MAX (0x00FFFFFF)
/* Takes a value in the range of [0, SST_RAND_FLOATBITS_MAX] and converts to float in the range 0.0 to 1.0 */
static INLINE float randIntToFloat(uint32_t value)
{
return (float)value / (float)SST_RAND_FLOATBITS_MAX;
}
/* Take any random integer in [INT_MIN,INT_MAX] and bound it to [min,max] */
static INLINE int boundInt(int x, int min, int max)
{
int diff;
x &= 0x7FFFFFFF; /* Ensure this number is positive. Modulus with negative numbers can be "surprising", e.g. 340 % 60 == 40, but -340 % 60 == 20 */
/* Handle edge cases */
if(min == max)
return min;
if(min > max)
{
int tmp = min;
min = max;
max = tmp;
}
diff = max - min;
return min + (x % diff);
}
extern const SST_PRNG_FuncTable _SST_MersenneFuncTable;
extern const SST_PRNG_FuncTable _SST_CMWCFuncTable;
extern const SST_PRNG_FuncTable _SST_SmallPRNGFuncTable;
#endif

121
libsst-random/SST_CMWC.c Normal file
View File

@@ -0,0 +1,121 @@
/*
SST_CMWC.c
Author: Chris Ertel <crertel@762studios.com>
Created: 2/26/2012
Purpose:
Implementation of complimentary multiply with carry algorithm
License:
This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#include "RandomFuncTbl.h"
/* Do you believe in magic? */
#define PHI 0x9e3779b9
#define CMWC_SIZE 4096
/* CMWC Data Struct */
typedef struct SST_CMWC_Private
{
uint32_t cmwc_buffer[CMWC_SIZE];
uint32_t cmwc_carry;
size_t cmwc_index;
} SST_CMWC_Private;
/*************************************************************************/
static int cmwc_random(SST_CMWC_Private* cmwc)
{
uint64_t t, a = (uint64_t)18782;
uint32_t x, r = 0xfffffffe;
cmwc->cmwc_index = (cmwc->cmwc_index + 1) % CMWC_SIZE;
t = a * cmwc->cmwc_buffer[cmwc->cmwc_index] + cmwc->cmwc_carry;
cmwc->cmwc_carry = (uint32_t)(t >> 32);
x = (uint32_t)(t + cmwc->cmwc_carry);
if (x < cmwc->cmwc_carry)
{
x++;
cmwc->cmwc_carry++;
}
cmwc->cmwc_buffer[cmwc->cmwc_index] = r - x;
return (int)cmwc->cmwc_buffer[cmwc->cmwc_index];
}
/*************************************************************************/
static void CMWC_InitFromSeed(void* priv, uint32_t seed)
{
SST_CMWC_Private* cmwc = (SST_CMWC_Private*)priv;
size_t i;
cmwc->cmwc_index = 4095;
cmwc->cmwc_carry = 362436;
cmwc->cmwc_buffer[0] = seed;
cmwc->cmwc_buffer[1] = seed + PHI;
cmwc->cmwc_buffer[2] = seed + PHI + PHI;
for (i = 3; i < CMWC_SIZE; i++)
cmwc->cmwc_buffer[i] = cmwc->cmwc_buffer[i - 3] ^ cmwc->cmwc_buffer[i - 2] ^ PHI ^ (uint32_t)i;
}
/*************************************************************************/
static void CMWC_GetFloatArray(void* priv, float* _out, size_t _numElements, float _min, float _max)
{
SST_CMWC_Private* cmwc = (SST_CMWC_Private*)priv;
size_t i;
const float diff = _max - _min;
/* compute and return a pseudorandom float in the range */
for ( i = 0; i < _numElements; i++ )
{
_out[i] = _min + randIntToFloat((uint32_t)boundInt(cmwc_random(cmwc), 0, SST_RAND_FLOATBITS_MAX)) * diff; /* x = [0,1]; value = min + x*(max - min) */
}
}
/*************************************************************************/
static int CMWC_GetInt(void* priv)
{
SST_CMWC_Private* cmwc = (SST_CMWC_Private*)priv;
return cmwc_random(cmwc);
}
/*************************************************************************/
static void CMWC_GetIntArray(void* priv, int* _out, size_t _numElements, int _min, int _max)
{
SST_CMWC_Private* cmwc = (SST_CMWC_Private*)priv;
size_t i;
/* grab an number of pseudorandom ints in the specified range */
for(i = 0; i < _numElements; i++)
{
_out[i] = boundInt(cmwc_random(cmwc), _min, _max);
}
}
/*************************************************************************/
/* Function table for CMWC random number generation. */
const SST_PRNG_FuncTable _SST_CMWCFuncTable =
{
CMWC_InitFromSeed,
CMWC_GetFloatArray,
CMWC_GetInt,
CMWC_GetIntArray,
sizeof(SST_CMWC_Private)
};

143
libsst-random/SST_Mersenne.c Normal file
View File

@@ -0,0 +1,143 @@
/*
SST_Mersenne.c
Author: Chris Ertel <crertel@762studios.com>
Created: 2/26/2012
Purpose:
Implementation of Mersenne Twister
License:
This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#include "RandomFuncTbl.h"
/*
Note: This implementation of mersenne twister was originally written by Michael Brundage and has
been placed in the public domain. We modified it somewhat.
*/
/* Length of our mersenne twister buffer */
#define MT_LEN 624
/* Bunch of useful macro functions and magic numbers */
#define MT_IA 397
#define MT_IB (MT_LEN - MT_IA)
#define UPPER_MASK 0x80000000
#define LOWER_MASK 0x7FFFFFFF
#define MATRIX_A 0x9908B0DF
#define SEED_MAGIC 0x6C078965
#define TWIST(b,i,j) ((b)[i] & UPPER_MASK) | ((b)[j] & LOWER_MASK)
#define MAGIC(s) (((s)&1)*MATRIX_A)
/*************************************************************************/
/* Mersenne Twister Data Struct */
typedef struct SST_Mersenne_Private
{
uint32_t mt_buffer[MT_LEN]; /* Buffer for our seed data */
size_t mt_index;
} SST_Mersenne_Private;
/*************************************************************************/
/* get the next random value from the mersenne twister array */
static int mt_random(SST_Mersenne_Private* mt)
{
uint32_t* b = mt->mt_buffer;
size_t idx = mt->mt_index;
uint32_t s;
int i;
if(idx == MT_LEN)
{
idx = 0;
i = 0;
for (; i < MT_IB; i++) {
s = TWIST(b, i, i+1);
b[i] = b[i + MT_IA] ^ (s >> 1) ^ MAGIC(s);
}
for (; i < MT_LEN-1; i++) {
s = TWIST(b, i, i+1);
b[i] = b[i - MT_IB] ^ (s >> 1) ^ MAGIC(s);
}
s = TWIST(b, MT_LEN-1, 0);
b[MT_LEN-1] = b[MT_IA-1] ^ (s >> 1) ^ MAGIC(s);
}
mt->mt_index = idx + 1;
return (int)b[idx];
}
/*************************************************************************/
static void Mersenne_InitFromSeed(void* priv, uint32_t seed)
{
SST_Mersenne_Private* mt_data = (SST_Mersenne_Private*)priv;
size_t i;
mt_data->mt_index = 0;
mt_data->mt_buffer[0] = seed;
/* Initialize the generator */
for(i = 1; i < MT_LEN; i++)
mt_data->mt_buffer[i] = (SEED_MAGIC * (mt_data->mt_buffer[i - 1] ^ (mt_data->mt_buffer[i - 1] >> 30)) + (uint32_t)i);
}
/*************************************************************************/
static void Mersenne_GetFloatArray(void* priv, float* _out, size_t _numElements, float _min, float _max)
{
SST_Mersenne_Private* mt_data = (SST_Mersenne_Private*)priv;
size_t i;
const float diff = _max - _min;
/* grab a number of pseudorandom floating point numbers in the specified range */
for (i = 0; i < _numElements; i++)
{
_out[i] = _min + randIntToFloat((uint32_t)boundInt(mt_random(mt_data), 0, SST_RAND_FLOATBITS_MAX)) * diff; /* x = [0,1]; value = min + x*(max - min) */
}
}
/*************************************************************************/
static int Mersenne_GetInt(void* priv)
{
SST_Mersenne_Private* mt_data = (SST_Mersenne_Private*)priv;
return mt_random(mt_data);
}
/*************************************************************************/
static void Mersenne_GetIntArray(void* priv, int* _out, size_t _numElements, int _min, int _max)
{
SST_Mersenne_Private* mt_data = (SST_Mersenne_Private*)priv;
size_t i;
/* grab an number of pseudorandom ints in the specified range */
for (i = 0; i <_numElements; i++)
_out[i] = boundInt(mt_random(mt_data), _min, _max);
}
/*************************************************************************/
/* Function table for mersenne random number generation. */
const SST_PRNG_FuncTable _SST_MersenneFuncTable =
{
Mersenne_InitFromSeed,
Mersenne_GetFloatArray,
Mersenne_GetInt,
Mersenne_GetIntArray,
sizeof(SST_Mersenne_Private)
};

157
libsst-random/SST_PRNG.c Normal file
View File

@@ -0,0 +1,157 @@
/*
SST_PRNG.c
Author: Patrick Baggett <ptbaggett@762studios.h>
Created: 5/1/2012
Purpose:
PRNG interface functions that call out to implementations as necessary
License:
This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#include "RandomFuncTbl.h"
#include <time.h> /* clock() */
#include <string.h> /* memcpy() */
/*
PRNG instances consist of a function table and associated private data that is implementation-specific.
In order to reduce the number of malloc() calls and points of failure, the private data is not stored as
a pointer but actually grafted onto the instance structure. Thus, the layout in memory is:
[ handle data ][ private data ]
In order to know the required size of the private data, the function table has a 'size_t' member called "privateSize"
that is used. The PRNG_GET_PRIVATE() macro is used to get the address of the private data section given the base handle.
This is what is passed to the implementation-specific functions.
The function tables mimic the API somewhat, but with a few exceptions. First, they don't do any memory allocation, so they
can't fail. Second, they only expose the functions required to implement the API optimally. For example, GetInt() is required, but
it returns the full range, and these functions convert it to the necessary range. GetFloat() does not exist because it can be
done via int -> float conversions; however the GetFloatArray() /is/ because it would require dereferencing a function pointer
(indirect jump) over and over which reduces performance compared to looping in implementation code. Same goes for GetIntArray().
The non-orthogonality may seem odd, but it is minimal and optimal.
*/
/* Macro to get the start of the private data section given a PRNG handle */
#define PRNG_GET_PRIVATE(prng) (void*)(((uintptr_t)prng) + sizeof(SST_PRNGImpl))
/*
This struct contains the data necessary for a created PRNG of any
of the implemented types.
*/
typedef struct SST_PRNGImpl {
const SST_PRNG_FuncTable* vtbl; /* function table for the generator */
} SST_PRNGImpl;
/*************************************************************************/
SST_PRNG SST_Random_CreatePRNG(SST_PRNG_TYPE type)
{
uint32_t seed = (uint32_t)clock();
return (SST_PRNG)SST_Random_CreatePRNGFromSeed(type, seed);
}
/*************************************************************************/
SST_PRNG SST_Random_CreatePRNGFromSeed(SST_PRNG_TYPE type, uint32_t seed)
{
SST_PRNGImpl* instance;
const SST_PRNG_FuncTable* vtbl;
switch(type)
{
case SST_PRNG_MERSENNE: vtbl = &_SST_MersenneFuncTable; break;
case SST_PRNG_CMWC: vtbl = &_SST_CMWCFuncTable; break;
case SST_PRNG_SMALLPRNG: vtbl = &_SST_SmallPRNGFuncTable; break;
/* Unknown */
default: return NULL;
}
/* Allocate instance + private data */
instance = (SST_PRNGImpl*)malloc(sizeof(SST_PRNGImpl) + vtbl->privateSize);
if(instance == NULL)
return NULL;
/* Initialize the instance */
instance->vtbl = vtbl;
vtbl->initFromSeed(PRNG_GET_PRIVATE(instance), seed);
return (SST_PRNG)instance;
}
/*************************************************************************/
SST_PRNG SST_Random_ClonePRNG(SST_PRNG instance)
{
SST_PRNGImpl* prng = (SST_PRNGImpl*)instance;
SST_PRNGImpl* newPrng;
/* Allocate new prng data */
newPrng = (SST_PRNGImpl*)malloc(sizeof(SST_PRNGImpl) + prng->vtbl->privateSize);
if(newPrng == NULL)
return NULL;
/* Copy function table, then private data area */
newPrng->vtbl = prng->vtbl;
memcpy(PRNG_GET_PRIVATE(newPrng), PRNG_GET_PRIVATE(prng), prng->vtbl->privateSize);
return (SST_PRNG)newPrng;
}
/*************************************************************************/
void SST_Random_DestroyPRNG(SST_PRNG instance)
{
free(instance);
}
/*************************************************************************/
float SST_Random_GetPRNGFloat(SST_PRNG instance, float min, float max)
{
int x;
/* Get integer value in the range [0, SST_RAND_FLOATBITS_MAX] */
x = SST_Random_GetPRNGInt(instance, 0, SST_RAND_FLOATBITS_MAX);
/* Convert to float in range [0, 1.0], then scale/bias to [min,max] range */
return randIntToFloat(x) * (max - min) + min; /* This works even if min >= max */
}
/*************************************************************************/
void SST_Random_GetPRNGFloatArray(SST_PRNG instance, float* out, size_t num, float min, float max)
{
SST_PRNGImpl* prng = (SST_PRNGImpl*)instance;
prng->vtbl->getFloatArray(PRNG_GET_PRIVATE(prng), out, num, min, max);
}
/*************************************************************************/
int SST_Random_GetPRNGInt(SST_PRNG instance, int min, int max)
{
SST_PRNGImpl* prng = (SST_PRNGImpl*)instance;
return boundInt(prng->vtbl->getInt(PRNG_GET_PRIVATE(prng)), min, max);
}
/*************************************************************************/
void SST_Random_GetPRNGIntArray(SST_PRNG instance, int* out, size_t num, int min, int max)
{
SST_PRNGImpl* prng = (SST_PRNGImpl*)instance;
prng->vtbl->getIntArray(PRNG_GET_PRIVATE(prng), out, num, min, max);
}

590
libsst-random/SST_SimplexNoise.c Normal file
View File

@@ -0,0 +1,590 @@
#include <SST/SST_SimplexNoise.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <pstdint.h>
#include <string.h> /* memcpy() */
static const int grad3[][3] =
{
{1,1,0}, {-1,1,0}, {1,-1,0}, {-1,-1,0},
{1,0,1}, {-1,0,1}, {1,0,-1}, {-1,0,-1},
{0,1,1}, {0,-1,1}, {0,1,-1}, {0,-1,-1}
};
static const int grad4[][4] =
{
{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}
};
static const int p[] =
{
151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,
225,140,36,103,30,69,142,8,99,37,240,21,10,23,190,6,
148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,
11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,
168, 68,175,74,165,71,134,139,48,27,166,77,146,158,
231,83,111,229,122,60,211,133,230,220,105,92,41,55,
46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,
209,76,132,187,208, 89,18,169,200,196,135,130,116,188,
159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,
123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,
47,16,58,17,182,189,28,42,223,183,170,213,119,248,152,
2,44,154,163, 70,221,153,101,155,167, 43,172,9,129,22,
39,253, 19,98,108,110,79,113,224,232,178,185,112,104,
218,246,97,228,251,34,242,193,238,210,144,12,191,179,
162,241, 81,51,145,235,249,14,239,107,49,192,214,31,
181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,
254, 138,236,205,93,222,114,67,29,24,72,243,141,128,195,
78,66,215,61,156,180
};
/*
A lookup table to traverse the simplex around a given point in 4D.
Details can be found where this table is used, in the 4D noise method.
*/
static const int simplex[][4] =
{
{0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
{0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
{1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
{2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}
};
typedef struct
{
int perm[512];
} SST_Simplex_Data_t;
static int fastfloor(const double x)
{
return (int) floor(x);
}
static double dot2(const int* g, const double x, const double y)
{
return g[0]*x + g[1]*y;
}
static double dot3(const int* g, const double x, const double y, const double z)
{
return g[0]*x + g[1]*y + g[2]*z;
}
static double dot4(const int* g, const double x, const double y, const double z, const double w)
{
return g[0]*x + g[1]*y + g[2]*z + g[3]*w;
}
SST_SimplexNoise SST_Random_CreateSimplexNoise()
{
return SST_Random_CreateSimplexNoiseFromSeed((uint32_t) time(NULL));
}
SST_SimplexNoise SST_Random_CreateSimplexNoiseFromSeed(uint32_t _seed)
{
SST_Simplex_Data_t* ret = (SST_Simplex_Data_t *)calloc(sizeof(SST_Simplex_Data_t), 1);
size_t i;
if (ret == NULL)
return NULL;
for(i = 0; i < 512; i++)
ret->perm[i] = p[i & 255];
SST_Random_ReseedSimplexNoise(ret, _seed);
return (SST_SimplexNoise) ret;
}
void SST_Random_ReseedSimplexNoise(SST_SimplexNoise _source, uint32_t _seed)
{
SST_Simplex_Data_t* temp = (SST_Simplex_Data_t *) _source;
int i;
/* reseeding here currently means shifting around the values */
for(i = 0; i < 512; i++)
temp->perm[i] = p[ ( (i + _seed) % 256) & 255];
}
SST_SimplexNoise SST_Random_CloneSimplexNoise(SST_SimplexNoise _source)
{
SST_Simplex_Data_t* ret;
if (_source == NULL)
return NULL;
ret = (SST_Simplex_Data_t*)calloc(sizeof(SST_Simplex_Data_t), 1);
memcpy(ret,(SST_Simplex_Data_t*)_source, sizeof(SST_Simplex_Data_t));
return (SST_SimplexNoise) ret;
}
void SST_Random_DestroySimplexNoise(SST_SimplexNoise _instance)
{
free(_instance);
}
float SST_Random_MapSimplexNoise1D( SST_SimplexNoise _instance, float _x)
{
/* HACKHACK */
return SST_Random_MapSimplexNoise2D(_instance,_x,0);
}
void SST_Random_MapSimplexNoise1DFromArray( SST_SimplexNoise _instance, float* _destination, float* _sourceX, size_t _numElements)
{
size_t i;
if (_destination == NULL || _sourceX == NULL)
return;
for (i = 0; i < _numElements; i++)
_destination[i] = SST_Random_MapSimplexNoise1D(_instance, _sourceX[i]);
}
float SST_Random_MapSimplexNoise2D( SST_SimplexNoise _instance, float _x, float _y)
{
int* perm;
int i, j;
int i1, j1; /* Offsets for second (middle) corner of simplex in (i,j) coords */
double n0, n1, n2; /* Noise contributions from the three corners */
double s, t,x0,X0,y0,Y0;
double x1,y1,x2,y2;
double t0,t1,t2;
int ii, jj, gi0, gi1, gi2;
/* Skew the input space to determine which simplex cell we're in */
const double F2 = 0.5*(sqrtf(3.0)-1.0);
const double G2 = (3.0-sqrtf(3.0))/6.0;
s = (_x+_y)*F2; // Hairy factor for 2D
i = fastfloor(_x+s);
j = fastfloor(_y+s);
t = (i+j)*G2;
X0 = i-t; /* Unskew the cell origin back to (x,y) space */
Y0 = j-t;
x0 = _x-X0; /* The x,y distances from the cell origin */
y0 = _y-Y0;
/*
For the 2D case, the simplex shape is an equilateral triangle.
Determine which simplex we are in.
*/
perm = ((SST_Simplex_Data_t*)_instance)->perm;
if(x0>y0)
{
i1=1;
j1=0;
} /* lower triangle, XY order: (0,0)->(1,0)->(1,1) */
else
{
i1=0;
j1=1;
} /* upper triangle, YX order: (0,0)->(0,1)->(1,1) */
/*
A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
c = (3-sqrt(3))/6
*/
x1 = x0 - i1 + G2; /* Offsets for middle corner in (x,y) unskewed coords */
y1 = y0 - j1 + G2;
x2 = x0 - 1.0 + 2.0 * G2; /* Offsets for last corner in (x,y) unskewed coords */
y2 = y0 - 1.0 + 2.0 * G2;
/* Work out the hashed gradient indices of the three simplex corners */
ii = i & 255;
jj = j & 255;
gi0 = perm[ii+perm[jj]] % 12;
gi1 = perm[ii+i1+perm[jj+j1]] % 12;
gi2 = perm[ii+1+perm[jj+1]] % 12;
/* Calculate the contribution from the three corners */
t0 = 0.5 - x0*x0-y0*y0;
if(t0<0)
n0 = 0.0;
else
{
t0 *= t0;
n0 = t0 * t0 * dot2(grad3[gi0], x0, y0); /* (x,y) of grad3 used for 2D gradient */
}
t1 = 0.5 - x1*x1-y1*y1;
if(t1<0)
n1 = 0.0;
else
{
t1 *= t1;
n1 = t1 * t1 * dot2(grad3[gi1], x1, y1);
}
t2 = 0.5 - x2*x2-y2*y2;
if (t2<0)
n2 = 0.0;
else
{
t2 *= t2;
n2 = t2 * t2 * dot2(grad3[gi2], x2, y2);
}
/*
Add contributions from each corner to get the final noise value.
The result is scaled to return values in the interval [-1,1].
TODO check accuracy of this
*/
return (float) (70.0 * (n0 + n1 + n2));
}
void SST_Random_MapSimplexNoise2DFromArray( SST_SimplexNoise _instance, float* _destination, float* _sourceX, float* _sourceY, size_t _numElements)
{
size_t i;
if (_destination == NULL || _sourceX == NULL || _sourceY == NULL)
return;
for (i = 0; i < _numElements; i++)
_destination[i] = SST_Random_MapSimplexNoise2D(_instance, _sourceX[i], _sourceY[i]);
}
float SST_Random_MapSimplexNoise3D( SST_SimplexNoise _instance, float _x, float _y, float _z)
{
double n0, n1, n2, n3; /* Noise contributions from the four corners */
/* Skew the input space to determine which simplex cell we're in */
const double F3 = 1.0/3.0;
const double G3 = 1.0/6.0; /* Very nice and simple unskew factor, too */
double s = (_x+_y+_z)*F3; /* Very nice and simple skew factor for 3D */
int i = (int)floor(_x+s);
int j = (int)floor(_y+s);
int k = (int)floor(_z+s);
double t = (i+j+k)*G3;
double X0 = i-t; /* Unskew the cell origin back to (x,y,z) space */
double Y0 = j-t;
double Z0 = k-t;
double x0 = _x-X0; /* The x,y,z distances from the cell origin */
double y0 = _y-Y0;
double z0 = _z-Z0;
double x1,y1,z1,x2,y2,z2,x3,y3,z3;
double t0,t1,t2,t3;
/*
For the 3D case, the simplex shape is a slightly irregular tetrahedron.
Determine which simplex we are in.
*/
int i1, j1, k1; /* Offsets for second corner of simplex in (i,j,k) coords */
int i2, j2, k2; /* Offsets for third corner of simplex in (i,j,k) coords */
int ii,jj,kk,gi0,gi1,gi2,gi3;
int* perm = ((SST_Simplex_Data_t*)_instance)->perm;
if(x0>=y0)
{
if(y0>=z0)
{
i1=1;
j1=0;
k1=0;
i2=1;
j2=1;
k2=0;
} /* X Y Z order */
else if(x0>=z0)
{
i1=1;
j1=0;
k1=0;
i2=1;
j2=0;
k2=1;
} /* X Z Y order */
else
{
i1=0;
j1=0;
k1=1;
i2=1;
j2=0;
k2=1;
} /* Z X Y order */
}
else
{ /* x0<y0 */
if(y0<z0)
{
i1=0;
j1=0;
k1=1;
i2=0;
j2=1;
k2=1;
} /* Z Y X order */
else if(x0<z0)
{
i1=0;
j1=1;
k1=0;
i2=0;
j2=1;
k2=1;
} /* Y Z X order */
else
{
i1=0;
j1=1;
k1=0;
i2=1;
j2=1;
k2=0;
} /* Y X Z order */
}
/*
A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
c = 1/6
*/
x1 = x0 - i1 + G3; /* Offsets for second corner in (x,y,z) coords */
y1 = y0 - j1 + G3;
z1 = z0 - k1 + G3;
x2 = x0 - i2 + 2.0*G3; /* Offsets for third corner in (x,y,z) coords */
y2 = y0 - j2 + 2.0*G3;
z2 = z0 - k2 + 2.0*G3;
x3 = x0 - 1.0 + 3.0*G3; /* Offsets for last corner in (x,y,z) coords */
y3 = y0 - 1.0 + 3.0*G3;
z3 = z0 - 1.0 + 3.0*G3;
/* Work out the hashed gradient indices of the four simplex corners */
ii = i & 255;
jj = j & 255;
kk = k & 255;
gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
/* Calculate the contribution from the four corners */
t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
if(t0<0)
n0 = 0.0;
else
{
t0 *= t0;
n0 = t0 * t0 * dot3(grad3[gi0], x0, y0, z0);
}
t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
if(t1<0) n1 = 0.0;
else
{
t1 *= t1;
n1 = t1 * t1 * dot3(grad3[gi1], x1, y1, z1);
}
t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
if(t2<0)
n2 = 0.0;
else
{
t2 *= t2;
n2 = t2 * t2 * dot3(grad3[gi2], x2, y2, z2);
}
t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
if(t3<0)
n3 = 0.0;
else
{
t3 *= t3;
n3 = t3 * t3 * dot3(grad3[gi3], x3, y3, z3);
}
/*
Add contributions from each corner to get the final noise value.
The result is scaled to stay just inside [-1,1]
*/
return (float)(32.0*(n0 + n1 + n2 + n3));
}
void SST_Random_MapSimplexNoise3DFromArray( SST_SimplexNoise _instance, float* _destination, float* _sourceX, float* _sourceY, float* _sourceZ, size_t _numElements)
{
size_t i;
if (_destination == NULL || _sourceX == NULL || _sourceY == NULL || _sourceZ == NULL)
return;
for (i = 0; i < _numElements; i++)
_destination[i] = SST_Random_MapSimplexNoise3D(_instance, _sourceX[i], _sourceY[i], _sourceZ[i]);
}
float SST_Random_MapSimplexNoise4D( SST_SimplexNoise _instance, float _x, float _y, float _z, float _w)
{
/* The skewing and unskewing factors are hairy again for the 4D case */
const double F4 = (sqrtf(5.0)-1.0)/4.0;
const double G4 = (5.0-sqrtf(5.0))/20.0;
double n0, n1, n2, n3, n4; /* Noise contributions from the five corners */
/* Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in */
double s = (_x + _y + _z + _w) * F4; /* Factor for 4D skewing */
int i = fastfloor(_x + s);
int j = fastfloor(_y + s);
int k = fastfloor(_z + s);
int l = fastfloor(_w + s);
double t = (i + j + k + l) * G4; /* Factor for 4D unskewing */
double X0 = i - t; /* Unskew the cell origin back to (x,y,z,w) space */
double Y0 = j - t;
double Z0 = k - t;
double W0 = l - t;
double x0,x1,x2,x3,x4,y0,y1,y2,y3,y4,z0,z1,z2,z3,z4,w0,w1,w2,w3,w4;
int c,c1,c2,c3,c4,c5,c6;
double t0,t1,t2,t3,t4;
int i1, j1, k1, l1; /* The integer offsets for the second simplex corner */
int i2, j2, k2, l2; /* The integer offsets for the third simplex corner */
int i3, j3, k3, l3; /* The integer offsets for the fourth simplex corner */
int ii,jj,kk,ll,gi0,gi1,gi2,gi3,gi4;
int* perm = ((SST_Simplex_Data_t*)_instance)->perm;
x0 = _x - X0; /* The x,y,z,w distances from the cell origin */
y0 = _y - Y0;
z0 = _z - Z0;
w0 = _w - W0;
/*
For the 4D case, the simplex is a 4D shape I won't even try to describe.
To find out which of the 24 possible simplices we're in, we need to
determine the magnitude ordering of x0, y0, z0 and w0.
The method below is a good way of finding the ordering of x,y,z,w and
then find the correct traversal order for the simplex we<77>re in.
First, six pair-wise comparisons are performed between each possible pair
of the four coordinates, and the results are used to add up binary bits
for an integer index.
*/
c1 = (x0 > y0) ? 32 : 0;
c2 = (x0 > z0) ? 16 : 0;
c3 = (y0 > z0) ? 8 : 0;
c4 = (x0 > w0) ? 4 : 0;
c5 = (y0 > w0) ? 2 : 0;
c6 = (z0 > w0) ? 1 : 0;
c = c1 + c2 + c3 + c4 + c5 + c6;
/*
simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
impossible. Only the 24 indices which have non-zero entries make any sense.
We use a thresholding to set the coordinates in turn from the largest magnitude.
The number 3 in the "simplex" array is at the position of the largest coordinate.
*/
i1 = simplex[c][0]>=3 ? 1 : 0;
j1 = simplex[c][1]>=3 ? 1 : 0;
k1 = simplex[c][2]>=3 ? 1 : 0;
l1 = simplex[c][3]>=3 ? 1 : 0;
/* The number 2 in the "simplex" array is at the second largest coordinate. */
i2 = simplex[c][0]>=2 ? 1 : 0;
j2 = simplex[c][1]>=2 ? 1 : 0;
k2 = simplex[c][2]>=2 ? 1 : 0;
l2 = simplex[c][3]>=2 ? 1 : 0;
/* The number 1 in the "simplex" array is at the second smallest coordinate. */
i3 = simplex[c][0]>=1 ? 1 : 0;
j3 = simplex[c][1]>=1 ? 1 : 0;
k3 = simplex[c][2]>=1 ? 1 : 0;
l3 = simplex[c][3]>=1 ? 1 : 0;
/* The fifth corner has all coordinate offsets = 1, so no need to look that up. */
x1 = x0 - i1 + G4; /* Offsets for second corner in (x,y,z,w) coords */
y1 = y0 - j1 + G4;
z1 = z0 - k1 + G4;
w1 = w0 - l1 + G4;
x2 = x0 - i2 + 2.0*G4; /* Offsets for third corner in (x,y,z,w) coords */
y2 = y0 - j2 + 2.0*G4;
z2 = z0 - k2 + 2.0*G4;
w2 = w0 - l2 + 2.0*G4;
x3 = x0 - i3 + 3.0*G4; /* Offsets for fourth corner in (x,y,z,w) coords */
y3 = y0 - j3 + 3.0*G4;
z3 = z0 - k3 + 3.0*G4;
w3 = w0 - l3 + 3.0*G4;
x4 = x0 - 1.0 + 4.0*G4; /* Offsets for last corner in (x,y,z,w) coords */
y4 = y0 - 1.0 + 4.0*G4;
z4 = z0 - 1.0 + 4.0*G4;
w4 = w0 - 1.0 + 4.0*G4;
/* Work out the hashed gradient indices of the five simplex corners */
ii = i & 255;
jj = j & 255;
kk = k & 255;
ll = l & 255;
gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
/* Calculate the contribution from the five corners */
t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
if(t0<0)
n0 = 0.0;
else
{
t0 *= t0;
n0 = t0 * t0 * dot4(grad4[gi0], x0, y0, z0, w0);
}
t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
if(t1<0)
n1 = 0.0;
else
{
t1 *= t1;
n1 = t1 * t1 * dot4(grad4[gi1], x1, y1, z1, w1);
}
t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
if(t2<0)
n2 = 0.0;
else
{
t2 *= t2;
n2 = t2 * t2 * dot4(grad4[gi2], x2, y2, z2, w2);
}
t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
if(t3<0)
n3 = 0.0;
else
{
t3 *= t3;
n3 = t3 * t3 * dot4(grad4[gi3], x3, y3, z3, w3);
}
t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
if(t4<0)
n4 = 0.0;
else
{
t4 *= t4;
n4 = t4 * t4 * dot4(grad4[gi4], x4, y4, z4, w4);
}
/* Sum up and scale the result to cover the range [-1,1] */
return (float)(27.0 * (n0 + n1 + n2 + n3 + n4));
}
void SST_Random_MapSimplexNoise4DFromArray( SST_SimplexNoise _instance, float* _destination, float* _sourceX, float* _sourceY, float* _sourceZ, float* _sourceW, size_t _numElements)
{
size_t i;
if (_destination == NULL || _sourceX == NULL || _sourceY == NULL || _sourceZ == NULL || _sourceW == NULL)
return;
for (i = 0; i < _numElements; i++)
_destination[i] = SST_Random_MapSimplexNoise4D(_instance, _sourceX[i], _sourceY[i], _sourceZ[i], _sourceW[i]);
}

100
libsst-random/SST_SmallPRNG.c Normal file
View File

@@ -0,0 +1,100 @@
/*
SST_SmallPRNG.c
Author: Chris Ertel <crertel@762studios.com>
Created: 2/26/2012
Purpose:
Implementation of SmallPRNG
License:
This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#include "RandomFuncTbl.h"
#define BIT_ROTATE(x,k) (((x)<<(k))|((x)>>(32-(k))))
/*************************************************************************/
typedef struct SST_SmallPRNG_Private
{
uint32_t a;
uint32_t b;
uint32_t c;
uint32_t d;
} SST_SmallPRNG_Private;
static int sprng_random(SST_SmallPRNG_Private* x)
{
uint32_t e = x->a - BIT_ROTATE(x->b, 27);
x->a = x->b ^ BIT_ROTATE(x->c, 17);
x->b = x->c + x->d;
x->c = x->d + e;
x->d = e + x->a;
return (int)x->d;
}
/*************************************************************************/
static void SmallPRNG_InitFromSeed(void* priv, uint32_t seed)
{
SST_SmallPRNG_Private* sprng = (SST_SmallPRNG_Private*)priv;
int i;
sprng->a = 0xf1ea5eed;
sprng->b = sprng->c = sprng->d = seed;
for(i=0; i<20; ++i)
(void)sprng_random(sprng);
}
/*************************************************************************/
static void SmallPRNG_GetFloatArray(void* priv, float* _out, size_t _numElements, float _min, float _max)
{
SST_SmallPRNG_Private* sprng_data = (SST_SmallPRNG_Private*)priv;
size_t i;
const float diff = _max - _min;
for (i = 0; i < _numElements; i++)
_out[i] = _min + randIntToFloat(boundInt(sprng_random(sprng_data), 0, SST_RAND_FLOATBITS_MAX)) * diff;
}
/*************************************************************************/
static int SmallPRNG_GetInt(void* priv)
{
SST_SmallPRNG_Private* sprng_data = (SST_SmallPRNG_Private*)priv;
return sprng_random(sprng_data);
}
/*************************************************************************/
static void SmallPRNG_GetIntArray(void* priv, int* _out, size_t _numElements, int _min, int _max)
{
SST_SmallPRNG_Private* sprng_data = (SST_SmallPRNG_Private*)priv;
size_t i;
for (i = 0; i < _numElements; i++)
{
_out[i] = boundInt(sprng_random(sprng_data), _min, _max); /* TODO: This does redundant operations. Compilers may not be able to optimize. */
}
}
/*************************************************************************/
/* Function table for SmallPRNG random number generator */
const SST_PRNG_FuncTable _SST_SmallPRNGFuncTable =
{
SmallPRNG_InitFromSeed,
SmallPRNG_GetFloatArray,
SmallPRNG_GetInt,
SmallPRNG_GetIntArray,
sizeof(SST_SmallPRNG_Private)
};

331
libsst-random/libsst-random.vcproj Normal file
View File

@@ -0,0 +1,331 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="libsst-random"
ProjectGUID="{8AA34F81-4045-4613-88B7-6FF58D7E0A7A}"
RootNamespace="libsstrandom"
TargetFrameworkVersion="196613"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)\Lib\x86"
IntermediateDirectory="$(SolutionDir)Intermediate\$(ConfigurationName)\$(PlatformName)\$(ProjectName)"
ConfigurationType="4"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\Lib\Include"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
WarningLevel="4"
WarnAsError="false"
DebugInformationFormat="4"
CompileAs="1"
DisableSpecificWarnings="4996"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)\$(ProjectName)-debug.lib"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)\Lib\x64"
IntermediateDirectory="$(SolutionDir)Intermediate\$(ConfigurationName)\$(PlatformName)\$(ProjectName)"
ConfigurationType="4"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\Lib\Include"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
WarningLevel="4"
WarnAsError="false"
DebugInformationFormat="3"
CompileAs="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)\$(ProjectName)-debug.lib"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)\Lib\x86"
IntermediateDirectory="$(SolutionDir)Intermediate\$(ConfigurationName)\$(PlatformName)\$(ProjectName)"
ConfigurationType="4"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
EnableIntrinsicFunctions="true"
AdditionalIncludeDirectories="..\Lib\Include"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
WarningLevel="4"
WarnAsError="false"
DebugInformationFormat="3"
CompileAs="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)\Lib\x64"
IntermediateDirectory="$(SolutionDir)Intermediate\$(ConfigurationName)\$(PlatformName)\$(ProjectName)"
ConfigurationType="4"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
EnableIntrinsicFunctions="true"
AdditionalIncludeDirectories="..\Lib\Include"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
WarningLevel="4"
WarnAsError="false"
DebugInformationFormat="3"
CompileAs="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\RandomFuncTbl.h"
>
</File>
<File
RelativePath=".\SST_CMWC.c"
>
</File>
<File
RelativePath=".\SST_Mersenne.c"
>
</File>
<File
RelativePath=".\SST_PRNG.c"
>
</File>
<File
RelativePath=".\SST_SimplexNoise.c"
>
</File>
<File
RelativePath=".\SST_SmallPRNG.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\Lib\Include\SST\SST_PRNG.h"
>
</File>
<File
RelativePath="..\Lib\Include\SST\SST_Random.h"
>
</File>
<File
RelativePath="..\Lib\Include\SST\SST_SimplexNoise.h"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

196
libsst-random/libsst-random.vcxproj Normal file
View File

@@ -0,0 +1,196 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{8AA34F81-4045-4613-88B7-6FF58D7E0A7A}</ProjectGuid>
<RootNamespace>libsstrandom</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>11.0.50727.1</_ProjectFileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>$(SolutionDir)\Lib\x86\</OutDir>
<IntDir>$(SolutionDir)Intermediate\$(Configuration)\$(Platform)\$(ProjectName)\</IntDir>
<TargetName>$(ProjectName)-debug</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>$(SolutionDir)\Lib\x64\</OutDir>
<IntDir>$(SolutionDir)Intermediate\$(Configuration)\$(Platform)\$(ProjectName)\</IntDir>
<TargetName>$(ProjectName)-debug</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>$(SolutionDir)\Lib\x86\</OutDir>
<IntDir>$(SolutionDir)Intermediate\$(Configuration)\$(Platform)\$(ProjectName)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>$(SolutionDir)\Lib\x64\</OutDir>
<IntDir>$(SolutionDir)Intermediate\$(Configuration)\$(Platform)\$(ProjectName)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\Lib\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<MinimalRebuild>false</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>false</TreatWarningAsError>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<CompileAs>CompileAsC</CompileAs>
<DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<WholeProgramOptimization>true</WholeProgramOptimization>
<StringPooling>true</StringPooling>
<ExceptionHandling>false</ExceptionHandling>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FunctionLevelLinking>true</FunctionLevelLinking>
<CreateHotpatchableImage>false</CreateHotpatchableImage>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
</ClCompile>
<Lib />
<Lib>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\Lib\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<MinimalRebuild>false</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>false</TreatWarningAsError>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<WholeProgramOptimization>true</WholeProgramOptimization>
<StringPooling>true</StringPooling>
<ExceptionHandling>false</ExceptionHandling>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FunctionLevelLinking>true</FunctionLevelLinking>
<CreateHotpatchableImage>false</CreateHotpatchableImage>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
</ClCompile>
<Lib />
<Lib>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>..\Lib\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>false</TreatWarningAsError>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<StringPooling>true</StringPooling>
<ExceptionHandling>false</ExceptionHandling>
<BufferSecurityCheck>false</BufferSecurityCheck>
<CreateHotpatchableImage>false</CreateHotpatchableImage>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>..\Lib\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>false</TreatWarningAsError>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<StringPooling>true</StringPooling>
<ExceptionHandling>false</ExceptionHandling>
<BufferSecurityCheck>false</BufferSecurityCheck>
<CreateHotpatchableImage>false</CreateHotpatchableImage>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
</ClCompile>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="RandomFuncTbl.h" />
<ClInclude Include="..\Lib\Include\SST\SST_PRNG.h" />
<ClInclude Include="..\Lib\Include\SST\SST_Random.h" />
<ClInclude Include="..\Lib\Include\SST\SST_SimplexNoise.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="SST_CMWC.c" />
<ClCompile Include="SST_Mersenne.c" />
<ClCompile Include="SST_PRNG.c" />
<ClCompile Include="SST_SimplexNoise.c" />
<ClCompile Include="SST_SmallPRNG.c" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

44
libsst-random/libsst-random.vcxproj.filters Normal file
View File

@@ -0,0 +1,44 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="RandomFuncTbl.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="..\Lib\Include\SST\SST_PRNG.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\Lib\Include\SST\SST_Random.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\Lib\Include\SST\SST_SimplexNoise.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="SST_CMWC.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="SST_Mersenne.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="SST_PRNG.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="SST_SimplexNoise.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="SST_SmallPRNG.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
</Project>

BIN
libsst-random/obj/x86-64/release/SST_CMWC.o Normal file
View File

Binary file not shown.

BIN
libsst-random/obj/x86-64/release/SST_Mersenne.o Normal file
View File

Binary file not shown.

BIN
libsst-random/obj/x86-64/release/SST_PRNG.o Normal file
View File

Binary file not shown.

BIN
libsst-random/obj/x86-64/release/SST_SimplexNoise.o Normal file
View File

Binary file not shown.

BIN
libsst-random/obj/x86-64/release/SST_SmallPRNG.o Normal file
View File

Binary file not shown.