path: root/indra/newview/llpatchvertexarray.cpp

/** 
 * @file llpatchvertexarray.cpp
 * @brief Implementation of the LLSurfaceVertexArray class.
 *
 * $LicenseInfo:firstyear=2001&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "llpatchvertexarray.h"
#include "llsurfacepatch.h"

// constructors

LLPatchVertexArray::LLPatchVertexArray() :
	mSurfaceWidth(0),
	mPatchWidth(0),
	mPatchOrder(0),
	mRenderLevelp(NULL),
	mRenderStridep(NULL)
{
}

LLPatchVertexArray::LLPatchVertexArray(U32 surface_width, U32 patch_width, F32 meters_per_grid) :
	mRenderLevelp(NULL),
	mRenderStridep(NULL)
{
	create(surface_width, patch_width, meters_per_grid);
}


LLPatchVertexArray::~LLPatchVertexArray() 
{
	destroy();
}


void LLPatchVertexArray::create(U32 surface_width, U32 patch_width, F32 meters_per_grid) 
{
	// PART 1 -- Make sure the arguments are good...
	// Make sure patch_width is not greater than surface_width
	if (patch_width > surface_width) 
	{
		U32 temp = patch_width;
		patch_width = surface_width;
		surface_width = temp;
	}

	// Make sure (surface_width-1) is equal to a power_of_two.
	// (The -1 is there because an LLSurface has a buffer of 1 on 
	// its East and North edges).
	U32 power_of_two = 1;
	while (power_of_two < (surface_width-1))
	{
		power_of_two *= 2;
	}

	if (power_of_two == (surface_width-1))
	{
		mSurfaceWidth = surface_width;

		// Make sure patch_width is a factor of (surface_width - 1)
		U32 ratio = (surface_width - 1) / patch_width;
		F32 fratio = ((float)(surface_width - 1)) / ((float)(patch_width));
		if ( fratio == (float)(ratio))
		{
			// Make sure patch_width is a power of two
			power_of_two = 1;
			U32 patch_order = 0;
			while (power_of_two < patch_width)
			{
				power_of_two *= 2;
				patch_order += 1;
			}
			if (power_of_two == patch_width)
			{
				mPatchWidth = patch_width;
				mPatchOrder = patch_order;
			}
			else // patch_width is not a power of two...
			{
				mPatchWidth = 0;
				mPatchOrder = 0;
			}
		}
		else // patch_width is not a factor of (surface_width - 1)...
		{
			mPatchWidth = 0;
			mPatchOrder = 0;
		}
	}
	else // surface_width is not a power of two...
	{
		mSurfaceWidth = 0;
		mPatchWidth = 0;
		mPatchOrder = 0;
	}

	// PART 2 -- Allocate memory for the render level table
	if (mPatchWidth > 0) 
	{
		mRenderLevelp = new U32 [2*mPatchWidth + 1];
		mRenderStridep = new U32 [mPatchOrder + 1];
	}

	if (NULL == mRenderLevelp || NULL == mRenderStridep)
	{
		// init() and some other things all want to deref these
		// pointers, so this is serious.
		LL_ERRS() << "mRenderLevelp or mRenderStridep was NULL; we'd crash soon." << LL_ENDL;
		return;
	}

	// Now that we've allocated memory, we can initialize
	// the arrays...
	init();
}


void LLPatchVertexArray::destroy()
{
	if (mPatchWidth == 0)
	{
		return;
	}

	delete [] mRenderLevelp;
	delete [] mRenderStridep;
	mSurfaceWidth = 0;
	mPatchWidth = 0;
	mPatchOrder = 0;
}


void LLPatchVertexArray::init() 
// Initializes the triangle strip arrays.
{
	U32 j;
	U32 level, stride;
	U32 k;

	// We need to build two look-up tables... 

	// render_level -> render_stride 
	// A 16x16 patch has 5 render levels : 2^0 to 2^4
	// render_level		render_stride
	//		4				1
	//		3				2
	//		2				4
	//		1				8
	//		0				16
	stride = mPatchWidth;
	for (level=0; level<mPatchOrder + 1; level++)
	{
		mRenderStridep[level] = stride;
		stride /= 2;
	}

	// render_level <- render_stride.
/*
	// For a 16x16 patch we'll clamp the render_strides to 0 through 16
	// and enter the nearest render_level in the table.  Of course, only
	// power-of-two render strides are actually used. 
	//
	// render_stride	render_level
	//		0				4
	//		1				4	*
	//		2				3	*
	//		3				3
	//		4				2	*
	//		5				2
	//		6				2
	//		7				1
	//		8				1	*
	//		9				1
	//		10				1
	//		11				1
	//		12				1
	//		13				0
	//		14				0
	//		15				0
	//		16				Always 0

	level = mPatchOrder;
	for (stride=0; stride<mPatchWidth; stride++)
	{
		if ((F32) stride > 2.1f * mRenderStridep[level])
		{
			level--;	
		};
		mRenderLevelp[stride] = level;
	}
	*/

	// This method is more agressive about putting triangles onscreen
	level = mPatchOrder;
	k = 2;
	mRenderLevelp[0] = mPatchOrder;
	mRenderLevelp[1] = mPatchOrder;
	stride = 2;
	while(stride < 2*mPatchWidth)
	{
		for (j=0; j<k  &&  stride<2*mPatchWidth; j++)
		{
			mRenderLevelp[stride++] = level;
		}
		k *= 2;
		level--;	
	}
	mRenderLevelp[2*mPatchWidth] = 0;
}


std::ostream& operator<<(std::ostream &s, const LLPatchVertexArray &va)
{
	U32 i;
	s << "{ \n";
	s << "  mSurfaceWidth = " << va.mSurfaceWidth << "\n";
	s << "  mPatchWidth = " << va.mPatchWidth << "\n";
	s << "  mPatchOrder = " << va.mPatchOrder << "\n";
	s << "  mRenderStridep = \n";
	for (i=0; i<va.mPatchOrder+1; i++)
	{
		s << "    " << i << "    " << va.mRenderStridep[i] << "\n";
	}
	s << "  mRenderLevelp = \n";
	for (i=0; i < 2*va.mPatchWidth + 1; i++)
	{
		s << "    " << i << "    " << va.mRenderLevelp[i] << "\n";
	}
	s << "}";	
	return s;
}


// EOF