774 lines
19 KiB
C++
774 lines
19 KiB
C++
// 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"
|
|
|
|
// For MAX_RELEASE
|
|
#include <plugapi.h>
|
|
#include <MaxScrpt/maxscrpt.h>
|
|
|
|
#include "rpo.h"
|
|
#include "nel/3d/zone.h"
|
|
#include "nel/3d/zone_symmetrisation.h"
|
|
|
|
using namespace std;
|
|
using namespace NL3D;
|
|
using namespace NLMISC;
|
|
|
|
|
|
// ***************************************************************************
|
|
static int getCommonEdge(PatchMesh* pPM, int edge, Patch& patch2)
|
|
{
|
|
for(int e=0 ; e<4 ; e++)
|
|
{
|
|
if (patch2.edge[e]==edge)
|
|
return(e);
|
|
}
|
|
nlassert (0); // no!
|
|
return(-1);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
static int getCommonVertex(PatchMesh* pPM, int ipatch1, int ipatch2, int* pordervtx=NULL)
|
|
{
|
|
Patch* patch1;
|
|
Patch* patch2;
|
|
|
|
patch1=&pPM->patches[ipatch1];
|
|
patch2=&pPM->patches[ipatch2];
|
|
|
|
int i;
|
|
for(i=0 ; i<4 ; i++)
|
|
{
|
|
if (patch1->v[i]==patch2->v[0])
|
|
{
|
|
break;
|
|
}
|
|
if (patch1->v[i]==patch2->v[1])
|
|
{
|
|
break;
|
|
}
|
|
if (patch1->v[i]==patch2->v[2])
|
|
{
|
|
break;
|
|
}
|
|
if (patch1->v[i]==patch2->v[3])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (i==4)
|
|
{
|
|
return(-1);
|
|
}
|
|
if (pordervtx)
|
|
{
|
|
*pordervtx=i;
|
|
}
|
|
return(patch1->v[i]);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
static int getOtherBindedVertex(RPatchMesh* pRPM, PatchMesh* pPM, int ipatch1, int ipatch2, int iOtherVertex)
|
|
{
|
|
Patch* patch1;
|
|
Patch* patch2;
|
|
|
|
patch1=&pPM->patches[ipatch1];
|
|
patch2=&pPM->patches[ipatch2];
|
|
|
|
for(int i=0 ; i<4 ; i++)
|
|
{
|
|
UI_VERTEX uiv=pRPM->getUIVertex (patch1->v[i]);
|
|
if (uiv.Binding.bBinded)
|
|
{
|
|
if ((int)uiv.Binding.nPatch==ipatch2 && i!=iOtherVertex)
|
|
{
|
|
return(patch1->v[i]);
|
|
}
|
|
}
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
static int getEdge(PatchMesh* pPM, Patch* patch, int iv1, int iv2)
|
|
{
|
|
for(int i=0 ; i<4 ; i++)
|
|
{
|
|
PatchEdge edge=pPM->edges[patch->edge[i]];
|
|
if (edge.v1==iv1 && edge.v2==iv2)
|
|
{
|
|
return(i);
|
|
}
|
|
if (edge.v2==iv1 && edge.v1==iv2)
|
|
{
|
|
return(i);
|
|
}
|
|
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
int getScriptAppData (Animatable *node, uint32 id, int def)
|
|
{
|
|
// Get the chunk
|
|
AppDataChunk *ap=node->GetAppDataChunk (MAXSCRIPT_UTILITY_CLASS_ID, UTILITY_CLASS_ID, id);
|
|
|
|
// Not found ? return default
|
|
if (ap==NULL)
|
|
return def;
|
|
|
|
// String to int
|
|
int value;
|
|
if (sscanf ((const char*)ap->data, "%d", &value)==1)
|
|
return value;
|
|
else
|
|
return def;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
bool RPatchMesh::exportZone(INode* pNode, PatchMesh* pPM, NL3D::CZone& zone, CZoneSymmetrisation &zoneSymmetry, int zoneId, float snapCell, float weldThreshold, bool forceBuildZoneSymmetry)
|
|
{
|
|
Matrix3 TM;
|
|
CPatchInfo pi;
|
|
std::vector<CPatchInfo> patchinfo;
|
|
sint i,j;
|
|
Point3 v;
|
|
Patch* pPatch;
|
|
|
|
TM=pNode->GetObjectTM(0);
|
|
|
|
// --- Get the rotation value and symmetry flags
|
|
bool symmetry = getScriptAppData (pNode, NEL3D_APPDATA_ZONE_SYMMETRY, 0) != 0;
|
|
int rotate = getScriptAppData (pNode, NEL3D_APPDATA_ZONE_ROTATE, 0);
|
|
|
|
// Need a tile bank ?
|
|
if (symmetry || rotate || forceBuildZoneSymmetry)
|
|
{
|
|
// Bank loaded
|
|
bool loaded = false;
|
|
|
|
// Get the bank name
|
|
std::string sName=GetBankPathName ();
|
|
if (sName!="")
|
|
{
|
|
// Open the bank
|
|
CIFile file;
|
|
if (file.open (sName))
|
|
{
|
|
try
|
|
{
|
|
// Read it
|
|
bank.clear();
|
|
bank.serial (file);
|
|
bank.computeXRef ();
|
|
|
|
// Ok
|
|
loaded = true;
|
|
}
|
|
catch (EStream& stream)
|
|
{
|
|
MessageBox (NULL, stream.what(), "Error", MB_OK|MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Not loaded ?
|
|
if (loaded == false)
|
|
{
|
|
nlwarning ("Can't load any tile bank. Select on with the tile_utility plug-in");
|
|
mprintf ("Can't load any tile bank. Select on with the tile_utility plug-in");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// ---
|
|
// --- Basic checks
|
|
// ---
|
|
|
|
// Map edge count
|
|
map<pair<uint, uint>, uint > edgeSet;
|
|
|
|
// Triple edge Patch error
|
|
set<uint> patchError;
|
|
|
|
// For each patches
|
|
for (uint patch=0; patch<(uint)pPM->numPatches; patch++)
|
|
{
|
|
// For each edges
|
|
for (uint edge=0; edge<4; edge++)
|
|
{
|
|
// Two vertices
|
|
uint v1 = pPM->edges[pPM->patches[patch].edge[edge]].v1;
|
|
uint v2 = pPM->edges[pPM->patches[patch].edge[edge]].v2;
|
|
|
|
// Insert in the map
|
|
map<pair<uint, uint>, uint >::iterator ite;
|
|
ite = edgeSet.find (pair<uint, uint>(min(v1, v2), max(v1, v2)));
|
|
|
|
// Inserted ?
|
|
if (ite == edgeSet.end())
|
|
ite = edgeSet.insert (pair<pair<uint, uint>, uint>(pair<uint, uint>(min(v1, v2), max(v1, v2)), 1)).first;
|
|
else
|
|
{
|
|
// Add a ref
|
|
ite->second++;
|
|
|
|
// Patch error ?
|
|
if (ite->second>=3)
|
|
{
|
|
// Add a patch error
|
|
patchError.insert (patch);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Some errors ?
|
|
if (!patchError.empty())
|
|
{
|
|
// Make an error message
|
|
char error[2098];
|
|
smprintf (error, 2098, "Error: triple edge detected in ");
|
|
|
|
// For each error
|
|
set<uint>::iterator ite=patchError.begin();
|
|
while (ite!=patchError.end())
|
|
{
|
|
// Sub error message
|
|
char subError[512];
|
|
smprintf (subError, 512, "patch %d ", (*ite)+1);
|
|
strcat (error, subError);
|
|
|
|
// Next error
|
|
ite++;
|
|
}
|
|
|
|
// Show the message
|
|
mprintf (error);
|
|
nlwarning (error);
|
|
|
|
// Error
|
|
return false;
|
|
}
|
|
|
|
// ---
|
|
// --- Basic exports
|
|
// ---
|
|
for(i=0 ; i<pPM->numPatches ; i++)
|
|
{
|
|
pPatch=&pPM->patches[i];
|
|
// - Vertices
|
|
for(j=0 ; j<4 ; j++)
|
|
{
|
|
v=pPM->verts[pPatch->v[j]].p;
|
|
v=v*TM;
|
|
pi.Patch.Vertices[j].x=v.x;
|
|
pi.Patch.Vertices[j].y=v.y;
|
|
pi.Patch.Vertices[j].z=v.z;
|
|
}
|
|
// - Tangents
|
|
for(j=0 ; j<8 ; j++)
|
|
{
|
|
v=pPM->vecs[pPatch->vec[j]].p;
|
|
v=v*TM;
|
|
pi.Patch.Tangents[j].x=v.x;
|
|
pi.Patch.Tangents[j].y=v.y;
|
|
pi.Patch.Tangents[j].z=v.z;
|
|
}
|
|
// - Interiors
|
|
for(j=0 ; j<4 ; j++)
|
|
{
|
|
v=pPM->vecs[pPatch->interior[j]].p;
|
|
v=v*TM;
|
|
pi.Patch.Interiors[j].x=v.x;
|
|
pi.Patch.Interiors[j].y=v.y;
|
|
pi.Patch.Interiors[j].z=v.z;
|
|
}
|
|
pi.OrderS=1<<getUIPatch (i).NbTilesU;
|
|
pi.OrderT=1<<getUIPatch (i).NbTilesV;
|
|
pi.BindEdges[0].ZoneId=zoneId;
|
|
pi.BindEdges[1].ZoneId=zoneId;
|
|
pi.BindEdges[2].ZoneId=zoneId;
|
|
pi.BindEdges[3].ZoneId=zoneId;
|
|
pi.BaseVertices[0]=pPatch->v[0];
|
|
pi.BaseVertices[1]=pPatch->v[1];
|
|
pi.BaseVertices[2]=pPatch->v[2];
|
|
pi.BaseVertices[3]=pPatch->v[3];
|
|
pi.Tiles.resize(pi.OrderS*pi.OrderT);
|
|
|
|
// ** Export tile colors
|
|
|
|
// Resize color table
|
|
pi.TileColors.resize ((pi.OrderS+1)*(pi.OrderT+1));
|
|
|
|
// Export it
|
|
int u,v;
|
|
for (v=0; v<pi.OrderT+1; v++)
|
|
for (u=0; u<pi.OrderS+1; u++)
|
|
{
|
|
// Get rgb value at this vertex
|
|
uint color=getUIPatch (i).getColor (u+v*(pi.OrderS+1));
|
|
|
|
// Create a rgba value
|
|
CRGBA rgba ( (color&0xff0000)>>16, (color&0x00ff00)>>8, color&0xff );
|
|
|
|
// Store it in the tile info
|
|
pi.TileColors[u+v*(pi.OrderS+1)].Color565=rgba.get565();
|
|
}
|
|
|
|
// ** Export tile shading
|
|
|
|
pi.Lumels.resize ((pi.OrderS*4)*(pi.OrderT*4), 255);
|
|
|
|
// ---
|
|
// --- Smooth flags
|
|
// ---
|
|
|
|
// Clear smooth flags
|
|
pi.Flags&=~0xf;
|
|
|
|
for (int edge=0; edge<4; edge++)
|
|
{
|
|
// Edge smooth ?
|
|
if (!getUIPatch (i).getEdgeFlag (edge))
|
|
{
|
|
// Don't smooth
|
|
pi.Flags|=(1<<edge);
|
|
}
|
|
}
|
|
|
|
// Add this tile info
|
|
patchinfo.push_back(pi);
|
|
|
|
}
|
|
|
|
// ---
|
|
// --- Pass 1 :
|
|
// --- Parse each patch and then each vertex.
|
|
// ---
|
|
int isrcpatch;
|
|
Patch* srcpatch;
|
|
for(isrcpatch=0 ; isrcpatch<pPM->numPatches ; isrcpatch++)
|
|
{
|
|
srcpatch=&pPM->patches[isrcpatch];
|
|
|
|
for(int nv=0 ; nv<4 ; nv++)
|
|
{
|
|
UI_VERTEX uiv=getUIVertex (srcpatch->v[nv]);
|
|
|
|
if (uiv.Binding.bBinded)
|
|
{
|
|
int isrcedge;
|
|
int n;
|
|
int icv;
|
|
int idstpatch=uiv.Binding.nPatch;
|
|
int idstedge=uiv.Binding.nEdge;
|
|
int orderdstvtx;
|
|
|
|
n=-1;
|
|
// -
|
|
if (uiv.Binding.nType==BIND_SINGLE)
|
|
{
|
|
icv=getCommonVertex(pPM,idstpatch,isrcpatch,&orderdstvtx);
|
|
if (icv==-1)
|
|
{
|
|
mprintf ("Invalid bind");
|
|
nlwarning ("Invalid bind");
|
|
return false;
|
|
}
|
|
if (idstedge==orderdstvtx)
|
|
{
|
|
n=0;
|
|
}
|
|
else
|
|
{
|
|
n=1;
|
|
}
|
|
}
|
|
// -
|
|
if (uiv.Binding.nType==BIND_25)
|
|
{
|
|
n=1;
|
|
icv=getOtherBindedVertex(this, pPM, isrcpatch,idstpatch,nv);
|
|
if (icv==-1)
|
|
{
|
|
n=0;
|
|
icv=getCommonVertex(pPM,idstpatch,isrcpatch);
|
|
if (icv==-1)
|
|
{
|
|
mprintf ("Invalid bind");
|
|
nlwarning ("Invalid bind");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// -
|
|
if (uiv.Binding.nType==BIND_75)
|
|
{
|
|
n=2;
|
|
icv=getOtherBindedVertex(this, pPM, isrcpatch,idstpatch,nv);
|
|
if (icv==-1)
|
|
{
|
|
n=3;
|
|
icv=getCommonVertex(pPM,idstpatch,isrcpatch);
|
|
if (icv==-1)
|
|
{
|
|
mprintf ("Invalid bind");
|
|
nlwarning ("Invalid bind");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// -
|
|
if (n!=-1)
|
|
{
|
|
isrcedge=getEdge(pPM,srcpatch,srcpatch->v[nv],icv);
|
|
if (isrcedge==-1)
|
|
{
|
|
mprintf ("Invalid edge");
|
|
nlwarning ("Invalid bind");
|
|
return false;
|
|
}
|
|
// let's fill the dst patch (n is important here... it's the order)
|
|
patchinfo[idstpatch].BindEdges[idstedge].NPatchs++;
|
|
patchinfo[idstpatch].BindEdges[idstedge].Edge[n]=isrcedge;
|
|
patchinfo[idstpatch].BindEdges[idstedge].Next[n]=isrcpatch;
|
|
|
|
// let's fill the src patch also...
|
|
patchinfo[isrcpatch].BindEdges[isrcedge].NPatchs=5;
|
|
patchinfo[isrcpatch].BindEdges[isrcedge].Edge[0]=idstedge;
|
|
patchinfo[isrcpatch].BindEdges[isrcedge].Next[0]=idstpatch;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---
|
|
// --- Pass 2 :
|
|
// --- Get all one/one cases.
|
|
// --- Parse each patch and each edge
|
|
// ---
|
|
for(i=0 ; i<pPM->numPatches ; i++)
|
|
{
|
|
pPatch=&pPM->patches[i];
|
|
for(int e=0 ; e<4 ; e++)
|
|
{
|
|
PatchEdge edge=pPM->edges[pPatch->edge[e]];
|
|
|
|
// One/One binding
|
|
#if (MAX_RELEASE < 4000)
|
|
if (edge.patch2>=0)
|
|
{
|
|
patchinfo[i].BindEdges[e].NPatchs=1;
|
|
// 'coz i don't know wether edge.patch1 or edge.patch2 is
|
|
// the patch that i am parsing
|
|
if (edge.patch2!=i)
|
|
{
|
|
patchinfo[i].BindEdges[e].Next[0]=edge.patch2;
|
|
patchinfo[i].BindEdges[e].Edge[0]=getCommonEdge(pPM, pPatch->edge[e], pPM->patches[edge.patch2]);
|
|
}
|
|
else
|
|
{
|
|
patchinfo[i].BindEdges[e].Next[0]=edge.patch1;
|
|
patchinfo[i].BindEdges[e].Edge[0]=getCommonEdge(pPM, pPatch->edge[e], pPM->patches[edge.patch1]);
|
|
}
|
|
}
|
|
#else // (MAX_RELEASE < 4000)
|
|
if (edge.patches.Count()>1)
|
|
{
|
|
patchinfo[i].BindEdges[e].NPatchs=1;
|
|
// 'coz i don't know wether edge.patch1 or edge.patch2 is
|
|
// the patch that i am parsing
|
|
if (edge.patches[1]!=i)
|
|
{
|
|
patchinfo[i].BindEdges[e].Next[0]=edge.patches[1];
|
|
patchinfo[i].BindEdges[e].Edge[0]=getCommonEdge(pPM, pPatch->edge[e], pPM->patches[edge.patches[1]]);
|
|
}
|
|
else
|
|
{
|
|
patchinfo[i].BindEdges[e].Next[0]=edge.patches[0];
|
|
patchinfo[i].BindEdges[e].Edge[0]=getCommonEdge(pPM, pPatch->edge[e], pPM->patches[edge.patches[0]]);
|
|
}
|
|
}
|
|
#endif // (MAX_RELEASE < 4000)
|
|
}
|
|
}
|
|
|
|
// Fill tile infos with temp data
|
|
// Tileset of the tile and rotation is important but tile number, rotation and case will be ajusted later
|
|
// For each patches
|
|
for (i=0; i<pPM->numPatches; i++)
|
|
{
|
|
// Ref on the patch info
|
|
CPatchInfo &patchInfo = patchinfo[i];
|
|
|
|
int u,v;
|
|
for (v=0; v<patchInfo.OrderT; v++)
|
|
for (u=0; u<patchInfo.OrderS; u++)
|
|
{
|
|
tileDesc &desc=getUIPatch (i).getTileDesc (u+v*patchInfo.OrderS);
|
|
for (int l=0; l<3; l++)
|
|
{
|
|
if (l>=desc.getNumLayer ())
|
|
{
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].Tile[l]=0xffff;
|
|
}
|
|
else
|
|
{
|
|
// Get the tile index
|
|
uint tile = desc.getLayer (l).Tile;
|
|
uint tileRotation = desc.getLayer (l).Rotate;
|
|
// this check was intended to avoid nel patch paint crash, but it breaks zone export
|
|
//if (tile >= (uint)bank.getTileCount())
|
|
//{
|
|
// std::string error = NLMISC::toString(
|
|
// "Incorrect tileset for this zone.\r\n"
|
|
// "Tile %u does not exist.\r\n"
|
|
// "There are %u tiles in the tilebank.",
|
|
// tile, bank.getTileCount());
|
|
// nlwarning(error.c_str());
|
|
// MessageBoxA(NULL, error.c_str(), "RPO2NEL", MB_OK | MB_ICONERROR);
|
|
// return false;
|
|
//}
|
|
|
|
// Set the tile
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].Tile[l] = tile;
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].setTileOrient (l, (uint8)tileRotation);
|
|
}
|
|
}
|
|
if (patchInfo.Tiles[u+v*patchInfo.OrderS].Tile[0]==0xffff)
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].setTile256Info (false, 0);
|
|
else
|
|
{
|
|
if (desc.getCase()==0)
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].setTile256Info (false, 0);
|
|
else
|
|
{
|
|
// Transform 256 case
|
|
uint case256 = desc.getCase()-1;
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].setTile256Info (true, case256);
|
|
}
|
|
}
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].setTileSubNoise (desc.getDisplace());
|
|
|
|
// Default VegetableState: AboveWater. Important: must not be VegetableDisabled
|
|
patchInfo.Tiles[u+v*patchInfo.OrderS].setVegetableState (CTileElement::AboveWater);
|
|
}
|
|
}
|
|
|
|
// Transform the zone (symmetry and rotate)
|
|
if (symmetry || rotate)
|
|
{
|
|
CMatrix sym, rot;
|
|
sym.identity ();
|
|
rot.identity ();
|
|
if (symmetry)
|
|
sym.scale (CVector (1, -1, 1));
|
|
rot.rotateZ ((float) Pi * (float) rotate / 2.f);
|
|
sym *= rot;
|
|
sym.invert ();
|
|
if (!CPatchInfo::transform (patchinfo, zoneSymmetry, bank, symmetry, rotate, snapCell, weldThreshold, sym))
|
|
{
|
|
mprintf ("Can't transform the zone");
|
|
nlwarning ("Invalid bind");
|
|
return false;
|
|
}
|
|
}
|
|
// Force the build ?
|
|
else if (forceBuildZoneSymmetry)
|
|
{
|
|
// For each patches
|
|
NL3D::CZoneSymmetrisation::CError error;
|
|
|
|
// Build the structure
|
|
if (!zoneSymmetry.build (patchinfo, snapCell, weldThreshold, bank, error, CMatrix::Identity))
|
|
{
|
|
uint i;
|
|
for (i=0; i<error.Errors.size (); i++)
|
|
{
|
|
mprintf (error.Errors[i].c_str ());
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Build the zone
|
|
zone.build (zoneId, patchinfo, std::vector<CBorderVertex>());
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void RPatchMesh::importZone (PatchMesh* pPM, NL3D::CZone& zone, int &zoneId)
|
|
{
|
|
// Patch info
|
|
std::vector<CPatchInfo> patchs;
|
|
std::vector<CBorderVertex> borderVertices;
|
|
|
|
// Retrieve the geometry
|
|
zone.retrieve (patchs, borderVertices);
|
|
|
|
// Get the zone id
|
|
zoneId = zone.getZoneId ();
|
|
|
|
// Vertex number
|
|
int vertexNum = 0;
|
|
|
|
// Vertex map
|
|
map<pair<uint, uint>, uint> mapEdgeVertex;
|
|
|
|
// Number of vertices
|
|
pPM->setNumVerts (4*patchs.size());
|
|
SetNumVerts (0);
|
|
SetNumVerts (4*patchs.size());
|
|
|
|
// Number of patches
|
|
pPM->setNumPatches (patchs.size());
|
|
SetNumPatches (0);
|
|
SetNumPatches (patchs.size());
|
|
|
|
// Number of tangents
|
|
// Number of interiors
|
|
pPM->setNumVecs (12*patchs.size());
|
|
|
|
// Number of edges
|
|
pPM->setNumEdges (4*patchs.size());
|
|
|
|
// Fill the vertices and tangents
|
|
for (uint patch=0; patch<patchs.size(); patch++)
|
|
{
|
|
// The vector
|
|
for (uint vert=0; vert<4; vert++)
|
|
{
|
|
// Pos ref
|
|
CVector &pos = patchs[patch].Patch.Vertices[vert];
|
|
CVector &inter = patchs[patch].Patch.Interiors[vert];
|
|
|
|
// Dest ref
|
|
PatchVert &destVert = pPM->verts[patch*4+vert];
|
|
PatchVec &destVect = pPM->vecs[patch*12+vert];
|
|
|
|
// Set the position
|
|
destVert.p = Point3 (pos.x, pos.y, pos.z);
|
|
destVect.p = Point3 (inter.x, inter.y, inter.z);
|
|
|
|
// Set the flag
|
|
destVert.flags = PVERT_CORNER;
|
|
destVect.flags = PVEC_INTERIOR;
|
|
}
|
|
|
|
// The tan
|
|
for (uint tang=0; tang<8; tang++)
|
|
{
|
|
// Pos ref
|
|
CVector &pos = patchs[patch].Patch.Tangents[tang];
|
|
|
|
// Dest ref
|
|
PatchVec &destVect = pPM->vecs[patch*12+4+tang];
|
|
|
|
// Set the position
|
|
destVect.p = Point3 (pos.x, pos.y, pos.z);
|
|
|
|
// Set the flag
|
|
destVect.flags = 0;
|
|
}
|
|
|
|
// The indexes
|
|
Patch &patchRef = pPM->patches[patch];
|
|
for (uint i=0; i<4; i++)
|
|
{
|
|
patchRef.v[i] = patch*4 + i;
|
|
patchRef.vec[2*i] = patch*12 + 4 + 2*i;
|
|
patchRef.vec[2*i+1] = patch*12 + 4 + 2*i + 1;
|
|
patchRef.interior[i] = patch*12 + i;
|
|
patchRef.edge[i] = patch*4 + i;
|
|
patchRef.smGroup = 1;
|
|
patchRef.flags = 0;
|
|
patchRef.type = PATCH_QUAD;
|
|
}
|
|
|
|
// Get the userinfo patch
|
|
UI_PATCH &uiRef = getUIPatch (patch);
|
|
uiRef.Init (getPowerOf2 (patchs[patch].OrderS), getPowerOf2 (patchs[patch].OrderT));
|
|
|
|
// Copy tiles
|
|
uint u, v;
|
|
for (v=0; v<patchs[patch].OrderT; v++)
|
|
for (u=0; u<patchs[patch].OrderS; u++)
|
|
{
|
|
// Tile index
|
|
uint tileindex = u+v*patchs[patch].OrderS;
|
|
|
|
// Get the tile des
|
|
tileDesc& desc = uiRef.getTileDesc (tileindex);
|
|
int numLayer =
|
|
(patchs[patch].Tiles[tileindex].Tile[0]==NL_TILE_ELM_LAYER_EMPTY)?0:
|
|
(patchs[patch].Tiles[tileindex].Tile[1]==NL_TILE_ELM_LAYER_EMPTY)?1:
|
|
(patchs[patch].Tiles[tileindex].Tile[2]==NL_TILE_ELM_LAYER_EMPTY)?2:
|
|
3;
|
|
|
|
// Case info
|
|
bool is256x256;
|
|
uint8 uvOff;
|
|
CTileElement &tileElement = patchs[patch].Tiles[tileindex];
|
|
tileElement.getTile256Info(is256x256, uvOff);
|
|
|
|
// Set the tile
|
|
desc.setTile (numLayer, is256x256?uvOff+1:0, tileElement.getTileSubNoise(),
|
|
tileIndex (tileElement.Tile[0], tileElement.getTileOrient (0)),
|
|
tileIndex (tileElement.Tile[1], tileElement.getTileOrient (1)),
|
|
tileIndex (tileElement.Tile[2], tileElement.getTileOrient (2)));
|
|
}
|
|
|
|
// Tile colors
|
|
for (v=0; v<(uint)(patchs[patch].OrderT+1); v++)
|
|
for (u=0; u<(uint)(patchs[patch].OrderS+1); u++)
|
|
{
|
|
CRGBA color;
|
|
color.set565 (patchs[patch].TileColors[u+v*(patchs[patch].OrderS+1)].Color565);
|
|
uiRef.setColor (u+v*(patchs[patch].OrderS+1), (color.R<<16)|(color.G<<8)|(color.B));
|
|
}
|
|
|
|
// Edge flags
|
|
for (uint edge=0; edge<4; edge++)
|
|
{
|
|
uiRef.setEdgeFlag (edge, (patchs[patch].Flags&(1<<edge))==0);
|
|
}
|
|
}
|
|
|
|
// Rebuild the patch mesh
|
|
pPM->InvalidateGeomCache();
|
|
nlverify (pPM->buildLinkages ()==TRUE);
|
|
pPM->computeInteriors ();
|
|
pPM->ApplyConstraints ();
|
|
|
|
// Invalidate
|
|
InvalidateBindingInfo ();
|
|
UpdateBinding (*pPM, 0);
|
|
Validity (*pPM, true);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
|