CWE-ou-minkata/Sources/Plasma/PubUtilLib/plGeometry/hsOscillator.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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.

This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "hsStream.h"
#include "hsOscillator.h"
#include "../plMath/hsFastMath.h"
#include "hsGTriMesh.h"
#include "hsTriangle3.h"
#include "../plPipeline/plPipeline.h"

#if defined(__MWERKS__) && !defined(HS_DEBUGGING)
#pragma optimization_level 0
#endif

static hsScalar rnd0_1()
{
    return hsScalar(rand()) / hsScalar(RAND_MAX);
}

void hsWave::Save(hsStream* s, hsScalar secs)
{
    fWorldCenter.Write(s);
    
    s->WriteSwapScalar(fWorldFrequency);

    s->WriteSwapScalar(fWorldAmplitude);

    s->WriteSwapScalar(fPhase);
    s->WriteSwapScalar(fRate);

    s->WriteSwapScalar(secs - fStartSecs);

    s->WriteSwapScalar(fSecsToLive);
}

void hsWave::Load(hsStream* s, hsScalar secs)
{
    fWorldCenter.Read(s);
    
    fWorldFrequency = s->ReadSwapScalar();

    fWorldAmplitude = s->ReadSwapScalar();

    fPhase = s->ReadSwapScalar();
    fRate = s->ReadSwapScalar();

    fStartSecs = s->ReadSwapScalar();
    fStartSecs = secs - fStartSecs;

    fSecsToLive = s->ReadSwapScalar();
}

void hsWave::Init(hsScalar secs, hsPoint3& center, hsScalar per, hsScalar amp, hsScalar rate, hsScalar life, hsBool32 attenOut)
{
    fStartSecs = secs;
    fWorldCenter = center;
    fWorldFrequency = hsScalarInvert(per);
    fWorldAmplitude = amp;
    fRate = rate;
    fSecsToLive = life;
    AttenuateOut(attenOut);
}

hsBool32 hsWave::IsSpent(hsScalar secs) const
{ 
    return secs - fStartSecs > fSecsToLive;
}

void hsWave::Accumulate(const hsPoint3& pos, const hsVector3& localZ, hsVector3& accum, hsVector3& accumNorm) const
{
    hsVector3 del(&pos, &fLocalCenter);
    hsScalar dot = del.InnerProduct(localZ);
    dot *= -2.f;
    del += localZ * dot;

    hsScalar dist = del.MagnitudeSquared();
    dist = hsFastMath::InvSqrtAppr(dist);
    del *= dist;
    dist = hsScalarInvert(dist);

    hsScalar ampl = fLocalAmplitude;
    if( fAttenuateOutScale > 0 )
    {
        if( dist > fInnerRadius )
        {
            if( dist > fOuterRadius )
                return;
            ampl *= fOuterRadius - dist;
            ampl *= fAttenuateOutScale;
        }
    }

    dist *= fLocalFrequency;
    dist += fPhase;

    hsScalar s, c;
    hsFastMath::SinCosAppr(dist, s, c);

    s *= ampl;
    s += ampl;
    c *= ampl * fLocalFrequency;

//  accum += s * localZ;
    accum.fZ += s / localZ.fZ;

    hsVector3 norm;
    norm = localZ;
    norm += del * -c;
    accumNorm += norm;

    return;
}

void hsWave::Update(hsScalar secs, const hsMatrix44& l2w, const hsMatrix44& w2l)
{
    if( l2w.fFlags & hsMatrix44::kIsIdent )
    {
        fLocalCenter = fWorldCenter;
        fLocalFrequency = fWorldFrequency;
        fLocalAmplitude = fWorldAmplitude;
    }
    else
    {
        hsVector3 ax;
        ax.Set(w2l.fMap[0][2], w2l.fMap[1][2], w2l.fMap[2][2]);
        hsScalar ooScale = ax.MagnitudeSquared();
        ooScale = hsFastMath::InvSqrtAppr(ooScale);

        fLocalCenter = w2l * fWorldCenter;
        fLocalFrequency = fWorldFrequency * ooScale;
        
        hsScalar scale = 1.f / ooScale;
        fLocalAmplitude = fWorldAmplitude * scale;
    }
    fLocalAmplitude *= AgeScale(secs);

    if( fAttenuateOutScale > 0 )
    {
        fInnerRadius = fRate * (secs - fStartSecs) * hsScalarPI * 2.f;
        fOuterRadius = fInnerRadius * (5.f/4.f);
        fAttenuateOutScale = hsScalarInvert(fOuterRadius - fInnerRadius);
    }

    fPhase = -(secs - fStartSecs) * fRate * hsScalarPI * 2.f;
}

hsScalar hsWave::ScaledAmplitude(hsScalar secs) const
{
    return fWorldAmplitude * AgeScale(secs);
}

hsScalar hsWave::AgeScale(hsScalar secs) const
{
    hsScalar age = secs - fStartSecs;
    extern int dbgCurrentTest;
    if( dbgCurrentTest )
    {
        age *= 4.f;
        age -= 2.f * fSecsToLive;
        if( age < 0 )
            age = -age;
        age -= fSecsToLive;
    }
    else
    {
        age *= 2.f;
        age -= fSecsToLive;
        if( age < 0 )
            age = -age;
    }
    hsScalar ageScale = 1.f - age / fSecsToLive;
    if( ageScale < 0 )
        ageScale = 0;
    else if( ageScale > 1.f )
        ageScale = 1.f;
    return ageScale;
}

hsOscillator::hsOscillator()
{
}

hsOscillator::~hsOscillator()
{
}

hsWave& hsOscillator::GetWeakestWave(hsScalar secs)
{
    hsAssert(!GetDisabled(), "Shouldn't be messing with disabled oscillator system");
    int weakest = 0;
    hsScalar amp = fWaves[0].ScaledAmplitude(secs);
    int i;
    for( i = 0; i < fWaves.GetCount(); i++ )
    {
        hsScalar tAmp = fWaves[i].ScaledAmplitude(secs);
        if( tAmp < amp )
        {
            weakest = i;
            amp = tAmp;
        }
    }
    return fWaves[weakest];
}

hsWave& hsOscillator::GetTempWave(hsScalar secs)
{
    int i;
    for( i = 0; i < fTempWaves.GetCount(); i++ )
    {
        if( fTempWaves[i].IsSpent(secs) )
            return fTempWaves[i];
    }
    fTempWaves.Push();
    return fTempWaves[fTempWaves.GetCount()-1];
}

void hsOscillator::ISpawnWave(hsScalar secs, int i)
{
    hsPoint3 corner;
    fWorldCenterBounds.GetCorner(&corner);
    hsVector3 ax[3];
    fWorldCenterBounds.GetAxes(ax+0, ax+1, ax+2);
    hsScalar r;
    r = rnd0_1();
    ax[0] *= r;
    corner += ax[0];
    r = rnd0_1();
    ax[1] *= r;
    corner += ax[1];
    r = rnd0_1();
    ax[2] *= r;
    corner += ax[2];

    hsScalar per = fMinPeriod;
    r = rnd0_1();
    hsScalar rr = r;
    r *= fMaxPeriod - fMinPeriod;
    per += r;

    hsScalar amp = fMinAmplitude;
    r = rr * rnd0_1();
    r *= fMaxAmplitude - fMinAmplitude;
    amp += r;

    hsScalar life = fMinLife;
    r = rnd0_1();
    r *= fMaxLife - fMinLife;
    life += r;

    hsScalar rate = fMinRate;
    r = rnd0_1();
    r *= fMaxRate - fMinRate;
    rate += r;

    fWaves[i].Init(secs, corner, per, amp, rate, life);

}

void hsOscillator::IUpdate(hsScalar secs, plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l)
{
    if( GetDisabled() )
        return;

    fWorldCenter = pipe->GetViewPositionWorld();
    fWorldCenter.fZ = (fWorldCenterBounds.GetMins().fZ + fWorldCenterBounds.GetMaxs().fZ) * 0.5f;
    fLocalCenter = w2l * fWorldCenter;

    fLocalToWorld = l2w;
    fWorldToLocal = w2l;

    fLocalX.Set(w2l.fMap[0][0],w2l.fMap[1][0],w2l.fMap[2][0]);
    fLocalX.Normalize();
    fLocalY.Set(w2l.fMap[0][1],w2l.fMap[1][1],w2l.fMap[2][1]);
    fLocalY.Normalize();
    fLocalZ.Set(w2l.fMap[0][2],w2l.fMap[1][2],w2l.fMap[2][2]);
    fLocalZ.Normalize();

    hsVector3 ax;
    hsScalar ooScale;
    ax.Set(w2l.fMap[0][0], w2l.fMap[1][0], w2l.fMap[2][0]);
    ooScale = ax.MagnitudeSquared();
    ooScale = hsFastMath::InvSqrtAppr(ooScale);
    fLocalAttenScale.fX = fWorldAttenScale.fX * ooScale;

    ax.Set(w2l.fMap[0][1], w2l.fMap[1][1], w2l.fMap[2][1]);
    ooScale = ax.MagnitudeSquared();
    ooScale = hsFastMath::InvSqrtAppr(ooScale);
    fLocalAttenScale.fY = fWorldAttenScale.fY * ooScale;

    fLocalAttenScale.fZ = 0;

    int i;
    for( i = 0; i < fWaves.GetCount(); i++ )
    {
        if( fWaves[i].IsSpent(secs) )
            ISpawnWave(secs, i);
        fWaves[i].Update(secs, l2w, w2l);
    }
    for( i = 0; i < fTempWaves.GetCount(); i++ )
    {
        while( (i < fTempWaves.GetCount()) && fTempWaves[i].IsSpent(secs) )
            fTempWaves.Remove(i, 1);
        if( i < fTempWaves.GetCount() )
            fTempWaves[i].Update(secs, l2w, w2l);
    }
}

hsScalar hsOscillator::IAttenuate(const hsPoint3& in) const 
{
    const hsPoint3& cen = fLocalCenter;
    hsVector3 del(&in, &cen);

    hsScalar atX = del.InnerProduct(fLocalX);
    atX *= fLocalAttenScale.fX;
    if( atX > 0 )
        atX = -atX;
    atX += 1.f;
    if( atX < 0 )
        atX = 0;

    hsScalar atY = del.InnerProduct(fLocalY);
    atY *= fLocalAttenScale.fY;
    if( atY > 0 )
        atY = -atY;
    atY += 1.f;
    if( atY < 0 )
        atY = 0;

    hsScalar at = atX * atY;
    return at;
}

void hsOscillator::AdjustWorldBounds(const hsMatrix44& l2w, const hsMatrix44& w2l, hsBounds3Ext& bnd) const
{
    if( GetDisabled() )
        return;

    hsVector3 adj;
    adj.Set(0,1.f/fLocalZ.fZ,0);
    adj = l2w * adj;
    adj *= fMaxAmplitude * fWaves.GetCount();

    bnd.Union(&adj);
    adj = -adj;
    bnd.Union(&adj);
}

void hsOscillator::IPerterb(const hsPoint3& in, hsGVertex3& out) const
{
    hsPoint3 pos = in;
    hsVector3 del(&pos, &fLocalCenter);
    hsScalar dot = del.InnerProduct(fLocalZ);
    pos += fLocalZ * -dot;

    hsVector3 accum;
    hsVector3 accumNorm;
    accum.Set(0,0,0);
    accumNorm.Set(0,0,0);
    int i;
    for( i = 0; i < fWaves.GetCount(); i++ )
    {
        fWaves[i].Accumulate(pos, fLocalZ, accum, accumNorm);
    }
    for( i = 0; i < fTempWaves.GetCount(); i++ )
    {
        fTempWaves[i].Accumulate(pos, fLocalZ, accum, accumNorm);
    }
    hsScalar atten = IAttenuate(pos);
    static int attenuating = 1;
    if( attenuating ) // nuke me
        accum *= atten;
    out.fLocalPos = in + accum;

    hsScalar invNorm = hsFastMath::InvSqrtAppr(accumNorm.MagnitudeSquared());
    accumNorm *= invNorm;
    out.fNormal = accumNorm;
}

void hsOscillator::Read(hsStream* s)
{
    int n = s->ReadSwap32();
    SetNumWaves(n);

    fWorldAttenScale.Read(s);
    fWorldCenterBounds.Read(s);

    fMinPeriod = s->ReadSwapScalar();
    fMaxPeriod = s->ReadSwapScalar();

    fMinAmplitude = s->ReadSwapScalar();
    fMaxAmplitude = s->ReadSwapScalar();

    fMinRate = s->ReadSwapScalar();
    fMaxRate = s->ReadSwapScalar();

    fMinLife = s->ReadSwapScalar();
    fMaxLife = s->ReadSwapScalar();

    int i;
    for( i = 0; i < fWaves.GetCount(); i++ )
        fWaves[i].Kill();

    fTempWaves.Reset();
}

void hsOscillator::Load(hsStream* s, hsScalar secs)
{
    Read(s);

    int i;
    for( i = 0; i < fWaves.GetCount(); i++ )
        fWaves[i].Load(s, secs);

    fTempWaves.Reset();
}

void hsOscillator::Write(hsStream* s)
{
    s->WriteSwap32(fWaves.GetCount());

    fWorldAttenScale.Write(s);
    fWorldCenterBounds.Write(s);

    s->WriteSwapScalar(fMinPeriod);
    s->WriteSwapScalar(fMaxPeriod);

    s->WriteSwapScalar(fMinAmplitude);
    s->WriteSwapScalar(fMaxAmplitude);

    s->WriteSwapScalar(fMinRate);
    s->WriteSwapScalar(fMaxRate);

    s->WriteSwapScalar(fMinLife);
    s->WriteSwapScalar(fMaxLife);

}

void hsOscillator::Save(hsStream* s, hsScalar secs)
{
    Write(s);

    int i;
    for( i = 0; i < fWaves.GetCount(); i++ )
        fWaves[i].Save(s, secs);
}

void hsOscillator::SetNumWaves(int n)
{
    fWaves.SetCount(n);
    int i;
    for( i = 0; i < n; i++ )
        fWaves[i].Kill();
}

void hsOscillator::Init(Int32 nParams, hsScalar* params)
{
// NumWaves             = 1
// AttenScale           = 2
// WorldCenterBounds    = 6
// Period               = 2
// Amp                  = 2
// Rate                 = 2
// Life                 = 2

    hsAssert(17 == nParams, "Parameter input mismatch");

    SetNumWaves(int(*params++));

    fWorldAttenScale.fX = *params++;
    fWorldAttenScale.fY = *params++;
    fWorldAttenScale.fZ = 0;

    hsPoint3 pt;
    hsBounds3Ext bnd;
    pt.fX = *params++;
    pt.fY = *params++;
    pt.fZ = *params++;
    bnd.Reset(&pt);
    pt.fX = *params++;
    pt.fY = *params++;
    pt.fZ = *params++;
    bnd.Union(&pt);
    SetWorldCenterBounds(bnd);

    SetPeriodRange(params[0], params[1]);
    params += 2;

    SetAmplitudeRange(params[0], params[1]);
    params += 2;

    SetRateRange(params[0], params[1]);
    params += 2;

    SetLifeRange(params[0], params[1]);

    fTempWaves.Reset();
}


#if 1
hsGTriMesh* hsOscillator::MakeWaveMesh(int nSpokes, const hsPoint3& center, hsScalar minRad, hsScalar maxRad, hsScalar uRange, hsScalar vRange, hsScalar attenStartFrac, hsBool32 stitch)
{
    hsGTriMesh* triMesh = new hsGTriMesh;

    hsTArray<hsScalar> radii;
    hsScalar cRad = 0;
    while( cRad < maxRad )
    {
        // OOPS - for the half circle, this should be PI*R/n, not 2PI. Don't fix until we've corrected the callers. Or we might want to leave it like
        // this anyway, since we're looking obliquely at these faces anyway, and this error stretches the side that perspective compresses. May
        // want to make the unstitched version wrong in the same way.
        hsScalar tRad = 2.f * hsScalarPI * cRad / nSpokes;
        if( tRad < minRad )
            tRad = minRad;
        cRad += tRad;
        radii.Append(cRad);
    }

    int nShell = radii.GetCount();

    int nTris = stitch
        ? 2 * nSpokes * (nShell-1) + nSpokes
        : 2 * (nSpokes-1) * (nShell-1) + (nSpokes-1);
    int nVerts = nSpokes * nShell + 1;
    triMesh->AllocatePointers(nTris, nVerts, nVerts, nVerts);
    triMesh->SetNumTriVertex(nVerts);
    triMesh->SetNumPoints(nVerts);
    triMesh->SetNumUvs(nVerts);
    triMesh->SetHasColors(true);

    *triMesh->GetPoint(0) = center;
    triMesh->GetNormal(0)->Set(0,1.f,0);
    triMesh->GetColor(0)->Set(0,0,0,1.f);
    triMesh->GetUvs(0)->fX = triMesh->GetUvs(0)->fY = triMesh->GetUvs(0)->fZ = 0;

    hsScalar iToRadians = stitch 
        ? 2.f * hsScalarPI / nSpokes
        : hsScalarPI / nSpokes;
    hsScalar attenStart = maxRad * attenStartFrac;
    hsScalar attenEnd = maxRad;
    hsScalar attenScale = hsScalarInvert(attenEnd - attenStart);
    int i, j;
    for( i = 0; i < nSpokes; i++ )
    {
        hsScalar s = hsSine(i * iToRadians);
        hsScalar c = hsCosine(i * iToRadians);
        for( j = 0; j < nShell; j++ )
        {
            hsAssert(1 + i*nShell + j < nVerts, "Going out of range on verts");
            hsGVertex3* vtx = triMesh->GetVertex(1 + i*nShell + j);
            hsColorRGBA* col = triMesh->GetColor(1 + i*nShell + j);
            hsGUv* uv = triMesh->GetUvs(1 + i*nShell + j);

            hsScalar x = c * radii[j];
            hsScalar y = s * radii[j];

            hsScalar u = x / uRange;
            hsScalar v = y / vRange;

            vtx->fLocalPos.fX = center.fX + x;
            vtx->fLocalPos.fY = center.fY + y;
            vtx->fLocalPos.fZ = 0.f;

            vtx->fNormal.Set(0,0,1.f);

            uv->fX = u;
            uv->fY = v;
            uv->fZ = 0.f;

            if( radii[j] > attenStart )
            {
                hsScalar a = (attenEnd - radii[j]) * attenScale;
                if( a < 0 )
                    a = 0;
                else if( a > 1.f )
                    a = 1.f;
                col->Set(0,0,0,a);
            }
            else
                col->Set(0,0,0,1.f);
        }
    }

    int spokeEnd = stitch ? nSpokes : nSpokes-1;
    int nextTri = 0;
    for( i = 0; i < spokeEnd; i++ )
    {
        hsTriangle3* tri = triMesh->GetTriFromPool(nextTri);
        tri->Zero();
        tri->fOrigTri = tri;
        triMesh->SetTriangle(nextTri++, tri);

        tri->fVert[0] = triMesh->GetTriVertex(0);
        tri->fVert[0]->fVtx = triMesh->GetVertex(0);
        tri->fVert[0]->SetNumUvChannels(1);
        tri->fVert[0]->fUvChan[0] = triMesh->GetUvs(0);
        tri->fVert[0]->fVtxColor = triMesh->GetColor(0);

        int iv0 = 1 + i * nShell;
        int iv1 = i < nSpokes - 1 ? 1 + (i+1)*nShell : 1;
        hsAssert((iv0 < nVerts)&&(iv1 < nVerts), "Out of range on triverts");
        
        tri->fVert[1] = triMesh->GetTriVertex(iv0);
        tri->fVert[1]->fVtx = triMesh->GetVertex(iv0);
        tri->fVert[1]->SetNumUvChannels(1);
        tri->fVert[1]->fUvChan[0] = triMesh->GetUvs(iv0);
        tri->fVert[1]->fVtxColor = triMesh->GetColor(iv0);

        tri->fVert[2] = triMesh->GetTriVertex(iv1);
        tri->fVert[2]->fVtx = triMesh->GetVertex(iv1);
        tri->fVert[2]->SetNumUvChannels(1);
        tri->fVert[2]->fUvChan[0] = triMesh->GetUvs(iv1);
        tri->fVert[2]->fVtxColor = triMesh->GetColor(iv1);

        tri->fVert[0]->fFlags = hsGTriVertex::kHasPointers
            | hsGTriVertex::kHasVertexUvs
            | hsGTriVertex::kHasVertexColors;
        tri->fVert[1]->fFlags = hsGTriVertex::kHasPointers
            | hsGTriVertex::kHasVertexUvs
            | hsGTriVertex::kHasVertexColors;
        tri->fVert[2]->fFlags = hsGTriVertex::kHasPointers
            | hsGTriVertex::kHasVertexUvs
            | hsGTriVertex::kHasVertexColors;

        tri->fFlags |= hsTriangle3::kHasVertexPosNorms 
            | hsTriangle3::kHasVertexUvs
            | hsTriangle3::kHasVertexColors
            | hsTriangle3::kHasPointers;

        int iv2 = iv0 + 1;
        int iv3 = iv1 + 1;
        hsAssert((iv1 < nVerts)&&(iv2 < nVerts), "Out of range on triverts");
        for( j = 0; j < nShell-1; j++ )
        {
            tri = triMesh->GetTriFromPool(nextTri);
            tri->Zero();
            tri->fOrigTri = tri;
            triMesh->SetTriangle(nextTri++, tri);

            tri->fVert[0] = triMesh->GetTriVertex(iv0);
            tri->fVert[0]->fVtx = triMesh->GetVertex(iv0);
            tri->fVert[0]->SetNumUvChannels(1);
            tri->fVert[0]->fUvChan[0] = triMesh->GetUvs(iv0);
            tri->fVert[0]->fVtxColor = triMesh->GetColor(iv0);

            tri->fVert[1] = triMesh->GetTriVertex(iv2);
            tri->fVert[1]->fVtx = triMesh->GetVertex(iv2);
            tri->fVert[1]->SetNumUvChannels(1);
            tri->fVert[1]->fUvChan[1] = triMesh->GetUvs(iv2);
            tri->fVert[1]->fVtxColor = triMesh->GetColor(iv2);

            tri->fVert[2] = triMesh->GetTriVertex(iv3);
            tri->fVert[2]->fVtx = triMesh->GetVertex(iv3);
            tri->fVert[2]->SetNumUvChannels(1);
            tri->fVert[2]->fUvChan[0] = triMesh->GetUvs(iv3);
            tri->fVert[2]->fVtxColor = triMesh->GetColor(iv3);

            tri->fVert[0]->fFlags = hsGTriVertex::kHasPointers
                | hsGTriVertex::kHasVertexUvs
                | hsGTriVertex::kHasVertexColors;
            tri->fVert[1]->fFlags = hsGTriVertex::kHasPointers
                | hsGTriVertex::kHasVertexUvs
                | hsGTriVertex::kHasVertexColors;
            tri->fVert[2]->fFlags = hsGTriVertex::kHasPointers
                | hsGTriVertex::kHasVertexUvs
                | hsGTriVertex::kHasVertexColors;

            tri->fFlags |= hsTriangle3::kHasVertexPosNorms 
                | hsTriangle3::kHasVertexUvs
                | hsTriangle3::kHasVertexColors
                | hsTriangle3::kHasPointers;

            tri = triMesh->GetTriFromPool(nextTri);
            tri->Zero();
            tri->fOrigTri = tri;
            triMesh->SetTriangle(nextTri++, tri);

            tri->fVert[0] = triMesh->GetTriVertex(iv0);
            tri->fVert[0]->fVtx = triMesh->GetVertex(iv0);
            tri->fVert[0]->SetNumUvChannels(1);
            tri->fVert[0]->fUvChan[0] = triMesh->GetUvs(iv0);
            tri->fVert[0]->fVtxColor = triMesh->GetColor(iv0);

            tri->fVert[1] = triMesh->GetTriVertex(iv3);
            tri->fVert[1]->fVtx = triMesh->GetVertex(iv3);
            tri->fVert[1]->SetNumUvChannels(1);
            tri->fVert[1]->fUvChan[0] = triMesh->GetUvs(iv3);
            tri->fVert[1]->fVtxColor = triMesh->GetColor(iv3);

            tri->fVert[2] = triMesh->GetTriVertex(iv1);
            tri->fVert[2]->fVtx = triMesh->GetVertex(iv1);
            tri->fVert[2]->SetNumUvChannels(1);
            tri->fVert[2]->fUvChan[0] = triMesh->GetUvs(iv1);
            tri->fVert[2]->fVtxColor = triMesh->GetColor(iv1);

            tri->fVert[0]->fFlags = hsGTriVertex::kHasPointers
                | hsGTriVertex::kHasVertexUvs
                | hsGTriVertex::kHasVertexColors;
            tri->fVert[1]->fFlags = hsGTriVertex::kHasPointers
                | hsGTriVertex::kHasVertexUvs
                | hsGTriVertex::kHasVertexColors;
            tri->fVert[2]->fFlags = hsGTriVertex::kHasPointers
                | hsGTriVertex::kHasVertexUvs
                | hsGTriVertex::kHasVertexColors;

            tri->fFlags |= hsTriangle3::kHasVertexPosNorms 
                | hsTriangle3::kHasVertexUvs
                | hsTriangle3::kHasVertexColors
                | hsTriangle3::kHasPointers;

            iv0++;
            iv1++;
            iv2++;
            iv3++;
        }
    }
    hsAssert(nextTri <= nTris, "Out of range on tris");

    triMesh->StoreOrigPoints();

    return triMesh;
}
#endif