path: root/nGenEx/Water.cpp

/*  Project nGenEx
	Destroyer Studios LLC
	Copyright © 1997-2006. All Rights Reserved.

	SUBSYSTEM:    nGen.lib
	FILE:         Water.cpp
	AUTHOR:       John DiCamillo


	OVERVIEW
	========
	Water surface effect w/ reflection and caustics
*/

#include "MemDebug.h"
#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(__FILE__,__LINE__) WATER_SURFACE[n*n];
	ZeroMemory(surface, n*n * sizeof(WATER_SURFACE));

	if (waves)
	delete [] waves;

	waves = new(__FILE__,__LINE__) 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;
	}
}