mirror of
https://github.com/electronicarts/CnC_Renegade.git
synced 2025-12-16 07:31:40 -05:00
Initial commit of Command & Conquer Renegade source code.
This commit is contained in:
LFeenanEA
383
Code/wwphys/renegadeterrainmaterialpass.cpp
Normal file
383
Code/wwphys/renegadeterrainmaterialpass.cpp
Normal file
@@ -0,0 +1,383 @@
|
||||
/*
|
||||
** Command & Conquer Renegade(tm)
|
||||
** Copyright 2025 Electronic Arts Inc.
|
||||
**
|
||||
** This program is free software: you can redistribute it and/or modify
|
||||
** it under the terms of the GNU 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 General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/***********************************************************************************************
|
||||
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
||||
***********************************************************************************************
|
||||
* *
|
||||
* Project Name : wwphys *
|
||||
* *
|
||||
* $Archive:: /Commando/Code/wwphys/renegadeterrainmaterialpass.cpp $*
|
||||
* *
|
||||
* Author:: Patrick Smith *
|
||||
* *
|
||||
* $Modtime:: 3/05/02 10:56a $*
|
||||
* *
|
||||
* $Revision:: 2 $*
|
||||
* *
|
||||
*---------------------------------------------------------------------------------------------*
|
||||
* Functions: *
|
||||
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
||||
|
||||
#include "renegadeterrainmaterialpass.h"
|
||||
#include "terrainmaterial.h"
|
||||
#include "vector2.h"
|
||||
#include "dx8vertexbuffer.h"
|
||||
#include "dx8indexbuffer.h"
|
||||
#include "chunkio.h"
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Local constants
|
||||
////////////////////////////////////////////////////////////////
|
||||
enum
|
||||
{
|
||||
CHUNKID_VARIABLES = 0x03040552,
|
||||
CHUNKID_VERTEX_ALPHAS,
|
||||
CHUNKID_VERTEX_UVS,
|
||||
CHUNKID_MATERIAL,
|
||||
CHUNKID_QUAD_LIST,
|
||||
CHUNKID_VERTEX_RENDER_LIST,
|
||||
CHUNKID_VERTEX_INDEX_MAP
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
VARID_VERTEX_COUNT = 0x01,
|
||||
};
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// RenegadeTerrainMaterialPassClass
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
RenegadeTerrainMaterialPassClass::RenegadeTerrainMaterialPassClass (void) :
|
||||
VertexAlpha (NULL),
|
||||
GridUVs (NULL),
|
||||
Material (NULL),
|
||||
VertexCount (0)
|
||||
{
|
||||
::memset (VertexIndexMap, 0, sizeof (VertexIndexMap));
|
||||
::memset (IndexBuffers, 0, sizeof (IndexBuffers));
|
||||
::memset (VertexBuffers, 0, sizeof (VertexBuffers));
|
||||
|
||||
//
|
||||
// Prep the lists
|
||||
//
|
||||
for (int index = 0; index < PASS_COUNT; index ++) {
|
||||
QuadList[index].Set_Growth_Step (1000);
|
||||
VertexRenderList[index].Set_Growth_Step (1000);
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// ~RenegadeTerrainMaterialPassClass
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
RenegadeTerrainMaterialPassClass::~RenegadeTerrainMaterialPassClass (void)
|
||||
{
|
||||
REF_PTR_RELEASE (Material);
|
||||
|
||||
//
|
||||
// Free the UV array
|
||||
//
|
||||
if (GridUVs != NULL) {
|
||||
delete [] GridUVs;
|
||||
GridUVs = NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// Free the vertex alpha array
|
||||
//
|
||||
if (VertexAlpha != NULL) {
|
||||
delete [] VertexAlpha;
|
||||
VertexAlpha = NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// Free the vertex index arrays
|
||||
//
|
||||
for (int index = 0; index < PASS_COUNT; index ++) {
|
||||
if (VertexIndexMap[index] != NULL) {
|
||||
delete [] VertexIndexMap[index];
|
||||
VertexIndexMap[index] = NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// Release our hold on the index and vertex buffers for this pass
|
||||
//
|
||||
REF_PTR_RELEASE (IndexBuffers[index]);
|
||||
REF_PTR_RELEASE (VertexBuffers[index]);
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Allocate
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
RenegadeTerrainMaterialPassClass::Allocate (int vertex_count)
|
||||
{
|
||||
//
|
||||
// Allocate the vertex alpha and UV arrays
|
||||
//
|
||||
VertexCount = vertex_count;
|
||||
VertexAlpha = new float[vertex_count];
|
||||
GridUVs = new Vector2[vertex_count];
|
||||
|
||||
//
|
||||
// Initialize the arrays
|
||||
//
|
||||
for (int index = 0; index < vertex_count; index ++) {
|
||||
VertexAlpha[index] = 1.0F;
|
||||
GridUVs[index].Set (0.0F, 0.0F);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Allocate the vertex index map
|
||||
//
|
||||
for (index = 0; index < PASS_COUNT; index ++) {
|
||||
VertexIndexMap[index] = new int[vertex_count];
|
||||
::memset (VertexIndexMap[index], -1, sizeof (int) * vertex_count);
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Reset
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
RenegadeTerrainMaterialPassClass::Reset (void)
|
||||
{
|
||||
//
|
||||
// Allocate the vertex index map
|
||||
//
|
||||
for (int index = 0; index < PASS_COUNT; index ++) {
|
||||
::memset (VertexIndexMap[index], -1, sizeof (int) * VertexCount);
|
||||
QuadList[index].Reset_Active ();
|
||||
VertexRenderList[index].Reset_Active ();
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Save
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
RenegadeTerrainMaterialPassClass::Save (ChunkSaveClass &csave)
|
||||
{
|
||||
//
|
||||
// Write the variables
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_VARIABLES);
|
||||
WRITE_MICRO_CHUNK (csave, VARID_VERTEX_COUNT, VertexCount);
|
||||
csave.End_Chunk ();
|
||||
|
||||
//
|
||||
// Save the vertex alpha array
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_VERTEX_ALPHAS);
|
||||
csave.Write (VertexAlpha, sizeof (float) * VertexCount);
|
||||
csave.End_Chunk ();
|
||||
|
||||
//
|
||||
// Save the grid UVs array
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_VERTEX_UVS);
|
||||
csave.Write (GridUVs, sizeof (Vector2) * VertexCount);
|
||||
csave.End_Chunk ();
|
||||
|
||||
//
|
||||
// Save the material
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_MATERIAL);
|
||||
Material->Save (csave);
|
||||
csave.End_Chunk ();
|
||||
|
||||
//
|
||||
// Save the per-pass lists
|
||||
//
|
||||
int count = 0;
|
||||
for (int index = 0; index < PASS_COUNT; index ++) {
|
||||
|
||||
//
|
||||
// Save the quad list
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_QUAD_LIST);
|
||||
count = QuadList[index].Count ();
|
||||
csave.Write (&count, sizeof (int));
|
||||
csave.Write (&QuadList[index][0], sizeof (int) * QuadList[index].Count ());
|
||||
csave.End_Chunk ();
|
||||
|
||||
//
|
||||
// Save the vertex render list
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_VERTEX_RENDER_LIST);
|
||||
count = VertexRenderList[index].Count ();
|
||||
csave.Write (&count, sizeof (int));
|
||||
csave.Write (&VertexRenderList[index][0], sizeof (int) * VertexRenderList[index].Count ());
|
||||
csave.End_Chunk ();
|
||||
|
||||
//
|
||||
// Save the vertex index map
|
||||
//
|
||||
csave.Begin_Chunk (CHUNKID_VERTEX_INDEX_MAP);
|
||||
csave.Write (VertexIndexMap[index], sizeof (int) * VertexCount);
|
||||
csave.End_Chunk ();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Load
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
RenegadeTerrainMaterialPassClass::Load (ChunkLoadClass &cload)
|
||||
{
|
||||
int pass = -1;
|
||||
|
||||
while (cload.Open_Chunk ()) {
|
||||
switch (cload.Cur_Chunk_ID ()) {
|
||||
|
||||
//
|
||||
// Load all the variables from this chunk
|
||||
//
|
||||
case CHUNKID_VARIABLES:
|
||||
Load_Variables (cload);
|
||||
break;
|
||||
|
||||
case CHUNKID_VERTEX_ALPHAS:
|
||||
cload.Read (VertexAlpha, sizeof (float) * VertexCount);
|
||||
break;
|
||||
|
||||
case CHUNKID_VERTEX_UVS:
|
||||
cload.Read (GridUVs, sizeof (Vector2) * VertexCount);
|
||||
break;
|
||||
|
||||
case CHUNKID_MATERIAL:
|
||||
{
|
||||
//
|
||||
// Load the material
|
||||
//
|
||||
Material = new TerrainMaterialClass;
|
||||
Material->Load (cload);
|
||||
break;
|
||||
}
|
||||
|
||||
case CHUNKID_QUAD_LIST:
|
||||
{
|
||||
pass ++;
|
||||
|
||||
//
|
||||
// Read the number of quads
|
||||
//
|
||||
int count = 0;
|
||||
cload.Read (&count, sizeof (int));
|
||||
|
||||
//
|
||||
// Allocate enough room for this many quads and read them in...
|
||||
//
|
||||
QuadList[pass].Resize (count);
|
||||
if (count > 0) {
|
||||
cload.Read (&QuadList[pass][0], sizeof (int) * count);
|
||||
QuadList[pass].Set_Active (count);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case CHUNKID_VERTEX_RENDER_LIST:
|
||||
{
|
||||
//
|
||||
// Read the number of vertices
|
||||
//
|
||||
int count = 0;
|
||||
cload.Read (&count, sizeof (int));
|
||||
|
||||
//
|
||||
// Allocate enough room for this many vertices and read them in...
|
||||
//
|
||||
VertexRenderList[pass].Resize (count);
|
||||
if (count > 0) {
|
||||
cload.Read (&VertexRenderList[pass][0], sizeof (int) * count);
|
||||
VertexRenderList[pass].Set_Active (count);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case CHUNKID_VERTEX_INDEX_MAP:
|
||||
cload.Read (VertexIndexMap[pass], sizeof (int) * VertexCount);
|
||||
break;
|
||||
}
|
||||
|
||||
cload.Close_Chunk ();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Load_Variables
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
RenegadeTerrainMaterialPassClass::Load_Variables (ChunkLoadClass &cload)
|
||||
{
|
||||
int vertex_count = 0;
|
||||
|
||||
while (cload.Open_Micro_Chunk ()) {
|
||||
switch (cload.Cur_Micro_Chunk_ID ()) {
|
||||
|
||||
//
|
||||
// Read each of the microchunks
|
||||
//
|
||||
READ_MICRO_CHUNK (cload, VARID_VERTEX_COUNT, vertex_count);
|
||||
}
|
||||
|
||||
cload.Close_Micro_Chunk ();
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate the necessary data structures
|
||||
//
|
||||
Allocate (vertex_count);
|
||||
return ;
|
||||
}
|
||||
Reference in New Issue
Block a user