NL3D::CPatchInfo Struct Reference

#include <zone.h>

---

Detailed Description

The struct for building a patch. NB: Different from the one which is stored.

Author:

Lionel Berenguier

Nevrax France

Date:

2000

Definition at line 86 of file src/3d/zone.h.

Patch geometry.
bool	getCornerSmoothFlag (uint corner) const
void	setCornerSmoothFlag (uint corner, bool smooth)
	setup NoiseSmooth flags: used for Noise geometry and lighting. NB: convention: corner0==A, corner1==B ...
uint16	BaseVertices [4]
	The base corner vertices indices in the current zone. Used for patch connectivity.
float	ErrorSize
	The Base Size*bumpiness of the patch (/2 at each subdivide). Set to 0, if you want CZone to compute it for you.
uint8	Flags
uint8	NoiseRotation
	The orientation of the NoiseMap. 0,1,2,3. This represent a CCW rotation of the NoiseMap.
uint8	OrderS
	Tile Order for the patch.
uint8	OrderT
	Tile Order for the patch.
CBezierPatch	Patch
	The patch coordinates.
Smooth flags methods
bool	getNeighborTile (uint patchId, uint edge, sint position, uint &patchOut, sint &sOut, sint &tOut, const std::vector< CPatchInfo > &patchInfos) const
bool	getSmoothFlag (uint edge)
void	setSmoothFlag (uint edge, bool flag)
bool	getTileSymmetryRotate (const NL3D::CTileBank &bank, uint tile, bool &symmetry, uint &rotate)
bool	transform (std::vector< CPatchInfo > &patchInfo, NL3D::CZoneSymmetrisation &zoneSymmetry, const NL3D::CTileBank &bank, bool symmetry, uint rotate, float snapCell, float weldThreshold, const NLMISC::CMatrix &toOriginalSpace)
void	transform256Case (const NL3D::CTileBank &bank, uint8 &case256, uint tileRotation, bool symmetry, uint rotate, bool goofy)
bool	transformTile (const NL3D::CTileBank &bank, uint &tile, uint &tileRotation, bool symmetry, uint rotate, bool goofy)
Public Member Functions
	CPatchInfo ()
Data Fields
Patch Binding.
CBindInfo	BindEdges [4]
Patch texture.
std::vector< uint8 >	Lumels
std::vector< CTileColor >	TileColors
std::vector< CTileLightInfluence >	TileLightInfluences
std::vector< CTileElement >	Tiles
Private Attributes
uint8	_CornerSmoothFlag

---

Constructor & Destructor Documentation

NL3D::CPatchInfo::CPatchInfo (   )  [inline]

Definition at line 241 of file src/3d/zone.h. { ErrorSize= 0; // No Rotation / not smooth by default. NoiseRotation= 0; _CornerSmoothFlag= 0; }

---

Member Function Documentation

bool NL3D::CPatchInfo::getCornerSmoothFlag (  uint  corner  )  const

Definition at line 67 of file 3d/zone.cpp. References nlassert, and uint. Referenced by NL3D::CZone::build(). { nlassert(corner<=3); uint mask= 1<<corner; return (_CornerSmoothFlag & mask)!=0; }

bool NL3D::CPatchInfo::getNeighborTile (  uint  patchId, uint  edge, sint  position, uint &  patchOut, sint &  sOut, sint &  tOut, const std::vector< CPatchInfo > &  patchInfos )  const

Get neighbor tile across a edge Parameters: patchid  is the id of this patch edge  is the edge shared with the neigbor position  is the position over the edge in CCW across the patch. So if edge == 0, position is oriented like OT So if edge == 1, position is oriented like OS So if edge == 2, position is oriented like -OT So if edge == 3, position is oriented like -OS patchOut  will be filled with the output patch id sOut  will be filled with the output patch s coordinate tOut  will be filled with the output patch t coordinate patchInfos  is the vector of all patch info Returns: false if no neighbor has been found or tile ratio is not the same than in this patch. Definition at line 1551 of file 3d/zone.cpp. References BindEdges, NL3D::CPatchInfo::CBindInfo::Edge, NL3D::CPatchInfo::CBindInfo::Next, nlassert, NL3D::CPatchInfo::CBindInfo::NPatchs, sint, and uint. { nlassert (edge<4); // S or T ? uint length = (edge&1) ? OrderS : OrderT; nlassert ((uint)position<length); // What kind of case ? switch (BindEdges[edge].NPatchs) { case 1: case 2: case 4: { // Get neighbor index and position in neighbor uint neighborLength = (length / BindEdges[edge].NPatchs); uint neighbor = position / neighborLength; uint neighborPosition = neighborLength - (position % neighborLength) - 1; uint neighborEdge = BindEdges[edge].Edge[neighbor]; // Patch id patchOut = BindEdges[edge].Next[neighbor]; // Check neighbor uint neighborRealLength = (neighborEdge&1) ? patchInfos[patchOut].OrderS : patchInfos[patchOut].OrderT; if (neighborRealLength == neighborLength) { // Get final coordinate switch (neighborEdge) { case 0: sOut = 0; tOut = neighborPosition; break; case 1: sOut = neighborPosition; tOut = patchInfos[patchOut].OrderT-1; break; case 2: sOut = patchInfos[patchOut].OrderS-1; tOut = patchInfos[patchOut].OrderT-neighborPosition-1; break; case 3: sOut = patchInfos[patchOut].OrderS-neighborPosition-1; tOut = 0; break; } // Ok todo remove return true; } } break; case 5: { // Find in the neighbor where we are patchOut = BindEdges[edge].Next[0]; uint neighborEdge = BindEdges[edge].Edge[0]; uint neighborEdgeCount = patchInfos[patchOut].BindEdges[neighborEdge].NPatchs; // Check neighbor uint neighborRealLength = (neighborEdge&1) ? patchInfos[patchOut].OrderS : patchInfos[patchOut].OrderT; // Good length ? if ((neighborRealLength / neighborEdgeCount) == length) { // Find us in the neighbor uint neighborPosition; for (neighborPosition=0; neighborPosition<neighborEdgeCount; neighborPosition++) { // Found ? if (patchInfos[patchOut].BindEdges[neighborEdge].Next[neighborPosition] == patchId) break; } // Must be found nlassert (neighborPosition!=neighborEdgeCount); neighborPosition = (neighborPosition + 1) * (neighborRealLength / neighborEdgeCount) - position - 1; // Get final coordinate switch (neighborEdge) { case 0: sOut = 0; tOut = neighborPosition; break; case 1: sOut = neighborPosition; tOut = patchInfos[patchOut].OrderT-1; break; case 2: sOut = patchInfos[patchOut].OrderS-1; tOut = patchInfos[patchOut].OrderT-neighborPosition-1; break; case 3: sOut = patchInfos[patchOut].OrderS-neighborPosition-1; tOut = 0; break; } // Ok return true; } } break; } return false; }

bool NL3D::CPatchInfo::getSmoothFlag (  uint  edge  )  [inline]

Get the smooth flag for the n-th edge. Return true if this edge must by smoothed, false else. Definition at line 192 of file src/3d/zone.h. References uint. Referenced by NL3D::CZoneTgtSmoother::makeVerticesCoplanar(), NL3D::CZoneSmoother::smoothTangents(), and transform(). { // Test it return ((Flags&(1<<edge))!=0); }

bool NL3D::CPatchInfo::getTileSymmetryRotate (  const NL3D::CTileBank &  bank, uint  tile, bool &  symmetry, uint &  rotate )  [static]

Get neighbor tile across a edge Parameters: patchid  is the id of this patch edge  is the edge shared with the neigbor position  is the position over the edge in CCW across the patch. So if edge == 0, position is oriented like OT So if edge == 1, position is oriented like OS So if edge == 2, position is oriented like -OT So if edge == 3, position is oriented like -OS patchOut  will be filled with the output patch id sOut  will be filled with the output patch s coordinate tOut  will be filled with the output patch t coordinate patchInfos  is the vector of all patch info Returns: false if no neighbor has been found or tile ratio is not the same than in this patch. Definition at line 1667 of file 3d/zone.cpp. References NL3D::CTileSet::getOriented(), NL3D::CTileBank::getTileCount(), NL3D::CTileBank::getTileSet(), NL3D::CTileBank::getTileSetCount(), NL3D::CTileBank::getTileXRef(), nlwarning, type, and uint. Referenced by transform(). { // Need check the tile ? if ( (symmetry || (rotate != 0)) && (tile != 0xffffffff) ) { // Tile exist ? if (tile < (uint)bank.getTileCount()) { // Get xref int tileSet; int number; CTileBank::TTileType type; // Get tile xref bank.getTileXRef ((int)tile, tileSet, number, type); if ((tileSet < 0) || (tileSet >= bank.getTileSetCount())) { nlwarning("tile %d has an unknown tileSet (%d)",tile, tileSet); return false; } // Is it an oriented tile ? if (bank.getTileSet (tileSet)->getOriented()) { // New rotation value rotate = 0; } // Ok return true; } return false; } else return true; }

void NL3D::CPatchInfo::setCornerSmoothFlag (  uint  corner, bool  smooth )

setup NoiseSmooth flags: used for Noise geometry and lighting. NB: convention: corner0==A, corner1==B ... Definition at line 56 of file 3d/zone.cpp. References nlassert, and uint. Referenced by NL3D::CZone::retrieve(). { nlassert(corner<=3); uint mask= 1<<corner; if(smooth) _CornerSmoothFlag|= mask; else _CornerSmoothFlag&= ~mask; }

void NL3D::CPatchInfo::setSmoothFlag (  uint  edge, bool  flag )  [inline]

Set the smooth flag for the n-th edge. flag is false if this edge must by smoothed, true else. Definition at line 180 of file src/3d/zone.h. References uint. { // Erase it Flags&=~(1<<edge); // Set it Flags|=(((uint)flag)<<edge); }

bool NL3D::CPatchInfo::transform (  std::vector< CPatchInfo > &  patchInfo, NL3D::CZoneSymmetrisation &  zoneSymmetry, const NL3D::CTileBank &  bank, bool  symmetry, uint  rotate, float  snapCell, float  weldThreshold, const NLMISC::CMatrix &  toOriginalSpace )  [static]

Adjusts a CPatchInfo array to get a symmetrized / rotated zone with matching oriented tiles. This method only adjuste tile and vertex color array, does'nt transform vertices. Transform an array of patchInfo by a symmetry on OY axis followed by a 90deg CCW rotation (0, 1, 2, 3). The method doesn't transform vertices. If symmetry, the method invert 0-3 and 1-2 vertices indexes to get CCW oriented patches. It will fix bind informations. The method fixes tile and color vertex arrays. The method fixes tile rotation, 256 cases and tile transistions. Return false if something wrong. Definition at line 1825 of file 3d/zone.cpp. References BaseVertices, BindEdges, NL3D::CZoneSymmetrisation::build(), NL3D::CPatchInfo::CBindInfo::Edge, Flags, getSmoothFlag(), NL3D::CTileElement::getTile256Info(), NL3D::CTileElement::getTileOrient(), NL3D::CZoneSymmetrisation::getTileState(), getTileSymmetryRotate(), NL3D::CBezierPatch::Interiors, NL3D::CPatchInfo::CBindInfo::Next, nlwarning, NL3D::CPatchInfo::CBindInfo::NPatchs, OrderS, OrderT, Patch, NL3D::CTileElement::setTile256Info(), NL3D::CTileElement::setTileOrient(), NL3D::CBezierPatch::Tangents, NL3D::CTileElement::Tile, TileColors, Tiles, transform256Case(), transformTile(), uint, uint16, uint8, v, and NL3D::CBezierPatch::Vertices. { uint patchCount = patchInfo.size (); uint i; // --- Export tile info Symmetry of the bind info. // --- Parse each patch and each edge // For each patches NL3D::CZoneSymmetrisation::CError error; // Build the structure if (!zoneSymmetry.build (patchInfo, snapCell, weldThreshold, bank, error, toOriginalSpace)) { return false; } // Symmetry ? if (symmetry) { for(i=0 ; i<patchCount; i++) { // Ref on the current patch CPatchInfo &pi = patchInfo[i]; // --- Symmetry vertex indexes // Vertices CVector tmp = pi.Patch.Vertices[0]; pi.Patch.Vertices[0] = pi.Patch.Vertices[3]; pi.Patch.Vertices[3] = tmp; tmp = pi.Patch.Vertices[1]; pi.Patch.Vertices[1] = pi.Patch.Vertices[2]; pi.Patch.Vertices[2] = tmp; // Tangents tmp = pi.Patch.Tangents[0]; pi.Patch.Tangents[0] = pi.Patch.Tangents[5]; pi.Patch.Tangents[5] = tmp; tmp = pi.Patch.Tangents[1]; pi.Patch.Tangents[1] = pi.Patch.Tangents[4]; pi.Patch.Tangents[4] = tmp; tmp = pi.Patch.Tangents[2]; pi.Patch.Tangents[2] = pi.Patch.Tangents[3]; pi.Patch.Tangents[3] = tmp; tmp = pi.Patch.Tangents[6]; pi.Patch.Tangents[6] = pi.Patch.Tangents[7]; pi.Patch.Tangents[7] = tmp; // Interior tmp = pi.Patch.Interiors[0]; pi.Patch.Interiors[0] = pi.Patch.Interiors[3]; pi.Patch.Interiors[3] = tmp; tmp = pi.Patch.Interiors[1]; pi.Patch.Interiors[1] = pi.Patch.Interiors[2]; pi.Patch.Interiors[2] = tmp; // ** Symmetries tile colors uint u,v; uint countU = pi.OrderS/2+1; uint countV = pi.OrderT+1; for (v=0; v<countV; v++) for (u=0; u<countU; u++) { // Store it in the tile info uint index0 = u+v*(pi.OrderS+1); uint index1 = (pi.OrderS-u)+v*(pi.OrderS+1); // XChg uint16 tmp = pi.TileColors[index0].Color565; pi.TileColors[index0].Color565 = pi.TileColors[index1].Color565; pi.TileColors[index1].Color565 = tmp; } // Smooth flags uint flags = (uint)(pi.getSmoothFlag (0))<<2; flags |= (uint)(pi.getSmoothFlag (2))<<0; flags |= (uint)(pi.getSmoothFlag (1))<<1; flags |= (uint)(pi.getSmoothFlag (3))<<3; pi.Flags &= ~3; pi.Flags |= flags; } // --- Symmetry of the bind info. // --- Parse each patch and each edge // For each patches for (i=0 ; i<patchCount; i++) { // Ref on the patch info CPatchInfo &pi = patchInfo[i]; // Xchg left and right swap (pi.BindEdges[0], pi.BindEdges[2]); swap (pi.BaseVertices[0], pi.BaseVertices[3]); swap (pi.BaseVertices[1], pi.BaseVertices[2]); // Flip edges for (uint edge=0; edge<4; edge++) { // Ref on the patch info CPatchInfo::CBindInfo &bindEdge = pi.BindEdges[edge]; uint next; // Look if it is a bind ? if ( (bindEdge.NPatchs>1) && (bindEdge.NPatchs!=5) ) { for (next=0; next<(uint)bindEdge.NPatchs/2; next++) { swap (bindEdge.Next[bindEdge.NPatchs - next - 1], bindEdge.Next[next]); swap (bindEdge.Edge[bindEdge.NPatchs - next - 1], bindEdge.Edge[next]); } } // Look if we are binded on a reversed edge uint bindCount = (bindEdge.NPatchs==5) ? 1 : bindEdge.NPatchs; for (next=0; next<bindCount; next++) { // Left or right ? if ( (bindEdge.Edge[next] & 1) == 0) { // Invert bindEdge.Edge[next] += 2; bindEdge.Edge[next] &= 3; } } } } } // For each patches for (i=0 ; i<patchCount; i++) { // Tile infos CPatchInfo &pi = patchInfo[i]; // Backup tiles std::vector<CTileElement> tiles = pi.Tiles; int u,v; for (v=0; v<pi.OrderT; v++) for (u=0; u<pi.OrderS; u++) { // U tile int uSymmetry = symmetry ? (pi.OrderS-u-1) : u; // Destination tile CTileElement &element = pi.Tiles[u+v*pi.OrderS]; // Copy the orginal symmetrical element element = tiles[uSymmetry+v*pi.OrderS]; // For each layer for (int l=0; l<3; l++) { // Empty ? if (element.Tile[l] != 0xffff) { // Get the tile index uint tile = element.Tile[l]; uint tileRotation = element.getTileOrient (l); // Get rot and symmetry for this tile uint tileRotate = rotate; bool tileSymmetry = symmetry; bool goofy = symmetry && (zoneSymmetry.getTileState (i, uSymmetry+v*pi.OrderS, l) == CZoneSymmetrisation::Goofy); // Transform the transfo if (getTileSymmetryRotate (bank, tile, tileSymmetry, tileRotate)) { // Transform the tile if (!transformTile (bank, tile, tileRotation, tileSymmetry, (4-tileRotate)&3, goofy)) { // Info nlwarning ("Error getting symmetrical / rotated zone tile."); return false; } } else { // Info nlwarning ("Error getting symmetrical / rotated zone tile."); return false; } // Set the tile element.Tile[l] = tile; element.setTileOrient (l, (uint8)tileRotation); } } // Empty ? if (element.Tile[0]!=0xffff) { // Get 256 info bool is256x256; uint8 uvOff; element.getTile256Info (is256x256, uvOff); // 256 ? if (is256x256) { // Get rot and symmetry for this tile uint tileRotate = rotate; bool tileSymmetry = symmetry; uint tileRotation = tiles[uSymmetry+v*pi.OrderS].getTileOrient (0); bool goofy = symmetry && (zoneSymmetry.getTileState (i, uSymmetry+v*pi.OrderS, 0) == CZoneSymmetrisation::Goofy); // Transform the transfo getTileSymmetryRotate (bank, element.Tile[0], tileSymmetry, tileRotate); // Transform the case transform256Case (bank, uvOff, tileRotation, tileSymmetry, (4-tileRotate)&3, goofy); element.setTile256Info (true, uvOff); } } } } // Ok return true; }

void NL3D::CPatchInfo::transform256Case (  const NL3D::CTileBank &  bank, uint8 &  case256, uint  tileRotation, bool  symmetry, uint  rotate, bool  goofy )  [static]

Get neighbor tile across a edge Parameters: patchid  is the id of this patch edge  is the edge shared with the neigbor position  is the position over the edge in CCW across the patch. So if edge == 0, position is oriented like OT So if edge == 1, position is oriented like OS So if edge == 2, position is oriented like -OT So if edge == 3, position is oriented like -OS patchOut  will be filled with the output patch id sOut  will be filled with the output patch s coordinate tOut  will be filled with the output patch t coordinate patchInfos  is the vector of all patch info Returns: false if no neighbor has been found or tile ratio is not the same than in this patch. Definition at line 1799 of file 3d/zone.cpp. References uint, and uint8. Referenced by transform(). { // Tile exist ? if ( (rotate!=0) || symmetry ) { // Symmetry ? if (symmetry) { // Take the symmetry uint symArray[4] = {3, 2, 1, 0}; case256 = symArray[case256]; if (goofy && ((tileRotation & 1) ==0)) case256 += 2; if ((!goofy) && (tileRotation & 1)) case256 += 2; } // Rotation ? case256 -= rotate; case256 &= 3; } }

bool NL3D::CPatchInfo::transformTile (  const NL3D::CTileBank &  bank, uint &  tile, uint &  tileRotation, bool  symmetry, uint  rotate, bool  goofy )  [static]

Get neighbor tile across a edge Parameters: patchid  is the id of this patch edge  is the edge shared with the neigbor position  is the position over the edge in CCW across the patch. So if edge == 0, position is oriented like OT So if edge == 1, position is oriented like OS So if edge == 2, position is oriented like -OT So if edge == 3, position is oriented like -OS patchOut  will be filled with the output patch id sOut  will be filled with the output patch s coordinate tOut  will be filled with the output patch t coordinate patchInfos  is the vector of all patch info Returns: false if no neighbor has been found or tile ratio is not the same than in this patch. Definition at line 1708 of file 3d/zone.cpp. References NL3D::CTileSet::getOrientedBorder(), NL3D::CTileSetTransition::getTile(), NL3D::CTileBank::getTileCount(), NL3D::CTileBank::getTileSet(), NL3D::CTileBank::getTileXRef(), NL3D::CTileSet::getTransition(), NL3D::CTileSet::getTransitionTile(), nlassert, type, and uint. Referenced by transform(). { // Tile exist ? if ( (rotate!=0) || symmetry ) { if (tile < (uint)bank.getTileCount()) { // Get xref int tileSet; int number; CTileBank::TTileType type; // Get tile xref bank.getTileXRef ((int)tile, tileSet, number, type); // Transition ? if (type == CTileBank::transition) { // Rotation for transition uint transRotate = rotate; // Number should be ok nlassert (number>=0); nlassert (number<CTileSet::count); // Tlie set number const CTileSet *pTileSet = bank.getTileSet (tileSet); // Get border desc CTileSet::TFlagBorder oriented[4] = { pTileSet->getOrientedBorder (CTileSet::left, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::left)), pTileSet->getOrientedBorder (CTileSet::bottom, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::bottom)), pTileSet->getOrientedBorder (CTileSet::right, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::right)), pTileSet->getOrientedBorder (CTileSet::top, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::top)) }; // Symmetry ? if (symmetry) { if ( (tileRotation & 1) ^ goofy ) { CTileSet::TFlagBorder tmp = oriented[1]; oriented[1] = CTileSet::getInvertBorder (oriented[3]); oriented[3] = CTileSet::getInvertBorder (tmp); oriented[2] = CTileSet::getInvertBorder (oriented[2]); oriented[0] = CTileSet::getInvertBorder (oriented[0]); } else { CTileSet::TFlagBorder tmp = oriented[0]; oriented[0] = CTileSet::getInvertBorder (oriented[2]); oriented[2] = CTileSet::getInvertBorder (tmp); oriented[1] = CTileSet::getInvertBorder (oriented[1]); oriented[3] = CTileSet::getInvertBorder (oriented[3]); } } // Rotation CTileSet::TFlagBorder edges[4]; edges[0] = pTileSet->getOrientedBorder (CTileSet::left, oriented[(0 + transRotate )&3]); edges[1] = pTileSet->getOrientedBorder (CTileSet::bottom, oriented[(1 + transRotate )&3]); edges[2] = pTileSet->getOrientedBorder (CTileSet::right, oriented[(2 + transRotate )&3]); edges[3] = pTileSet->getOrientedBorder (CTileSet::top, oriented[(3 + transRotate )&3]); // Get the good tile number CTileSet::TTransition transition = pTileSet->getTransitionTile (edges[3], edges[1], edges[0], edges[2]); nlassert ((CTileSet::TTransition)transition != CTileSet::notfound); tile = (uint)(pTileSet->getTransition (transition)->getTile ()); } // Transform rotation: invert rotation tileRotation += rotate; // If goofy, add +2 if (goofy && symmetry) tileRotation += 2; // Mask the rotation tileRotation &= 3; } else return false; } // Ok return true; }

---

Field Documentation

uint8 NL3D::CPatchInfo::_CornerSmoothFlag [private]

Definition at line 251 of file src/3d/zone.h.

uint16 NL3D::CPatchInfo::BaseVertices[4]

The base corner vertices indices in the current zone. Used for patch connectivity. Definition at line 126 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZoneTgtSmoother::makeVerticesCoplanar(), NL3D::CZone::retrieve(), and transform().

CBindInfo NL3D::CPatchInfo::BindEdges[4]

Definition at line 236 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), getNeighborTile(), NL3D::CZoneTgtSmoother::makeVerticesCoplanar(), NL3D::CZone::retrieve(), NL3D::CZoneSmoother::smoothTangents(), and transform().

float NL3D::CPatchInfo::ErrorSize

The Base Size*bumpiness of the patch (/2 at each subdivide). Set to 0, if you want CZone to compute it for you. Definition at line 124 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), and NL3D::CZone::retrieve().

uint8 NL3D::CPatchInfo::Flags

"The don't smooth" flags. For each edge of the patch (0~3), the flag means that this patch mustn't be smoothed with its neightbor. The n-th edge links the vertices "n" and "(n+1)%4". The flag for the n-th edge is (1<<n). Definition at line 130 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZone::retrieve(), and transform().

std::vector<uint8> NL3D::CPatchInfo::Lumels

The Tile lumels for this patch. There must be (OrderS*4+1)*(OrderT*4+1) tile lumels. Those are lumel value in tiles. There is 4x4 lumels by tiles plus last lumels. They are stored in line first order, from S=0 to 1, and T=0 to 1. Definition at line 161 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZoneLighter::processCalc(), and NL3D::CZone::retrieve().

uint8 NL3D::CPatchInfo::NoiseRotation

The orientation of the NoiseMap. 0,1,2,3. This represent a CCW rotation of the NoiseMap. Definition at line 134 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), and NL3D::CZone::retrieve().

uint8 NL3D::CPatchInfo::OrderS

Tile Order for the patch. Definition at line 122 of file src/3d/zone.h. Referenced by NL3D::CZoneSymmetrisation::build(), NL3D::CZone::build(), NL3D::CZoneSymmetrisation::propagateTileState(), NL3D::CZone::retrieve(), NL3D::CZoneSymmetrisation::setOrientedTileState(), NL3D::CZoneSymmetrisation::setTileState(), NL3D::st2uv(), transform(), and NL3D::uv2st().

uint8 NL3D::CPatchInfo::OrderT

Tile Order for the patch. Definition at line 122 of file src/3d/zone.h. Referenced by NL3D::CZoneSymmetrisation::build(), NL3D::CZone::build(), NL3D::CZone::retrieve(), NL3D::CZoneSymmetrisation::setOrientedTileState(), NL3D::CZoneSymmetrisation::setTileState(), NL3D::st2uv(), transform(), and NL3D::uv2st().

CBezierPatch NL3D::CPatchInfo::Patch

The patch coordinates. Definition at line 120 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZoneTgtSmoother::makeVerticesCoplanar(), NL3D::CZone::retrieve(), NL3D::CZoneSymmetrisation::setOrientedTileState(), NL3D::CZoneSymmetrisation::setTileState(), NL3D::CZoneSmoother::smoothTangents(), and transform().

std::vector<CTileColor> NL3D::CPatchInfo::TileColors

The Tile colors for this patch. There must be (OrderS+1)*(OrderT+1) tile colors. Those are the colors at the corners of the tiles. They are stored in line first order, from S=0 to 1, and T=0 to 1. Definition at line 155 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZone::retrieve(), and transform().

std::vector<CTileLightInfluence> NL3D::CPatchInfo::TileLightInfluences

There is (OrderS/2+1) * (OrderT/2+1) tiles light influence. It indicates which static pointLight influence each corner of a TessBlock (block of 2*2 tiles). If size()==0, suppose no light influence. but CZone::retrieve() always return a size() == (OrderS/2+1) * (OrderT/2+1). They are stored in line first order, from S=0 to 1, and T=0 to 1. Definition at line 171 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZoneLighter::processZonePointLightRT(), and NL3D::CZone::retrieve().

std::vector<CTileElement> NL3D::CPatchInfo::Tiles

The Tiles for this patch. There must be OrderS*OrderT tiles. They are stored in line first order, from S=0 to 1, and T=0 to 1. Definition at line 149 of file src/3d/zone.h. Referenced by NL3D::CZone::build(), NL3D::CZoneSymmetrisation::propagateTileState(), NL3D::CZone::retrieve(), NL3D::CZoneSymmetrisation::setOrientedTileState(), NL3D::CZoneSymmetrisation::setTileState(), and transform().

---

The documentation for this struct was generated from the following files:

• src/3d/zone.h
• 3d/zone.cpp

---