windows-xp/Source/XPSP1/NT/multimedia/opengl/pmesh/resolutn.cxx

/**     
 **       File       : resolutn.cxx
 **       Description: Implementations of CPMeshGL methods that change the 
 **                    pmesh resolution.
 **/
#include "precomp.h"
#pragma hdrstop

#include "cpmesh.h"
#include "array.h"
#include "pmerrors.h"
#include <math.h>

void CPMeshGL::sub_reflect(WORD a, const GLwedgeAttrib& abase, 
                           const WEDGEATTRD& ad)
{
    /*
     * note: may have abase==a -> not really const
     * dr == -d +2*(d.n)n
     * an = n + dr
     * optimized: a.normal=-d+((2.f)*dot(d,n)+1.f)*n;
     */

    register float vdot = ad[0]*abase.n.x + ad[1]*abase.n.y + ad[2]*abase.n.z;
    register float vdot2p1 = vdot * 2.0f + 1.0f;

    m_glmesh.m_narray[a].x = -ad[0] + vdot2p1*abase.n.x;
    m_glmesh.m_narray[a].y = -ad[1] + vdot2p1*abase.n.y;
    m_glmesh.m_narray[a].z = -ad[2] + vdot2p1*abase.n.z;

    m_glmesh.m_tarray[a].s = abase.t.s - ad[3];
    m_glmesh.m_tarray[a].t = abase.t.t - ad[4];
}


void CPMeshGL::sub_noreflect(WORD a, WORD abase, const WEDGEATTRD& ad)
{
    m_glmesh.m_narray[a].x = m_glmesh.m_narray[abase].x - ad[0];
    m_glmesh.m_narray[a].y = m_glmesh.m_narray[abase].y - ad[1];
    m_glmesh.m_narray[a].z = m_glmesh.m_narray[abase].z - ad[2];

    m_glmesh.m_tarray[a].s = m_glmesh.m_tarray[abase].s - ad[3];
    m_glmesh.m_tarray[a].t = m_glmesh.m_tarray[abase].t - ad[4];
}


void interp(GLwedgeAttrib& a, const GLwedgeAttrib& a1,
            const GLwedgeAttrib& a2, float f1, float f2)
{
    if (a1.n.x==a2.n.x && a1.n.y==a2.n.y && a1.n.z==a2.n.z)
    {
        a.n = a1.n;
    }
    else
    {
        a.n.x = f1*a1.n.x + f2*a2.n.x;
        a.n.y = f1*a1.n.y + f2*a2.n.y;
        a.n.z = f1*a1.n.z + f2*a2.n.z;
        float denom = (float) sqrt ((double)(a.n.x*a.n.x + a.n.y*a.n.y + 
                                             a.n.z*a.n.z));
        if (denom!=0) 
        {
            a.n.x/=denom;
            a.n.y/=denom;
            a.n.z/=denom;
        }
    }
    a.t.s = f1*a1.t.s + f2*a2.t.s;
    a.t.t = f1*a1.t.t + f2*a2.t.t;
}

void CPMeshGL::gather_vf_jw (WORD v, WORD f, int& j, WORD& w) const
{
    j = get_jvf (v,f);
    w = (m_glmesh.m_farray[f]).w[j];
}

void CPMeshGL::gather_vf_j0j2pw(WORD v, WORD f, int& j0, int& j2, WORD*& pw)
{
    j0 = get_jvf (v,f);
    pw = &(m_glmesh.m_farray[f]).w[j0];
    j2 = (j0 + 2) % 3;
}

void CPMeshGL::gather_vf_j2w(WORD v, WORD f, int& j2, WORD& w) const
{
    WORD j = get_jvf (v,f);
    w = (m_glmesh.m_farray[f]).w[j];
    j2 = (j + 2) % 3;
}

void CPMeshGL::gather_vf_j1w (WORD v, WORD f, int& j1, WORD& w) const
{
    WORD j = get_jvf(v,f);
    w = (m_glmesh.m_farray[f]).w[j];
    j1 = (j + 1) % 3;
}

void CPMeshGL::gather_vf_jpw(WORD v, WORD f, int& j, WORD*& pw)
{
    j = get_jvf(v,f);
    pw = &(m_glmesh.m_farray[f]).w[j];
}

WORD CPMeshGL::MatidOfFace(WORD f)
{
    //Binary search helps if there are a lot of materials
    for (WORD i=1; i<m_maxMaterials; ++i)
        if (f < m_glmesh.m_matpos[i])
            return i-1;
    return m_maxMaterials-1;
    
    //throw CBadFace();
    //return 0; // never
}


//  note: vspl is modified!
void CPMeshGL::apply_vsplit(Vsplit& vspl)
{
    const BOOL isl = TRUE; 
    BOOL isr = vspl.vlr_offset1 > 1;
    HRESULT hr;
    
    /*
     * Get vertices, faces, and wedges in the neigbhorhood of the split.
     * Look at the diagram in mesh.vld for more information about the 
     * meanings of various variables.
     */

    WORD vs;
    WORD code=vspl.code;
    int ii=(code&Vsplit::II_MASK)>>Vsplit::II_SHIFT;
    WORD flccw, flclw;           // either (not both) may be UNDEF
    WORD frccw, frclw;           // either (or both) may be UNDEF
    WORD wlccw, wlclw, wrccw, wrclw; // ==UNDEF if faces do not exist
    int jlccw, jlclw, jrccw, jrclw;  // only defined if faces exist
    int jlclw2;
    WORD flmatid, frmatid;
    GLvertex glvs, glvt;             // vertices vs and vt
    PArray<WORD*,10> ar_pwedges;
    LPGLface farray = m_glmesh.m_farray;
    LPGLvertex varray = m_glmesh.m_varray;
    LPGLnormal narray = m_glmesh.m_narray;
    LPGLtexCoord tarray = m_glmesh.m_tarray;
    WORD (*fnei)[3] = m_glmesh.m_fnei;    
    WORD* wedgelist = m_glmesh.m_wedgelist;    
    WORD* matcnt = m_glmesh.m_matcnt;    
    WORD* matpos = m_glmesh.m_matpos;    
    WORD* facemap = m_glmesh.m_facemap;    

    /* 
     * 1) Gather all the wedges surrounding Vs into ar_pwedges array
     * -------------------------------------------------------------
     */

    if (vspl.vlr_offset1 == 0) 
    {
        /* 
         * Extremely rare case when flclw does not exist.
         */
        flclw = UNDEF;
        wlclw = UNDEF;
        if (vspl.modified)
        {
            flccw = vspl.flclw;
        }
        else
        {
            flccw = WORD(facemap[WORD(vspl.flclw)]);
            vspl.flclw = flccw;
            vspl.modified = TRUE;
        }
        
        int vs_index = (code & Vsplit::VSINDEX_MASK)>>Vsplit::VSINDEX_SHIFT;
        jlccw = vs_index;
        wlccw = farray[flccw].w[jlccw];
        vs = m_glmesh.FindVertexIndex(wlccw);
        frccw = frclw = wrccw = wrclw = UNDEF;
    } 
    else 
    {
        if (vspl.modified)
        {
            flclw = vspl.flclw;
        }
        else
        {
            flclw = WORD(facemap[WORD(vspl.flclw)]);
            vspl.flclw = flclw;
            vspl.modified = TRUE;
        }
        
        //flclw = WORD(facemap[WORD(vspl.flclw)]);
        int vs_index = (code&Vsplit::VSINDEX_MASK)>>Vsplit::VSINDEX_SHIFT;
        
        jlclw = vs_index;       //The vs's index
        jlclw2 = (jlclw + 2)%3; //The vl's index

        WORD* pwlclw = &(farray[flclw].w[jlclw]);
        wlclw = *pwlclw;
        vs = m_glmesh.FindVertexIndex (wlclw);
        flccw = fnei[flclw][(jlclw+1)%3];
        if (flccw == UNDEF) 
        {
            wlccw = UNDEF;
        } 
        else 
        {
            gather_vf_jw(vs, flccw, jlccw, wlccw);
        }

        if (!isr) 
        {
            frccw = frclw = wrccw = wrclw = UNDEF;
            ar_pwedges += pwlclw;

            /*
             *  Rotate around and record all wedges CLW from wlclw.
             */
            int j0 = jlclw, j2 = jlclw2;
            WORD f = flclw;
            for (;;) 
            {
                f = fnei[f][j2];
                if (f == UNDEF) break;
                WORD* pw;
                gather_vf_j0j2pw (vs, f, j0, j2, pw);
                ar_pwedges += pw;
            }
        } 
        else 
        {
            ar_pwedges.init (vspl.vlr_offset1 - 1);
            ar_pwedges[0] = pwlclw;

            /* 
             * Rotate around the first vlr_offset-1 faces.
             */
            int j0 = jlclw, j2 = jlclw2;
            WORD f = flclw;
            for(int count=0; count < vspl.vlr_offset1-2; ++count) 
            {
                f = fnei[f][j2];
                WORD* pw;
                gather_vf_j0j2pw (vs, f, j0, j2, pw);
                ar_pwedges[count+1] = pw;
            }
            frccw=f;

            /* 
             * On the last face, find adjacent faces.
             */
            jrccw = j0;
            wrccw = farray[frccw].w[jrccw];
            frclw = fnei[frccw][j2];
            if (frclw==UNDEF) 
            {
                wrclw=UNDEF;
            } 
            else 
            {
                gather_vf_jw(vs,frclw,jrclw,wrclw);
            }
        }
    }


    /*
     * 2) Obtain the matIDs of the two new faces generated by applying vsplit.
     * -----------------------------------------------------------------------
     *    ?? could use L_MASK instead of ii for prediction instead.
     *    face_prediction() is the shady part.
     */

    if (code & Vsplit::FLN_MASK)
    {
        flmatid = vspl.fl_matid;
    }
    else
    {
        flmatid = MatidOfFace(face_prediction(flclw,flccw,ii));
        // save computed value for undo_vsplit and future vsplits
        vspl.fl_matid = flmatid;
        vspl.code |= Vsplit::FLN_MASK;
    }

    if (isr)
    {
        if (code&Vsplit::FRN_MASK)
            frmatid = vspl.fr_matid;
        else
        {
            frmatid = MatidOfFace(face_prediction(frccw,frclw,ii));
            // save computed value for undo_vsplit and future vsplits
            vspl.fr_matid = frmatid;
            vspl.code|=Vsplit::FRN_MASK;
        }
    }

    /*
     * 3) Compute new coordinates of vt and vs (calc coordinates).
     * -----------------------------------------------------------
     */
    
    switch (ii) 
    {
    case 2:
        glvt.x = varray[vs].x + vspl.vad_large[0];
        glvt.y = varray[vs].y + vspl.vad_large[1];
        glvt.z = varray[vs].z + vspl.vad_large[2];

        glvs.x = varray[vs].x + vspl.vad_small[0];
        glvs.y = varray[vs].y + vspl.vad_small[1];
        glvs.z = varray[vs].z + vspl.vad_small[2];
        break;
    case 0:
        glvt.x = varray[vs].x + vspl.vad_small[0];
        glvt.y = varray[vs].y + vspl.vad_small[1];
        glvt.z = varray[vs].z + vspl.vad_small[2];

        glvs.x = varray[vs].x + vspl.vad_large[0];
        glvs.y = varray[vs].y + vspl.vad_large[1];
        glvs.z = varray[vs].z + vspl.vad_large[2];
        break;
    case 1:
        glvt.x = varray[vs].x + vspl.vad_small[0];
        glvt.y = varray[vs].y + vspl.vad_small[1];
        glvt.z = varray[vs].z + vspl.vad_small[2];

        glvs.x = glvt.x - vspl.vad_large[0];
        glvs.y = glvt.y - vspl.vad_large[1];
        glvs.z = glvt.z - vspl.vad_large[2];

        glvt.x = glvt.x + vspl.vad_large[0];
        glvt.y = glvt.y + vspl.vad_large[1];
        glvt.z = glvt.z + vspl.vad_large[2];
        break;
    default:
        throw CBadVsplitCode();
    }
    
    /*
     * 4) un-share wedges around vt (?) Add 2 wedges around Vs 
     * -------------------------------------------------------
     *  (may be gap on top). may modify wlclw and wrccw!
     */

    WORD wnl = UNDEF, wnr = UNDEF;
    int iil = 0, iir = ar_pwedges.num()-1;
    if (isl && (wlclw == wlccw)) 
    {  
        /*
         * first go clw. Add new wedge.
         */

        wnl = m_glmesh.m_numWedges++;

        /*
         * Add wnl to the list of wedges sharing Vs
         */
        wedgelist[wnl] = wedgelist[vs];
        wedgelist[vs] = wnl;

        /* 
         * Copy wedge attributes
         */
        narray[wnl] = narray[wlccw];
        tarray[wnl] = tarray[wlccw];
        wlclw = wnl;              // has been changed

        for (;;) 
        {
            *ar_pwedges[iil] = wnl;
            iil++;
            if (iil > iir) 
            {
                wrccw = wnl;      // has been changed
                break;
            }
            if (*ar_pwedges[iil] != wlccw) 
                break;
        }
    }

    if (isr && (wrccw == wrclw)) 
    {  
        /*
         * now go ccw from other side.
         */

        if ((wrclw == wlccw) && (wnl != UNDEF)) 
        {
            wnr = wnl;
        } 
        else 
        {
            // Add new wedge
            wnr = m_glmesh.m_numWedges++;

            // Add wnr to the list of wedges sharing vs
            wedgelist[wnr] = wedgelist[vs];
            wedgelist[vs] = wnr;
            
            // Copy wedge attributes
            narray[wnr] = narray[wrclw];
            tarray[wnr] = tarray[wrclw];
        }
        wrccw=wnr;              // has been changed

        for (;;) 
        {
            *ar_pwedges[iir] = wnr;
            iir--;
            if (iir < iil) 
            {
                if (iir < 0) wlclw=wnr; // has been changed
                break;
            }
            if (*ar_pwedges[iir] != wrclw) 
                break;
        }
    }

    /*
     * 5) Add other new wedges around Vt and record wedge ancestries
     * -------------------------------------------------------------
     */

    WORD wvtfl, wvtfr, vt = UNDEF;
    if (!isr) 
    {
        wvtfr=UNDEF;
        switch (code&Vsplit::T_MASK) 
        {
        case Vsplit::T_LSAME|Vsplit::T_RSAME:
            wvtfl=wlclw;
            break;
        case Vsplit::T_RSAME:
            // Add new wedge.
            wvtfl = m_glmesh.m_numWedges++;
            wedgelist[wvtfl] = wvtfl;
            varray[wvtfl] = glvt;
            vt = wvtfl;
            break;
        default:
            throw CBadVsplitCode();
        }
    } 
    else 
    {
        switch (code&Vsplit::T_MASK) 
        {
        case Vsplit::T_LSAME|Vsplit::T_RSAME|Vsplit::T_CSAME:
        case Vsplit::T_LSAME|Vsplit::T_RSAME:
            wvtfl=wlclw;
            wvtfr=wrccw;
            break;
        case Vsplit::T_LSAME|Vsplit::T_CSAME:
            wvtfl=wlclw;
            wvtfr=wvtfl;
            break;
        case Vsplit::T_RSAME|Vsplit::T_CSAME:
            wvtfl=wrccw;
            wvtfr=wvtfl;
            break;
        case Vsplit::T_LSAME:
            wvtfl=wlclw;
            // Add new wedge.
            wvtfr = m_glmesh.m_numWedges++;
            wedgelist[wvtfr] = wvtfr;
            varray[wvtfr] = glvt;
            vt = wvtfr;
            break;
        case Vsplit::T_RSAME:
            // Add new wedge.
            wvtfl = m_glmesh.m_numWedges++;
            wedgelist[wvtfl] = wvtfl;
            varray[wvtfl] = glvt;
            vt = wvtfl;
            wvtfr=wrccw;
            break;
        case Vsplit::T_CSAME:
            // Add new wedge.
            wvtfl = m_glmesh.m_numWedges++;
            wedgelist[wvtfl] = wvtfl;
            varray[wvtfl] = glvt;
            vt = wvtfl;
            wvtfr=wvtfl;
            break;
        case 0:
            // Add new wedge.
            wvtfl = m_glmesh.m_numWedges++;
            varray[wvtfl] = glvt;
            vt = wvtfl;

            // Add new wedge.
            wvtfr = m_glmesh.m_numWedges++;
            varray[wvtfr] = glvt;

            // Add wvtfr and wvtfl to list of wedges sharing vt
            wedgelist[wvtfl] = wvtfr;
            wedgelist[wvtfr] = wvtfl;
            break;
        default:
            throw CBadVsplitCode();
        }
    }

    /*
     * 6) Add other new wedges around Vs.
     * ----------------------------------
     * Do we really need to find vertex index ? Optimize
     */

    WORD wvsfl, wvsfr;
    if (!isr) 
    {
        wvsfr = UNDEF;
        switch (code&Vsplit::S_MASK) 
        {
        case Vsplit::S_LSAME|Vsplit::S_RSAME:
            wvsfl=wlccw;
            break;
        case Vsplit::S_RSAME:
            // Add new wedge.
            wvsfl = m_glmesh.m_numWedges++;
            varray[wvsfl] = glvs;

            // Add wvsfl to the list wedges sharing vs
            wedgelist[wvsfl] = wedgelist[vs];
            wedgelist[vs] = wvsfl;
            break;
        default:
            throw CBadVsplitCode();
        }
    } 
    else 
    {
        switch (code&Vsplit::S_MASK) 
        {
        case Vsplit::S_LSAME|Vsplit::S_RSAME|Vsplit::S_CSAME:
        case Vsplit::S_LSAME|Vsplit::S_RSAME:
            wvsfl=wlccw;
            wvsfr=wrclw;
            break;
        case Vsplit::S_LSAME|Vsplit::S_CSAME:
            wvsfl=wlccw;
            wvsfr=wvsfl;
            break;
        case Vsplit::S_RSAME|Vsplit::S_CSAME:
            wvsfl=wrclw;
            wvsfr=wvsfl;
            break;
        case Vsplit::S_LSAME:
            wvsfl=wlccw;
            // Add new wedge.
            wvsfr = m_glmesh.m_numWedges++;
            wedgelist[wvsfr] = wedgelist[vs];
            wedgelist[vs] = wvsfr;
            varray[wvsfr] = glvs;
            break;
        case Vsplit::S_RSAME:
            // Add new wedge.
            wvsfl = m_glmesh.m_numWedges++;
            wedgelist[wvsfl] = wedgelist[vs];
            wedgelist[vs] = wvsfl;
            varray[wvsfl] = glvs;
            wvsfr=wrclw;
            break;
        case Vsplit::S_CSAME:
            // Add new wedge.
            wvsfl = m_glmesh.m_numWedges++;
            wedgelist[wvsfl] = wedgelist[vs];
            wedgelist[vs] = wvsfl;
            varray[wvsfl] = glvs;
            wvsfr = wvsfl;
            break;
        case 0:
            // Add new wedge.
            wvsfl = m_glmesh.m_numWedges++;
            varray[wvsfl] = glvs;

            // Add new wedge.
            wvsfr = m_glmesh.m_numWedges++;
            varray[wvsfr] = glvs;

            // Add wvsfr and wvsfl to list of wedges sharing vt
            wedgelist[wvsfl] = wedgelist[vs];
            wedgelist[wvsfr] =wvsfl;
            wedgelist[vs] = wvsfr;
            break;
        default:
            throw CBadVsplitCode();
        }
    }

    /*
     * 7) Add outside wedges wvlfl and wvrfr
     * -------------------------------------
     */

    WORD wvlfl, wvrfr;
    if (isl) 
    {
        switch (code&Vsplit::L_MASK) 
        {
        case Vsplit::L_ABOVE:
            wvlfl = farray[flclw].w[jlclw2];
            break;
        case Vsplit::L_BELOW:
            wvlfl = farray[flccw].w[(jlccw+1)%3];
            break;
        case Vsplit::L_NEW:
        {
            wvlfl = m_glmesh.m_numWedges++;

            WORD vl = (flclw != UNDEF) ? farray[flclw].w[jlclw2] :
                                         farray[flccw].w[(jlccw+1)%3];
            wedgelist[wvlfl] = wedgelist[vl];
            wedgelist[vl] = wvlfl;

            varray[wvlfl] = varray[vl];
        }
        break;
        default:
            throw CBadVsplitCode();
        }
    }

    if (!isr) 
    {
        wvrfr = UNDEF;
    } 
    else 
    {
        switch (code&Vsplit::R_MASK) 
        {
        case Vsplit::R_ABOVE:
            wvrfr = farray[frccw].w[(jrccw+1)%3];
            break;
        case Vsplit::R_BELOW:
            wvrfr = farray[frclw].w[(jrclw+2)%3];
            break;
        case Vsplit::R_NEW:
        {
            wvrfr = m_glmesh.m_numWedges++;
            WORD vr = farray[frccw].w[(jrccw+1)%3];

            wedgelist[wvrfr] = wedgelist[vr];
            wedgelist[vr] = wvrfr;

            varray[wvrfr] = varray[vr];
        }
        break;
        default:
            throw CBadVsplitCode();
        }
    }

    /*
     * 8) Add 1 or 2 faces, and update adjacency information.
     * ------------------------------------------------------
     */

    WORD fl, fr;
    matcnt [flmatid]++;
    fl = matpos[flmatid] + matcnt[flmatid] - 1;
    facemap [m_glmesh.m_numFaces] = fl;
    
    if (isr) 
    {
        matcnt [frmatid]++;
        fr = matpos[frmatid] + matcnt[frmatid] - 1;
        facemap [m_glmesh.m_numFaces+1] = fr;
        m_glmesh.m_numFaces += 2;
    }
    else 
    {
        fr = UNDEF;
        m_glmesh.m_numFaces ++;
    }

    if (isl) 
    {
        farray[fl].w[0] = wvsfl;
        farray[fl].w[1] = wvtfl;
        farray[fl].w[2] = wvlfl;

        if (flccw != UNDEF) fnei[flccw][(jlccw+2)%3] = fl;
        if (flclw != UNDEF) fnei[flclw][(jlclw+1)%3] = fl;

        fnei[fl][0] = flclw;
        fnei[fl][1] = flccw;
        fnei[fl][2] = fr;
    }

    if (isr) 
    {
        farray[fr].w[0] = wvsfr;
        farray[fr].w[1] = wvrfr;
        farray[fr].w[2] = wvtfr;

        if (frccw != UNDEF) fnei[frccw][(jrccw+2)%3] = fr;
        if (frclw != UNDEF) fnei[frclw][(jrclw+1)%3] = fr;

        fnei[fr][0] = frccw;
        fnei[fr][1] = fl;
        fnei[fr][2] = frclw;
    }

    /*
     * 9) Update wedge vertices.
     * -------------------------
     */

    if (wnl != UNDEF)
    {
        WedgeListDelete(wnl);
        varray[wnl] = glvt;

        if (vt == UNDEF)
        {
            wedgelist[wnl] = wnl;
            vt = wnl;
        }
        else
        {
            wedgelist[wnl] = wedgelist[vt];
            wedgelist[vt] = wnl;
        }
    }

    if (wnr != UNDEF)
    {
        WedgeListDelete(wnr);
        varray[wnr] = glvt;

        if (vt==UNDEF)
        {
            wedgelist[wnr] = wnr;
            vt = wnr;
        }
        else
        {
            wedgelist[wnr] = wedgelist[vt];
            wedgelist[vt] = wnr;
        }
    }

    WORD prev = UNDEF;
    for (; iil <= iir; iil++) 
    {
        WORD w = *ar_pwedges[iil];
        if (w != prev)
        {
            WedgeListDelete(w);
            varray[w] = glvt;
            if (vt==UNDEF)
            {
                wedgelist[w] = w;
                vt = w;
            }
            else
            {
                wedgelist[w] = wedgelist[vt];
                wedgelist[vt] = w;
            }
        }
        prev = w;
    }

    /*
     * 10) Update all wedges sharing Vs to it's new coordinates.
     * ---------------------------------------------------------
     * Note the prev loop in ar_pwedges could have modified wedge pointed by 
     * vs to be part of vt now.
     * wvsfl is the only sure way of a wedge pointing to vs
     */

    WORD p = wvsfl;
    do
    {
        varray[p] = glvs;
        p = wedgelist[p];
    }
    while (p != wvsfl);

    /*
     * 11) Update wedge attributes.
     * ----------------------------
     */

    GLwedgeAttrib  awvtfr, awvsfr;
    if (isr) 
    {
        // backup for isr
        //awvtfrV = varray[wvtfr]; 
        awvtfr.n = narray[wvtfr]; 
        awvtfr.t = tarray[wvtfr]; 

        // backup for isr
        //awvsfrV = varray[wvsfr]; 
        awvsfr.n = narray[wvsfr]; 
        awvsfr.t = tarray[wvsfr]; 
    }

    int lnum = 0;
    if (isl) 
    {
        int nt = !(code&Vsplit::T_LSAME);
        int ns = !(code&Vsplit::S_LSAME);
        if (nt && ns) 
        {
            add_zero(wvtfl, vspl.ar_wad[lnum++]);
            add_zero(wvsfl, vspl.ar_wad[lnum++]);
        } 
        else 
        {
            switch (ii) 
            {
            case 2:
            {
                GLwedgeAttrib wa;
                if (ns)
                {
                    narray[wvsfl] = narray[wvtfl];
                    tarray[wvsfl] = tarray[wvtfl];
                }
                if (!ns) {wa.n = narray[wvsfl]; wa.t = tarray[wvsfl];}
                else {wa.n = narray[wvtfl]; wa.t = tarray[wvtfl];}       
                add(wvtfl, wa, vspl.ar_wad[lnum++]);
                break;
            }
            case 0:
            {
                GLwedgeAttrib wa;
                if (nt)
                {
                    narray[wvtfl] = narray[wvsfl];
                    tarray[wvtfl] = tarray[wvsfl];
                }
                if (!nt) {wa.n = narray[wvtfl]; wa.t = tarray[wvtfl];}
                else {wa.n = narray[wvsfl]; wa.t = tarray[wvsfl];}       
                add(wvsfl, wa, vspl.ar_wad[lnum++]);
                break;
            }
            case 1:
            {
                const WEDGEATTRD& wad = vspl.ar_wad[lnum];
                if (!ns) 
                {
                    GLwedgeAttrib wabase;
                    wabase.n = narray[wvsfl];
                    wabase.t = tarray[wvsfl];
                    add(wvtfl, wabase, wad);
                    sub_reflect(wvsfl, wabase, wad);
                } 
                else 
                {
                    GLwedgeAttrib wabase;
                    wabase.n = narray[wvtfl];
                    wabase.t = tarray[wvtfl];
                    sub_reflect(wvsfl, wabase, wad);
                    add(wvtfl, wabase, wad);
                }
                lnum++;
            }
                break;
            default:
                throw CBadVsplitCode();
            }
        }
    }

    if (isr) 
    {
        int nt = !(code&Vsplit::T_RSAME);
        int ns = !(code&Vsplit::S_RSAME);
        int ut = !(code&Vsplit::T_CSAME);
        int us = !(code&Vsplit::S_CSAME);
        if (nt && ns) 
        {
            if (ut)
                add_zero(wvtfr, vspl.ar_wad[lnum++]);
            if (us)
                add_zero(wvsfr, vspl.ar_wad[lnum++]);
        } 
        else 
        {
            switch (ii) 
            {
            case 2:
                if (us && ns)
                {
                    narray[wvsfr] = awvtfr.n;
                    tarray[wvsfr] = awvtfr.t;
                }
                if (ut)
                    add(wvtfr, (!ns?awvsfr:awvtfr), vspl.ar_wad[lnum++]);
                break;
            case 0:
                if (ut && nt)
                {
                    narray[wvtfr] = awvsfr.n;
                    tarray[wvtfr] = awvsfr.t;
                }
                if (us)
                    add(wvsfr, (!nt?awvtfr:awvsfr), vspl.ar_wad[lnum++]);
                break;
            case 1:
            {
                const WEDGEATTRD& wad = vspl.ar_wad[lnum];
                if (!ns) 
                {
                    const GLwedgeAttrib& wabase = awvsfr;
                    if (ut)
                        add(wvtfr, wabase, wad);
                    if (us)
                        sub_reflect(wvsfr, wabase, wad);
                } 
                else 
                {
                    const GLwedgeAttrib& wabase=awvtfr;
                    if (us)
                        sub_reflect(wvsfr, wabase, wad);
                    if (ut)
                        add(wvtfr, wabase, wad);
                }
                if (ut || us)
                    lnum++;
            }
                break;
            default:
                throw CBadVsplitCode();
            }
        }
    }
    if (code&Vsplit::L_NEW) 
    {
        add_zero(wvlfl, vspl.ar_wad[lnum++]);
    }
    if (code&Vsplit::R_NEW)
    {
        add_zero(wvrfr, vspl.ar_wad[lnum++]);
    }
}


void CPMeshGL::undo_vsplit(const Vsplit& vspl)
{
    unsigned int code=vspl.code;
    int ii=(code&Vsplit::II_MASK)>>Vsplit::II_SHIFT;
    const int isl=1; int isr;
    WORD fl, fr;
    LPGLface farray = m_glmesh.m_farray;
    LPGLvertex varray = m_glmesh.m_varray;
    LPGLnormal narray = m_glmesh.m_narray;
    LPGLtexCoord tarray = m_glmesh.m_tarray;
    WORD (*fnei)[3] = m_glmesh.m_fnei;    
    WORD* wedgelist = m_glmesh.m_wedgelist;    
    WORD* matcnt = m_glmesh.m_matcnt;    
    WORD* matpos = m_glmesh.m_matpos;    
    WORD* facemap = m_glmesh.m_facemap;    
    GLvertex glvs, glvt;
    
    /*
     * 1) Remove the faces
     * -------------------
     */

    if (vspl.vlr_offset1 > 1) 
    {
        WORD frmid = vspl.fr_matid, flmid = vspl.fl_matid;
      
        isr = 1;
        
        // remove fr
        matcnt[frmid]--;
        fr = matpos[frmid] + matcnt[frmid]; 

        // remove fl
        matcnt[flmid]--;
        fl = matpos[flmid] + matcnt[flmid]; 

        m_glmesh.m_numFaces -= 2;
    } 
    else 
    {
        WORD frmid = vspl.fr_matid, flmid = vspl.fl_matid;

        isr = 0;

        // remove fl
        matcnt[flmid]--;
        fl = matpos[flmid] + matcnt[flmid]; 
        fr = UNDEF;
        --m_glmesh.m_numFaces;
    }

    /*
     * 2) Get wedges in neighborhood.
     * ------------------------------
     */

    WORD wvsfl, wvtfl, wvlfl;
    WORD wvsfr, wvtfr, wvrfr;

    wvsfl = farray[fl].w[0];
    wvtfl = farray[fl].w[1];
    wvlfl = farray[fl].w[2];

    if (!isr) 
    {
        wvsfr=UNDEF; 
        wvtfr=UNDEF; 
        wvrfr=UNDEF;
    } 
    else 
    {
        wvsfr = farray[fr].w[0];
        wvtfr = farray[fr].w[2];
        wvrfr = farray[fr].w[1];
    }

    /*
     * 3) Obtain the vertices Vs and Vt and save them.
     * -----------------------------------------------
     */

    WORD vs = m_glmesh.FindVertexIndex (wvsfl);
    WORD vt = m_glmesh.FindVertexIndex (wvtfl);

    glvt.x = varray[vt].x;
    glvt.y = varray[vt].y;
    glvt.z = varray[vt].z;

    /* 
     * 4) Get adjacent faces and wedges on left and right.
     * ---------------------------------------------------
     * (really needed??)
     */

    WORD flccw, flclw;           // either (not both) may be UNDEF
    WORD frccw, frclw;           // either (or both) may be UNDEF

    /*
     * Also find index of vs within those adjacent faces
     */
    int jlccw2, jlclw0, jlclw2, jrccw, jrclw1; // only defined if faces exist
    WORD* pwlclw;
    WORD wlccw, wlclw, wrccw, wrclw; // UNDEF if faces does not exist

    /* 
     * Left side
     */

    if (isl) 
    {
        flccw = fnei[fl][1];
        flclw = fnei[fl][0];

        if (flccw == UNDEF) 
        {
            wlccw=UNDEF;
        } 
        else 
        {
            gather_vf_j2w (vs, flccw, jlccw2, wlccw);
        }

        if (flclw==UNDEF) 
        {
            wlclw = UNDEF;
        } 
        else 
        {
            gather_vf_j0j2pw (vt, flclw, jlclw0, jlclw2, pwlclw);
            wlclw = *pwlclw;
        }
    }

    /* 
     * Right side
     */

    if (!isr) 
    {
        frccw = frclw = wrccw = wrclw = UNDEF;
    } 
    else 
    {
        frccw = fnei[fr][0];
        frclw = fnei[fr][2];

        if (frccw == UNDEF) 
        {
            wrccw = UNDEF;
        } 
        else 
        {
            gather_vf_jw(vt, frccw, jrccw, wrccw);
        }

        if (frclw == UNDEF) 
        {
            wrclw = UNDEF;
        } 
        else 
        {
            gather_vf_j1w (vs, frclw, jrclw1, wrclw);
        }
    }

    int thru_l = ((wlccw == wvsfl) && (wlclw == wvtfl));
    int thru_r = ((wrclw == wvsfr) && (wrccw == wvtfr));

    /*
     * 5) Update adjacency information.
     * --------------------------------
     */

    if (flccw != UNDEF) fnei[flccw][jlccw2] = flclw;
    if (flclw != UNDEF) fnei[flclw][(jlclw0+1)%3] = flccw;
    if (frccw != UNDEF) fnei[frccw][(jrccw+2)%3] = frclw;
    if (frclw != UNDEF) fnei[frclw][jrclw1] = frccw;

    /*
     * 6) Propagate wedges id's across collapsed faces if can go thru.
     * ---------------------------------------------------------------
     */

    WORD ffl = flclw, ffr = frccw;
    int jjl0 = jlclw0, jjl2 = jlclw2, jjr = jrccw;
    WORD* pwwl=pwlclw;
    
    /*
     * first go clw
     */
    if (thru_l) 
    {            
        for (;;) 
        {
            *pwwl = wlccw;
            if (ffl == ffr) 
            {
                ffl = ffr = UNDEF;  // all wedges seen
                break;
            }
            ffl = fnei[ffl][jjl2];
            if (ffl == UNDEF) break;
            gather_vf_j0j2pw(vt, ffl, jjl0, jjl2, pwwl);
            if (*pwwl != wlclw) break;
        }
    }

    /*
     * now go ccw from other side
     */
    if ((ffr != UNDEF) && thru_r) 
    {     
        WORD* pw = &(farray[ffr].w[jjr]);
        for (;;) 
        {
            *pw = wrclw;
            if (ffr == ffl) 
            {
                ffl = ffr = UNDEF;  // all wedges seen
                break;
            }
            ffr = fnei[ffr][(jjr+1)%3];
            if (ffr == UNDEF) break;
            gather_vf_jpw (vt, ffr, jjr, pw);
            if (*pw != wrccw) break;
        }
    }

    /*
     * 7) Identify those wedges that will need to be updated to vs.
     * ------------------------------------------------------------
     * (wmodif may contain some duplicates)
     */

    PArray<WORD,10> ar_wmodif;
    if (ffl!=UNDEF) 
    {
        for (;;) 
        {
            int w = *pwwl;
            ar_wmodif += w;
            if (ffl == ffr) 
            { 
                ffl = ffr = UNDEF; 
                break; 
            }

            ffl = fnei[ffl][jjl2];
            if (ffl == UNDEF) break;
            gather_vf_j0j2pw (vt, ffl, jjl0, jjl2, pwwl);
        }
    }

    /*
     * 8) Update wedge vertices to vs.
     * -------------------------------
     */

    for (int i=0; i<ar_wmodif.num(); ++i)
    {
        // _wedges[w].vertex=vs;
        WORD w = ar_wmodif[i];
        WedgeListDelete(w);
        varray[w] = varray[vs];
        wedgelist[w] = wedgelist[vs];
        wedgelist[vs] = w;
    }

    /*
     * 9) Update vertex attributes.
     * ----------------------------
     */

    float vsx, vsy, vsz;
    switch (ii) 
    {
    case 2:
        glvs.x = varray[vs].x - vspl.vad_small[0];
        glvs.y = varray[vs].y - vspl.vad_small[1];
        glvs.z = varray[vs].z - vspl.vad_small[2];
        break;
    case 0:
        glvs.x = glvt.x - vspl.vad_small[0];
        glvs.y = glvt.y - vspl.vad_small[1];
        glvs.z = glvt.z - vspl.vad_small[2];
        break;
    case 1:
        glvs.x = glvt.x - vspl.vad_large[0] - vspl.vad_small[0];
        glvs.y = glvt.y - vspl.vad_large[1] - vspl.vad_small[1];
        glvs.z = glvt.z - vspl.vad_large[2] - vspl.vad_small[2];
        break;
    default:
        throw CBadVsplitCode();
    }

    /*
     * 10) update all wedges sharing vs with it's coordinates
     * ------------------------------------------------------
     */

    WORD p = vs;
    do
    {
        varray[p] = glvs;
        p = wedgelist[p];
    }
    while (p!=vs);

    /*
     * 11) Udpate wedge attributes. they are currently predicted exactly.
     * ------------------------------------------------------------------
     */

    GLwedgeAttrib awvtfr, awvsfr;
    //GLvertex awvtfrV, awvsfrV;

    if (isr) 
    {
      //awvtfrV = varray[wvtfr];
        awvtfr.n = narray[wvtfr];
        awvtfr.t = tarray[wvtfr];

        //awvsfrV = varray[wvsfr];
        awvsfr.n = narray[wvsfr];
        awvsfr.t = tarray[wvsfr];
    }

    int problem = 0;
    if (isl) 
    {
        int nt = !(code&Vsplit::T_LSAME);
        int ns = !(code&Vsplit::S_LSAME);
        if (nt && ns) 
        {
            problem = 1;
        } 
        else 
        {
            switch (ii) 
            {
            case 2:
                if (!thru_l)
                {
                    narray[wvtfl] = narray[wvsfl];
                    tarray[wvtfl] = tarray[wvsfl];
                }
                break;
            case 0:
                narray[wvsfl] = narray[wvtfl];
                tarray[wvsfl] = tarray[wvtfl];
                break;
            case 1:
                sub_noreflect (wvsfl, wvtfl, vspl.ar_wad[0]);
                if (!thru_l)
                {
                    narray[wvtfl] = narray[wvsfl];
                    tarray[wvtfl] = tarray[wvsfl];
                }
                break;
            default:
                throw CBadVsplitCode();
            }
        }
    }

    if (isr) 
    {
        int nt = !(code&Vsplit::T_RSAME);
        int ns = !(code&Vsplit::S_RSAME);
        int ut = !(code&Vsplit::T_CSAME);
        int us = !(code&Vsplit::S_CSAME);

        if (problem || us || ut) 
        {
            switch (ii) {
            case 2:
                /*
                 * If thru_r, then wvtfr & wrccw no longer exist.
                 * This may be duplicating some work already done for isl.
                 */
                if (!nt && !thru_r)
                {
                    narray[wvtfr] = awvsfr.n;
                    tarray[wvtfr] = awvsfr.t;
                }
                break;
            case 0:
                // This may be duplicating some work already done for isl.
                if (!ns)
                {
                    narray[wvsfr] = awvtfr.n;
                    tarray[wvsfr] = awvtfr.t;
                }
                break;
            case 1:
            {
                GLwedgeAttrib wa;
                interp(wa, awvsfr, awvtfr, 0.5f, 0.5f);
                if (!ns) 
                {
                    narray[wvsfr] = wa.n;
                    tarray[wvsfr] = wa.t;
                }
                if (!nt && !thru_r)
                {
                    narray[wvtfr] = wa.n;
                    tarray[wvtfr] = wa.t;
                }
            }
            break;
            default:
                throw CBadVsplitCode();
            }
        }
    }

    /*
     * 12) Remove wedges.
     * ------------------
     */

    if (isr && (code&Vsplit::R_NEW))
    {
        WORD w = --m_glmesh.m_numWedges; // wvrfr
        WedgeListDelete(w);
    }

    if (code&Vsplit::L_NEW)
    {
        WORD w = --m_glmesh.m_numWedges; // wvlfl
        WedgeListDelete(w);
    }

    if (isr && (!(code&Vsplit::S_CSAME) && !(code&Vsplit::S_RSAME)))
    {
        WORD w = --m_glmesh.m_numWedges; // wvsfr
        WedgeListDelete(w);
    }

    if ((!(code&Vsplit::S_LSAME) && (!(code&Vsplit::S_CSAME) || 
                                     !(code&Vsplit::S_RSAME))))
    {
        WORD w = --m_glmesh.m_numWedges; // wvsfl
        WedgeListDelete(w);
    }

    if (isr && (!(code&Vsplit::T_CSAME) && !(code&Vsplit::T_RSAME)))
    {
        WORD w = --m_glmesh.m_numWedges; // wvtfr
        WedgeListDelete(w);
    }

    if ((!(code&Vsplit::T_LSAME) && (!(code&Vsplit::T_CSAME) || 
                                     !(code&Vsplit::T_RSAME))))
    {
        WORD w = --m_glmesh.m_numWedges; // wvtfl
        WedgeListDelete(w);
    }

    int was_wnl = isl && (code&Vsplit::T_LSAME) && (code&Vsplit::S_LSAME);
    if (isr && (code&Vsplit::T_RSAME) && (code&Vsplit::S_RSAME) &&
        !(was_wnl && (code&Vsplit::T_CSAME)))
    {
        WORD w = --m_glmesh.m_numWedges; // wrccw
        WedgeListDelete(w);
    }

    if (was_wnl)
    {
        WORD w = --m_glmesh.m_numWedges; // wlclw
        WedgeListDelete(w);
    }
}