Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/tools/3d/plugin_max/nel_patch_lib/nel_patch_mesh.cpp

3153 lines
78 KiB
C++
Raw Blame History

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdafx.h"
#include "nel_patch_mesh.h"
#include "nel/misc/time_nl.h"
#include "vertex_neighborhood.h"
#include "../nel_3dsmax_shared/nel_3dsmax_shared.h"
#include "nel/3d/zone_symmetrisation.h"
// For MAX_RELEASE
#include <plugapi.h>
using namespace NL3D;
using namespace NLMISC;
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif max
//#ifndef min
//#define min(a,b) (((a) < (b)) ? (a) : (b))
//#endif min
#define PBLOCK_REF 0
#ifdef USE_CACHE
#ifndef NDEBUG
#define DEBUG_PIPELINE
#endif // NDEBUG
#endif // USE_CACHE
float bindWhere[BIND_COUNT]=
{
0.25f,
0.75f,
0.5f,
0.5f
};
#define RK_APPDATA_TILEFILE 0
#define RK_APPDATA_LAND 1
#define REGKEY_TILEDIT "Software\\Nevrax\\Ryzom\\Tile_Edit"
//#define CHECK_VALIDITY // check validity
// Default constructor, allocate the array
CPatchMeshData::CPatchMeshData ()
{
// Get a global allocator
CPatchAllocator& _Allocator=GetAllocator ();
_UIPatch=_Allocator.AllocPatch.allocate();
_UIVertex=_Allocator.AllocVertex.allocate();
_MapHitToTileIndex=_Allocator.AllocInt.allocate();
}
// Copy constructor, allocate the array
CPatchMeshData::CPatchMeshData (const CPatchMeshData& src)
{
this->CPatchMeshData::CPatchMeshData ();
this->operator= (src);
}
// Destructor
CPatchMeshData::~CPatchMeshData ()
{
// Get a global allocator
CPatchAllocator& _Allocator=GetAllocator ();
_Allocator.AllocPatch.free (_UIPatch);
_Allocator.AllocVertex.free (_UIVertex);
_Allocator.AllocInt.free (_MapHitToTileIndex);
}
// Copy
CPatchMeshData& CPatchMeshData::operator= (const CPatchMeshData& src)
{
*_UIPatch=*src._UIPatch;
*_UIVertex=*src._UIVertex;
*_MapHitToTileIndex=*src._MapHitToTileIndex;
return *this;
}
NL3D::CTileBank bank;
std::string GetBankPathName ()
{
HKEY hKey;
if (RegOpenKeyEx(HKEY_CURRENT_USER, REGKEY_TILEDIT, 0, KEY_READ, &hKey)==ERROR_SUCCESS)
{
char path[256];
DWORD len=256;
DWORD type;
if (RegQueryValueEx(hKey, "Bank Path", 0, &type, (LPBYTE)path, &len)==ERROR_SUCCESS)
return std::string (path);
RegCloseKey (hKey);
}
return "";
}
int GetBankTileSetSet ()
{
HKEY hKey;
if (RegOpenKeyEx(HKEY_CURRENT_USER, REGKEY_TILEDIT, 0, KEY_READ, &hKey)==ERROR_SUCCESS)
{
int tileSetSet;
DWORD len=256;
DWORD type;
if (RegQueryValueEx(hKey, "Tileset Set", 0, &type, (LPBYTE)&tileSetSet, &len)==ERROR_SUCCESS)
return tileSetSet;
RegCloseKey (hKey);
}
return -1;
}
void SetBankPathName (const std::string& path)
{
HKEY hKey;
if (RegCreateKey(HKEY_CURRENT_USER, REGKEY_TILEDIT, &hKey)==ERROR_SUCCESS)
{
RegSetValueEx(hKey, "Bank Path", 0, REG_SZ, (LPBYTE)path.c_str(), path.length()+1);
RegCloseKey (hKey);
}
}
void SetBankTileSetSet (int tileSetSet)
{
HKEY hKey;
if (RegCreateKey(HKEY_CURRENT_USER, REGKEY_TILEDIT, &hKey)==ERROR_SUCCESS)
{
RegSetValueEx(hKey, "Tileset Set", 0, REG_DWORD, (LPBYTE)&tileSetSet, 4);
RegCloseKey (hKey);
}
}
// RPatchMesh --------------------------------------------------------------------------------------------------------------------------------------------
// Constructeur
RPatchMesh::RPatchMesh (PatchMesh *pmesh)
{
// Invalidate
ValidGeom=NEVER;
ValidTopo=NEVER;
ValidTexmap=NEVER;
ValidSelect=NEVER;
ValidDisplay=NEVER;
ValidBindingInfo=FOREVER;
ValidBindingPos=FOREVER;
rTess.ModeTile=true;
rTess.KeepMapping=false;
rTess.TransitionType=1;
SetSelLevel (EP_OBJECT);
rTess.TileTesselLevel=0;
build=-1;
paintHack=false;
if (pmesh)
{
// Patches
SetNumPatches (pmesh->getNumPatches());
// Vertices
SetNumVerts (pmesh->getNumVerts());
}
// Getback the binding informations
for (int v=0; v<pmesh->hooks.Count(); v++)
{
int hookPoint=pmesh->hooks[v].hookPoint;
int hookEdge=pmesh->hooks[v].hookEdge;
int hookPatch=pmesh->hooks[v].hookPatch;
AddHook (hookPoint, hookEdge, *pmesh);
}
}
RPatchMesh::RPatchMesh ()
{
// Set level
SetSelLevel (EP_OBJECT);
build=-1;
rTess.TransitionType=1;
paintHack=false;
// Invalidate
ValidGeom=NEVER;
ValidTopo=NEVER;
ValidTexmap=NEVER;
ValidSelect=NEVER;
ValidDisplay=NEVER;
ValidBindingInfo=FOREVER;
ValidBindingPos=FOREVER;
rTess.ModeTile=true;
rTess.KeepMapping=false;
rTess.TransitionType=1;
SetSelLevel (EP_OBJECT);
rTess.TileTesselLevel=0;
build=-1;
paintHack=false;
};
RPatchMesh::~RPatchMesh ()
{
};
// Check if a vertex is in a seg
bool IsVertexInEdge (int nVert, int nSeg, const PatchMesh& patch)
{
if ((patch.edges[nSeg].v1==nVert)||(patch.edges[nSeg].v2==nVert))
return true;
else
return false;
}
// return other vertex in edge
int GetOtherVertex (int nVert, int nSeg, const PatchMesh& patch)
{
if (patch.edges[nSeg].v1==nVert)
return patch.edges[nSeg].v2;
else
{
nlassert (patch.edges[nSeg].v2==nVert);
return patch.edges[nSeg].v1;
}
}
// Check if two vertex are joined by a edge
int IsVerticesJoined (int nVert0, int nVert1, const CVertexNeighborhood& tab, const PatchMesh& patch)
{
// Count of neigbor for vertex 0
uint listSize=tab.getNeighborCount (nVert0);
// List of neigbor
const uint* pList=tab.getNeighborList (nVert0);
// For each neigbor
for (uint n=0; n<listSize; n++)
{
// If the vertex is on this edge, return the edge number
if (IsVertexInEdge (nVert1, pList[n], patch))
return pList[n];
}
return -1;
}
// Check if two vertex are joined by a edge
bool IsVerticesJoined2 (int nVert0, int nVert1, int& nVert2, int& nEdge0, int& nEdge1, const CVertexNeighborhood& tab, const PatchMesh& patch)
{
int nCount=0;
//
if (IsVerticesJoined (nVert0, nVert1, tab, patch)!=-1)
return false;
// Count of neigbor for vertex 0
uint listSize=tab.getNeighborCount (nVert0);
// List of neigbor
const uint* pList=tab.getNeighborList (nVert0);
// For each neigbor
for (uint n=0; n<listSize; n++)
{
// Index of the next vertex of this edge
int nNextVert=(patch.edges[pList[n]].v1==nVert0)?patch.edges[pList[n]].v2:patch.edges[pList[n]].v1;
if (nNextVert!=-1)
{
// The two vertex are joined ?
int nEdge=IsVerticesJoined (nNextVert, nVert1, tab, patch);
// Yes !
if (nEdge!=-1)
{
// One more
nCount++;
nVert2=nNextVert;
nEdge0=nEdge;
nEdge1=pList[n];
}
}
}
return (nCount==1);
}
// Check if a vertex is in a patch
bool IsVertexInPatch (int nVert, int nPatch, const PatchMesh& patch)
{
for (int i=0; i<4; i++)
{
if (patch.patches[nPatch].v[i]==nVert)
return true;
}
return false;
}
// Check binding
int CheckBind (int nVert, int nSeg, int& v0, int& v1, int& v2, int& v3, const CVertexNeighborhood& tab, const PatchMesh& patch, bool bAssert, bool bCreate)
{
int config=-1;
// Check config 1
// v0 ******* nVert ******* v1
// *************************
v0=patch.edges[nSeg].v1;
v1=patch.edges[nSeg].v2;
// Valid edge to bind on
if (v0==-1)
{
if (bAssert)
nlassert (0);
}
else
{
if (v1==-1)
{
if (bAssert)
nlassert (0);
}
else
{
#if (MAX_RELEASE < 4000)
if ((patch.edges[nSeg].patch2!=-1)&&bCreate)
{
if (bAssert)
nlassert (0);
}
else
#else // (MAX_RELEASE < 4000)
if ((patch.edges[nSeg].patches.Count()>1)&&bCreate)
{
if (bAssert)
nlassert (0);
}
else if (patch.edges[nSeg].patches.Count() > 0)
#endif // (MAX_RELEASE < 4000)
{
// config 1?
int nSeg0=IsVerticesJoined (v0, nVert, tab, patch);
int nSeg1=IsVerticesJoined (v1, nVert, tab, patch);
if ((nSeg0!=-1)&&(nSeg1!=-1))
{
// additionnal check.
#if (MAX_RELEASE < 4000)
if ((patch.edges[nSeg0].patch2==-1)&&(patch.edges[nSeg1].patch2==-1))
{
if (!IsVertexInPatch (nVert, patch.edges[nSeg].patch1, patch))
config=0;
}
#else // (MAX_RELEASE < 4000)
if ((patch.edges[nSeg0].patches.Count()<2)&&(patch.edges[nSeg1].patches.Count()<2))
{
if (!IsVertexInPatch (nVert, patch.edges[nSeg].patches[0], patch))
config=0;
}
#endif // (MAX_RELEASE < 4000)
}
if (config==-1)
{
// Check config 2
// v0 **** v2 **** nVert **** v3 **** v1
// ***********************************
int nEdge0;
int nEdge1;
int nEdge2;
int nEdge3;
if (IsVerticesJoined2 (v0, nVert, v2, nEdge0, nEdge1, tab, patch)&&
IsVerticesJoined2 (v1, nVert, v3, nEdge2, nEdge3, tab, patch))
{
// additionnal check
if ((v2!=v3)&&
(nEdge0!=nEdge1)&&
(nEdge0!=nEdge2)&&
(nEdge0!=nEdge3)&&
(nEdge1!=nEdge2)&&
(nEdge1!=nEdge3)&&
(nEdge2!=nEdge3)&&
#if (MAX_RELEASE < 4000)
(patch.edges[nEdge0].patch2==-1)&&
(patch.edges[nEdge1].patch2==-1)&&
(patch.edges[nEdge2].patch2==-1)&&
(patch.edges[nEdge3].patch2==-1)&&
(!IsVertexInPatch (nVert, patch.edges[nSeg].patch1, patch))&&
(!IsVertexInPatch (v2, patch.edges[nSeg].patch1, patch))&&
(!IsVertexInPatch (v3, patch.edges[nSeg].patch1, patch)))
#else // (MAX_RELEASE < 4000)
(patch.edges[nEdge0].patches.Count()<2)&&
(patch.edges[nEdge1].patches.Count()<2)&&
(patch.edges[nEdge2].patches.Count()<2)&&
(patch.edges[nEdge3].patches.Count()<2)&&
(!IsVertexInPatch (nVert, patch.edges[nSeg].patches[0], patch))&&
(!IsVertexInPatch (v2, patch.edges[nSeg].patches[0], patch))&&
(!IsVertexInPatch (v3, patch.edges[nSeg].patches[0], patch)))
#endif // (MAX_RELEASE < 4000)
{
config=1;
}
}
}
if (config==-1)
{
// No config
if (bAssert)
nlassert (0);
}
}
}
}
return config;
}
// Patchmesh Check validity (debug stuff)
bool RPatchMesh::Validity (const PatchMesh& patch, bool bAssert)
{
#ifdef CHECK_VALIDITY
bool bRet=true;
// Check patches count
int nPatchCount=patch.numPatches;
int nPatchUICount=getUIPatchSize();
if (nPatchCount!=nPatchUICount)
{
if (bAssert)
nlassert (0); // Not the same patch count
bRet=false;
}
// Check vertices count
int nVertCount=patch.numVerts;
int nVertUICount=getUIVertexSize();
if (nVertCount!=nVertUICount)
{
if (bAssert)
nlassert (0); // Not the same vertices count
bRet=false;
}
// Static table to avoid alloc prb
CVertexNeighborhood& tab=vertexNeighborhoodGlobal;
tab.build (patch);
// Check binding info in vertices
for (int nVertex=0; nVertex<(int)getUIVertexSize(); nVertex++)
{
// Binding on this vertex ?
if (getUIVertex(nVertex).Binding.bBinded)
{
// Check # of the patch
int nPatchNumber=getUIVertex(nVertex).Binding.nPatch;
if ((nPatchNumber>=nPatchUICount)||(nPatchNumber<0))
{
if (bAssert)
nlassert (0); // # patch invalid in binding info
bRet=false;
}
// Check # of the edge
int nEdgeNumber=getUIVertex(nVertex).Binding.nEdge;
if ((nEdgeNumber>=4)||(nEdgeNumber<0))
{
if (bAssert)
nlassert (0); // # edge invalid in binding info
bRet=false;
}
// Check fWhere
typeBind type = (typeBind)(getUIVertex(nVertex).Binding.nType);
if ((type!=BIND_25)&&
(type!=BIND_50)&&
(type!=BIND_75)&&
(type!=BIND_SINGLE))
{
if (bAssert)
nlassert (0); // fWhere value invalid in binding info
bRet=false;
}
// Primary vertex
int nPrim=getUIVertex(nVertex).Binding.nPrimVert;
if ((nPrim<0)||(nPrim>=patch.numVerts))
{
if (bAssert)
nlassert(0);
bRet=false;
if (nPrim!=nVertex)
{
if (!getUIVertex(nPrim).Binding.bBinded)
{
if (bAssert)
nlassert(0);
bRet=false;
}
if (getUIVertex(nPrim).Binding.nEdge!=(uint)nEdgeNumber)
{
if (bAssert)
nlassert(0);
bRet=false;
}
if (getUIVertex(nPrim).Binding.nPatch!=(uint)nPatchNumber)
{
if (bAssert)
nlassert(0);
bRet=false;
}
if ((getUIVertex(nPrim).Binding.nPrimVert==BIND_50)||(getUIVertex(nPrim).Binding.nPrimVert==BIND_SINGLE))
{
if (bAssert)
nlassert(0);
bRet=false;
}
}
}
// Check geom
int v0, v1, v2, v3;
switch (CheckBind (nPrim, patch.patches[nPatchNumber].edge[nEdgeNumber], v0, v1, v2, v3, tab, patch, bAssert, false))
{
case 0:
if (type!=BIND_SINGLE)
{
if (bAssert)
nlassert(0);
bRet=false;
}
break;
case 1:
if (nVertex!=nPrim)
{
if (v2==nVertex)
{
if (type!=BIND_25)
{
if (bAssert)
nlassert(0);
bRet=false;
}
}
else if (v3==nVertex)
{
if (type!=BIND_75)
{
if (bAssert)
nlassert(0);
bRet=false;
}
}
else
{
if (type!=BIND_50)
{
if (bAssert)
nlassert(0);
bRet=false;
}
}
}
break;
}
}
}
// Check mode tile
int nSelTileSize=tileSel.GetSize();
int nTileSize=getUIPatchSize()*NUM_TILE_SEL;
if (nSelTileSize!=nTileSize)
{
if (bAssert)
nlassert(0);
bRet=false;
}
// Check count of it index
if (rTess.TileTesselLevel>=0)
{
int nFaceCount=mesh.numFaces;
int nHitCount=_Data._MapHitToTileIndex->size();
if (nFaceCount!=nHitCount)
{
if (bAssert)
nlassert (0);
bRet=false;
}
}
// Return the bad news...
return bRet;
#else // CHECK_VALIDITY
return true;
#endif
}
static Point3 InterpCenter(Point3 e1, Point3 i1, Point3 i2, Point3 e2, Point3 *v1 = NULL, Point3 *v2 = NULL, Point3 *v3 = NULL, Point3 *v4 = NULL)
{
Point3 e1i1 =(e1 + i1) / 2.0f;
Point3 i1i2 =(i1 + i2) / 2.0f;
Point3 i2e2 =(i2 + e2) / 2.0f;
Point3 a =(e1i1 + i1i2) / 2.0f;
Point3 b =(i1i2 + i2e2) / 2.0f;
if (v1)
*v1 = e1i1;
if (v2)
*v2 = a;
if (v3)
*v3 = b;
if (v4)
*v4 = i2e2;
return (a + b) / 2.0f;
}
// Update binded vertices's position
void RPatchMesh::UpdateBindingPos (PatchMesh& patch)
{
// Check validity
#ifndef NDEBUG
Validity (patch, true);
#endif // NDEBUG
// Vertex count
int nVertexCount=patch.getNumVerts ();
// Pointer
uint vertSize=getUIVertexSize();
for (uint nV=0; nV<vertSize; nV++)
{
// Pointer on the patch
UI_VERTEX* pVertex=&getUIVertex (nV);
// Binded?
if (pVertex->Binding.bBinded)
{
static const float fU[4]={0.f, 1.f, 0.f, -1.f};
static const float fV[4]={1.f, 0.f, -1.f, 0.f};
static const float fUadd[4]={0.f, 0.f, 1.f, 1.f};
static const float fVadd[4]={0.f, 1.f, 1.f, 0.f};
// Calcule new position of the vertex
int nEdge=patch.patches[pVertex->Binding.nPatch].edge[pVertex->Binding.nEdge];
PatchEdge &edge=patch.edges[nEdge];
// Save
Point3 vOld=patch.verts[nV].p;
switch (pVertex->Binding.nType)
{
case BIND_25:
{
Point3 v0, v1, v2, v3, v4;
v2=InterpCenter(patch.verts[edge.v1].p, patch.vecs[edge.vec12].p, patch.vecs[edge.vec21].p,
patch.verts[edge.v2].p, &v0, &v1, &v3, &v4);
// Final interpolation
patch.verts[nV].p=InterpCenter(patch.verts[edge.v1].p, v0, v1, v2,
&patch.vecs[pVertex->Binding.nBefore2].p, &patch.vecs[pVertex->Binding.nBefore].p,
&patch.vecs[pVertex->Binding.nAfter].p, &patch.vecs[pVertex->Binding.nAfter2].p);
}
break;
case BIND_50:
patch.verts[nV].p=InterpCenter(patch.verts[edge.v1].p, patch.vecs[edge.vec12].p, patch.vecs[edge.vec21].p,
patch.verts[edge.v2].p, NULL, NULL, NULL, NULL);
break;
case BIND_75:
{
Point3 v0, v1, v2, v3, v4;
v2=InterpCenter(patch.verts[edge.v1].p, patch.vecs[edge.vec12].p, patch.vecs[edge.vec21].p,
patch.verts[edge.v2].p, &v0, &v1, &v3, &v4);
// Final interpolation
patch.verts[nV].p=InterpCenter(v2, v3, v4, patch.verts[edge.v2].p,
&patch.vecs[pVertex->Binding.nBefore2].p, &patch.vecs[pVertex->Binding.nBefore].p,
&patch.vecs[pVertex->Binding.nAfter].p, &patch.vecs[pVertex->Binding.nAfter2].p);
}
break;
case BIND_SINGLE:
patch.verts[nV].p=InterpCenter(patch.verts[edge.v1].p, patch.vecs[edge.vec12].p, patch.vecs[edge.vec21].p,
patch.verts[edge.v2].p, &patch.vecs[pVertex->Binding.nBefore2].p, &patch.vecs[pVertex->Binding.nBefore].p,
&patch.vecs[pVertex->Binding.nAfter].p, &patch.vecs[pVertex->Binding.nAfter2].p);
break;
default:
nlassert (0);
}
patch.vecs[pVertex->Binding.nT].p += patch.verts[nV].p-vOld;
}
}
patch.computeInteriors();
patch.InvalidateGeomCache();
}
// Build internal binding info
void RPatchMesh::UpdateBindingInfo (PatchMesh& patch)
{
// Make tab vert to edge list
// Static table to avoid alloc prb
CVertexNeighborhood& tab=vertexNeighborhoodGlobal;
tab.build (patch);
for (int n=0; n<patch.numVerts; n++)
{
if (getUIVertex (n).Binding.bBinded)
{
int v0=patch.edges[patch.patches[getUIVertex (n).Binding.nPatch].edge[getUIVertex (n).Binding.nEdge]].v1;
int v1=patch.edges[patch.patches[getUIVertex (n).Binding.nPatch].edge[getUIVertex (n).Binding.nEdge]].v2;
int vB=-1;
int vA=-1;
int vT=-1;
// Count of neigbor for vertex n
uint listSize=tab.getNeighborCount (n);
// List of neigbor
const uint* pList=tab.getNeighborList (n);
// For each neigbor
for (uint nn=0; nn<listSize; nn++)
{
if (getUIVertex (n).Binding.nType==BIND_25)
{
if (IsVertexInEdge (v0, pList[nn], patch))
{
nlassert (vB==-1);
vB=pList[nn];
}
else if (IsVertexInEdge (getUIVertex (n).Binding.nPrimVert, pList[nn], patch))
{
nlassert (vA==-1);
vA=pList[nn];
}
else
{
vT=pList[nn];
}
}
else if (getUIVertex (n).Binding.nType==BIND_75)
{
if (IsVertexInEdge (getUIVertex (n).Binding.nPrimVert, pList[nn], patch))
{
nlassert (vB==-1);
vB=pList[nn];
}
else if (IsVertexInEdge (v1, pList[nn], patch))
{
nlassert (vA==-1);
vA=pList[nn];
}
else
{
vT=pList[nn];
}
}
else if (getUIVertex (n).Binding.nType==BIND_50)
{
int nother=GetOtherVertex (n, pList[nn], patch);
nlassert (nother!=-1);
if ((getUIVertex (nother).Binding.bBinded&&
(getUIVertex (nother).Binding.nType==BIND_25)&&
(getUIVertex (nother).Binding.nPrimVert==(uint)n)))
{
nlassert (vB==-1);
vB=pList[nn];
}
else if ((getUIVertex (nother).Binding.bBinded&&
(getUIVertex (nother).Binding.nType==BIND_75)&&
(getUIVertex (nother).Binding.nPrimVert==(uint)n)))
{
nlassert (vA==-1);
vA=pList[nn];
}
else
{
vT=pList[nn];
}
}
else if (getUIVertex (n).Binding.nType==BIND_SINGLE)
{
int nother=GetOtherVertex (n, pList[nn], patch);
nlassert (nother!=-1);
if (IsVertexInEdge (v0, pList[nn], patch))
{
nlassert (vB==-1);
vB=pList[nn];
}
else if (IsVertexInEdge (v1, pList[nn], patch))
{
nlassert (vA==-1);
vA=pList[nn];
}
else
{
vT=pList[nn];
}
}
}
nlassert (vB!=-1);
nlassert (vA!=-1);
nlassert (vT!=-1);
getUIVertex (n).Binding.nBefore=(patch.edges[vB].v1==n)?patch.edges[vB].vec12:patch.edges[vB].vec21;
getUIVertex (n).Binding.nAfter=(patch.edges[vA].v1==n)?patch.edges[vA].vec12:patch.edges[vA].vec21;
getUIVertex (n).Binding.nT=(patch.edges[vT].v1==n)?patch.edges[vT].vec12:patch.edges[vT].vec21;
getUIVertex (n).Binding.nBefore2=(patch.edges[vB].v1==n)?patch.edges[vB].vec21:patch.edges[vB].vec12;
getUIVertex (n).Binding.nAfter2=(patch.edges[vA].v1==n)?patch.edges[vA].vec21:patch.edges[vA].vec12;
}
}
}
// Update binding
void RPatchMesh::UpdateBinding (PatchMesh& patch, TimeValue t)
{
if (!ValidBindingInfo.InInterval (t))
{
ValidBindingInfo=FOREVER;
UpdateBindingInfo (patch);
}
if (!ValidBindingPos.InInterval (t))
{
ValidBindingPos=FOREVER;
UpdateBindingPos (patch);
}
}
// Fill the binding info for a vertex. Don't forget to call UpdateBindingInfo after
void RPatchMesh::BindingVertex (int nVertex, int nPatch, int nEdge, int nPrimary, typeBind nType)
{
// Some check
nlassert (nVertex>=0);
nlassert (nVertex<(sint)getUIVertexSize());
nlassert (nPrimary>=0);
nlassert (nPrimary<(sint)getUIVertexSize());
nlassert (nPatch>=0);
nlassert (nPatch<(sint)getUIPatchSize());
nlassert (nEdge>=0);
nlassert (nEdge<4);
nlassert ((nType==BIND_25)||(nType==BIND_50)||(nType==BIND_75)||(nType==BIND_SINGLE));
// Go...
getUIVertex (nVertex).Binding.bBinded=true;
getUIVertex (nVertex).Binding.nPatch=nPatch;
getUIVertex (nVertex).Binding.nEdge=nEdge;
getUIVertex (nVertex).Binding.nType=nType;
getUIVertex (nVertex).Binding.nPrimVert=nPrimary;
getUIVertex (nVertex).Binding.nBefore=-1;
getUIVertex (nVertex).Binding.nAfter=-1;
getUIVertex (nVertex).Binding.nT=-1;
getUIVertex (nVertex).Binding.nBefore2=-1;
getUIVertex (nVertex).Binding.nAfter2=-1;
}
// Unbind a vertex
void RPatchMesh::UnBindingVertex (int nVertex)
{
getUIVertex (nVertex).Binding.bBinded=false;
getUIVertex (nVertex).Binding.nAfter=-1;
getUIVertex (nVertex).Binding.nAfter2=-1;
getUIVertex (nVertex).Binding.nBefore=-1;
getUIVertex (nVertex).Binding.nBefore2=-1;
getUIVertex (nVertex).Binding.nT=-1;
}
// Resize vertex buffer
void RPatchMesh::SetNumVerts (int nVert)
{
int nOldSize=getUIVertexSize();
resizeUIVertex (nVert);
for (int n=nOldSize; n<nVert; n++)
{
getUIVertex (n).Init ();
}
}
// Resize patch buffer
void RPatchMesh::SetNumPatches (int nPatch)
{
int nOldSize=getUIPatchSize();
resizeUIPatch (nPatch);
for (int n=nOldSize; n<nPatch; n++)
{
getUIPatch (n).Init ();
}
// Resize sel array
tileSel.SetSize (NUM_TILE_SEL*nPatch, 1);
}
// Subdivide both way
void RPatchMesh::Subdivide (int nPatch, int nV0, int nV1, int nV2, int nV3, int nCenter, int nFirstPatch, PatchMesh& patch)
{
// Subdivide patch
int nOldTileCount=(1<<getUIPatch (nPatch).NbTilesU)*(1<<getUIPatch (nPatch).NbTilesV);
int nOldVertexCount=((1<<getUIPatch (nPatch).NbTilesU)+1)*((1<<getUIPatch (nPatch).NbTilesV)+1);
int nTileU=max (0, (int)getUIPatch (nPatch).NbTilesU-1);
int nTileV=max (0, (int)getUIPatch (nPatch).NbTilesV-1);
// Copy info
int nTileCountU=1<<nTileU;
int nTileCountV=1<<nTileV;
// * 0
// Patch ptr
UI_PATCH *pPatch=&getUIPatch (nFirstPatch);
// Init patch info without intialize tabl
pPatch->Init (nTileU, nTileV, true);
int v;
for(v=0; v<nTileCountV; v++)
for(int u=0; u<nTileCountU; u++)
{
// Tile info
int nTile=u+v*nTileCountU;
nlassert (nTile<(int)pPatch->getTileSize());
int nOldTile=u+(2*nTileCountU*v);
nOldTile%=nOldTileCount;
nlassert (nOldTile<(int)getUIPatch (nPatch).getTileSize());
pPatch->getTileDesc (nTile)=getUIPatch (nPatch).getTileDesc (nOldTile);
}
for(v=0; v<nTileCountV+1; v++)
for(int u=0; u<nTileCountU+1; u++)
{
// Vertex info
int nVertex=u+v*(nTileCountU+1);
nlassert (nVertex<(int)pPatch->getColorSize());
int nOldVertex=u+((2*nTileCountU+1)*v);
nOldVertex%=nOldVertexCount;
nlassert (nOldVertex<(int)getUIPatch (nPatch).getColorSize());
pPatch->setColor (nVertex, getUIPatch (nPatch).getColor (nOldVertex));
}
// Edge info
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (0);
pPatch->getEdge (3)=getUIPatch (nPatch).getEdge (3);
// * 1
// Patch ptr
pPatch++;
// Init patch info without intialize tabl
pPatch->Init (nTileV, nTileU, true);
for(v=0; v<nTileCountV; v++)
for(int u=0; u<nTileCountU; u++)
{
// Tile info
int nTile=(nTileCountV-1-v)+u*nTileCountV;
nlassert (nTile<(int)pPatch->getTileSize());
int nOldTile=u+(2*nTileCountU*(nTileCountV+v));
nOldTile%=nOldTileCount;
nlassert (nOldTile<(int)getUIPatch (nPatch).getTileSize());
/*pPatch->Tile[nTile]=getUIPatch (nPatch).Tile[nOldTile];
pPatch->Tile[nTile].Rotate=(getUIPatch (nPatch).Tile[nOldTile].Rotate+3)&3;*/
pPatch->getTileDesc (nTile)=getUIPatch (nPatch).getTileDesc (nOldTile);
pPatch->getTileDesc (nTile).rotate (3);
}
for(v=0; v<nTileCountV+1; v++)
for(int u=0; u<nTileCountU+1; u++)
{
// Vertex info
int nVertex=(nTileCountV-v)+u*(nTileCountV+1);
nlassert (nVertex<(int)pPatch->getColorSize());
int nOldVertex=u+((2*nTileCountU+1)*(nTileCountV+v));
nOldVertex%=nOldVertexCount;
nlassert (nOldVertex<(int)getUIPatch (nPatch).getColorSize());
pPatch->setColor (nVertex, getUIPatch (nPatch).getColor (nOldVertex));
}
// Edge info
pPatch->getEdge (3)=getUIPatch (nPatch).getEdge (0);
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (1);
// * 2
// Patch ptr
pPatch++;
// Init patch info without intialize tabl
pPatch->Init (nTileU, nTileV, true);
for(v=0; v<nTileCountV; v++)
for(int u=0; u<nTileCountU; u++)
{
// Tile info
int nTile=(nTileCountU-1-u)+(nTileCountV-1-v)*nTileCountU;
nlassert (nTile<(int)pPatch->getTileSize());
int nOldTile=nTileCountU+u+(2*nTileCountU*(nTileCountV+v));
nOldTile%=nOldTileCount;
nlassert (nOldTile<(int)getUIPatch (nPatch).getTileSize());
pPatch->getTileDesc (nTile)=getUIPatch (nPatch).getTileDesc (nOldTile);
//pPatch->Tile[nTile].Rotate=(getUIPatch (nPatch).Tile[nOldTile].Rotate+2)&3;
pPatch->getTileDesc (nTile).rotate (2);
}
for(v=0; v<nTileCountV+1; v++)
for(int u=0; u<nTileCountU+1; u++)
{
// Vertex info
int nVertex=(nTileCountU-u)+(nTileCountV-v)*(nTileCountU+1);
nlassert (nVertex<(int)pPatch->getColorSize());
int nOldVertex=nTileCountU+u+((2*nTileCountU+1)*(nTileCountV+v));
nOldVertex%=nOldVertexCount;
nlassert (nOldVertex<(int)getUIPatch (nPatch).getColorSize());
pPatch->setColor (nVertex, getUIPatch (nPatch).getColor (nOldVertex));
}
// Edge info
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (2);
pPatch->getEdge (3)=getUIPatch (nPatch).getEdge (1);
// * 3
// Patch ptr
pPatch++;
// Init patch info without intialize tabl
pPatch->Init (nTileV, nTileU, true);
for(v=0; v<nTileCountV; v++)
for(int u=0; u<nTileCountU; u++)
{
// Tile info
int nTile=v+(nTileCountU-1-u)*nTileCountV;
nlassert (nTile<(int)pPatch->getTileSize());
int nOldTile=nTileCountU+u+(2*nTileCountU*v);
nOldTile%=nOldTileCount;
nlassert (nOldTile<(int)getUIPatch (nPatch).getTileSize());
pPatch->getTileDesc (nTile)=getUIPatch (nPatch).getTileDesc (nOldTile);
//pPatch->Tile[nTile].Rotate=(getUIPatch (nPatch).Tile[nOldTile].Rotate+1)&3;
pPatch->getTileDesc (nTile).rotate (1);
}
for(v=0; v<nTileCountV+1; v++)
for(int u=0; u<nTileCountU+1; u++)
{
// Vertex info
int nVertex=v+(nTileCountU-u)*(nTileCountV+1);
nlassert (nVertex<(int)pPatch->getColorSize());
int nOldVertex=nTileCountU+u+((2*nTileCountU+1)*v);
nOldVertex%=nOldVertexCount;
nlassert (nOldVertex<(int)getUIPatch (nPatch).getColorSize());
pPatch->setColor (nVertex, getUIPatch (nPatch).getColor (nOldVertex));
}
// Edge info
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (3);
pPatch->getEdge (3)=getUIPatch (nPatch).getEdge (2);
// Update binding info
for (int i=0; i<(int)getUIVertexSize(); i++)
{
if (getUIVertex (i).Binding.bBinded)
{
if ((int)getUIVertex (i).Binding.nPatch==nPatch)
{
UnBindingVertex (i);
}
}
}
UnbindRelatedPatch (nPatch, patch);
InvalidateBindingInfo ();
}
// Subdivide edge 1 and 3
void RPatchMesh::SubdivideU (int nPatch, int nV0, int nV1, int nFirstPatch, PatchMesh& patch)
{
// Subdivide patch
int nOldTileCount=(1<<getUIPatch (nPatch).NbTilesU)*(1<<getUIPatch (nPatch).NbTilesV);
int nOldVertexCount=((1<<getUIPatch (nPatch).NbTilesU)+1)*((1<<getUIPatch (nPatch).NbTilesV)+1);
int nTileU=(int)getUIPatch (nPatch).NbTilesV;
int nTileV=max (0, (int)getUIPatch (nPatch).NbTilesU-1);
for (int nNewPatch=nFirstPatch; nNewPatch<nFirstPatch+2; nNewPatch++)
{
// Patch ptr
UI_PATCH *pPatch=&getUIPatch (nNewPatch);
// New patch number
int nNewPatchNum=nNewPatch-nFirstPatch;
// Coord of the subpatch
int nU=nNewPatchNum;
// Init patch info without intialize tabl
pPatch->Init (nTileU, nTileV, true);
// Copy info
int nTileCountU=1<<nTileU;
int nTileCountV=1<<nTileV;
int v;
for(v=0; v<nTileCountV; v++)
for(int u=0; u<nTileCountU; u++)
{
// Tile info
int nTile=u+v*nTileCountU;
nlassert (nTile<(int)pPatch->getTileSize());
int nOldTile=v+nTileCountV*nU+(nTileCountU-1-u)*nTileCountV*2;
nOldTile%=nOldTileCount;
nlassert (nOldTile<(int)getUIPatch (nPatch).getTileSize());
pPatch->getTileDesc (nTile)=getUIPatch (nPatch).getTileDesc (nOldTile);
//pPatch->Tile[nTile].Rotate=(getUIPatch (nPatch).Tile[nOldTile].Rotate+3)&3;
pPatch->getTileDesc (nTile).rotate (3);
}
for(v=0; v<nTileCountV+1; v++)
for(int u=0; u<nTileCountU+1; u++)
{
// Vertex info
int nVertex=u+v*(nTileCountU+1);
nlassert (nVertex<(int)pPatch->getColorSize());
int nOldVertex=v+nTileCountV*nU+(nTileCountU-u)*(nTileCountV*2+1);
nOldVertex%=nOldVertexCount;
nlassert (nOldVertex<(int)getUIPatch (nPatch).getColorSize ());
pPatch->setColor (nVertex, getUIPatch (nPatch).getColor (nOldVertex));
}
// Edge info
if (nNewPatch==nFirstPatch)
{
pPatch->getEdge (3)=getUIPatch (nPatch).getEdge (0);
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (1);
pPatch->getEdge (2)=getUIPatch (nPatch).getEdge (3);
}
else
{
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (1);
pPatch->getEdge (1)=getUIPatch (nPatch).getEdge (2);
pPatch->getEdge (2)=getUIPatch (nPatch).getEdge (3);
}
}
// Update binding info
for (int i=0; i<(int)getUIVertexSize(); i++)
{
if ((getUIVertex (i).Binding.bBinded)&&((int)getUIVertex (i).Binding.nPatch==nPatch))
{
if (getUIVertex (i).Binding.nEdge&1)
{
UnBindingVertex (i);
}
else
{
if (getUIVertex (i).Binding.nEdge==0)
{
getUIVertex (i).Binding.nPatch=nFirstPatch;
getUIVertex (i).Binding.nEdge=3;
}
else
{
nlassert (getUIVertex (i).Binding.nEdge==2);
getUIVertex (i).Binding.nPatch=nFirstPatch+1;
getUIVertex (i).Binding.nEdge=1;
}
}
}
}
UnbindRelatedPatch (nPatch, patch);
InvalidateBindingInfo ();
}
// Subdivide edge 0 and 2
void RPatchMesh::SubdivideV (int nPatch, int nV0, int nV1, int nFirstPatch, PatchMesh& patch)
{
// Subdivide patch
int nOldTileCount=(1<<getUIPatch (nPatch).NbTilesU)*(1<<getUIPatch (nPatch).NbTilesV);
int nOldVertexCount=((1<<getUIPatch (nPatch).NbTilesU)+1)*((1<<getUIPatch (nPatch).NbTilesV)+1);
int nTileU=getUIPatch (nPatch).NbTilesU;
int nTileV=max (0, (int)getUIPatch (nPatch).NbTilesV-1);
for (int nNewPatch=nFirstPatch; nNewPatch<nFirstPatch+2; nNewPatch++)
{
// Patch ptr
UI_PATCH *pPatch=&getUIPatch (nNewPatch);
// New patch number
int nNewPatchNum=nNewPatch-nFirstPatch;
// Coord of the subpatch
int nV=nNewPatchNum;
// Init patch info without intialize tabl
pPatch->Init (nTileU, nTileV, true);
// Copy info
int nTileCountU=1<<nTileU;
int nTileCountV=1<<nTileV;
int v;
int u;
for(v=0; v<nTileCountV; v++)
for(u=0; u<nTileCountU; u++)
{
// Tile info
int nTile=u+v*nTileCountU;
nlassert (nTile<(int)pPatch->getTileSize());
int nOldTile=u+(nTileCountU*(nV*nTileCountV+v));
nOldTile%=nOldTileCount;
nlassert (nOldTile<(int)getUIPatch (nPatch).getTileSize());
pPatch->getTileDesc (nTile)=getUIPatch (nPatch).getTileDesc (nOldTile);
//pPatch->Tile[nTile].Rotate=getUIPatch (nPatch).Tile[nOldTile].Rotate;
}
for(v=0; v<nTileCountV+1; v++)
for(u=0; u<nTileCountU+1; u++)
{
// Vertex info
int nVertex=u+v*(nTileCountU+1);
nlassert (nVertex<(int)pPatch->getColorSize());
int nOldVertex=u+((nTileCountU+1)*(nV*nTileCountV+v));
nOldVertex%=nOldVertexCount;
nlassert (nOldVertex<(int)getUIPatch (nPatch).getColorSize());
pPatch->setColor (nVertex, getUIPatch (nPatch).getColor (nOldVertex));
}
// Edge info
if (nNewPatch==nFirstPatch)
{
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (0);
pPatch->getEdge (2)=getUIPatch (nPatch).getEdge (2);
pPatch->getEdge (3)=getUIPatch (nPatch).getEdge (3);
}
else
{
pPatch->getEdge (0)=getUIPatch (nPatch).getEdge (0);
pPatch->getEdge (1)=getUIPatch (nPatch).getEdge (1);
pPatch->getEdge (2)=getUIPatch (nPatch).getEdge (2);
}
}
// Update binding info
for (int i=0; i<(int)getUIVertexSize (); i++)
{
if ((getUIVertex (i).Binding.bBinded)&&((int)getUIVertex (i).Binding.nPatch==nPatch))
{
if ((getUIVertex (i).Binding.nEdge&1)==0)
{
UnBindingVertex (i);
}
else
{
if (getUIVertex (i).Binding.nEdge==1)
{
getUIVertex (i).Binding.nPatch=nFirstPatch+1;
getUIVertex (i).Binding.nEdge=1;
}
else
{
nlassert (getUIVertex (i).Binding.nEdge==3);
getUIVertex (i).Binding.nPatch=nFirstPatch;
getUIVertex (i).Binding.nEdge=3;
}
}
}
}
UnbindRelatedPatch (nPatch, patch);
InvalidateBindingInfo ();
}
// return on which edge is
int WhereIsTheEdge (int nPatch, int nEdge, const PatchMesh& patch)
{
for (int i=0; i<4; i++)
{
if ((patch.patches[nPatch].edge[i])==nEdge)
return i;
}
nlassert (0);
return -1;
}
// AddHook
void RPatchMesh::AddHook (int nVert, int nSeg, PatchMesh& patch)
{
#if (MAX_RELEASE < 4000)
// Une side of the edge must be cleared
nlassert (patch.edges[nSeg].patch2==-1);
int patch1 = patch.edges[nSeg].patch1;
#else // (MAX_RELEASE < 4000)
// Une side of the edge must be cleared
nlassert (patch.edges[nSeg].patches.Count()<2);
int patch1 = patch.edges[nSeg].patches.Count()>0?patch.edges[nSeg].patches[0]:-1;
#endif // (MAX_RELEASE < 4000)
int nEdge=WhereIsTheEdge(patch1, nSeg, patch);
nlassert(patch.patches[patch1].edge[nEdge]==nSeg);
BindingVertex(nVert, patch1, nEdge, nVert, BIND_SINGLE);
InvalidateBindingInfo ();
}
// AddHook
void RPatchMesh::AddHook (int nVert0, int nVert1, int nVert2, int nSeg, PatchMesh& patch)
{
#if (MAX_RELEASE < 4000)
// Une side of the edge must be cleared
nlassert (patch.edges[nSeg].patch2==-1);
int patch1 = patch.edges[nSeg].patch1;
#else // (MAX_RELEASE < 4000)
// Une side of the edge must be cleared
nlassert (patch.edges[nSeg].patches.Count()<2);
int patch1 = patch.edges[nSeg].patches.Count()>0?patch.edges[nSeg].patches[0]:-1;
#endif // (MAX_RELEASE < 4000)
int nEdge = WhereIsTheEdge(patch1, nSeg, patch);
BindingVertex(nVert0, patch1, nEdge, nVert1, BIND_25);
BindingVertex(nVert1, patch1, nEdge, nVert1, BIND_50);
BindingVertex(nVert2, patch1, nEdge, nVert1, BIND_75);
InvalidateBindingInfo ();
}
// RemoveHook
void RPatchMesh::RemoveHook (PatchMesh& patch)
{
for (int i=0; i<patch.numVerts; i++)
{
if (patch.vertSel[i])
UnbindRelatedVertex (i, patch);
}
}
// Attach -> binding safe
void RPatchMesh::Attach(RPatchMesh *rattPatch, PatchMesh& patch)
{
// Add to the end.
// Resize buffers
int nOldVertCount=getUIVertexSize();
int nOldPolyCount=getUIPatchSize();
int nNewVertCount=nOldVertCount+rattPatch->getUIVertexSize();
int nNewPolyCount=nOldPolyCount+rattPatch->getUIPatchSize();
SetNumVerts (nNewVertCount);
SetNumPatches (nNewPolyCount);
// Add vert and patch, binding safe
for (int nV=0; nV<nNewVertCount-nOldVertCount; nV++)
{
getUIVertex (nOldVertCount+nV)=rattPatch->getUIVertex (nV);
// Bind patch
if (getUIVertex (nOldVertCount+nV).Binding.bBinded)
{
getUIVertex (nOldVertCount+nV).Binding.nPatch+=nOldPolyCount;
getUIVertex (nOldVertCount+nV).Binding.nPrimVert+=nOldVertCount;
}
}
for (int nP=0; nP<nNewPolyCount-nOldPolyCount; nP++)
getUIPatch (nOldPolyCount+nP)=rattPatch->getUIPatch (nP);
InvalidateBindingInfo ();
}
int GetAdjacent (int nMe, int nedge, PatchMesh *pMesh)
{
int nEdge=pMesh->patches[nMe].edge[nedge];
#if (MAX_RELEASE < 4000)
if (pMesh->edges[nEdge].patch1==nMe)
return pMesh->edges[nEdge].patch2;
else
{
nlassert (pMesh->edges[nEdge].patch2==nMe);
return pMesh->edges[nEdge].patch1;
}
#else // (MAX_RELEASE < 4000)
if ((pMesh->edges[nEdge].patches.Count()>0?pMesh->edges[nEdge].patches[0]:-1)==nMe)
return (pMesh->edges[nEdge].patches.Count()>1?pMesh->edges[nEdge].patches[1]:-1);
else
{
nlassert ((pMesh->edges[nEdge].patches.Count()>1?pMesh->edges[nEdge].patches[1]:-1)==nMe);
return (pMesh->edges[nEdge].patches.Count()>0?pMesh->edges[nEdge].patches[0]:-1);
}
#endif // (MAX_RELEASE < 4000)
}
// return on which edge is
int WhereInMyAdjacent (int nMe, int nAdjacent, PatchMesh *pMesh)
{
for (int i=0; i<4; i++)
{
if (GetAdjacent (nAdjacent, i, pMesh)==nMe)
return i;
}
return -1;
}
// Extrude
void RPatchMesh::CreateExtrusion (PatchMesh *patch)
{
// Resize buffer
int nOldVertCount=getUIVertexSize();
int nOldPolyCount=getUIPatchSize();
int nNewVertCount=patch->getNumVerts ();
int nNewPolyCount=patch->getNumPatches ();
SetNumVerts (nNewVertCount);
SetNumPatches (nNewPolyCount);
patch->buildLinkages();
// update bind data
for (int i=0; i<nOldPolyCount; i++)
{
// Patch selected
if (patch->patchSel[i])
{
/*int nNewFaces[4];
int nWhichEdge[4];
int nEdgeCount=(patch->patches[i].type==PATCH_QUAD)?4:3;
// For all edges
for (int nEdge=0; nEdge<nEdgeCount; nEdge++)
{
// Find the edge
int nE=patch->patches[i].edge[nEdge];
// Find the new face
FindPatch (patch, nE, nWhichEdge[nEdge], nNewFaces[nEdge], nOldPolyCount);
}
// Look for binded point...
for (int nV=0; nV<nOldVertCount; nV++)
{
if (getUIVertex (nV).Binding.bBinded)
{
if ((int)getUIVertex (nV).Binding.nPatch==i)
{
int nEd=getUIVertex (nV).Binding.nEdge;
// Must have been found
nlassert (nNewFaces[nEd]!=-1);
nlassert (nWhichEdge[nEd]!=-1);
UnBindingVertex (i);
getUIVertex (nV).Binding.nPatch=nNewFaces[nEd];
getUIVertex (nV).Binding.nEdge=(nWhichEdge[nEd]+2)&3;
}
}
}*/
// Look for binded point...
for (int nV=0; nV<nOldVertCount; nV++)
{
if (getUIVertex (nV).Binding.bBinded)
{
if ((int)getUIVertex (nV).Binding.nPatch==i)
{
UnbindRelatedVertex (nV, *patch);
}
}
}
}
}
InvalidateBindingInfo ();
// Reinit some patches to get the good UV tessel level
for (int nP=nOldPolyCount; nP<nNewPolyCount; nP++)
{
// Tessel
int nU=RPO_DEFAULT_TESSEL;
int nV=RPO_DEFAULT_TESSEL;
// Look for old adjacent patch
int nAdj=GetAdjacent (nP, 0, patch);
if ((nAdj==-1)||(nAdj>=nOldPolyCount))
nAdj=GetAdjacent (nP, 2, patch);
if ((nAdj!=-1)&&(nAdj<nOldPolyCount))
{
// Where in my adjacent patch
int nInAdj=WhereInMyAdjacent (nP, nAdj, patch);
// Very chelou!
nlassert (nInAdj!=-1);
// Rip U or V?
if (nInAdj&1)
nV=getUIPatch (nAdj).NbTilesU;
else
nV=getUIPatch (nAdj).NbTilesV;
}
// Look for old adjacent patch
nAdj=GetAdjacent (nP, 1, patch);
if ((nAdj==-1)||(nAdj>=nOldPolyCount))
nAdj=GetAdjacent (nP, 3, patch);
if ((nAdj!=-1)&&(nAdj<nOldPolyCount))
{
// Where in my adjacent patch
int nInAdj=WhereInMyAdjacent (nP, nAdj, patch);
// Very chelou!
nlassert (nInAdj!=-1);
// Rip U or V?
if (nInAdj&1)
nU=getUIPatch (nAdj).NbTilesU;
else
nU=getUIPatch (nAdj).NbTilesV;
}
// Reinit?
if ((nU!=RPO_DEFAULT_TESSEL)||(nV!=RPO_DEFAULT_TESSEL))
getUIPatch (nP).Init (nU, nV);
}
}
// Look for a patch with this edge
void RPatchMesh::FindPatch (PatchMesh *patch, int nEdge, int &WhichEdge, int &nPatch, int nFirstPatch)
{
// In the new polygones
int nn;
for (nn=nFirstPatch; nn<patch->numPatches; nn++)
{
int nv;
for (nv=0; nv<4; nv++)
{
if (patch->patches[nn].edge[nv]==nEdge)
{
nPatch=nn;
WhichEdge=nv;
break;
}
}
if (nv!=4)
break;
}
// Not found ?
if (nn==patch->numPatches)
{
nPatch=-1;
WhichEdge=-1;
}
}
// Resolve topologie changes -> Bind safe
void RPatchMesh::ResolveTopoChanges(PatchMesh *patch, bool aux1)
{
// Nombre de patches
if (patch->numPatches>(int)getUIPatchSize())
SetNumPatches (patch->numPatches);
if (patch->numVerts>(int)getUIVertexSize())
SetNumVerts (patch->numVerts);
// static array to avoid alloc prob
static std::vector<UI_PATCH> cUIPatch;
static std::vector<UI_VERTEX> cUIVertex;
static std::vector<int> pnRemapPatch;
static std::vector<int> pnRemapVertex;
// Reserve static array
cUIPatch.reserve (300);
cUIVertex.reserve (300);
pnRemapPatch.reserve (300);
pnRemapVertex.reserve (300);
// Resize arrays
pnRemapPatch.resize (0);
pnRemapPatch.resize (getUIPatchSize(), -1);
pnRemapVertex.resize (0);
pnRemapVertex.resize (getUIVertexSize(), -1);
// Fill the patch array
uint size=getUIPatchSize();
cUIPatch.resize (size);
uint n;
for (n=0; n<size; n++)
cUIPatch[n]=getUIPatch (n);
// Fill the vertex array
size=getUIVertexSize();
cUIVertex.resize (size);
for (n=0; n<size; n++)
cUIVertex[n]=getUIVertex (n);
// Build remap vertex info
int i;
for (i = 0; i < patch->numVerts; ++i)
{
int nTag;
if (aux1)
nTag=patch->verts[i].aux1;
else
nTag=patch->verts[i].aux2;
if (nTag>=0)
{
pnRemapVertex[nTag]=i;
}
}
// Build remap poly info
for (i = 0; i < patch->numPatches; ++i)
{
int nTag;
if (aux1)
nTag=patch->patches[i].aux1;
else
nTag=patch->patches[i].aux2;
if (nTag>=0)
{
pnRemapPatch[nTag]=i;
}
}
// Unbind vertex from deleted vertex
for (i=0; i<(int)pnRemapVertex.size(); i++)
{
if (pnRemapVertex[i]==-1)
{
UnbindRelatedVertex (i, *patch);
}
}
// Unbind vertex from deleted poly
for (i=0; i<(int)pnRemapPatch.size(); i++)
{
if (pnRemapPatch[i]==-1)
{
UnbindRelatedPatch (i, *patch);
}
}
// Remap poly info
for (i = 0; i < patch->numPatches; ++i)
{
int nTag;
if (aux1)
nTag=patch->patches[i].aux1;
else
nTag=patch->patches[i].aux2;
if (nTag>=0)
{
if (nTag!=i)
getUIPatch (i)=cUIPatch[nTag];
}
}
// Remap vertex info
for (i = 0; i < patch->numVerts; ++i)
{
int nTag;
if (aux1)
nTag=patch->verts[i].aux1;
else
nTag=patch->verts[i].aux2;
if ((nTag>=0)&&(nTag!=i))
{
getUIVertex (i)=cUIVertex[nTag];
}
if (getUIVertex (i).Binding.bBinded)
{
int nPatchTag;
nPatchTag=pnRemapPatch[cUIVertex[nTag].Binding.nPatch];
int nVertexTag=pnRemapVertex[cUIVertex[nTag].Binding.nPrimVert];
if ((nPatchTag==-1)||(nVertexTag==-1))
UnBindingVertex (i);
else
{
getUIVertex (i).Binding.nPrimVert=nVertexTag;
getUIVertex (i).Binding.nPatch=nPatchTag;
}
}
}
// Resize buffers
SetNumPatches (patch->numPatches);
SetNumVerts (patch->numVerts);
// Invalidate binding infos
InvalidateBindingInfo ();
}
// Weld -> Bind safe
void RPatchMesh::Weld (PatchMesh *patch)
{
ResolveTopoChanges(patch, false);
}
int GetEdgeNumberInPatch (int nPatch, int nEdge, PatchMesh *patch)
{
for (int i=0; i<4; i++)
{
if (patch->patches[nPatch].edge[i]==nEdge)
return i;
}
return -1;
}
// Add a patch
void RPatchMesh::AddPatch (int nEdge, int nFirstPatch, PatchMesh *patch)
{
// Add a patch
SetNumPatches (getUIPatchSize()+1);
// Find the tile resolution...
int nV=RPO_DEFAULT_TESSEL;
int nedge=GetEdgeNumberInPatch (nFirstPatch, nEdge, patch);
nlassert (nedge!=-1);
if (nedge&1)
nV=getUIPatch (nFirstPatch).NbTilesU;
else
nV=getUIPatch (nFirstPatch).NbTilesV;
getUIPatch (getUIPatchSize()-1).Init (nV, nV);
}
// Unbind vertex associed to the vertex
void RPatchMesh::UnbindRelatedVertex (int nVertex, PatchMesh& patch)
{
uint nFace=getUIVertex (nVertex).Binding.nPatch;
uint nEdge=getUIVertex (nVertex).Binding.nEdge;
for (int j=0; j<(int)getUIVertexSize(); j++)
{
if ((getUIVertex (j).Binding.bBinded)&&
(getUIVertex (j).Binding.nPatch==nFace)&&
(getUIVertex (j).Binding.nEdge==nEdge))
{
UnBindingVertex (j);
}
}
}
// Unbind vertex associed to the patch
void RPatchMesh::UnbindRelatedPatch (int nPatch, PatchMesh& patch)
{
for (int i=0; i<4; i++)
{
int n=patch.patches[nPatch].v[i];
if (getUIVertex (n).Binding.bBinded)
{
UnbindRelatedVertex (n, patch);
}
}
}
// Delete patches and vertices
void RPatchMesh::DeleteAndSweep (const BitArray &remapVerts, const BitArray &remapPatches, PatchMesh& patch)
{
int mapVSize=remapVerts.GetSize();
int vSize=getUIVertexSize();
int mapPSize=remapPatches.GetSize();
int pSize=getUIPatchSize();
nlassert (mapVSize==vSize);
nlassert (mapPSize==pSize);
int i,j;
// Unbind vertex from deleted vertex
for (i=0; i<(int)getUIVertexSize(); i++)
{
if (remapVerts[i])
{
UnbindRelatedVertex (i, patch);
}
}
// Unbind vertex from deleted poly
for (i=0; i<(int)getUIPatchSize(); i++)
{
if (remapPatches[i])
{
UnbindRelatedPatch (i, patch);
}
}
// Make vertex remap table
static std::vector<int> newVIndex;
newVIndex.reserve (1000);
newVIndex.resize (vSize);
for (i=0, j=0; i<vSize; i++)
{
if (i!=j)
getUIVertex (j)=getUIVertex (i);
if (remapVerts[i])
newVIndex[i]=-1;
else
newVIndex[i]=j++;
}
SetNumVerts (j);
//UIVertex.resize (j);
// Make patch remap table
static std::vector<int> newPIndex;
newPIndex.reserve (1000);
newPIndex.resize (pSize);
for (i=0, j=0; i<pSize; i++)
{
if (i!=j)
getUIPatch (j)=getUIPatch (i);
if (remapPatches[i])
newPIndex[i]=-1;
else
newPIndex[i]=j++;
}
SetNumPatches (j);
//getUIPatch )resize (j);
// Remap bind
for (i=0; i<(int)getUIVertexSize(); i++)
{
if (getUIVertex (i).Binding.bBinded)
{
int nPrim=newVIndex[getUIVertex (i).Binding.nPrimVert];
int nPatch=newPIndex[getUIVertex (i).Binding.nPatch];
if ((nPatch==-1)||(nPrim==-1))
UnBindingVertex (i);
else
{
getUIVertex (i).Binding.nPrimVert=nPrim;
getUIVertex (i).Binding.nPatch=nPatch;
}
}
}
InvalidateBindingInfo ();
}
// Invalidate channels
void RPatchMesh::InvalidateChannels(ChannelMask channels)
{
if (channels&TOPO_CHANNEL)
{
ValidTopo=NEVER;
//InvalidateBindingInfo ();
}
if (channels&GEOM_CHANNEL)
{
ValidGeom=NEVER;
//InvalidateBindingPos ();
}
if (channels&SELECT_CHANNEL)
ValidSelect=NEVER;
if (channels&TEXMAP_CHANNEL)
ValidTexmap=NEVER;
if (channels&DISP_ATTRIB_CHANNEL)
ValidDisplay=NEVER;
}
// Load
IOResult RPatchMesh::Load(ILoad *iload)
{
ULONG nb;
// Version
unsigned int nVersion;
iload->Read(&nVersion, sizeof (nVersion), &nb);
switch (nVersion)
{
case RPATCHMESH_SERIALIZE_VERSION_9:
case RPATCHMESH_SERIALIZE_VERSION_8:
case RPATCHMESH_SERIALIZE_VERSION_7:
case RPATCHMESH_SERIALIZE_VERSION_6:
case RPATCHMESH_SERIALIZE_VERSION_5:
case RPATCHMESH_SERIALIZE_VERSION_4:
case RPATCHMESH_SERIALIZE_VERSION_3:
case RPATCHMESH_SERIALIZE_VERSION_2:
case RPATCHMESH_SERIALIZE_VERSION_1:
{
// Patch info
int nSize;
iload->Read(&nSize, sizeof (nSize), &nb);
SetNumPatches (nSize);
int i;
for (i=0; i<nSize; i++)
{
iload->Read(&getUIPatch (i).NbTilesU, sizeof (int), &nb);
iload->Read(&getUIPatch (i).NbTilesV, sizeof (int), &nb);
if (nVersion<RPATCHMESH_SERIALIZE_VERSION_3)
{
// Tiles
int nSize2;
iload->Read(&nSize2, sizeof (int), &nb);
for (int j=0; j<nSize2; j++)
{
int old;
iload->Read(&old, sizeof (int), &nb);
iload->Read(&old, sizeof (int), &nb);
getUIPatch (i).getTileDesc (j).setEmpty ();
}
}
else // RPATCHMESH_SERIALIZE_VERSION_3
{
// Tiles
int nSize2;
iload->Read(&nSize2, sizeof (int), &nb);
for (int j=0; j<nSize2; j++)
{
iload->Read(&getUIPatch (i).getTileDesc (j)._Num, sizeof (USHORT), &nb);
// Version 5, number of cell for 256x256 tiles
if (nVersion>=RPATCHMESH_SERIALIZE_VERSION_5)
iload->Read(&getUIPatch (i).getTileDesc (j)._Flags, sizeof (USHORT), &nb);
else
getUIPatch (i).getTileDesc (j)._Flags=0;
// Clear displace flags in version lower than 8
if (nVersion<RPATCHMESH_SERIALIZE_VERSION_9)
{
// Random a noise tile between 0 and 7
uint noise=rand ()&0x7;
getUIPatch (i).getTileDesc (j).setDisplace (noise);
}
else
{
// Read the noise
uint8 noise;
iload->Read(&noise, sizeof (uint8), &nb);
getUIPatch (i).getTileDesc (j).setDisplace (noise);
}
for (int k=0; k<3; k++)
{
bool invert;
int tile;
int rotate;
iload->Read(&invert, sizeof (bool), &nb);
iload->Read(&tile, sizeof (int), &nb);
iload->Read(&rotate, sizeof (int), &nb);
// Not used anymore getUIPatch (i).getTileDesc (j)._MatIDTab[k].Invert=invert;
getUIPatch (i).getTileDesc (j)._MatIDTab[k].Tile=tile;
getUIPatch (i).getTileDesc (j)._MatIDTab[k].Rotate=rotate;
}
}
}
// Colors
int nSize2;
iload->Read(&nSize2, sizeof (int), &nb);
for (int j=0; j<nSize2; j++)
{
uint color;
iload->Read(&color, sizeof (uint), &nb);
getUIPatch (i).setColor (j, color);
// Before RPATCHMESH_SERIALIZE_VERSION_6, force color to white
if (nVersion<RPATCHMESH_SERIALIZE_VERSION_6)
getUIPatch (i).setColor (j, 0xffffff);
}
// Edges info
if (nVersion>=RPATCHMESH_SERIALIZE_VERSION_7)
{
// Save the 4 edges
for (int e=0; e<4; e++)
{
// Get an edge ref
CEdgeInfo& edge=getUIPatch (i).getEdge (e);
// Read it
iload->Read(&edge.Flags, sizeof (uint32), &nb);
}
}
}
// Vertex info
iload->Read(&nSize, sizeof (nSize), &nb);
SetNumVerts (nSize);
for (i=0; i<nSize; i++)
{
bool bBinded;
typeBind nType;
uint nEdge;
uint nPatch;
uint nBefore;
uint nBefore2;
uint nAfter;
uint nAfter2;
uint nT;
uint nPrimVert;
iload->Read(&bBinded, sizeof (bool), &nb);
iload->Read(&nType, sizeof (typeBind), &nb);
iload->Read(&nEdge, sizeof (uint), &nb);
iload->Read(&nPatch, sizeof (uint), &nb);
iload->Read(&nBefore, sizeof (uint), &nb);
iload->Read(&nBefore2, sizeof (uint), &nb);
iload->Read(&nAfter, sizeof (uint), &nb);
iload->Read(&nAfter2, sizeof (uint), &nb);
iload->Read(&nT, sizeof (uint), &nb);
iload->Read(&nType, sizeof (typeBind), &nb);
iload->Read(&nPrimVert, sizeof (uint), &nb);
getUIVertex (i).Binding.bBinded=bBinded;
getUIVertex (i).Binding.nType=nType;
getUIVertex (i).Binding.nEdge=nEdge;
getUIVertex (i).Binding.nPatch=nPatch;
getUIVertex (i).Binding.nBefore=nBefore;
getUIVertex (i).Binding.nBefore2=nBefore2;
getUIVertex (i).Binding.nAfter=nAfter;
getUIVertex (i).Binding.nAfter2=nAfter2;
getUIVertex (i).Binding.nT=nT;
getUIVertex (i).Binding.nType=nType;
getUIVertex (i).Binding.nPrimVert=nPrimVert;
}
// Some info
iload->Read(&rTess.TileTesselLevel, sizeof (rTess.TileTesselLevel), &nb);
iload->Read(&rTess.ModeTile, sizeof (rTess.ModeTile), &nb);
iload->Read(&rTess.KeepMapping, sizeof (rTess.KeepMapping), &nb);
if (nVersion==RPATCHMESH_SERIALIZE_VERSION_4)
iload->Read(&rTess.TransitionType, sizeof (rTess.TransitionType), &nb);
iload->Read(&selLevel, sizeof (selLevel), &nb);
}
break;
default:
return IO_ERROR;
}
ValidGeom.SetEmpty();
ValidTopo.SetEmpty();
ValidTexmap.SetEmpty();
ValidSelect.SetEmpty();
ValidDisplay.SetEmpty();
ValidBindingInfo.SetEmpty();
ValidBindingPos.SetEmpty();
return IO_OK;
}
// Save
IOResult RPatchMesh::Save(ISave *isave)
{
ULONG nb;
// Version
unsigned int nVersion=RPATCHMESH_SERIALIZE_VERSION;
isave->Write(&nVersion, sizeof (nVersion), &nb);
// Patch info
int nSize=getUIPatchSize();
isave->Write(&nSize, sizeof (nSize), &nb);
int i;
for (int i=0; i<nSize; i++)
{
isave->Write(&getUIPatch (i).NbTilesU, sizeof (int), &nb);
isave->Write(&getUIPatch (i).NbTilesV, sizeof (int), &nb);
// Tiles
int nSize2=getUIPatch (i).getTileSize();
isave->Write(&nSize2, sizeof (int), &nb);
int j;
for (j=0; j<nSize2; j++)
{
USHORT num=getUIPatch (i).getTileDesc (j)._Num;
isave->Write(&num, sizeof (USHORT), &nb);
num=getUIPatch (i).getTileDesc (j)._Flags;
isave->Write(&num, sizeof (USHORT), &nb);
// Save noise
uint8 noise=getUIPatch (i).getTileDesc (j).getDisplace ();
isave->Write(&noise, sizeof (uint8), &nb);
for (int k=0; k<3; k++)
{
bool invert = false;
int tile;
int rotate;
// Not used anymore invert=(getUIPatch (i).getTileDesc (j)._MatIDTab[k].Invert!=0);
tile=getUIPatch (i).getTileDesc (j)._MatIDTab[k].Tile;
rotate=getUIPatch (i).getTileDesc (j)._MatIDTab[k].Rotate;
isave->Write(&invert, sizeof (bool), &nb);
isave->Write(&tile, sizeof (int), &nb);
isave->Write(&rotate, sizeof (int), &nb);
}
}
// Colors
nSize2=getUIPatch (i).getColorSize();
isave->Write(&nSize2, sizeof (int), &nb);
for (j=0; j<nSize2; j++)
{
uint color=getUIPatch (i).getColor (j);
isave->Write(&color, sizeof (int), &nb);
}
// Edges info (nVersion >= RPATCHMESH_SERIALIZE_VERSION_7)
// Save the 4 edges
for (int e=0; e<4; e++)
{
// Get an edge ref
const CEdgeInfo& edge=getUIPatch (i).getEdge (e);
// Write it
isave->Write(&edge.Flags, sizeof (uint32), &nb);
}
}
// Vertex info
nSize=getUIVertexSize();
isave->Write(&nSize, sizeof (nSize), &nb);
for (i=0; i<nSize; i++)
{
bool bBinded=(getUIVertex (i).Binding.bBinded!=0);
uint nEdge=getUIVertex (i).Binding.nEdge;
uint nPatch=getUIVertex (i).Binding.nPatch;
uint nBefore=getUIVertex (i).Binding.nBefore;
uint nBefore2=getUIVertex (i).Binding.nBefore2;
uint nAfter=getUIVertex (i).Binding.nAfter;
uint nAfter2=getUIVertex (i).Binding.nAfter2;
uint nT=getUIVertex (i).Binding.nT;
typeBind nType=(typeBind)getUIVertex (i).Binding.nType;
uint nPrimVert=getUIVertex (i).Binding.nPrimVert;
isave->Write(&bBinded, sizeof (bool), &nb);
isave->Write(&nType, sizeof (typeBind), &nb);
isave->Write(&nEdge, sizeof (uint), &nb);
isave->Write(&nPatch, sizeof (uint), &nb);
isave->Write(&nBefore, sizeof (uint), &nb);
isave->Write(&nBefore2, sizeof (uint), &nb);
isave->Write(&nAfter, sizeof (uint), &nb);
isave->Write(&nAfter2, sizeof (uint), &nb);
isave->Write(&nT, sizeof (uint), &nb);
isave->Write(&nType, sizeof (typeBind), &nb);
isave->Write(&nPrimVert, sizeof (uint), &nb);
}
// Some info
isave->Write(&rTess.TileTesselLevel, sizeof (rTess.TileTesselLevel), &nb);
isave->Write(&rTess.ModeTile, sizeof (rTess.ModeTile), &nb);
isave->Write(&rTess.KeepMapping, sizeof (rTess.KeepMapping), &nb);
isave->Write(&rTess.TransitionType, sizeof (rTess.TransitionType), &nb);
isave->Write(&selLevel, sizeof (selLevel), &nb);
return IO_OK;
};
// *** Tile Methods
// Get the matrix of the selected tiles
Matrix3 RPatchMesh::GetSelTileTm(PatchMesh& patch, TimeValue t, INode *node, bool& bHasSel) const
{
Interval valid;
Box3 box;
Matrix3 otm = node->GetObjectTM(t, &valid);
Matrix3 tm = node->GetNodeTM(t, &valid);
bHasSel = false;
// For all patchs
for (int nPatch=0; nPatch<(int)getUIPatchSize(); nPatch++)
{
float fV=0;
int nBU=1<<getUIPatch (nPatch).NbTilesU;
int nBV=1<<getUIPatch (nPatch).NbTilesV;
float fDU=1.f/(float)nBU;
float fDV=1.f/(float)nBV;
for (int nV=0; nV<nBV; nV++)
{
float fU=0;
for (int nU=0; nU<nBU; nU++)
{
int nTileNumber=GetTileNumber(nPatch, nU, nV);
if (tileSel[nTileNumber])
{
bHasSel = true;
box += patch.patches[nPatch].interp (&patch, fU, fV);
box += patch.patches[nPatch].interp (&patch, fU+fDU, fV);
box += patch.patches[nPatch].interp (&patch, fU+fDU, fV+fDV);
box += patch.patches[nPatch].interp (&patch, fU, fV+fDV);
}
fU += fDU;
}
fV += fDV;
}
}
tm.SetTrans(otm * box.Center());
return tm;
}
// Get the center of the selected tiles
Point3 RPatchMesh::GetSelTileCenter(PatchMesh& patch, TimeValue t, INode *node, bool& bHasSel) const
{
Interval valid;
Box3 box;
Matrix3 tm = node->GetObjectTM(t, &valid);
bHasSel=false;
// For all patchs
for (int nPatch=0; nPatch<(int)getUIPatchSize(); nPatch++)
{
float fV=0;
int nBU=1<<getUIPatch (nPatch).NbTilesU;
int nBV=1<<getUIPatch (nPatch).NbTilesV;
float fDU=1.f/(float)nBU;
float fDV=1.f/(float)nBV;
for (int nV=0; nV<nBV; nV++)
{
float fU=0;
for (int nU=0; nU<nBU; nU++)
{
int nTileNumber=GetTileNumber(nPatch, nU, nV);
if (tileSel[nTileNumber])
{
bHasSel=true;
box += patch.patches[nPatch].interp (&patch, fU, fV) * tm;
box += patch.patches[nPatch].interp (&patch, fU+fDU, fV) * tm;
box += patch.patches[nPatch].interp (&patch, fU+fDU, fV+fDV) * tm;
box += patch.patches[nPatch].interp (&patch, fU, fV+fDV) * tm;
}
fU += fDU;
}
fV += fDV;
}
}
return box.Center();
}
// Hittest method
BOOL RPatchMesh::SubObjectHitTest (GraphicsWindow *gw, Material *ma, HitRegion *hr, DWORD flags, SubPatchHitList& hitList,
TimeValue t, PatchMesh& patch)
{
// Return value
BOOL bRet=FALSE;
// Build the mesh
BuildMesh (t, patch);
if (rTess.TileTesselLevel>=0)
{
nlassert (mesh.numFaces==(int)getMapHitSize ());
for (int nf=0; nf<mesh.numFaces; nf++)
{
if (mesh.faceSel[nf])
int toto=0;
}
// Hittest the mesh
int nFlags=SUBHIT_FACES;
if (flags&SUBHIT_PATCH_SELONLY)
{
nFlags|=SUBHIT_SELONLY;
}
if (flags&SUBHIT_PATCH_UNSELONLY)
nFlags|=SUBHIT_UNSELONLY;
if (flags&SUBHIT_PATCH_ABORTONHIT)
nFlags|=SUBHIT_ABORTONHIT;
if (flags&SUBHIT_PATCH_SELSOLID)
nFlags|=SUBHIT_SELSOLID;
// Mesh flags
mesh.SetDispFlag (DISP_SELFACES);
mesh.selLevel = MESH_FACE;
// Hittest
SubObjHitList list;
gw->setRndLimits(gw->getRndLimits() & ~GW_BACKCULL);
bRet=mesh.SubObjectHitTest (gw, ma, hr, nFlags, list);
MeshSubHitRec *rec=list.First();
while (rec)
{
if (flags&SUBHIT_PATCH_SELONLY)
{
int otot=0;
}
if (flags&SUBHIT_PATCH_UNSELONLY)
{
int otot=0;
}
// Check the hit
nlassert (rec->index>=0);
nlassert (rec->index<(int)getMapHitSize ());
nlassert (rec->index<mesh.numFaces);
// Remap the index
int nRemapedIndex=remapTriangle (rec->index);
// Add a patch hit
hitList.AddHit (rec->dist, &patch, nRemapedIndex, PATCH_HIT_TILE);
// Next hit
rec=rec->Next();
}
}
return bRet;
}
// Return the patch adjacent at nPatch in the edge nEdge. If no patch adjacent, return nPatch
int GetAdjacentPatch (int nPatch, int nEdge, PatchMesh *patch)
{
PatchEdge *pEdge=patch->edges+patch->patches[nPatch].edge[nEdge];
#if (MAX_RELEASE < 4000)
nlassert ((pEdge->patch1==nPatch)||(pEdge->patch2==nPatch));
if (pEdge->patch1==nPatch)
return (pEdge->patch2!=-1)?pEdge->patch2:nPatch;
else
return (pEdge->patch1!=-1)?pEdge->patch1:nPatch;
#else // (MAX_RELEASE < 4000)
nlassert ((pEdge->patches.Count()>0&&pEdge->patches[0]==nPatch)||(pEdge->patches.Count()>1&&pEdge->patches[1]==nPatch));
if (pEdge->patches[0]==nPatch)
return (pEdge->patches.Count()>1&&pEdge->patches[1]!=-1)?pEdge->patches[1]:nPatch;
else
return (pEdge->patches.Count()>0&&pEdge->patches[0]!=-1)?pEdge->patches[0]:nPatch;
#endif // (MAX_RELEASE < 4000)
}
// Build the mesh
void RPatchMesh::BuildMesh(TimeValue t, PatchMesh& patch, Mesh *pMesh)
{
// Check validity
Point3 point;
int x,y;
// Mesh pointer
if (!pMesh)
pMesh=&mesh;
// Chech binding info are valid
UpdateBinding (patch, t);
nlassert (ValidBindingPos.InInterval (t));
nlassert (ValidBindingInfo.InInterval (t));
ChannelMask Build=0;
if (!ValidTopo.InInterval (t))
{
Build|=PART_TOPO;
}
if (!ValidGeom.InInterval (t))
{
Build|=PART_GEOM;
}
if (!ValidTexmap.InInterval (t))
{
Build|=PART_TEXMAP;
}
if (!ValidSelect.InInterval (t))
{
Build|=PART_SELECT|PART_TOPO|PART_GEOM;
}
if (!ValidDisplay.InInterval (t))
{
Build|=PART_DISPLAY;
}
if (!Build)
return;
TTicks ticks=CTime::getPerformanceTime ();
#ifndef NDEBUG
Validity (patch, true);
#endif // NDEBUG
// Build tracking
static int nBuildNumber=0;
build=nBuildNumber++;
// Textured mode ?
bool bTextured=false;
if (rTess.TileTesselLevel>=0)
// ok, there is at least two tri for a tile, so we can texture...
bTextured=true;
// Count channels
int nChannelCount=0;
BitArray pChannelBit (MAX_MESHMAPS);
pChannelBit.ClearAll ();
int nChannel;
for (nChannel=0; nChannel<MAX_MESHMAPS; nChannel++)
{
if ((patch.getNumMapVerts(nChannel)>0)||((!rTess.KeepMapping)&&(nChannel==1)))
{
pChannelBit.Set (nChannel);
nChannelCount=nChannel+1;
}
}
// Show interior ?
bool bShowInter=(patch.GetShowInterior()!=0);
if (Build&(PART_TOPO|PART_GEOM))
{
int nbdivsU,nbdivsV;
int nf=0;
int finalVertexCount=0;
for(int p=0 ; p<patch.getNumPatches() ; p++)
{
if (patch.patches[p].type==PATCH_QUAD)
{
// Quads count in U and V
GetPatchTess (p, nbdivsU, nbdivsV);
// Quads count in U and V
nf+=2*nbdivsU*nbdivsV;
finalVertexCount+=(nbdivsV+1)*(nbdivsU+1);
}
}
// Setup count
if (Build|=PART_GEOM)
{
pMesh->setNumVerts(finalVertexCount,FALSE,TRUE);
// Rebuild bind info
//UpdateBindingInfo (patch);
}
if (Build|=PART_TOPO)
{
// Num of patch
pMesh->setNumFaces(nf,FALSE,TRUE);
if (bTextured)
resizeMapHit (nf);
// For each channel
for (nChannel=0; nChannel<nChannelCount; nChannel++)
{
if (pChannelBit[nChannel])
{
// Activate this channel (mandatory for Max 4.2)
pMesh->setMapSupport(nChannel, TRUE);
if (rTess.KeepMapping||!bTextured||(nChannel!=1))
{
// Number of vertex
pMesh->setNumMapVerts (nChannel, finalVertexCount);
}
else
{
// Number of vertex
pMesh->setNumMapVerts (nChannel, (nf/2)*4);
}
// Num of patch
pMesh->setNumMapFaces(nChannel, nf);
}
}
}
}
if (Build&(PART_GEOM|PART_GEOM|PART_SELECT|PART_TEXMAP))
{
// First vertex of the two tri...
int offset=0;
// Next face index
int f=0;
// Next vertex index
int nv=0;
// Next mapping vertex index
int mp=0;
// First Edge
int ne=0;
// Clear the edges
if (Build&PART_SELECT)
pMesh->edgeSel.ClearAll ();
// Tile level
int nTileLevel=rTess.TileTesselLevel;
// Count of vertex by tile
int nVertexTileCount=(1<<nTileLevel)*2;
// Corner coord
Point3 vTt[4][5]=
{
{ Point3 (0,1,0), Point3 (0,1,0), Point3 (0.f,0.5f,0.f), Point3 (0.5f,0.5f,0.f), Point3 (0.5f,1.f,0.f) },
{ Point3 (0,0,0), Point3 (0.f,0.5f,0.f), Point3 (0,0,0), Point3 (0.5f,0.f,0.f), Point3 (0.5f,0.5f,0.f) },
{ Point3 (1,0,0), Point3 (0.5f,0.5f,0.f), Point3 (0.5f,0.f,0.f), Point3 (1.f,0.f,0.f), Point3 (1.f,0.5f,0.f) },
{ Point3 (1,1,0), Point3 (0.5f,1.f,0.f), Point3 (0.5f,0.5f,0.f), Point3 (1.f,0.5f,0.f), Point3 (1.f,1.f,0.f) }
};
for(int p=0 ; p<patch.getNumPatches() ; p++)
{
// Check it's a quad patch
if (patch.patches[p].type==PATCH_QUAD)
{
int nbdivsU, nbdivsV;
// Tessel in U and V
GetPatchTess (p, nbdivsU, nbdivsV);
// Delta for mapping
float fUd=1.f/(float)nbdivsU;
float fVd=1.f/(float)nbdivsV;
// Delta for mapping
float fTiled=1.f/(float)(1<<nTileLevel);
// Count of vertex in the patch
int nUCount=nbdivsU+1;
int nVCount=nbdivsV+1;
// Number of tile
int nTileCountU=1<<getUIPatch (p).NbTilesU;
int nTileCountV=1<<getUIPatch (p).NbTilesV;
// Nb face in a tile
int nTess=1<<rTess.TileTesselLevel;
// Vertices have changed
if (Build&(PART_GEOM|PART_SELECT))
{
int nV;
if (Build&PART_GEOM)
{
float oonbdivsU=1.0f/(float)nbdivsU;
float oonbdivsV=1.0f/(float)nbdivsV;
// Compute the vertices
for(nV=0 ; nV<=nbdivsV; ++nV)
{
float v=(float)nV*oonbdivsV;
for(int nU=0 ; nU<=nbdivsU ; nU++)
{
float u=(float)nU*oonbdivsU;
point=patch.patches[p].interp(&patch,u,v);
pMesh->setVert(nv, point);
nv++;
}
}
}
// Vertices selection
if (Build&PART_SELECT)
{
pMesh->vertSel.Set ( offset, patch.vertSel[patch.patches[p].v[0]]);
pMesh->vertSel.Set ( offset+nbdivsV*(nbdivsU+1), patch.vertSel[patch.patches[p].v[1]]);
pMesh->vertSel.Set ( offset+nbdivsV*(nbdivsU+1)+nbdivsU, patch.vertSel[patch.patches[p].v[2]]);
pMesh->vertSel.Set ( offset+nbdivsU, patch.vertSel[patch.patches[p].v[3]]);
}
}
if (Build&(PART_TOPO|PART_SELECT|PART_TEXMAP))
{
if (Build&PART_SELECT)
{
// Hide all verts
int nLastVert=offset+(nbdivsV+1)*(nbdivsU+1);
for (int tt=offset; tt<nLastVert; tt++)
{
pMesh->vertHide.Set (tt);
}
// Show some of them
pMesh->vertHide.Clear (offset);
pMesh->vertHide.Clear (offset+nbdivsU);
pMesh->vertHide.Clear (nLastVert-1-nbdivsU);
pMesh->vertHide.Clear (nLastVert-1);
// Edge selection
int ne=f*3;
if (GetSelLevel()==EP_PATCH)
{
int bPatchSel=patch.patchSel[p];
int nUV=nbdivsU*nbdivsV;
if (bPatchSel||patch.patchSel[GetAdjacentPatch (p, 3, &patch)])
{
// Top
for (int ee=0; ee<nbdivsU; ee++)
pMesh->edgeSel.Set (ne+6*ee+2);
}
if (bPatchSel||patch.patchSel[GetAdjacentPatch (p, 1, &patch)])
{
// Bottom
for (int ee=nUV-nbdivsU; ee<nUV; ee++)
pMesh->edgeSel.Set (ne+6*ee+3);
}
if (bPatchSel||patch.patchSel[GetAdjacentPatch (p, 0, &patch)])
{
// Left
for (int ee=0; ee<nbdivsV; ee++)
pMesh->edgeSel.Set (ne+6*nbdivsU*ee);
}
if (bPatchSel||patch.patchSel[GetAdjacentPatch (p, 2, &patch)])
{
// Right
for (int ee=0; ee<nbdivsV; ee++)
pMesh->edgeSel.Set (ne+6*nbdivsU*ee+4+6*(nbdivsU-1));
}
}
else if ((GetSelLevel()==EP_EDGE)||paint)
{
// Top
if (patch.edgeSel[patch.patches[p].edge[3]])
{
for (int ee=0; ee<nbdivsU; ee++)
pMesh->edgeSel.Set(ne+6*ee+2);
}
// Bottom
if (patch.edgeSel[patch.patches[p].edge[1]])
{
int nUV=nbdivsU*nbdivsV;
for (int ee=nUV-nbdivsU; ee<nUV; ee++)
pMesh->edgeSel.Set(ne+6*ee+3);
}
// Left
if (patch.edgeSel[patch.patches[p].edge[0]])
{
for (int ee=0; ee<nbdivsV; ee++)
pMesh->edgeSel.Set(ne+6*nbdivsU*ee);
}
// Right
if (patch.edgeSel[patch.patches[p].edge[2]])
{
for (int ee=0; ee<nbdivsV; ee++)
pMesh->edgeSel.Set(ne+6*nbdivsU*ee+4+6*(nbdivsU-1));
}
}
}
// Topology has changed
int mpcopy=mp;
int offsetcopy=offset;
for(y=0 ; y<nbdivsV ; y++)
{
for(x=0 ; x<nbdivsU ; x++)
{
if (Build&(PART_TOPO|PART_SELECT))
{
pMesh->faces[f].v[0]=offset+x;
pMesh->faces[f].v[1]=offset+x+(nbdivsU+1);
pMesh->faces[f].v[2]=offset+x+1;
pMesh->faces[f].flags&=~(EDGE_ALL);
if (bShowInter)
pMesh->faces[f].flags|=EDGE_A|EDGE_C;
if (x==0)
pMesh->faces[f].flags|=EDGE_A;
if (y==0)
pMesh->faces[f].flags|=EDGE_C;
pMesh->faces[f].smGroup=1;
pMesh->faces[f+1].v[0]=offset+x+(nbdivsU+1);
pMesh->faces[f+1].v[1]=offset+x+(nbdivsU+1)+1;
pMesh->faces[f+1].v[2]=offset+x+1;
pMesh->faces[f+1].flags&=~(EDGE_ALL);
if (bShowInter)
pMesh->faces[f+1].flags|=EDGE_A|EDGE_B;
if (x==nbdivsU-1)
pMesh->faces[f+1].flags|=EDGE_B;
if (y==nbdivsV-1)
pMesh->faces[f+1].flags|=EDGE_A;
pMesh->faces[f+1].smGroup=1;
// MatId
/*pMesh->faces[f].setMatID((abs(f>>1)%3));
pMesh->faces[f+1].setMatID((abs(f>>1)%3));*/
// Tile number
// Face display
if (patch.patches[p].flags&PATCH_HIDDEN)
{
pMesh->faces[f].flags|=FACE_HIDDEN;
pMesh->faces[f+1].flags|=FACE_HIDDEN;
}
else
{
pMesh->faces[f].flags&=~(FACE_HIDDEN);
pMesh->faces[f+1].flags&=~(FACE_HIDDEN);
}
// Texture maps
int nTileU=x>>nTileLevel;
int nTileV=y>>nTileLevel;
for (nChannel=0; nChannel<nChannelCount; nChannel++)
{
if (pChannelBit[nChannel])
{
TVFace *pTvP=pMesh->mapFaces(nChannel);
nlassert (pTvP);
if (pTvP)
{
pTvP+=f;
if (rTess.KeepMapping||!bTextured||(nChannel!=1))
{
pTvP->t[0]=offset+x;
pTvP->t[1]=offset+x+(nbdivsU+1);
pTvP->t[2]=offset+x+1;
pTvP++;
pTvP->t[0]=offset+x+(nbdivsU+1);
pTvP->t[1]=offset+x+(nbdivsU+1)+1;
pTvP->t[2]=offset+x+1;
}
else
{
int nX2=x*2;
pTvP->t[0]=mp+nX2;
pTvP->t[1]=mp+nX2+nbdivsU*2;
pTvP->t[2]=mp+nX2+1;
pTvP++;
pTvP->t[0]=mp+nX2+nbdivsU*2;
pTvP->t[1]=mp+nX2+nbdivsU*2+1;
pTvP->t[2]=mp+nX2+1;
}
}
}
}
}
if (Build&PART_TEXMAP)
{
int uTile=x>>nTileLevel;
int vTile=y>>nTileLevel;
uint nTileNumber=0;
tileDesc& desc=getUIPatch (p).getTileDesc (uTile+vTile*nTileCountU);
if (!desc.isEmpty ())
{
nTileNumber=desc.getLayer(std::min (desc.getNumLayer()-1, rTess.TransitionType-1)).Tile+1;
}
pMesh->faces[f].setMatID(nTileNumber);
pMesh->faces[f+1].setMatID(nTileNumber);
}
if (Build&PART_SELECT)
{
// Remap for hittest
if (bTextured)
{
int nU=x>>rTess.TileTesselLevel;
int nV=y>>rTess.TileTesselLevel;
int tileNumber=GetTileNumber(p, nU, nV);
setRemapEntry (f, tileNumber);
setRemapEntry (f+1, tileNumber);
if (GetSelLevel()==EP_TILE)
{
int bTileSel=tileSel[tileNumber];
if (bTileSel)
{
// Top
if ((y&(nTess-1))==0)
pMesh->edgeSel.Set(3*f+2);
// Left
if ((x&(nTess-1))==0)
pMesh->edgeSel.Set(3*f);
// Bottom
if ((y&(nTess-1))==(nTess-1))
pMesh->edgeSel.Set(3*f+3);
// Right
if ((x&(nTess-1))==(nTess-1))
pMesh->edgeSel.Set(3*f+4);
}
// Face selection
pMesh->faceSel.Set (f, bTileSel);
pMesh->faceSel.Set (f+1, bTileSel);
}
}
}
f+=2;
}
offset+=nbdivsU+1;
mp+=nbdivsU*4;
}
offset+=nbdivsU+1;
// Generate texture vertices
if ((Build&PART_TOPO)|(Build&PART_TEXMAP))
{
// Copy mapping
// For each channel
for (nChannel=0; nChannel<nChannelCount; nChannel++)
{
if (pChannelBit[nChannel])
{
if (rTess.KeepMapping||!bTextured||(nChannel!=1))
{
Point3 vT[4];
if (rTess.KeepMapping||(nChannel!=1))
{
for (int ii=0; ii<4; ii++)
vT[ii]=patch.getMapVert (nChannel, patch.tvPatches[nChannel][p].tv[ii]);
}
else
{
for (int ii=0; ii<4; ii++)
vT[ii]=Point3 (0,0,0);
}
// For each vertex
float fV=0.f;
for (int v=0; v<nVCount; v++)
{
float fU=0.f;
for (int u=0; u<nUCount; u++)
{
Point3 vRight=(vT[(2)&3]-vT[(3)&3])*fV+vT[(3)&3];
Point3 vLeft=(vT[(1)&3]-vT[(0)&3])*fV+vT[(0)&3];
Point3 vPoint=(vRight-vLeft)*fU+vLeft;
pMesh->setMapVert (nChannel, offsetcopy+u+v*nUCount, vPoint);
fU+=fUd;
}
fV+=fVd;
}
}
else
{
// For each tile
for (int vTile=0; vTile<nTileCountV; vTile++)
{
for (int uTile=0; uTile<nTileCountU; uTile++)
{
// For each vertices
for (int v=0; v<nVertexTileCount; v++)
{
float fV=(float)((v+1)>>1)/(float)(nVertexTileCount>>1);
for (int u=0; u<nVertexTileCount; u++)
{
// rotate
tileDesc &desc=getUIPatch (p).getTileDesc (uTile+vTile*nTileCountU);
int nRotate=4-desc.getLayer(std::min (desc.getNumLayer()-1, rTess.TransitionType-1)).Rotate;
int nCase=desc.getCase();
float fU=(float)((u+1)>>1)/(float)(nVertexTileCount>>1);
int nIndex=mpcopy+vTile*nVertexTileCount*nVertexTileCount*nTileCountU+v*nVertexTileCount*nTileCountU+
uTile*nVertexTileCount+u;
Point3 vRight=(vTt[(2+nRotate)&3][nCase]-vTt[(3+nRotate)&3][nCase])*fV+vTt[(3+nRotate)&3][nCase];
Point3 vLeft=(vTt[(1+nRotate)&3][nCase]-vTt[(0+nRotate)&3][nCase])*fV+vTt[(0+nRotate)&3][nCase];
Point3 vPoint=(vRight-vLeft)*fU+vLeft;
pMesh->setMapVert (nChannel, nIndex, vPoint);
}
}
}
}
}
}
}
}
}
}
}
}
if (Build&PART_TOPO)
{
pMesh->InvalidateTopologyCache();
//pMesh->BuildStripsAndEdges();
}
if (Build&PART_GEOM)
{
pMesh->InvalidateGeomCache();
}
ValidGeom=FOREVER;
ValidTopo=FOREVER;
ValidTexmap=FOREVER;
ValidSelect=FOREVER;
ValidDisplay=FOREVER;
for (int nf=0; nf<mesh.numFaces; nf++)
{
if (mesh.faceSel[nf])
int toto=0;
}
ticks=CTime::getPerformanceTime ()-ticks;
nldebug ("%f", CTime::ticksToSecond(ticks));
}
// Get tessel level of a patch
void RPatchMesh::GetPatchTess (int nPatch, int& nUTess, int& nVTess)
{
// Check size
nlassert (nPatch<(int)getUIPatchSize());
// Return tessel level depending tessel of the pathmesh and count of tile in the patch
nUTess=1<<max (0, rTess.TileTesselLevel+getUIPatch (nPatch).NbTilesU);
nVTess=1<<max (0, rTess.TileTesselLevel+getUIPatch (nPatch).NbTilesV);
}
// Display
int RPatchMesh::Display(TimeValue t, INode* inode, ViewExp *vpt, int flags, PatchMesh& patch)
{
//TODO: Implement the displaying of the object here
// Update the mesh
BuildMesh (t, patch);
// Draw the mesh
GraphicsWindow *gw = vpt->getGW();
Matrix3 mat = inode->GetObjectTM(t);
gw->setTransform(mat);
// Becarful with sublevel selection
mesh.dispFlags=0;
switch (GetSelLevel())
{
case EP_VERTEX:
mesh.SetDispFlag(DISP_VERTTICKS|DISP_SELVERTS);
mesh.selLevel = MESH_VERTEX;
break;
case EP_EDGE:
case EP_PATCH:
case EP_TILE:
mesh.SetDispFlag(DISP_SELEDGES);
mesh.selLevel = MESH_EDGE;
break;
default:
mesh.SetDispFlag(0);
mesh.selLevel = MESH_OBJECT;
break;
}
if (paint)
{
mesh.SetDispFlag(DISP_SELEDGES);
mesh.selLevel = MESH_EDGE;
}
// Go
mesh.render( gw, inode->Mtls(),
(flags&USE_DAMAGE_RECT) ? &vpt->GetDammageRect() : NULL, COMP_ALL | ((flags&DISP_SHOWSUBOBJECT)?COMP_OBJSELECTED:0),
inode->NumMtls());
// Draw vector
if ((GetSelLevel()==EP_VERTEX)&&(inode->Selected()))
{
UpdateBinding (patch, t);
// Set new flags
patch.SetDispFlag(DISP_VERTTICKS|DISP_SELVERTS);
patch.selLevel=PATCH_VERTEX;
DWORD dw=gw->getRndLimits();
BitArray bit;
bit.SetSize (patch.numPatches);
bit.ClearAll ();
if ((dw&GW_PICK)==0)
{
// Hide all patch
for (int nP=0; nP<patch.numPatches; nP++)
{
if (patch.patches[nP].flags&PATCH_HIDDEN)
bit.Set (nP);
patch.patches[nP].flags|=PATCH_HIDDEN;
}
}
patch.render( gw, inode->Mtls(),
(flags&USE_DAMAGE_RECT) ? &vpt->GetDammageRect() : NULL, COMP_ALL | ((flags&DISP_SHOWSUBOBJECT)?COMP_OBJSELECTED:0),
inode->NumMtls());
if ((dw&GW_PICK)==0)
{
// Hide all patch
for (int nP=0; nP<patch.numPatches; nP++)
{
if (!bit[nP])
patch.patches[nP].flags&=~PATCH_HIDDEN;
}
}
}
// Point binded
if (inode->Selected())
{
gw->setColor(LINE_COLOR, 0, 0, 0);
for (int i=0; i<patch.numVerts; i++)
{
if (getUIVertex (i).Binding.bBinded)
{
// draw the point
gw->marker (&patch.verts[i].p, DOT_MRKR);
}
}
}
// A
// -
// B C
// -
// -
// D
// Draw the arrow
if (GetSelLevel()==EP_PATCH)
{
for (int i=0; i<patch.numPatches; i++)
{
if (patch.patches[i].type==PATCH_QUAD)
{
Point3 a,b,c,d;
Point3 p[2];
// 4 points
a=patch.patches[i].interp(&patch,0.5f,1.f/6.f);
b=patch.patches[i].interp(&patch,0.5f-1.f/6.f,1.f/3.f);
c=patch.patches[i].interp(&patch,0.5f+1.f/6.f,1.f/3.f);
d=patch.patches[i].interp(&patch,0.5f,5.f/6.f);
// draw the point
p[0]=a;
p[1]=b;
gw->polyline (2, p, NULL, NULL, FALSE, NULL);
p[1]=c;
gw->polyline (2, p, NULL, NULL, FALSE, NULL);
p[1]=d;
gw->polyline (2, p, NULL, NULL, FALSE, NULL);
}
}
}
return 0;
}
// Return a tile desc
tileDesc& RPatchMesh::getTileDesc (int nTile)
{
int patch=nTile/NUM_TILE_SEL;
int tile=nTile%NUM_TILE_SEL;
int tileY=tile/MAX_TILE_IN_PATCH;
int tileX=tile%MAX_TILE_IN_PATCH;
tile=tileY*(1<<getUIPatch (patch).NbTilesU)+tileX;
return getUIPatch (patch).getTileDesc (tile);
}
// Set a tile desc
void RPatchMesh::setTileDesc (int nTile, const tileDesc& desc)
{
int patch=nTile/NUM_TILE_SEL;
int tile=nTile%NUM_TILE_SEL;
int tileY=tile/MAX_TILE_IN_PATCH;
int tileX=tile%MAX_TILE_IN_PATCH;
tile=tileY*(1<<getUIPatch (patch).NbTilesU)+tileX;
getUIPatch (patch).getTileDesc (tile)=desc;
}
// Turn selected patch
void RPatchMesh::TurnPatch(PatchMesh *patch)
{
// For each patch
for (int p=0; p<patch->numPatches; p++)
{
// Selected ?
if (patch->patchSel[p])
{
// Tessel U and V
int nOldU=1<<(getUIPatch (p).NbTilesU);
int nOldV=1<<(getUIPatch (p).NbTilesV);
// Reverse UV count
int tmp=getUIPatch (p).NbTilesU;
getUIPatch (p).NbTilesU=getUIPatch (p).NbTilesV;
getUIPatch (p).NbTilesV=tmp;
// Copy old array
UI_PATCH old=getUIPatch (p);
// Turn tile array
int u, v;
for (v=0; v<nOldV; v++)
for (u=0; u<nOldU; u++)
{
int newU=nOldV-v-1;
int newV=u;
getUIPatch (p).getTileDesc (newU+newV*nOldV)=old.getTileDesc (u+v*nOldU);
// Rotate each layer
getUIPatch (p).getTileDesc (newU+newV*nOldV).rotate (3);
}
// Turn vertex color
// Tessel U and V
nOldU++;
nOldV++;
// Turn tile array
for (v=0; v<nOldV; v++)
for (u=0; u<nOldU; u++)
{
int newU=nOldV-v-1;
int newV=u;
getUIPatch (p).setColor (newU+newV*nOldV, old.getColor (u+v*nOldU));
}
}
}
// Check binding infos
for (int v=0; v<patch->numVerts; v++)
{
// Binded ?
if (getUIVertex (v).Binding.bBinded)
{
// On a patch turned ?
int nPatch=getUIVertex (v).Binding.nPatch;
if (patch->patchSel[nPatch])
{
// Ok, turn the bind info..
getUIVertex (v).Binding.nEdge--;
getUIVertex (v).Binding.nEdge&=3;
}
}
}
}
// Turn selected patch
void RPatchMesh::RotateTiles (PatchMesh *patch, int rot)
{
// For each patch
for (int p=0; p<patch->numPatches; p++)
{
// Tessel U and V
int nU=1<<(getUIPatch (p).NbTilesU);
int nV=1<<(getUIPatch (p).NbTilesV);
// Turn tile array
for (int v=0; v<nV; v++)
for (int u=0; u<nU; u++)
{
// Rotate each layer
getUIPatch (p).getTileDesc (u+v*nU).rotate (rot);
}
}
}
// Turn selected patch
/*void RPatchMesh::flipTilesUpDown (PatchMesh *patch)
{
// For each patch
for (int p=0; p<patch->numPatches; p++)
{
// Tessel U and V
int nU=1<<(getUIPatch (p).NbTilesU);
int nV=1<<(getUIPatch (p).NbTilesV);
// Copy old array
UI_PATCH old=getUIPatch (p);
// Turn tile array
for (int v=0; v<nV; v++)
for (int u=0; u<nU; u++)
{
// Rotate each layer
getUIPatch (p).getTileDesc (u+v*nU) = old.getTileDesc (u+(nV-1-v)*nU);
getUIPatch (p).getTileDesc (u+v*nU).flipUpDown ();
}
}
}*/
// Copy operator
#ifdef USE_CACHE
void RPatchMesh::operator= (const RPatchMesh& fromOb)
{
DeepCopy (const_cast<RPatchMesh*>(&fromOb), PART_GEOM|SELECT_CHANNEL|PART_SUBSEL_TYPE|PART_DISPLAY|PART_TOPO|TEXMAP_CHANNEL);
}
#endif // USE_CACHE
CBankManager RPatchMesh::manager;
Reference in a new issue View git blame Copy permalink