int32 FGeomObject::AddEdgeToPool( FGeomPoly* InPoly, int32 InParentPolyIndex, int32 InVectorIdxA, int32 InVectorIdxB )
{
const int32 idx0 = AddVertexToPool( InPoly->GetParentObjectIndex(), InParentPolyIndex, InPoly->ActualPolyIndex, InVectorIdxA );
const int32 idx1 = AddVertexToPool( InPoly->GetParentObjectIndex(), InParentPolyIndex, InPoly->ActualPolyIndex, InVectorIdxB );
// See if the edge is already in the pool. If so, leave.
FGeomEdge* ge = NULL;
for( int32 e = 0 ; e < EdgePool.Num() ; ++e )
{
if( EdgePool[e].VertexIndices[0] == idx0 && EdgePool[e].VertexIndices[1] == idx1 )
{
EdgePool[e].ParentPolyIndices.Add( InPoly->GetParentObject()->PolyPool.Find( *InPoly ) );
return e;
}
}
// Add a new edge to the pool and set it up.
new( EdgePool )FGeomEdge();
ge = &EdgePool[ EdgePool.Num()-1 ];
ge->VertexIndices[0] = idx0;
ge->VertexIndices[1] = idx1;
ge->ParentPolyIndices.Add( InPoly->GetParentObject()->PolyPool.Find( *InPoly ) );
ge->SetParentObjectIndex( InPoly->GetParentObjectIndex() );
return EdgePool.Num()-1;
}
void Encoder::Encode(DWORD ID, DWORD Class, DWORD CTNumber, DWORD MType)
{
BOOL bInsertSurfaceNode = FALSE;
BOOL bInsertTextureNode = FALSE;
m_pCurrentNode = m_pRootNode;
// COBRA - RED - Missing Last Texture Initialization to INVALID
DWORD dwCurrentTexture=-1;
DWORD dwCurrentzBias=0;
NodeType LastType=ROOT;
DXFlagsType LastFlags;
LastFlags.w=0x00;
bool ChangeSurface=false;
while(m_pCurrentNode != NULL)
{
IdleMode();
NodeType Type=m_pCurrentNode->Type;
DXFlagsType Flags;
Flags.w=m_pCurrentNode->Flags.w;
// Make all checks here
ChangeSurface=false;
if(Type!=LastType || Type==DOF || Type==CLOSEDOF || Type==SLOT ) ChangeSurface = true;
if(Flags.b.Texture && m_pCurrentNode->Texture!=dwCurrentTexture) ChangeSurface = true;
if(Flags.b.Texture != LastFlags.b.Texture) ChangeSurface=true;
if(Flags.b.Alpha != LastFlags.b.Alpha) ChangeSurface=true;
if(Flags.b.Gouraud != LastFlags.b.Gouraud ) ChangeSurface=true;
if(Flags.b.Lite != LastFlags.b.Lite ) ChangeSurface=true;
if((Flags.b.VColor) != (LastFlags.b.VColor)) ChangeSurface=true;
if(Flags.b.zBias != LastFlags.b.zBias) ChangeSurface=true;
if(Flags.b.zBias && m_pCurrentNode->dwzBias!=dwCurrentzBias) ChangeSurface=true;
if(Flags.b.ChromaKey != LastFlags.b.ChromaKey) ChangeSurface=true;
// if any change
if(ChangeSurface){
// Patch the segments
PatchDWORD();
switch (Type){
case DOT:
case LINE:
case TRIANGLE: // Check if a Textured new surace and last texture still valid
if(Flags.b.Texture && m_pCurrentNode->Texture!=dwCurrentTexture){
// No moer used Texture node
//WriteTextureNode(m_pCurrentNode);
dwCurrentTexture=m_pCurrentNode->Texture;
}
dwCurrentzBias=m_pCurrentNode->dwzBias;
// Write the new Surface
WriteSurfaceNode(m_pCurrentNode, dwCurrentTexture);
// New ID
m_dwNodeID++;
break;
case DOF: // We've to insert a new DOF node
{DXDof *pDof = (DXDof*)m_pCurrentNode; WriteDofNode(pDof);}
// and reset surfaces properties
Flags.w=0;
dwCurrentTexture=-1;
// New ID
m_dwNodeID++;
break;
case SLOT: // We've to insert a new SLOT node
WriteSlotNode((DXSlot*)m_pCurrentNode);
// New ID
m_dwNodeID++;
break;
case CLOSEDOF: // We've to insert a new END DOF node
WriteDofEndNode();
// and reset surfaces properties
Flags.w=0;
dwCurrentTexture=-1;
// New ID
m_dwNodeID++;
break;
default : MessageBox(NULL, "Unknown SURFACE TYPE!!", "Encoder", 0);
}
ChangeSurface=false;
LastFlags=Flags;
LastType=Type;
}
switch(Type)
{
case DOT:
{
DXVertex *pVertex = (DXVertex*)m_pCurrentNode;
D3DVERTEXEX dxVertex;
InitializeVertex(&dxVertex);
CopyVertex(&(pVertex->Vertex), pVertex->VColor, &dxVertex);
/*memcpy((void*)&dxVertex, (const void*)&pVertex->Vertex, sizeof(pVertex->Vertex));
memcpy((void*)(&dxVertex + sizeof(pVertex->Vertex)), (const void*)&pVertex->VColor, sizeof(pVertex->VColor));*/
// Add vertex in NON INDEXED MODE
Int16 iIndex = AddVertexToPool(&dxVertex, false);
WriteBuffer((const void*)&iIndex, sizeof(iIndex));
}
break;
case LINE:
{
DXLine *pLine = (DXLine*)m_pCurrentNode;
for(int i=0; i<2; i++)
{
D3DVERTEXEX dxVertex;
InitializeVertex(&dxVertex);
CopyVertex(&(pLine->Vertex[i]), pLine->VColor[i], &dxVertex);
/*memcpy((void*)&dxVertex, (const void*)&pLine->Vertex[i], sizeof(pLine->Vertex[i]));
memcpy((void*)(&dxVertex + sizeof(pLine->Vertex[i])), (const void*)&pLine->VColor[i], sizeof(pLine->VColor[0]));*/
Int16 iIndex = AddVertexToPool(&dxVertex);
WriteBuffer((const void*)&iIndex, sizeof(iIndex));
}
}
break;
case TRIANGLE:
{
DXTriangle *pTriangle = (DXTriangle*)m_pCurrentNode;
for(int i=0; i<3; i++)
{
D3DVERTEXEX dxVertex;
InitializeVertex(&dxVertex);
CopyVertex(&(pTriangle->Vertex[i]), pTriangle->VColor[i], &dxVertex);
/*BYTE *pVertex = (BYTE*)&dxVertex;
memcpy((void*)&dxVertex, (const void*)&pTriangle->Vertex[i], sizeof(pTriangle->Vertex[i]));
memcpy((void*)(pVertex + sizeof(pTriangle->Vertex[i])), (const void*)&pTriangle->VColor[i], sizeof(pTriangle->VColor[0]));*/
Int16 iIndex = AddVertexToPool(&dxVertex);
WriteBuffer((const void*)&iIndex, sizeof(iIndex));
}
}
break;
}
// Update pointers
//m_pPreviousNode = m_pCurrentNode;
m_pCurrentNode = m_pCurrentNode->Next;
//m_pNextNode = m_pCurrentNode != NULL ? m_pCurrentNode->Next : NULL;
}
//// Set last node total size (Node + Data (total indexes size))
//DWORD dwTotalNodeSize = (m_dwTotalSurfaceVertexes*sizeof(Int16) + sizeof(DxSurfaceType));
//memcpy((void*)m_pLastSurfaceNode, (const void*)&dwTotalNodeSize, sizeof(dwTotalNodeSize));
//// Add last node Vertex Counter to last surface node
//memcpy(m_pLastSurfaceNode + 12, (const void*)&m_dwTotalSurfaceVertexes, sizeof(m_dwTotalSurfaceVertexes));
// Patch the segments
PatchDWORD();
// Write ENDMODEL node
DxEndModelType dxEndModelNode;
dxEndModelNode.h.dwNodeSize = sizeof(DxEndModelType);
dxEndModelNode.h.Type = DX_MODELEND;
WriteBuffer((void*)&dxEndModelNode, sizeof(dxEndModelNode));
// Write total number of nodes
((DxDbHeader*)m_pHeader)->dwNodesNr=m_dwTotalNodeCount;
// Write other header fields
//DWORD dwVertexesPoolStart = (DWORD)(m_pBuffer + m_dwBufferOffset);
((DxDbHeader*)m_pHeader)->pVPool=m_dwBufferOffset;
((DxDbHeader*)m_pHeader)->dwPoolSize=m_dwVertexesPoolSize;
((DxDbHeader*)m_pHeader)->dwNVertices=m_dwVertexesNumber;
// Copy vertexes pool after nodes section
WriteBuffer((const void*)m_pVertexesPool, m_dwVertexesPoolSize);
((DxDbHeader*)m_pHeader)->Id=ID;
((DxDbHeader*)m_pHeader)->ModelSize= m_dwBufferOffset;
((DxDbHeader*)m_pHeader)->VBClass=Class;
((DxDbHeader*)m_pHeader)->Version=MODEL_VERSION|((MODEL_VERSION^0xffff)<<16);
// Assign Materials Features
m_dwBufferOffset=AssignSurfaceFeatures(m_pBuffer, CTNumber, MType);
#ifdef CRYPTED_MODELS
TheVbManager.Encrypt((DWORD*)m_pBuffer);
#endif
// Write file
//WriteFile();
}
void Encoder::Encode()
{
BOOL bInsertSurfaceNode = FALSE;
BOOL bInsertTextureNode = FALSE;
m_pCurrentNode = m_pRootNode;
while(m_pCurrentNode != NULL)
{
m_pPreviousNode = m_pCurrentNode->Prev;
//m_pNextNode = m_pCurrentNode->Next;
if(m_pCurrentNode == m_pRootNode)
{
// Root node, insert Texture and Surface node
if(m_pCurrentNode->Flags.b.Texture)
WriteTextureNode(m_pCurrentNode);
WriteSurfaceNode(m_pCurrentNode);
}
else
{
// Check for node property changes
if(m_pCurrentNode->Type != DOF && m_pCurrentNode->Type != CLOSEDOF)
{
if(m_pPreviousNode->Type == DOF || m_pPreviousNode->Type == CLOSEDOF)
{
if(m_pCurrentNode->Flags.b.Texture)
WriteTextureNode(m_pCurrentNode);
WriteSurfaceNode(m_pCurrentNode);
}
else
{
if(m_pCurrentNode->Flags.b.Texture)
{
if(m_pCurrentNode->Texture != m_pPreviousNode->Texture)
{
// Texture of current node differs from previous node, we've to insert a TEXTURE node before new SURFACE node
WriteTextureNode(m_pCurrentNode);
WriteSurfaceNode(m_pCurrentNode);
}
else
{
// Check if other fields are changed (in this case we've to insert a new SURFACE node
if( m_pCurrentNode->Flags.b.ALpha != m_pPreviousNode->Flags.b.ALpha ||
m_pCurrentNode->Flags.b.Gouraud != m_pPreviousNode->Flags.b.Gouraud ||
m_pCurrentNode->Flags.b.Lite != m_pPreviousNode->Flags.b.Lite ||
m_pCurrentNode->Type != m_pPreviousNode->Type )
WriteSurfaceNode(m_pCurrentNode);
}
}
else if(m_pCurrentNode->Flags.b.Solid || m_pCurrentNode->Flags.b.VColor)
{
// Colour node, check only for Alpha changes
if( m_pCurrentNode->Flags.b.ALpha != m_pPreviousNode->Flags.b.ALpha ||
m_pCurrentNode->Type != m_pPreviousNode->Type )
WriteSurfaceNode(m_pCurrentNode);
}
}
}
}
switch(m_pCurrentNode->Type)
{
case DOT:
{
DXVertex *pVertex = (DXVertex*)m_pCurrentNode;
D3DVERTEXEX dxVertex;
InitializeVertex(&dxVertex);
memcpy((void*)&dxVertex, (const void*)&pVertex->Vertex, sizeof(pVertex->Vertex));
memcpy((void*)(&dxVertex + sizeof(pVertex->Vertex)), (const void*)&pVertex->VColor, sizeof(pVertex->VColor));
Int16 iIndex = AddVertexToPool(&dxVertex);
WriteBuffer((const void*)&iIndex, sizeof(iIndex));
//if(m_pCurrentNode->Flags.b.Texture)
//{
// // Write all D3DVertex information
// WriteBuffer((void*)&pVertex->Vertex, sizeof(pVertex->Vertex));
//}
//else
//{
// // In this case, write only x,y,z,nx,ny,nz (24 bytes total) and VColour
// WriteBuffer((void*)&pVertex->Vertex, 24);
// WriteBuffer((void*)&pVertex->VColor, sizeof(pVertex->VColor));
//}
//m_dwTotalSurfaceVertexes++;
}
break;
case LINE:
{
DXLine *pLine = (DXLine*)m_pCurrentNode;
for(int i=0; i<2; i++)
{
D3DVERTEXEX dxVertex;
InitializeVertex(&dxVertex);
memcpy((void*)&dxVertex, (const void*)&pLine->Vertex[i], sizeof(pLine->Vertex[i]));
memcpy((void*)(&dxVertex + sizeof(pLine->Vertex[i])), (const void*)&pLine->VColor[i], sizeof(pLine->VColor[0]));
Int16 iIndex = AddVertexToPool(&dxVertex);
WriteBuffer((const void*)&iIndex, sizeof(iIndex));
}
//if(m_pCurrentNode->Flags.b.Texture)
//{
// // Write all D3DVertex information
// WriteBuffer((void*)&pLine->Vertex, sizeof(pLine->Vertex));
//}
//else
//{
// // In this case, write only x,y,z,nx,ny,nz (24 bytes total) and VColour
// for(int i=0;i<2;i++)
// {
// WriteBuffer((void*)&pLine->Vertex[i], 24);
// WriteBuffer((void*)&pLine->VColor[i], sizeof(pLine->VColor[0]));
// }
//}
//m_dwTotalSurfaceVertexes += 2;
}
break;
case TRIANGLE:
{
DXTriangle *pTriangle = (DXTriangle*)m_pCurrentNode;
for(int i=0; i<3; i++)
{
D3DVERTEXEX dxVertex;
InitializeVertex(&dxVertex);
BYTE *pVertex = (BYTE*)&dxVertex;
memcpy((void*)&dxVertex, (const void*)&pTriangle->Vertex[i], sizeof(pTriangle->Vertex[i]));
memcpy((void*)(pVertex + sizeof(pTriangle->Vertex[i])), (const void*)&pTriangle->VColor[i], sizeof(pTriangle->VColor[0]));
Int16 iIndex = AddVertexToPool(&dxVertex);
WriteBuffer((const void*)&iIndex, sizeof(iIndex));
}
//if(m_pCurrentNode->Flags.b.Texture)
//{
// // Write all D3DVertex information
// WriteBuffer((void*)&pTriangle->Vertex, sizeof(pTriangle->Vertex));
//}
//else
//{
// // In this case, write only x,y,z,nx,ny,nz (24 bytes total) and VColour
// for(int i=0;i<3;i++)
// {
// WriteBuffer((void*)&pTriangle->Vertex[i], 24);
// WriteBuffer((void*)&pTriangle->VColor[i], sizeof(pTriangle->VColor[0]));
// }
//}
//m_dwTotalSurfaceVertexes += 3;
}
break;
case DOF:
{
// We've to insert a new DOF node
DXDof *pDof = (DXDof*)m_pCurrentNode;
WriteDofNode(pDof);
}
break;
case CLOSEDOF:
{
// We've to insert a new END DOF node
WriteDofEndNode();
}
break;
}
// Update pointers
//m_pPreviousNode = m_pCurrentNode;
m_pCurrentNode = m_pCurrentNode->Next;
//m_pNextNode = m_pCurrentNode != NULL ? m_pCurrentNode->Next : NULL;
}
// Set last node total size (Node + Data (total indexes size))
DWORD dwTotalNodeSize = (m_dwTotalSurfaceVertexes*sizeof(Int16) + sizeof(DxSurfaceType));
memcpy((void*)m_pLastSurfaceNode, (const void*)&dwTotalNodeSize, sizeof(dwTotalNodeSize));
// Add last node Vertex Counter to last surface node
memcpy(m_pLastSurfaceNode + 12, (const void*)&m_dwTotalSurfaceVertexes, sizeof(m_dwTotalSurfaceVertexes));
// Write ENDMODEL node
DxEndModelType dxEndModelNode;
dxEndModelNode.h.dwNodeSize = sizeof(DxEndModelType);
dxEndModelNode.h.Type = DX_MODELEND;
WriteBuffer((void*)&dxEndModelNode, sizeof(dxEndModelNode));
// Write total number of nodes
memcpy((void*)m_pHeader, (const void*)&m_dwTotalNodeCount, sizeof(m_dwTotalNodeCount));
// Write other header fields
//DWORD dwVertexesPoolStart = (DWORD)(m_pBuffer + m_dwBufferOffset);
memcpy((void*)(m_pHeader+4), (const void*)&m_dwBufferOffset, sizeof(DWORD));
memcpy((void*)(m_pHeader+8), (const void*)&m_dwVertexesPoolSize, sizeof(DWORD));
memcpy((void*)(m_pHeader+12), (const void*)&m_dwVertexesNumber, sizeof(DWORD));
// Copy vertexes pool after nodes section
WriteBuffer((const void*)m_pVertexesPool, m_dwVertexesPoolSize);
// Write file
WriteFile();
}
