doom3-bfg/neo/idlib/geometry/Surface_Patch.cpp

/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#pragma hdrstop
#include "precompiled.h"

/*
=================
idSurface_Patch::SetSize
=================
*/
void idSurface_Patch::SetSize( int patchWidth, int patchHeight )
{
	if( patchWidth < 1 || patchWidth > maxWidth )
	{
		idLib::common->FatalError( "idSurface_Patch::SetSize: invalid patchWidth" );
	}
	if( patchHeight < 1 || patchHeight > maxHeight )
	{
		idLib::common->FatalError( "idSurface_Patch::SetSize: invalid patchHeight" );
	}
	width = patchWidth;
	height = patchHeight;
	verts.SetNum( width * height );
}

/*
=================
idSurface_Patch::PutOnCurve

Expects an expanded patch.
=================
*/
void idSurface_Patch::PutOnCurve()
{
	int i, j;
	idDrawVert prev, next;
	
	assert( expanded == true );
	// put all the approximating points on the curve
	for( i = 0; i < width; i++ )
	{
		for( j = 1; j < height; j += 2 )
		{
			LerpVert( verts[j * maxWidth + i], verts[( j + 1 )*maxWidth + i], prev );
			LerpVert( verts[j * maxWidth + i], verts[( j - 1 )*maxWidth + i], next );
			LerpVert( prev, next, verts[j * maxWidth + i] );
		}
	}
	
	for( j = 0; j < height; j++ )
	{
		for( i = 1; i < width; i += 2 )
		{
			LerpVert( verts[j * maxWidth + i], verts[j * maxWidth + i + 1], prev );
			LerpVert( verts[j * maxWidth + i], verts[j * maxWidth + i - 1], next );
			LerpVert( prev, next, verts[j * maxWidth + i] );
		}
	}
}

/*
================
idSurface_Patch::ProjectPointOntoVector
================
*/
void idSurface_Patch::ProjectPointOntoVector( const idVec3& point, const idVec3& vStart, const idVec3& vEnd, idVec3& vProj )
{
	idVec3 pVec, vec;
	
	pVec = point - vStart;
	vec = vEnd - vStart;
	vec.Normalize();
	// project onto the directional vector for this segment
	vProj = vStart + ( pVec * vec ) * vec;
}

/*
================
idSurface_Patch::RemoveLinearColumnsRows

Expects an expanded patch.
================
*/
void idSurface_Patch::RemoveLinearColumnsRows()
{
	int i, j, k;
	float len, maxLength;
	idVec3 proj, dir;
	
	assert( expanded == true );
	for( j = 1; j < width - 1; j++ )
	{
		maxLength = 0;
		for( i = 0; i < height; i++ )
		{
			idSurface_Patch::ProjectPointOntoVector( verts[i * maxWidth + j].xyz,
					verts[i * maxWidth + j - 1].xyz, verts[i * maxWidth + j + 1].xyz, proj );
			dir = verts[i * maxWidth + j].xyz - proj;
			len = dir.LengthSqr();
			if( len > maxLength )
			{
				maxLength = len;
			}
		}
		if( maxLength < Square( 0.2f ) )
		{
			width--;
			for( i = 0; i < height; i++ )
			{
				for( k = j; k < width; k++ )
				{
					verts[i * maxWidth + k] = verts[i * maxWidth + k + 1];
				}
			}
			j--;
		}
	}
	for( j = 1; j < height - 1; j++ )
	{
		maxLength = 0;
		for( i = 0; i < width; i++ )
		{
			idSurface_Patch::ProjectPointOntoVector( verts[j * maxWidth + i].xyz,
					verts[( j - 1 )*maxWidth + i].xyz, verts[( j + 1 )*maxWidth + i].xyz, proj );
			dir = verts[j * maxWidth + i].xyz - proj;
			len = dir.LengthSqr();
			if( len > maxLength )
			{
				maxLength = len;
			}
		}
		if( maxLength < Square( 0.2f ) )
		{
			height--;
			for( i = 0; i < width; i++ )
			{
				for( k = j; k < height; k++ )
				{
					verts[k * maxWidth + i] = verts[( k + 1 ) * maxWidth + i];
				}
			}
			j--;
		}
	}
}

/*
================
idSurface_Patch::ResizeExpanded
================
*/
void idSurface_Patch::ResizeExpanded( int newHeight, int newWidth )
{
	int i, j;
	
	assert( expanded == true );
	if( newHeight <= maxHeight && newWidth <= maxWidth )
	{
		return;
	}
	if( newHeight * newWidth > maxHeight * maxWidth )
	{
		verts.SetNum( newHeight * newWidth );
	}
	// space out verts for new height and width
	for( j = maxHeight - 1; j >= 0; j-- )
	{
		for( i = maxWidth - 1; i >= 0; i-- )
		{
			verts[j * newWidth + i] = verts[j * maxWidth + i];
		}
	}
	maxHeight = newHeight;
	maxWidth = newWidth;
}

/*
================
idSurface_Patch::Collapse
================
*/
void idSurface_Patch::Collapse()
{
	int i, j;
	
	if( !expanded )
	{
		idLib::common->FatalError( "idSurface_Patch::Collapse: patch not expanded" );
	}
	expanded = false;
	if( width != maxWidth )
	{
		for( j = 0; j < height; j++ )
		{
			for( i = 0; i < width; i++ )
			{
				verts[j * width + i] = verts[j * maxWidth + i];
			}
		}
	}
	verts.SetNum( width * height );
}

/*
================
idSurface_Patch::Expand
================
*/
void idSurface_Patch::Expand()
{
	int i, j;
	
	if( expanded )
	{
		idLib::common->FatalError( "idSurface_Patch::Expand: patch alread expanded" );
	}
	expanded = true;
	verts.SetNum( maxWidth * maxHeight );
	if( width != maxWidth )
	{
		for( j = height - 1; j >= 0; j-- )
		{
			for( i = width - 1; i >= 0; i-- )
			{
				verts[j * maxWidth + i] = verts[j * width + i];
			}
		}
	}
}

/*
============
idSurface_Patch::LerpVert
============
*/
void idSurface_Patch::LerpVert( const idDrawVert& a, const idDrawVert& b, idDrawVert& out ) const
{
	out.xyz[0] = 0.5f * ( a.xyz[0] + b.xyz[0] );
	out.xyz[1] = 0.5f * ( a.xyz[1] + b.xyz[1] );
	out.xyz[2] = 0.5f * ( a.xyz[2] + b.xyz[2] );
	out.SetNormal( ( a.GetNormal() + b.GetNormal() ) * 0.5f );
	out.SetTexCoord( ( a.GetTexCoord() + b.GetTexCoord() ) * 0.5f );
}

/*
=================
idSurface_Patch::GenerateNormals

Handles all the complicated wrapping and degenerate cases
Expects a Not expanded patch.
=================
*/
#define	COPLANAR_EPSILON	0.1f

void idSurface_Patch::GenerateNormals()
{
	int			i, j, k, dist;
	idVec3		norm;
	idVec3		sum;
	int			count;
	idVec3		base;
	idVec3		delta;
	int			x, y;
	idVec3		around[8], temp;
	bool		good[8];
	bool		wrapWidth, wrapHeight;
	static int	neighbors[8][2] =
	{
		{0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, { -1, -1}, { -1, 0}, { -1, 1}
	};
	
	assert( expanded == false );
	
	//
	// if all points are coplanar, set all normals to that plane
	//
	idVec3		extent[3];
	float		offset;
	
	extent[0] = verts[width - 1].xyz - verts[0].xyz;
	extent[1] = verts[( height - 1 ) * width + width - 1].xyz - verts[0].xyz;
	extent[2] = verts[( height - 1 ) * width].xyz - verts[0].xyz;
	
	norm = extent[0].Cross( extent[1] );
	if( norm.LengthSqr() == 0.0f )
	{
		norm = extent[0].Cross( extent[2] );
		if( norm.LengthSqr() == 0.0f )
		{
			norm = extent[1].Cross( extent[2] );
		}
	}
	
	// wrapped patched may not get a valid normal here
	if( norm.Normalize() != 0.0f )
	{
	
		offset = verts[0].xyz * norm;
		for( i = 1; i < width * height; i++ )
		{
			float d = verts[i].xyz * norm;
			if( idMath::Fabs( d - offset ) > COPLANAR_EPSILON )
			{
				break;
			}
		}
		
		if( i == width * height )
		{
			// all are coplanar
			for( i = 0; i < width * height; i++ )
			{
				verts[i].SetNormal( norm );
			}
			return;
		}
	}
	
	// check for wrapped edge cases, which should smooth across themselves
	wrapWidth = false;
	for( i = 0; i < height; i++ )
	{
		delta = verts[i * width].xyz - verts[i * width + width - 1].xyz;
		if( delta.LengthSqr() > Square( 1.0f ) )
		{
			break;
		}
	}
	if( i == height )
	{
		wrapWidth = true;
	}
	
	wrapHeight = false;
	for( i = 0; i < width; i++ )
	{
		delta = verts[i].xyz - verts[( height - 1 ) * width + i].xyz;
		if( delta.LengthSqr() > Square( 1.0f ) )
		{
			break;
		}
	}
	if( i == width )
	{
		wrapHeight = true;
	}
	
	for( i = 0; i < width; i++ )
	{
		for( j = 0; j < height; j++ )
		{
			count = 0;
			base = verts[j * width + i].xyz;
			for( k = 0; k < 8; k++ )
			{
				around[k] = vec3_origin;
				good[k] = false;
				
				for( dist = 1; dist <= 3; dist++ )
				{
					x = i + neighbors[k][0] * dist;
					y = j + neighbors[k][1] * dist;
					if( wrapWidth )
					{
						if( x < 0 )
						{
							x = width - 1 + x;
						}
						else if( x >= width )
						{
							x = 1 + x - width;
						}
					}
					if( wrapHeight )
					{
						if( y < 0 )
						{
							y = height - 1 + y;
						}
						else if( y >= height )
						{
							y = 1 + y - height;
						}
					}
					
					if( x < 0 || x >= width || y < 0 || y >= height )
					{
						break;					// edge of patch
					}
					temp = verts[y * width + x].xyz - base;
					if( temp.Normalize() == 0.0f )
					{
						continue;				// degenerate edge, get more dist
					}
					else
					{
						good[k] = true;
						around[k] = temp;
						break;					// good edge
					}
				}
			}
			
			sum = vec3_origin;
			for( k = 0; k < 8; k++ )
			{
				if( !good[k] || !good[( k + 1 ) & 7] )
				{
					continue;	// didn't get two points
				}
				norm = around[( k + 1 ) & 7].Cross( around[k] );
				if( norm.Normalize() == 0.0f )
				{
					continue;
				}
				sum += norm;
				count++;
			}
			if( count == 0 )
			{
				//idLib::common->Printf("bad normal\n");
				count = 1;
			}
			sum.Normalize();
			verts[j * width + i].SetNormal( sum );
		}
	}
}

/*
=================
idSurface_Patch::GenerateIndexes
=================
*/
void idSurface_Patch::GenerateIndexes()
{
	int i, j, v1, v2, v3, v4, index;
	
	indexes.SetNum( ( width - 1 ) * ( height - 1 ) * 2 * 3 );
	index = 0;
	for( i = 0; i < width - 1; i++ )
	{
		for( j = 0; j < height - 1; j++ )
		{
			v1 = j * width + i;
			v2 = v1 + 1;
			v3 = v1 + width + 1;
			v4 = v1 + width;
			indexes[index++] = v1;
			indexes[index++] = v3;
			indexes[index++] = v2;
			indexes[index++] = v1;
			indexes[index++] = v4;
			indexes[index++] = v3;
		}
	}
	
	GenerateEdgeIndexes();
}

/*
===============
idSurface_Patch::SampleSinglePatchPoint
===============
*/
void idSurface_Patch::SampleSinglePatchPoint( const idDrawVert ctrl[3][3], float u, float v, idDrawVert* out ) const
{
	float	vCtrl[3][8];
	int		vPoint;
	int		axis;
	
	// find the control points for the v coordinate
	for( vPoint = 0; vPoint < 3; vPoint++ )
	{
		for( axis = 0; axis < 8; axis++ )
		{
			float a, b, c;
			float qA, qB, qC;
			if( axis < 3 )
			{
				a = ctrl[0][vPoint].xyz[axis];
				b = ctrl[1][vPoint].xyz[axis];
				c = ctrl[2][vPoint].xyz[axis];
			}
			else if( axis < 6 )
			{
				a = ctrl[0][vPoint].GetNormal()[axis - 3];
				b = ctrl[1][vPoint].GetNormal()[axis - 3];
				c = ctrl[2][vPoint].GetNormal()[axis - 3];
			}
			else
			{
				a = ctrl[0][vPoint].GetTexCoord()[axis - 6];
				b = ctrl[1][vPoint].GetTexCoord()[axis - 6];
				c = ctrl[2][vPoint].GetTexCoord()[axis - 6];
			}
			qA = a - 2.0f * b + c;
			qB = 2.0f * b - 2.0f * a;
			qC = a;
			vCtrl[vPoint][axis] = qA * u * u + qB * u + qC;
		}
	}
	
	// interpolate the v value
	for( axis = 0; axis < 8; axis++ )
	{
		float a, b, c;
		float qA, qB, qC;
		
		a = vCtrl[0][axis];
		b = vCtrl[1][axis];
		c = vCtrl[2][axis];
		qA = a - 2.0f * b + c;
		qB = 2.0f * b - 2.0f * a;
		qC = a;
		
		if( axis < 3 )
		{
			out->xyz[axis] = qA * v * v + qB * v + qC;
		}
		else if( axis < 6 )
		{
			idVec3 tempNormal = out->GetNormal();
			tempNormal[axis - 3] = qA * v * v + qB * v + qC;
			out->SetNormal( tempNormal );
			//out->normal[axis-3] = qA * v * v + qB * v + qC;
		}
		else
		{
			idVec2 tempST = out->GetTexCoord();
			tempST[axis - 6] = qA * v * v + qB * v + qC;
			out->SetTexCoord( tempST );
		}
	}
}

/*
===================
idSurface_Patch::SampleSinglePatch
===================
*/
void idSurface_Patch::SampleSinglePatch( const idDrawVert ctrl[3][3], int baseCol, int baseRow, int width, int horzSub, int vertSub, idDrawVert* outVerts ) const
{
	int		i, j;
	float	u, v;
	
	horzSub++;
	vertSub++;
	for( i = 0; i < horzSub; i++ )
	{
		for( j = 0; j < vertSub; j++ )
		{
			u = ( float ) i / ( horzSub - 1 );
			v = ( float ) j / ( vertSub - 1 );
			SampleSinglePatchPoint( ctrl, u, v, &outVerts[( ( baseRow + j ) * width ) + i + baseCol] );
		}
	}
}

/*
=================
idSurface_Patch::SubdivideExplicit
=================
*/
void idSurface_Patch::SubdivideExplicit( int horzSubdivisions, int vertSubdivisions, bool genNormals, bool removeLinear )
{
	int i, j, k, l;
	idDrawVert sample[3][3];
	int outWidth = ( ( width - 1 ) / 2 * horzSubdivisions ) + 1;
	int outHeight = ( ( height - 1 ) / 2 * vertSubdivisions ) + 1;
	idDrawVert* dv = new( TAG_IDLIB_SURFACE ) idDrawVert[ outWidth * outHeight ];
	
	// generate normals for the control mesh
	if( genNormals )
	{
		GenerateNormals();
	}
	
	int baseCol = 0;
	for( i = 0; i + 2 < width; i += 2 )
	{
		int baseRow = 0;
		for( j = 0; j + 2 < height; j += 2 )
		{
			for( k = 0; k < 3; k++ )
			{
				for( l = 0; l < 3; l++ )
				{
					sample[k][l] = verts[( ( j + l ) * width ) + i + k ];
				}
			}
			SampleSinglePatch( sample, baseCol, baseRow, outWidth, horzSubdivisions, vertSubdivisions, dv );
			baseRow += vertSubdivisions;
		}
		baseCol += horzSubdivisions;
	}
	verts.SetNum( outWidth * outHeight );
	for( i = 0; i < outWidth * outHeight; i++ )
	{
		verts[i] = dv[i];
	}
	
	delete[] dv;
	
	width = maxWidth = outWidth;
	height = maxHeight = outHeight;
	expanded = false;
	
	if( removeLinear )
	{
		Expand();
		RemoveLinearColumnsRows();
		Collapse();
	}
	
	// normalize all the lerped normals
	if( genNormals )
	{
		idVec3 tempNormal;
		for( i = 0; i < width * height; i++ )
		{
			tempNormal = verts[i].GetNormal();
			tempNormal.Normalize();
			verts[i].SetNormal( tempNormal );
		}
	}
	
	GenerateIndexes();
}

/*
=================
idSurface_Patch::Subdivide
=================
*/
void idSurface_Patch::Subdivide( float maxHorizontalError, float maxVerticalError, float maxLength, bool genNormals )
{
	int			i, j, k, l;
	idDrawVert	prev, next, mid;
	idVec3		prevxyz, nextxyz, midxyz;
	idVec3		delta;
	float		maxHorizontalErrorSqr, maxVerticalErrorSqr, maxLengthSqr;
	
	// generate normals for the control mesh
	if( genNormals )
	{
		GenerateNormals();
	}
	
	maxHorizontalErrorSqr = Square( maxHorizontalError );
	maxVerticalErrorSqr = Square( maxVerticalError );
	maxLengthSqr = Square( maxLength );
	
	Expand();
	
	// horizontal subdivisions
	for( j = 0; j + 2 < width; j += 2 )
	{
		// check subdivided midpoints against control points
		for( i = 0; i < height; i++ )
		{
			for( l = 0; l < 3; l++ )
			{
				prevxyz[l] = verts[i * maxWidth + j + 1].xyz[l] - verts[i * maxWidth + j  ].xyz[l];
				nextxyz[l] = verts[i * maxWidth + j + 2].xyz[l] - verts[i * maxWidth + j + 1].xyz[l];
				midxyz[l] = ( verts[i * maxWidth + j  ].xyz[l] + verts[i * maxWidth + j + 1].xyz[l] * 2.0f +
							  verts[i * maxWidth + j + 2].xyz[l] ) * 0.25f;
			}
			
			if( maxLength > 0.0f )
			{
				// if the span length is too long, force a subdivision
				if( prevxyz.LengthSqr() > maxLengthSqr || nextxyz.LengthSqr() > maxLengthSqr )
				{
					break;
				}
			}
			// see if this midpoint is off far enough to subdivide
			delta = verts[i * maxWidth + j + 1].xyz - midxyz;
			if( delta.LengthSqr() > maxHorizontalErrorSqr )
			{
				break;
			}
		}
		
		if( i == height )
		{
			continue;	// didn't need subdivision
		}
		
		if( width + 2 >= maxWidth )
		{
			ResizeExpanded( maxHeight, maxWidth + 4 );
		}
		
		// insert two columns and replace the peak
		width += 2;
		
		for( i = 0; i < height; i++ )
		{
			idSurface_Patch::LerpVert( verts[i * maxWidth + j  ], verts[i * maxWidth + j + 1], prev );
			idSurface_Patch::LerpVert( verts[i * maxWidth + j + 1], verts[i * maxWidth + j + 2], next );
			idSurface_Patch::LerpVert( prev, next, mid );
			
			for( k = width - 1; k > j + 3; k-- )
			{
				verts[i * maxWidth + k] = verts[i * maxWidth + k - 2];
			}
			verts[i * maxWidth + j + 1] = prev;
			verts[i * maxWidth + j + 2] = mid;
			verts[i * maxWidth + j + 3] = next;
		}
		
		// back up and recheck this set again, it may need more subdivision
		j -= 2;
	}
	
	// vertical subdivisions
	for( j = 0; j + 2 < height; j += 2 )
	{
		// check subdivided midpoints against control points
		for( i = 0; i < width; i++ )
		{
			for( l = 0; l < 3; l++ )
			{
				prevxyz[l] = verts[( j + 1 ) * maxWidth + i].xyz[l] - verts[j * maxWidth + i].xyz[l];
				nextxyz[l] = verts[( j + 2 ) * maxWidth + i].xyz[l] - verts[( j + 1 ) * maxWidth + i].xyz[l];
				midxyz[l] = ( verts[j * maxWidth + i].xyz[l] + verts[( j + 1 ) * maxWidth + i].xyz[l] * 2.0f +
							  verts[( j + 2 ) * maxWidth + i].xyz[l] ) * 0.25f;
			}
			
			if( maxLength > 0.0f )
			{
				// if the span length is too long, force a subdivision
				if( prevxyz.LengthSqr() > maxLengthSqr || nextxyz.LengthSqr() > maxLengthSqr )
				{
					break;
				}
			}
			// see if this midpoint is off far enough to subdivide
			delta = verts[( j + 1 ) * maxWidth + i].xyz - midxyz;
			if( delta.LengthSqr() > maxVerticalErrorSqr )
			{
				break;
			}
		}
		
		if( i == width )
		{
			continue;	// didn't need subdivision
		}
		
		if( height + 2 >= maxHeight )
		{
			ResizeExpanded( maxHeight + 4, maxWidth );
		}
		
		// insert two columns and replace the peak
		height += 2;
		
		for( i = 0; i < width; i++ )
		{
			LerpVert( verts[j * maxWidth + i], verts[( j + 1 )*maxWidth + i], prev );
			LerpVert( verts[( j + 1 )*maxWidth + i], verts[( j + 2 )*maxWidth + i], next );
			LerpVert( prev, next, mid );
			
			for( k = height - 1; k > j + 3; k-- )
			{
				verts[k * maxWidth + i] = verts[( k - 2 ) * maxWidth + i];
			}
			verts[( j + 1 )*maxWidth + i] = prev;
			verts[( j + 2 )*maxWidth + i] = mid;
			verts[( j + 3 )*maxWidth + i] = next;
		}
		
		// back up and recheck this set again, it may need more subdivision
		j -= 2;
	}
	
	PutOnCurve();
	
	RemoveLinearColumnsRows();
	
	Collapse();
	
	// normalize all the lerped normals
	if( genNormals )
	{
		idVec3 tempNormal;
		for( i = 0; i < width * height; i++ )
		{
			tempNormal = verts[i].GetNormal();
			tempNormal.Normalize();
			verts[i].SetNormal( tempNormal );
		}
	}
	
	GenerateIndexes();
}