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