Moved Stars45 to StarsEx

1 files changed, 0 insertions, 293 deletions

diff --git a/Stars45/Water.cpp b/Stars45/Water.cpp
deleted file mode 100644
index 5509938..0000000
--- a/Stars45/Water.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/*  Starshatter: The Open Source Project
-    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
-    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
-    Copyright (c) 1997-2006, Destroyer Studios LLC.
-
-    AUTHOR:       John DiCamillo
-
-
-    OVERVIEW
-    ========
-    Water surface effect w/ reflection and caustics
-*/
-
-#include "Water.h"
-#include "Random.h"
-
-// +--------------------------------------------------------------------+
-
-struct WATER_REFRACT
-{
-    // Vrefract = (V + refract * N) * norm
-    float refract;
-    float refractNorm;
-    DWORD diffuse;
-};
-
-struct WATER_SURFACE
-{
-    float height;
-    Vec3  normal;
-};
-
-// +--------------------------------------------------------------------+
-
-#if defined(_X86) && !defined(_WIN64)
-inline int f2i(float flt)
-{
-    volatile int n;
-
-    __asm
-    {
-        fld flt
-        fistp n
-    }
-
-    return n;
-}
-#else
-inline int f2i(float flt)
-{
-    return (int) flt;
-}
-#endif
-
-
-// +--------------------------------------------------------------------+
-
-static WATER_REFRACT RefractionTable[512];
-static bool refractInit = false;
-
-static const int     WAVE_SIZE = 256;
-static const DWORD   WAVE_MASK = 0xff;
-
-// +--------------------------------------------------------------------+
-
-Water::Water()
-:  size(0), depth(0), scaleTex(1), avgHeight(0),
-nVertices(0), surface(0), waves(0)
-{
-}
-
-Water::~Water()
-{
-    delete [] surface;
-    delete [] waves;
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Water::Init(int n, float s, float d)
-{
-    size     = s;
-    depth    = d;
-    scaleTex = 1/size;
-
-    // Calculate number of vertices
-    nVertices = n;
-
-    // Create refraction table
-    if (!refractInit) {
-        WATER_REFRACT* refract = &RefractionTable[256];
-
-        for (UINT u = 0; u < 256; u++) {
-            float fCos0 = (float) u / (float) 256.0f;
-            float f0    = acosf(fCos0);
-            float fSin0 = sinf(f0);
-
-            float fSin1 = fSin0 / 1.333f; // water
-            float f1    = asinf(fSin1);
-            float fCos1 = cosf(f1);
-
-            refract[u].refract = fSin0 / fSin1 * fCos1 - fCos0;
-            refract[u].refractNorm = - fSin1 / fSin0;
-            refract[u].diffuse = ((((0xff - u)*(0xff - u)*(0xff - u)) << 8) & 0xff000000);
-
-            RefractionTable[u] = RefractionTable[256];
-        }
-
-        refractInit = true;
-    }
-
-    // Create maps
-    if (surface)
-    delete [] surface;
-
-    surface = new WATER_SURFACE[n*n];
-    ZeroMemory(surface, n*n * sizeof(WATER_SURFACE));
-
-    if (waves)
-    delete [] waves;
-
-    waves = new float[WAVE_SIZE*4];
-
-    double f = 1.0 / (double) WAVE_SIZE;
-    for (int i = 0; i < WAVE_SIZE; i++) {
-        double s0 = sin(2*PI*i*f);
-        double s1 = sin(4*PI*i*f);
-        double s2 = sin(6*PI*i*f);
-        double s3 = sin(8*PI*i*f);
-
-        waves[0*WAVE_SIZE + i] = (float) (1.8 * s0*s0 - 0.9);
-        waves[1*WAVE_SIZE + i] = (float) (1.6 * s1*s1 - 0.8);
-        waves[2*WAVE_SIZE + i] = (float) (0.4 * s2);
-        waves[3*WAVE_SIZE + i] = (float) (0.8 * s3*s3 - 0.4);
-    }
-
-    for (int i = 0; i < 4; i++) {
-        offsets[i]   = (float) Random(0, WAVE_SIZE);
-    }
-
-    offsets[4] = 12.45f;
-    offsets[5] = 14.23f;
-    offsets[6] = 16.72f;
-    offsets[7] = 20.31f;
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Water::CalcWaves(double seconds)
-{
-    int  i, n[4];
-    UINT SIZE = nVertices;
-    UINT STEP = WAVE_SIZE / (SIZE-1);
-    UINT STEP2 = STEP/2;
-    UINT AREA = SIZE * SIZE;
-    UINT x, y;
-
-    for (i = 0; i < 4; i++) {
-        n[i] = (int) offsets[i];
-    }
-
-    WATER_SURFACE* pSurf = surface;
-
-    // compute heights
-    for (y = 0; y < SIZE; y++) {
-        for (x = 0; x < SIZE; x++) {
-            float h = 0;
-            h += waves[ ((n[0] + x*STEP
-            - y*STEP2) & WAVE_MASK) + 0*WAVE_SIZE ];
-            h += waves[ ((n[1] + x*STEP2
-            + y*STEP)  & WAVE_MASK) + 1*WAVE_SIZE ];
-            h += waves[ ((n[2] + x*STEP)  & WAVE_MASK) + 2*WAVE_SIZE ];
-            h += waves[ ((n[3] + y*STEP)  & WAVE_MASK) + 3*WAVE_SIZE ];
-
-            pSurf->height = h * depth;
-            pSurf++;
-        }
-    }
-
-    // compute normals
-    UINT uXN, uX0, uXP;
-    UINT uYN, uY0, uYP;
-
-    uYP = AREA - SIZE;
-    uY0 = 0;
-    uYN = SIZE;
-
-    for (y = 0; y < SIZE; y++) {
-        uXP = SIZE - 1;
-        uX0 = 0;
-        uXN = 1;
-
-        for (x = 0; x < SIZE; x++) {
-            Vec3  vecN;
-            float f;
-
-            f = surface[uXN + uYN].height - surface[uXP + uYP].height; vecN.x = vecN.z = f;
-            f = surface[uX0 + uYN].height - surface[uX0 + uYP].height; vecN.z += f;
-            f = surface[uXP + uYN].height - surface[uXN + uYP].height; vecN.x -= f; vecN.z += f;
-            f = surface[uXN + uY0].height - surface[uXP + uY0].height; vecN.x += f;
-
-            vecN.y = -15.0f * depth;
-            vecN.Normalize();
-
-            surface[uX0 + uY0].normal = vecN * -1.0f;
-
-            uXP = uX0;
-            uX0 = uXN;
-            uXN = (uXN + 1) % SIZE;
-        }
-
-        uYP = uY0;
-        uY0 = uYN;
-        uYN = (uYN + SIZE) % AREA;
-    }
-
-    // update offsets
-    for (i = 0; i < 4; i++) {
-        offsets[i] += (float) (offsets[i+4] * seconds);
-
-        if (offsets[i] > WAVE_SIZE)
-        offsets[i] -= WAVE_SIZE;
-    }
-
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Water::UpdateSurface(Vec3& eyePos, VertexSet* vset)
-{
-    UINT SIZE = nVertices;
-    UINT AREA = SIZE * SIZE;
-    UINT x, y;
-
-    WATER_SURFACE* pSurf = surface;
-    Vec3*          pLoc  = vset->loc;
-    Vec3*          pNorm = vset->nrm;
-    DWORD*         pDiff = vset->diffuse;
-    float*         pTu   = vset->tu;
-    float*         pTv   = vset->tv;
-
-    float          fInc  = 1.0f / (float) (SIZE-1);
-    float          fx    = 0.0f;
-    float          fz    = 0.0f;
-
-    for (y = 0; y < SIZE; y++) {
-        for (x = 0; x < SIZE; x++) {
-            // update vertex height and normal
-            pLoc->y += pSurf->height;
-            *pNorm  =  pSurf->normal;
-
-            /*
-        // Update texture coords and diffuse based upon refraction
-        Vec3 vec = eyePos - *pLoc;
-        vec.Normalize();
-
-        WATER_REFRACT *pRefract;
-        pRefract = RefractionTable + 256 + f2i(vec.dot(*pNorm) * 255.0f);
-
-        *pDiff = pRefract->diffuse;
-
-        // compute apparent displacement
-        Vec3 vecD = (pSurf->normal * pRefract->refract + vec) * pRefract->refractNorm;
-        Vec3 vecP = *pLoc;
-        vecP.y -= depth;
-
-        // perturb texture coords
-        float fB = vecD * vecP * 2.0f;
-        float fD = fB * fB - depth;
-        float fScale = (-fB + sqrtf(fD)) * 0.5f;
-
-        *pTu = vecD.x * fScale + fx;
-        *pTv = vecD.z * fScale + fz;
-        */
-
-            fx += fInc;
-            pSurf++;
-            pLoc++;
-            pNorm++;
-            pDiff++;
-            pTu++;
-            pTv++;
-        }
-
-        fx =  0.0f;
-        fz += fInc;
-    }
-}
-
-