From 9f0f8a805904eaa27f3eb0f37a88fc83f95c608d Mon Sep 17 00:00:00 2001 From: Anonymous Date: Tue, 14 Jan 2014 10:55:25 -0700 Subject: [PATCH] Added sharedFractal library --- engine/shared/library/CMakeLists.txt | 1 + .../library/sharedFractal/CMakeLists.txt | 11 + .../public/sharedFractal/FirstSharedFractal.h | 1 + .../public/sharedFractal/MultiFractal.h | 1 + .../sharedFractal/MultiFractalReaderWriter.h | 1 + .../library/sharedFractal/src/CMakeLists.txt | 33 + .../src/shared/FirstSharedFractal.h | 20 + .../sharedFractal/src/shared/MultiFractal.cpp | 1105 +++++++++++++++++ .../sharedFractal/src/shared/MultiFractal.h | 332 +++++ .../src/shared/MultiFractalReaderWriter.cpp | 149 +++ .../src/shared/MultiFractalReaderWriter.h | 35 + .../src/win32/FirstSharedFractal.cpp | 8 + 12 files changed, 1697 insertions(+) create mode 100644 engine/shared/library/sharedFractal/CMakeLists.txt create mode 100644 engine/shared/library/sharedFractal/include/public/sharedFractal/FirstSharedFractal.h create mode 100644 engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractal.h create mode 100644 engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractalReaderWriter.h create mode 100644 engine/shared/library/sharedFractal/src/CMakeLists.txt create mode 100644 engine/shared/library/sharedFractal/src/shared/FirstSharedFractal.h create mode 100644 engine/shared/library/sharedFractal/src/shared/MultiFractal.cpp create mode 100644 engine/shared/library/sharedFractal/src/shared/MultiFractal.h create mode 100644 engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.cpp create mode 100644 engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.h create mode 100644 engine/shared/library/sharedFractal/src/win32/FirstSharedFractal.cpp diff --git a/engine/shared/library/CMakeLists.txt b/engine/shared/library/CMakeLists.txt index b4660081..af81f7dc 100644 --- a/engine/shared/library/CMakeLists.txt +++ b/engine/shared/library/CMakeLists.txt @@ -5,6 +5,7 @@ add_subdirectory(sharedDebug) add_subdirectory(sharedFile) add_subdirectory(sharedFoundation) add_subdirectory(sharedFoundationTypes) +add_subdirectory(sharedFractal) add_subdirectory(sharedGame) add_subdirectory(sharedLog) add_subdirectory(sharedMath) diff --git a/engine/shared/library/sharedFractal/CMakeLists.txt b/engine/shared/library/sharedFractal/CMakeLists.txt new file mode 100644 index 00000000..3c6adcee --- /dev/null +++ b/engine/shared/library/sharedFractal/CMakeLists.txt @@ -0,0 +1,11 @@ +cmake_minimum_required(VERSION 2.8) + +project(sharedFractal) + +if(WIN32) + add_definitions(/D_CRT_SECURE_NO_WARNINGS) +endif() + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/public) + +add_subdirectory(src) diff --git a/engine/shared/library/sharedFractal/include/public/sharedFractal/FirstSharedFractal.h b/engine/shared/library/sharedFractal/include/public/sharedFractal/FirstSharedFractal.h new file mode 100644 index 00000000..e118f74e --- /dev/null +++ b/engine/shared/library/sharedFractal/include/public/sharedFractal/FirstSharedFractal.h @@ -0,0 +1 @@ +#include "../../src/shared/FirstSharedFractal.h" diff --git a/engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractal.h b/engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractal.h new file mode 100644 index 00000000..12c9d3b8 --- /dev/null +++ b/engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractal.h @@ -0,0 +1 @@ +#include "../../src/shared/MultiFractal.h" diff --git a/engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractalReaderWriter.h b/engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractalReaderWriter.h new file mode 100644 index 00000000..89862d8b --- /dev/null +++ b/engine/shared/library/sharedFractal/include/public/sharedFractal/MultiFractalReaderWriter.h @@ -0,0 +1 @@ +#include "../../src/shared/MultiFractalReaderWriter.h" diff --git a/engine/shared/library/sharedFractal/src/CMakeLists.txt b/engine/shared/library/sharedFractal/src/CMakeLists.txt new file mode 100644 index 00000000..a535f013 --- /dev/null +++ b/engine/shared/library/sharedFractal/src/CMakeLists.txt @@ -0,0 +1,33 @@ + +set(SHARED_SOURCES + shared/FirstSharedFractal.h + shared/MultiFractal.cpp + shared/MultiFractal.h + shared/MultiFractalReaderWriter.cpp + shared/MultiFractalReaderWriter.h +) + +if(WIN32) + set(PLATFORM_SOURCES + win32/FirstSharedFractal.cpp + ) + + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/win32) +else() + set(PLATFORM_SOURCES "") +endif() + +include_directories( + ${CMAKE_CURRENT_SOURCE_DIR}/shared + ${SWG_ENGINE_SOURCE_DIR}/shared/library/sharedDebug/include/public + ${SWG_ENGINE_SOURCE_DIR}/shared/library/sharedFile/include/public + ${SWG_ENGINE_SOURCE_DIR}/shared/library/sharedFoundation/include/public + ${SWG_ENGINE_SOURCE_DIR}/shared/library/sharedFoundationTypes/include/public + ${SWG_ENGINE_SOURCE_DIR}/shared/library/sharedMemoryManager/include/public + ${SWG_ENGINE_SOURCE_DIR}/shared/library/sharedRandom/include/public +) + +add_library(sharedFractal STATIC + ${SHARED_SOURCES} + ${PLATFORM_SOURCES} +) diff --git a/engine/shared/library/sharedFractal/src/shared/FirstSharedFractal.h b/engine/shared/library/sharedFractal/src/shared/FirstSharedFractal.h new file mode 100644 index 00000000..9775607e --- /dev/null +++ b/engine/shared/library/sharedFractal/src/shared/FirstSharedFractal.h @@ -0,0 +1,20 @@ +// ====================================================================== +// +// FirstFractal.h +// copyright (c) 2001 Sony Online Entertainment +// +// ====================================================================== + +#ifndef INCLUDED_FirstFractal_H +#define INCLUDED_FirstFractal_H + +// ====================================================================== + +#include "sharedFoundation/FirstSharedFoundation.h" +#include "sharedDebug/FirstSharedDebug.h" +#include "sharedMemoryManager/FirstSharedMemoryManager.h" + +// ====================================================================== + +#endif + diff --git a/engine/shared/library/sharedFractal/src/shared/MultiFractal.cpp b/engine/shared/library/sharedFractal/src/shared/MultiFractal.cpp new file mode 100644 index 00000000..aca2d2af --- /dev/null +++ b/engine/shared/library/sharedFractal/src/shared/MultiFractal.cpp @@ -0,0 +1,1105 @@ +// +// MultiFractal.cpp +// asommers +// +// copyright 2001, sony online entertainment +// + +//------------------------------------------------------------------- + +#include "sharedFractal/FirstSharedFractal.h" +#include "sharedFractal/MultiFractal.h" + +#include + +//------------------------------------------------------------------- + +//@todo codereorg +namespace +{ + inline bool FloatsEqual (const float a, const float b) + { + return WithinEpsilonInclusive (a, b, 0.00001f); + } +} + +//------------------------------------------------------------------- +// +// MultiFractal::NoiseGenerator +// +#define PERLIN_floor(t,it) (it - ((t) < 0 && (t) != it)) +#define PERLIN_lerp(t,a,b) (a + t * (b - a)) +#define PERLIN_scurve(t) ((3.0f - (2.0f * t)) * t * t) +#define PERLIN_setup(i,b0,b1,r0,r1) \ + t = i + N; \ + it = static_cast (t); \ + ft = PERLIN_floor (t, it); \ + b0 = ft & BM; \ + b1 = (b0 + 1) & BM; \ + r0 = t - ft; \ + r1 = r0 - 1.f; +#define PERLIN_dot2(rx,ry) (rx * q[0] + ry * q[1]) + +//------------------------------------------------------------------- + +inline void PERLIN_normalize2 (float v[2]) +{ + const float s = static_cast (sqrt (sqr (v[0]) + sqr (v[1]))); + + v[0] /= s; + v[1] /= s; + + DEBUG_FATAL (v [0] < -1 || v [0] > 1, ("")); + DEBUG_FATAL (v [1] < -1 || v [1] > 1, ("")); +} + +//------------------------------------------------------------------- + +MultiFractal::NoiseGenerator::NoiseGenerator (uint32 seed) : + m_random () +{ + init (seed); +} + +//------------------------------------------------------------------- + +MultiFractal::NoiseGenerator::~NoiseGenerator (void) +{ +} + +//------------------------------------------------------------------- + +void MultiFractal::NoiseGenerator::init (uint32 seed) +{ + m_random.setSeed (seed); + + int i, j, k; + + for (i = 0; i < B; i++) + { + m_p [i] = i; + + m_g1[i] = static_cast((m_random.random () % (B + B)) - B) / B; + + for (j = 0; j < 2; j++) + m_g2[i][j] = static_cast((m_random.random () % (B + B)) - B) / B; + + PERLIN_normalize2 (m_g2[i]); + } + + while (--i) + { + k = m_p[i]; + m_p [i] = m_p [j = m_random.random () % B]; + m_p [j] = k; + } + + for (i = 0; i < B + 2; i++) + { + m_p [B + i] = m_p [i]; + m_g1 [B + i] = m_g1[i]; + for (j = 0 ; j < 2 ; j++) + m_g2 [B + i][j] = m_g2 [i][j]; + } +} + +//------------------------------------------------------------------- + +float MultiFractal::NoiseGenerator::getValue (float x) const +{ + int it, ft, bx0, bx1; + float t, rx0, rx1; + + PERLIN_setup (x, bx0, bx1, rx0, rx1); //lint !e514 //-- unusual use of a boolean + + const float sx = PERLIN_scurve(rx0); + const float u = rx0 * m_g1 [m_p [bx0]]; + const float v = rx1 * m_g1 [m_p [bx1]]; + + const float result = PERLIN_lerp (sx, u, v); + DEBUG_FATAL (result < -1.0f || result > 1.0f, ("result < -1.0f || result > 1.0f")); + return result; +} + +//------------------------------------------------------------------- + +float MultiFractal::NoiseGenerator::getValue (float x, float y) const +{ + int it, ft, bx0, bx1, by0, by1; + float t, rx0, rx1, ry0, ry1; + + PERLIN_setup (x, bx0, bx1, rx0, rx1); //lint !e514 //-- unusual use of a boolean + PERLIN_setup (y, by0, by1, ry0, ry1); //lint !e514 //-- unusual use of a boolean + + const float sx = PERLIN_scurve (rx0); + const float sy = PERLIN_scurve (ry0); + + const int b00 = m_p [m_p [bx0] + by0]; + const int b01 = m_p [m_p [bx0] + by1]; + const int b10 = m_p [m_p [bx1] + by0]; + const int b11 = m_p [m_p [bx1] + by1]; + + const float *q; + float u, v; + + q = m_g2 [b00]; + u = PERLIN_dot2 (rx0, ry0); + q = m_g2 [b10]; + v = PERLIN_dot2 (rx1, ry0); + const float a = PERLIN_lerp (sx, u, v); + + q = m_g2 [b01]; + u = PERLIN_dot2 (rx0, ry1); + q = m_g2 [b11]; + v = PERLIN_dot2 (rx1, ry1); + const float b = PERLIN_lerp (sx, u, v); + + const float result = PERLIN_lerp (sy, a, b); + DEBUG_FATAL (result < -1.0f || result > 1.0f, ("result < -1.0f || result > 1.0f")); + + return result; +} + +//------------------------------------------------------------------- +// +// MultiFractal +// +const float MultiFractal::ms_defaultScaleX = 0.01f; +const float MultiFractal::ms_defaultScaleY = 0.01f; +const float MultiFractal::ms_defaultOffsetX = 0.0f; +const float MultiFractal::ms_defaultOffsetY = 0.0f; +const int MultiFractal::ms_defaultNumberOfOctaves = 2; +const float MultiFractal::ms_defaultFrequency = 4.0f; +const float MultiFractal::ms_defaultAmplitude = 0.5f; +const float MultiFractal::ms_defaultBias = 0.5f; +const float MultiFractal::ms_defaultGain = 0.7f; + +#ifdef _DEBUG +int MultiFractal::ms_numberOfMultiFractalGetValueCalls; +int MultiFractal::ms_numberOfMultiFractalGetValueCacheHits; +#endif + +//------------------------------------------------------------------- + +MultiFractal::MultiFractal (void) : + m_seed (0), + m_scaleX (ms_defaultScaleX), + m_scaleY (ms_defaultScaleY), + m_offsetX (ms_defaultOffsetX), + m_offsetY (ms_defaultOffsetY), + m_numberOfOctaves (ms_defaultNumberOfOctaves), + m_frequency (ms_defaultFrequency), + m_amplitude (ms_defaultAmplitude), + m_ooTotalAmplitude (1), + m_useBias (false), + m_bias (ms_defaultBias), + m_useGain (false), + m_gain (ms_defaultGain), + m_useSin (false), + m_combinationRule (CR_add), + m_combinationFunction_1 (0), + m_combinationFunction_2 (0), + m_noiseGenerator (), + m_cacheX (0), + m_cacheY (0), + m_cache (0) +{ + initTotalAmplitude (); + + setCombinationRule (CR_add); + + m_noiseGenerator.init (m_seed); +} + +//------------------------------------------------------------------- + +MultiFractal::~MultiFractal (void) +{ + if (m_cache) + { + delete [] m_cache; + m_cache = 0; + } +} + +//------------------------------------------------------------------- + +MultiFractal::MultiFractal (const MultiFractal& rhs) : + m_seed (0), + m_scaleX (ms_defaultScaleX), + m_scaleY (ms_defaultScaleY), + m_offsetX (ms_defaultOffsetX), + m_offsetY (ms_defaultOffsetY), + m_numberOfOctaves (ms_defaultNumberOfOctaves), + m_frequency (ms_defaultFrequency), + m_amplitude (ms_defaultAmplitude), + m_ooTotalAmplitude (1), + m_useBias (false), + m_bias (ms_defaultBias), + m_useGain (false), + m_gain (ms_defaultGain), + m_useSin (false), + m_combinationRule (CR_add), + m_combinationFunction_1 (0), + m_combinationFunction_2 (0), + m_noiseGenerator (), + m_cacheX (0), + m_cacheY (0), + m_cache (0) +{ + copy (rhs); +} + +//------------------------------------------------------------------- + +MultiFractal& MultiFractal::operator= (const MultiFractal& rhs) +{ + if (this != &rhs) + copy (rhs); + + return *this; +} + +//------------------------------------------------------------------- + +void MultiFractal::copy (const MultiFractal& rhs) +{ + //-- perform shallow copy + m_seed = rhs.m_seed; + m_scaleX = rhs.m_scaleX; + m_scaleY = rhs.m_scaleY; + m_offsetX = rhs.m_offsetX; + m_offsetY = rhs.m_offsetY; + m_numberOfOctaves = rhs.m_numberOfOctaves; + m_frequency = rhs.m_frequency; + m_amplitude = rhs.m_amplitude; + m_ooTotalAmplitude = rhs.m_ooTotalAmplitude; + m_useBias = rhs.m_useBias; + m_bias = rhs.m_bias; + m_useGain = rhs.m_useGain; + m_gain = rhs.m_gain; + m_useSin = rhs.m_useSin; + m_combinationRule = rhs.m_combinationRule; + m_combinationFunction_1 = rhs.m_combinationFunction_1; + m_combinationFunction_2 = rhs.m_combinationFunction_2; + m_noiseGenerator = rhs.m_noiseGenerator; + + //-- reset cache parameters + m_cache = 0; + m_cacheX = 0; + m_cacheY = 0; + + //-- allocate cache (cache will be empty) + allocateCache (rhs.m_cacheX, rhs.m_cacheY); +} + +//------------------------------------------------------------------- + +void MultiFractal::allocateCache (int x, int y) +{ + if (x > m_cacheX || y > m_cacheY) + { + if (m_cache) + { + delete [] m_cache; + m_cache = 0; + } + + if (x != 0 && y != 0) + { + m_cacheX = x; + m_cacheY = y; + m_cache = new CachedNode [static_cast (x * y)]; + + resetCache (); + } + } +} + +//------------------------------------------------------------------- + +void MultiFractal::resetCache () +{ + if (m_cache) + memset (m_cache, 0, static_cast (isizeof (CachedNode) * m_cacheX * m_cacheY)); +} + +//------------------------------------------------------------------- + +void MultiFractal::setSeed (uint32 seed) +{ + if (m_seed != seed) + { + m_seed = seed; + + m_noiseGenerator.init (seed); + + resetCache (); + } +} + +//------------------------------------------------------------------- + +void MultiFractal::setScale (float scaleX, float scaleY) +{ + m_scaleX = scaleX; + m_scaleY = scaleY; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setOffset (float offsetX, float offsetY) +{ + m_offsetX = offsetX; + m_offsetY = offsetY; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setNumberOfOctaves (int numberOfOctaves) +{ + m_numberOfOctaves = numberOfOctaves; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setFrequency (float frequency) +{ + m_frequency = frequency; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setAmplitude (float amplitude) +{ + m_amplitude = amplitude; + + initTotalAmplitude (); + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setBias (bool useBias, float bias) +{ + m_useBias = useBias; + m_bias = bias; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setGain (bool useGain, float gain) +{ + m_useGain = useGain; + m_gain = gain; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setUseSin (bool useSin) +{ + m_useSin = useSin; + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::setCombinationRule (CombinationRule combinationRule) +{ + m_combinationRule = combinationRule; + + switch (m_combinationRule) + { + case CR_add: + case CR_multiply: + m_combinationFunction_1 = getValueAdd_1; + m_combinationFunction_2 = getValueAdd_2; + break; + + case CR_crest: + m_combinationFunction_1 = getValueCrest_1; + m_combinationFunction_2 = getValueCrest_2; + break; + + case CR_turbulence: + m_combinationFunction_1 = getValueTurbulence_1; + m_combinationFunction_2 = getValueTurbulence_2; + break; + + case CR_crestClamp: + m_combinationFunction_1 = getValueCrestClamp_1; + m_combinationFunction_2 = getValueCrestClamp_2; + break; + + case CR_turbulenceClamp: + m_combinationFunction_1 = getValueTurbulenceClamp_1; + m_combinationFunction_2 = getValueTurbulenceClamp_2; + break; + + case CR_COUNT: + default: + DEBUG_FATAL (true, ("invalid combination rule")); + break; + } + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::reset (void) +{ + m_seed = 0; + m_scaleX = ms_defaultScaleX; + m_scaleY = ms_defaultScaleY; + m_offsetX = ms_defaultOffsetX; + m_offsetY = ms_defaultOffsetY; + m_numberOfOctaves = ms_defaultNumberOfOctaves; + m_frequency = ms_defaultFrequency; + m_amplitude = ms_defaultAmplitude; + m_useBias = false; + m_bias = ms_defaultBias; + m_useGain = false; + m_gain = ms_defaultGain; + m_useSin = false; + setCombinationRule (CR_add); + + initTotalAmplitude (); + + resetCache (); +} + +//------------------------------------------------------------------- + +void MultiFractal::initTotalAmplitude (void) +{ + m_ooTotalAmplitude = 0.0f; + + float amplitude = 1.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, amplitude *= m_amplitude) + m_ooTotalAmplitude += amplitude; + + m_ooTotalAmplitude = RECIP (m_ooTotalAmplitude); +} + +//------------------------------------------------------------------- + +//bias (b, 0) =0 +//bias (b, 0.5)=b +//bias (b, 1) =1 +inline float NG_bias (float a, float b) +{ + return powf (a, logf (b) / logf (.5f)); +} + +//------------------------------------------------------------------- + +const float NG_log_0_5f = logf (0.5f); + +//gain (g, t) = if (t < 0.5) then bias (1 - g, 2 * t) else 1 - bias (1 - g,2 - 2 * 2t) / 2 +inline float NG_gain (float a, float b) +{ + if (a < .001) + return 0.; + else if (a > .999) + return 1.; + + float p = logf (1.f - b) / NG_log_0_5f; + + if (a < 0.5f) + return powf (2.f * a, p) * 0.5f; + else + return 1.f - powf (2.f * (1.f - a), p) * 0.5f; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueAdd_1 (const float x, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * multiFractal.m_noiseGenerator.getValue (x * frequency); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return ((sum * multiFractal.m_ooTotalAmplitude) + 1.0f) * 0.5f; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueCrest_1 (const float x, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (1.0f - fabsf (multiFractal.m_noiseGenerator.getValue (x * frequency))); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueTurbulence_1 (const float x, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (fabsf (multiFractal.m_noiseGenerator.getValue (x * frequency))); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueCrestClamp_1 (const float x, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (1.0f - clamp (0.f, multiFractal.m_noiseGenerator.getValue (x * frequency), 1.f)); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueTurbulenceClamp_1 (const float x, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (clamp (0.f, multiFractal.m_noiseGenerator.getValue (x * frequency), 1.f)); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValue (float x) const +{ + DEBUG_FATAL (m_numberOfOctaves == 0, ("m_numberOfOctaves == 0")); + NOT_NULL (m_combinationFunction_1); + + float result = 0.0f; + + x *= m_scaleX; + result = m_combinationFunction_1 (x + m_offsetX, *this); + + DEBUG_FATAL (result < 0.0f || result > 1.0f, ("result < 0.0f || result > 1.0f")); + + if (m_useBias) + result = NG_bias (result, m_bias); + + if (m_useGain) + result = NG_gain (result, m_gain); + + return result; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueAdd_2 (const float x, const float y, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * multiFractal.m_noiseGenerator.getValue (x * frequency, y * frequency); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return ((sum * multiFractal.m_ooTotalAmplitude) + 1.0f) * 0.5f; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueCrest_2 (const float x, const float y, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (1.0f - fabsf (multiFractal.m_noiseGenerator.getValue (x * frequency, y * frequency))); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueTurbulence_2 (const float x, const float y, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (fabsf (multiFractal.m_noiseGenerator.getValue (x * frequency, y * frequency))); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueCrestClamp_2 (const float x, const float y, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (1.0f - clamp (0.f, multiFractal.m_noiseGenerator.getValue (x * frequency, y * frequency), 1.f)); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueTurbulenceClamp_2 (const float x, const float y, const MultiFractal& multiFractal) +{ + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + int i; + for (i = 0; i < multiFractal.m_numberOfOctaves; ++i, frequency *= multiFractal.m_frequency, amplitude *= multiFractal.m_amplitude) + sum += amplitude * static_cast (clamp (0.f, multiFractal.m_noiseGenerator.getValue (x * frequency, y * frequency), 1.f)); + + if (multiFractal.m_useSin) + sum = sinf (x + sum); + + return sum * multiFractal.m_ooTotalAmplitude; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValue2 (float x, float y) const +{ + DEBUG_FATAL (m_numberOfOctaves == 0, ("m_numberOfOctaves == 0")); + NOT_NULL (m_combinationFunction_2); + + float result = 0.0f; + + x *= m_scaleX; + y *= m_scaleY; + result = m_combinationFunction_2 (x + m_offsetX, y + m_offsetY, *this); + + DEBUG_FATAL (result < 0.0f || result > 1.0f, ("result < 0.0f || result > 1.0f")); + + if (m_useBias) + result = NG_bias (result, m_bias); + + if (m_useGain) + result = NG_gain (result, m_gain); + + return result; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueCache2 (float x, float y, int cx, int cy) const +{ + NOT_NULL (m_cache); + +#ifdef _DEBUG + ++ms_numberOfMultiFractalGetValueCalls; +#endif + + VALIDATE_RANGE_INCLUSIVE_EXCLUSIVE (0, cx, m_cacheX); + VALIDATE_RANGE_INCLUSIVE_EXCLUSIVE (0, cy, m_cacheY); + + CachedNode& cachedNode = m_cache [m_cacheX * cy + cx]; + if (cachedNode.cached && FloatsEqual (cachedNode.x, x) && FloatsEqual (cachedNode.y, y)) + { +#ifdef _DEBUG + ++ms_numberOfMultiFractalGetValueCacheHits; +#endif + + return cachedNode.value; + } + + cachedNode.cached = true; + cachedNode.x = x; + cachedNode.y = y; + + DEBUG_FATAL (m_numberOfOctaves == 0, ("m_numberOfOctaves == 0")); + NOT_NULL (m_combinationFunction_2); + + float result = 0.0f; + + x *= m_scaleX; + y *= m_scaleY; + result = m_combinationFunction_2 (x + m_offsetX, y + m_offsetY, *this); + + DEBUG_FATAL (result < 0.0f || result > 1.0f, ("result < 0.0f || result > 1.0f")); + + if (m_useBias) + result = NG_bias (result, m_bias); + + if (m_useGain) + result = NG_gain (result, m_gain); + + cachedNode.value = result; + + return result; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValue (float x, float y) const +{ + DEBUG_FATAL (m_numberOfOctaves == 0, ("m_numberOfOctaves == 0")); + NOT_NULL (m_combinationFunction_2); + + float frequency = 1.0f; + float amplitude = 1.0f; + float result = 0.0f; + + x *= m_scaleX; + y *= m_scaleY; + + switch (m_combinationRule) + { + case CR_add: + case CR_multiply: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency); + + if (m_useSin) + sum = sinf (x + sum); + + result = ((sum * m_ooTotalAmplitude) + 1.0f) * 0.5f; + } + break; + + case CR_crest: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (1.0f - fabsf (m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency))); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_turbulence: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (fabsf (m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency))); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_crestClamp: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (1.0f - clamp (0.f, m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency), 1.f)); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_turbulenceClamp: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (clamp (0.f, m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency), 1.f)); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_COUNT: + default: + DEBUG_FATAL (true, ("invalid combination rule")); + break; + } + + if (m_useBias) + result = NG_bias (result, m_bias); + + if (m_useGain) + result = NG_gain (result, m_gain); + + return result; +} + +//------------------------------------------------------------------- + +float MultiFractal::getValueCache (float x, float y, int cx, int cy) const +{ + NOT_NULL (m_cache); + +#ifdef _DEBUG + ++ms_numberOfMultiFractalGetValueCalls; +#endif + + VALIDATE_RANGE_INCLUSIVE_EXCLUSIVE (0, cx, m_cacheX); + VALIDATE_RANGE_INCLUSIVE_EXCLUSIVE (0, cy, m_cacheY); + + CachedNode& cachedNode = m_cache [m_cacheX * cy + cx]; + if (cachedNode.cached && FloatsEqual (cachedNode.x, x) && FloatsEqual (cachedNode.y, y)) + { +#ifdef _DEBUG + ++ms_numberOfMultiFractalGetValueCacheHits; +#endif + + return cachedNode.value; + } + + cachedNode.cached = true; + cachedNode.x = x; + cachedNode.y = y; + + DEBUG_FATAL (m_numberOfOctaves == 0, ("m_numberOfOctaves == 0")); + NOT_NULL (m_combinationFunction_2); + + float frequency = 1.0f; + float amplitude = 1.0f; + float result = 0.0f; + + x *= m_scaleX; + y *= m_scaleY; + + switch (m_combinationRule) + { + case CR_add: + case CR_multiply: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency); + + if (m_useSin) + sum = sinf (x + sum); + + result = ((sum * m_ooTotalAmplitude) + 1.0f) * 0.5f; + } + break; + + case CR_crest: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (1.0f - fabsf (m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency))); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_turbulence: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (fabsf (m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency))); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_crestClamp: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (1.0f - clamp (0.f, m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency), 1.f)); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_turbulenceClamp: + { + float sum = 0.0f; + + int i; + for (i = 0; i < m_numberOfOctaves; ++i, frequency *= m_frequency, amplitude *= m_amplitude) + sum += amplitude * static_cast (clamp (0.f, m_noiseGenerator.getValue (x * frequency + m_offsetX * frequency, y * frequency + m_offsetY * frequency), 1.f)); + + if (m_useSin) + sum = sinf (x + sum); + + result = sum * m_ooTotalAmplitude; + } + break; + + case CR_COUNT: + default: + DEBUG_FATAL (true, ("invalid combination rule")); + break; + } + + if (m_useBias) + result = NG_bias (result, m_bias); + + if (m_useGain) + result = NG_gain (result, m_gain); + + cachedNode.value = result; + + return result; +} + +//------------------------------------------------------------------- + +bool MultiFractal::operator== (const MultiFractal& rhs) const +{ + const bool seedEqual = m_seed == rhs.m_seed; + if (!seedEqual) + return false; + + const bool scaleEqual = FloatsEqual (m_scaleX, rhs.m_scaleX) && FloatsEqual (m_scaleY, rhs.m_scaleY); + if (!scaleEqual) + return false; + + const bool offsetEqual = FloatsEqual (m_offsetX, rhs.m_offsetX) && FloatsEqual (m_offsetY, rhs.m_offsetY); + if (!offsetEqual) + return false; + + const bool octavesEqual = m_numberOfOctaves == rhs.m_numberOfOctaves; + if (!octavesEqual) + return false; + + const bool frequencyEqual = m_numberOfOctaves == 1 ? true : FloatsEqual (m_frequency, rhs.m_frequency); + if (!frequencyEqual) + return false; + + const bool amplitudeEqual = m_numberOfOctaves == 1 ? true : FloatsEqual (m_amplitude, rhs.m_amplitude); + if (!amplitudeEqual) + return false; + + const bool biasEqual = (m_useBias == rhs.m_useBias) ? (m_useBias ? FloatsEqual (m_bias, rhs.m_bias) : true) : false; + if (!biasEqual) + return false; + + const bool gainEqual = (m_useGain == rhs.m_useGain) ? (m_useGain ? FloatsEqual (m_gain, rhs.m_gain) : true) : false; + if (!gainEqual) + return false; + + const bool combinationRuleEqual = m_combinationRule == rhs.m_combinationRule; + if (!combinationRuleEqual) + return false; + + const bool sinEqual = m_useSin == rhs.m_useSin; + if (!sinEqual) + return false; + + return true; +} + +//------------------------------------------------------------------- + +#ifdef _DEBUG + +void MultiFractal::debugDump () +{ + DEBUG_REPORT_LOG_PRINT (true, ("MultiFractal::getValue calls = %i\n", ms_numberOfMultiFractalGetValueCalls)); + DEBUG_REPORT_LOG_PRINT (true, ("MultiFractal::getValue cache hits = %i\n", ms_numberOfMultiFractalGetValueCacheHits)); +} + +#endif + +//------------------------------------------------------------------- diff --git a/engine/shared/library/sharedFractal/src/shared/MultiFractal.h b/engine/shared/library/sharedFractal/src/shared/MultiFractal.h new file mode 100644 index 00000000..ecc8b208 --- /dev/null +++ b/engine/shared/library/sharedFractal/src/shared/MultiFractal.h @@ -0,0 +1,332 @@ +// +// MultiFractal.h +// asommers +// +// copyright 2001, sony online entertainment +// +//-- +// +// MultiFractal will return values from 0 to 1 + +//------------------------------------------------------------------- + +#ifndef INCLUDED_MultiFractal_H +#define INCLUDED_MultiFractal_H + +//------------------------------------------------------------------- + +#include "sharedRandom/RandomGenerator.h" + +//------------------------------------------------------------------- + +class MultiFractal +{ +public: + + static const float ms_defaultScaleX; + static const float ms_defaultScaleY; + static const float ms_defaultOffsetX; + static const float ms_defaultOffsetY; + static const float ms_defaultBias; + static const float ms_defaultGain; + static const int ms_defaultNumberOfOctaves; + static const float ms_defaultFrequency; + static const float ms_defaultAmplitude; + +public: + +#ifdef _DEBUG + static void debugDump (); +#endif + +public: + + enum CombinationRule + { + CR_add, + CR_multiply, + CR_crest, + CR_turbulence, + CR_crestClamp, + CR_turbulenceClamp, + + CR_COUNT + }; + +public: + + MultiFractal (void); + ~MultiFractal (void); + MultiFractal (const MultiFractal& rhs); + MultiFractal& operator= (const MultiFractal& rhs); + + bool operator== (const MultiFractal& rhs) const; + + void allocateCache (int x, int y); + + //-- + float getValue (float x) const; + float getValue (float x, float y) const; + float getValueCache (float x, float y, int cx, int cy) const; + float getValue2 (float x, float y) const; + float getValueCache2 (float x, float y, int cx, int cy) const; + + //-- parameters + uint32 getSeed (void) const; + void setSeed (uint32 seed); + + float getScaleX (void) const; + float getScaleY (void) const; + void setScale (float x=ms_defaultScaleX, float y=ms_defaultScaleY); + + float getOffsetX (void) const; + float getOffsetY (void) const; + void setOffset (float x=ms_defaultOffsetX, float y=ms_defaultOffsetY); + + //-- number of iterations of the noise + int getNumberOfOctaves (void) const; + void setNumberOfOctaves (int numberOfOctaves=ms_defaultNumberOfOctaves); + + //-- multiplier for the period of each successive octave + float getFrequency (void) const; + void setFrequency (float frequency=ms_defaultFrequency); + + //-- multiplier for the amplitude of each successive octave + float getAmplitude (void) const; + void setAmplitude (float amplitude=ms_defaultAmplitude); + + //-- rule used to combine octaves + CombinationRule getCombinationRule (void) const; + void setCombinationRule (CombinationRule combinationRule); + + //-- modifiers + bool getUseSin (void) const; + void setUseSin (bool newUseSin); + + bool getUseBias (void) const; + float getBias (void) const; + void setBias (bool useBias, float bias); + + bool getUseGain (void) const; + float getGain (void) const; + void setGain (bool useGain, float gain); + + //-- + void reset (void); + +private: + + static float getValueAdd_1 (float x, const MultiFractal& multiFractal); + static float getValueCrest_1 (float x, const MultiFractal& multiFractal); + static float getValueTurbulence_1 (float x, const MultiFractal& multiFractal); + static float getValueCrestClamp_1 (float x, const MultiFractal& multiFractal); + static float getValueTurbulenceClamp_1 (float x, const MultiFractal& multiFractal); + + static float getValueAdd_2 (float x, float y, const MultiFractal& multiFractal); + static float getValueCrest_2 (float x, float y, const MultiFractal& multiFractal); + static float getValueTurbulence_2 (float x, float y, const MultiFractal& multiFractal); + static float getValueCrestClamp_2 (float x, float y, const MultiFractal& multiFractal); + static float getValueTurbulenceClamp_2 (float x, float y, const MultiFractal& multiFractal); + +private: + + void copy (const MultiFractal& rhs); + + void initTotalAmplitude (void); + void resetCache (); + +private: + + typedef float (*CombinationFunction_1) (float x, const MultiFractal& multiFractal); + typedef float (*CombinationFunction_2) (float x, float y, const MultiFractal& multiFractal); + +private: + + //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // The NoiseGenerator algorithm came from Ken Perlin's PERLIN.C. + // it has been c++-ified. NoiseGenerator will return values from -1 to 1 + + class NoiseGenerator + { + public: + + explicit NoiseGenerator (uint32 seed=0); + ~NoiseGenerator (void); + + void init (uint32 seed); + + float getValue (float x) const; + float getValue (float x, float y) const; + + private: + + float realGetValue (float x) const; + float realGetValue (float x, float y) const; + + private: + + enum + { + B = 256, + BM = 255, + N = 4096, + NP = 12, + NM = 4095 + }; + + private: + + RandomGenerator m_random; + + int m_p [B + B + 2]; + float m_g2 [B + B + 2][2]; + float m_g1 [B + B + 2]; + }; + + //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +private: + +#ifdef _DEBUG + static int ms_numberOfMultiFractalGetValueCalls; + static int ms_numberOfMultiFractalGetValueCacheHits; +#endif + +private: + + uint32 m_seed; + float m_scaleX; + float m_scaleY; + float m_offsetX; + float m_offsetY; + int m_numberOfOctaves; + float m_frequency; + float m_amplitude; + float m_ooTotalAmplitude; + bool m_useBias; + float m_bias; + bool m_useGain; + float m_gain; + bool m_useSin; + + CombinationRule m_combinationRule; + CombinationFunction_1 m_combinationFunction_1; + CombinationFunction_2 m_combinationFunction_2; + + NoiseGenerator m_noiseGenerator; + + //-- used to cache generated values + struct CachedNode + { + bool cached; + float x; + float y; + float value; + }; + + int m_cacheX; + int m_cacheY; + mutable CachedNode* m_cache; +}; + +//------------------------------------------------------------------- + +inline uint32 MultiFractal::getSeed (void) const +{ + return m_seed; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getScaleX (void) const +{ + return m_scaleX; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getScaleY (void) const +{ + return m_scaleY; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getOffsetX (void) const +{ + return m_offsetX; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getOffsetY (void) const +{ + return m_offsetY; +} + +//------------------------------------------------------------------- + +inline int MultiFractal::getNumberOfOctaves (void) const +{ + return m_numberOfOctaves; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getFrequency (void) const +{ + return m_frequency; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getAmplitude (void) const +{ + return m_amplitude; +} + +//------------------------------------------------------------------- + +inline bool MultiFractal::getUseBias (void) const +{ + return m_useBias; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getBias (void) const +{ + return m_bias; +} + +//------------------------------------------------------------------- + +inline bool MultiFractal::getUseGain (void) const +{ + return m_useGain; +} + +//------------------------------------------------------------------- + +inline float MultiFractal::getGain (void) const +{ + return m_gain; +} + +//------------------------------------------------------------------- + +inline bool MultiFractal::getUseSin (void) const +{ + return m_useSin; +} + +//------------------------------------------------------------------- + +inline MultiFractal::CombinationRule MultiFractal::getCombinationRule (void) const +{ + return m_combinationRule; +} + +//------------------------------------------------------------------- + +#endif diff --git a/engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.cpp b/engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.cpp new file mode 100644 index 00000000..22ad77a3 --- /dev/null +++ b/engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.cpp @@ -0,0 +1,149 @@ +// +// MultiFractalReaderWriter.cpp +// asommers +// +// copyright 2001, sony online entertainment +// + +//------------------------------------------------------------------- + +#include "sharedFractal/FirstSharedFractal.h" +#include "sharedFractal/MultiFractalReaderWriter.h" + +#include "sharedFile/Iff.h" +#include "sharedFractal/MultiFractal.h" + +//------------------------------------------------------------------- + +void MultiFractalReaderWriter::save (Iff& iff, const MultiFractal& multiFractal) +{ + iff.insertForm (TAG (M,F,R,C)); + + iff.insertForm (TAG_0001); + + iff.insertChunk (TAG_DATA); + + iff.insertChunkData (multiFractal.getSeed ()); + iff.insertChunkData (multiFractal.getUseBias () ? static_cast (1) : static_cast (0)); + iff.insertChunkData (multiFractal.getBias ()); + iff.insertChunkData (multiFractal.getUseGain () ? static_cast (1) : static_cast (0)); + iff.insertChunkData (multiFractal.getGain ()); + iff.insertChunkData (multiFractal.getNumberOfOctaves ()); + iff.insertChunkData (multiFractal.getFrequency ()); + iff.insertChunkData (multiFractal.getAmplitude ()); + iff.insertChunkData (multiFractal.getScaleX ()); + iff.insertChunkData (multiFractal.getScaleY ()); + iff.insertChunkData (multiFractal.getOffsetX ()); + iff.insertChunkData (multiFractal.getOffsetY ()); + iff.insertChunkData (static_cast (multiFractal.getCombinationRule ())); + + iff.exitChunk (); + + iff.exitForm (); + + iff.exitForm (); +} + +//------------------------------------------------------------------- + +void MultiFractalReaderWriter::load (Iff& iff, MultiFractal& multiFractal) +{ + iff.enterForm (TAG (M,F,R,C)); + + switch (iff.getCurrentName ()) + { + case TAG_0000: + load_0000 (iff, multiFractal); + break; + + case TAG_0001: + load_0001 (iff, multiFractal); + break; + + default: + { + char tagBuffer [5]; + ConvertTagToString (iff.getCurrentName (), tagBuffer); + + char buffer [128]; + iff.formatLocation (buffer, sizeof (buffer)); + DEBUG_FATAL (true, ("unknown affector type %s/%s", buffer, tagBuffer)); + } + break; + } + + iff.exitForm (); +} + +//------------------------------------------------------------------- + +void MultiFractalReaderWriter::load_0000 (Iff& iff, MultiFractal& multiFractal) +{ + iff.enterForm (TAG_0000); + + iff.enterChunk (TAG_DATA); + + multiFractal.setSeed (iff.read_uint32 ()); + + const bool useBias = iff.read_int32 () != 0; + const real bias = iff.read_float (); + multiFractal.setBias (useBias, bias); + + const bool useGain = iff.read_int32 () != 0; + const real gain = iff.read_float (); + multiFractal.setGain (useGain, gain); + + multiFractal.setNumberOfOctaves (iff.read_int32 ()); + multiFractal.setFrequency (iff.read_float ()); + multiFractal.setAmplitude (iff.read_float ()); + + const real scaleX = iff.read_float (); + const real scaleY = iff.read_float (); + multiFractal.setScale (scaleX, scaleY); + + multiFractal.setCombinationRule (static_cast (iff.read_int32 ())); + + iff.exitChunk (); + + iff.exitForm (); +} + +//------------------------------------------------------------------- + +void MultiFractalReaderWriter::load_0001 (Iff& iff, MultiFractal& multiFractal) +{ + iff.enterForm (TAG_0001); + + iff.enterChunk (TAG_DATA); + + multiFractal.setSeed (iff.read_uint32 ()); + + const bool useBias = iff.read_int32 () != 0; + const real bias = iff.read_float (); + multiFractal.setBias (useBias, bias); + + const bool useGain = iff.read_int32 () != 0; + const real gain = iff.read_float (); + multiFractal.setGain (useGain, gain); + + multiFractal.setNumberOfOctaves (iff.read_int32 ()); + multiFractal.setFrequency (iff.read_float ()); + multiFractal.setAmplitude (iff.read_float ()); + + const real scaleX = iff.read_float (); + const real scaleY = iff.read_float (); + multiFractal.setScale (scaleX, scaleY); + + const real offsetX = iff.read_float (); + const real offsetY = iff.read_float (); + multiFractal.setOffset (offsetX, offsetY); + + multiFractal.setCombinationRule (static_cast (iff.read_int32 ())); + + iff.exitChunk (); + + iff.exitForm (); +} + +//------------------------------------------------------------------- + diff --git a/engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.h b/engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.h new file mode 100644 index 00000000..92cce361 --- /dev/null +++ b/engine/shared/library/sharedFractal/src/shared/MultiFractalReaderWriter.h @@ -0,0 +1,35 @@ +// +// MultiFractalReaderWriter.h +// asommers +// +// copyright 2001, sony online entertainment +// + +//------------------------------------------------------------------- + +#ifndef INCLUDED_MultiFractalReaderWriter_H +#define INCLUDED_MultiFractalReaderWriter_H + +//------------------------------------------------------------------- + +class Iff; +class MultiFractal; + +//------------------------------------------------------------------- + +class MultiFractalReaderWriter +{ +public: + + static void save (Iff& iff, const MultiFractal& multiFractal); + static void load (Iff& iff, MultiFractal& multiFractal); + +private: + + static void load_0000 (Iff& iff, MultiFractal& multiFractal); + static void load_0001 (Iff& iff, MultiFractal& multiFractal); +}; + +//------------------------------------------------------------------- + +#endif diff --git a/engine/shared/library/sharedFractal/src/win32/FirstSharedFractal.cpp b/engine/shared/library/sharedFractal/src/win32/FirstSharedFractal.cpp new file mode 100644 index 00000000..20d5ff2f --- /dev/null +++ b/engine/shared/library/sharedFractal/src/win32/FirstSharedFractal.cpp @@ -0,0 +1,8 @@ +// ====================================================================== +// +// FirstFractal.cpp +// copyright (c) 2001 Sony Online Entertainment +// +// ====================================================================== + +#include "sharedFractal/FirstSharedFractal.h"