450 lines
14 KiB
C++
450 lines
14 KiB
C++
/*
|
|
** 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/renegadeterrainpatch.h $*
|
|
* *
|
|
* Author:: Patrick Smith *
|
|
* *
|
|
* $Modtime:: 3/12/02 2:34p $*
|
|
* *
|
|
* $Revision:: 5 $*
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifndef __RENEGADETERRAINPATCH_H
|
|
#define __RENEGADETERRAINPATCH_H
|
|
|
|
|
|
#include "rendobj.h"
|
|
#include "vector.h"
|
|
#include "shader.h"
|
|
#include "coltest.h"
|
|
#include "castres.h"
|
|
#include "tri.h"
|
|
#include "renegadeterrainmaterialpass.h"
|
|
#include "terrainmaterial.h"
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Forward declarations
|
|
//////////////////////////////////////////////////////////////////////
|
|
class VertexMaterialClass;
|
|
class MaterialPassClass;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// RenegadeTerrainPatchClass
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
class RenegadeTerrainPatchClass : public RenderObjClass
|
|
{
|
|
public:
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Public constructors/destructors
|
|
///////////////////////////////////////////////////////////////////
|
|
RenegadeTerrainPatchClass (void);
|
|
RenegadeTerrainPatchClass (const RenegadeTerrainPatchClass &src);
|
|
virtual ~RenegadeTerrainPatchClass (void);
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Public operators
|
|
///////////////////////////////////////////////////////////////////
|
|
const RenegadeTerrainPatchClass & operator= (const RenegadeTerrainPatchClass &src);
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Public methods
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Creation
|
|
//
|
|
void Allocate (int points_x, int points_y, float meters_per_point);
|
|
|
|
//
|
|
// Vertex access
|
|
//
|
|
void Set_Vertex_Pos (int x, int y, const Vector3 &pos);
|
|
void Set_Vertex_Normal (int x, int y, const Vector3 &normal) { GridNormals[Grid_Index (x, y)] = normal; AreBuffersDirty = true; }
|
|
|
|
//
|
|
// Quad access
|
|
//
|
|
void Set_Quad_Flags (int quad_index, uint8 flags) { QuadFlags[quad_index] = flags; }
|
|
|
|
//
|
|
// UV access
|
|
//
|
|
void Update_UVs (void);
|
|
void Update_Vertex_Render_Lists (void);
|
|
|
|
//
|
|
// Informational
|
|
//
|
|
void Set_Bounding_Box_Min (const Vector3 &box_min) { BoundingBoxMin = box_min; }
|
|
void Set_Bounding_Box_Max (const Vector3 &box_max) { BoundingBoxMax = box_max; }
|
|
|
|
//
|
|
// Save/load support
|
|
//
|
|
bool Save (ChunkSaveClass &csave);
|
|
bool Load (ChunkLoadClass &cload);
|
|
void Load_Variables (ChunkLoadClass &cload);
|
|
void Load_Materials (ChunkLoadClass &cload);
|
|
const PersistFactoryClass & Get_Factory (void) const;
|
|
|
|
//
|
|
// Inherited
|
|
//
|
|
RenderObjClass * Clone (void) const { return new RenegadeTerrainPatchClass (*this); }
|
|
int Class_ID (void) const { return CLASSID_RENEGADE_TERRAIN; }
|
|
void Render (RenderInfoClass &rinfo);
|
|
void Get_Obj_Space_Bounding_Sphere (SphereClass &sphere) const;
|
|
void Get_Obj_Space_Bounding_Box (AABoxClass &box) const;
|
|
|
|
//
|
|
// Inherited collision detection
|
|
//
|
|
bool Cast_Ray (RayCollisionTestClass &raytest);
|
|
bool Cast_AABox (AABoxCollisionTestClass &boxtest);
|
|
bool Cast_OBBox (OBBoxCollisionTestClass &boxtest);
|
|
bool Intersect_AABox (AABoxIntersectionTestClass &boxtest);
|
|
bool Intersect_OBBox (OBBoxIntersectionTestClass &boxtest);
|
|
|
|
//
|
|
// Material access
|
|
//
|
|
int Add_Material (TerrainMaterialClass *material);
|
|
void Reset_Material_Passes (void);
|
|
RenegadeTerrainMaterialPassClass * Get_Material_Pass (int index, TerrainMaterialClass *material);
|
|
int Get_Material_Count (void) { return MaterialPassList.Count (); }
|
|
RenegadeTerrainMaterialPassClass * Peek_Material_Pass (int index) { return MaterialPassList[index]; }
|
|
|
|
//
|
|
// Access to internal mesh data
|
|
//
|
|
int Get_Vertex_Count (void) const { return GridPointCount; }
|
|
Vector3 * Get_Vertex_Array (void) const { return Grid; }
|
|
Vector3 * Get_Vertex_Normal_Array (void) const { return GridNormals; }
|
|
|
|
//
|
|
// Lighting support
|
|
//
|
|
bool Is_Prelit (void) const { return IsPreLit; }
|
|
void Set_Is_Prelit (bool onoff) { IsPreLit = onoff; }
|
|
void Set_Vertex_Color (int index, const Vector3 &color) { VertexColors[index] = color; AreBuffersDirty = true; }
|
|
const Vector3 & Get_Vertex_Color (int index) { return VertexColors[index]; }
|
|
|
|
protected:
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Protected methods
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Index utility functions
|
|
//
|
|
int Grid_Index (int x, int y) { return (y * GridPointsX) + x; }
|
|
|
|
int Get_Quad_Index_X (float x_pos, bool clamp = true);
|
|
int Get_Quad_Index_Y (float y_pos, bool clamp = true);
|
|
float Get_Grid_Line_Pos_X (int grid_line_index);
|
|
float Get_Grid_Line_Pos_Y (int grid_line_index);
|
|
|
|
bool Is_Valid_Quad (int x, int y);
|
|
|
|
//
|
|
// Matrix utility functions
|
|
//
|
|
void Get_Inverse_Transform (Matrix3D &tm);
|
|
|
|
//
|
|
// Misc initialization and cleanup routines
|
|
//
|
|
void Free_Grid (void);
|
|
void Free_Materials (void);
|
|
void Initialize_Material (void);
|
|
void Initialize (void);
|
|
void Allocate_Grid (void);
|
|
|
|
//
|
|
// Rendering
|
|
//
|
|
void Render_By_Texture (int texture_index, int pass_type);
|
|
void Submit_Rendering_Buffers (int texture_index, int pass_type);
|
|
void Update_Rendering_Buffers (void);
|
|
void Free_Rendering_Buffers (void);
|
|
void Build_Rendering_Buffers (int texture_index, int pass_type);
|
|
void Render_Procedural_Material_Pass(MaterialPassClass * matpass);
|
|
|
|
//
|
|
// Ray casting
|
|
//
|
|
bool Cast_Vertical_Ray (RayCollisionTestClass &raytest);
|
|
bool Cast_Non_Vertical_Ray (RayCollisionTestClass &raytest);
|
|
bool Brute_Force_Cast_Ray (RayCollisionTestClass &raytest);
|
|
|
|
bool Collide_Quad (const LineSegClass &line_seg, int cell_x, int cell_y, CastResultStruct &result);
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Protected data types
|
|
///////////////////////////////////////////////////////////////////
|
|
enum
|
|
{
|
|
QF_NORMAL = 0,
|
|
QF_HIDDEN = 1,
|
|
} QUAD_FLAGS;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Protected member data
|
|
///////////////////////////////////////////////////////////////////
|
|
Vector3 * Grid;
|
|
Vector3 * GridNormals;
|
|
Vector3 * VertexColors;
|
|
uint8 * QuadFlags;
|
|
int GridPointsX;
|
|
int GridPointsY;
|
|
int GridPointCount;
|
|
float Density;
|
|
VertexMaterialClass * BaseMaterial;
|
|
ShaderClass BaseShader;
|
|
VertexMaterialClass * LayerMaterial;
|
|
ShaderClass LayerShader;
|
|
Vector3 BoundingBoxMin;
|
|
Vector3 BoundingBoxMax;
|
|
bool AreBuffersDirty;
|
|
bool IsPreLit;
|
|
|
|
DynamicVectorClass<RenegadeTerrainMaterialPassClass *> MaterialPassList;
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Collide_Quad
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE bool
|
|
RenegadeTerrainPatchClass::Collide_Quad
|
|
(
|
|
const LineSegClass & line_seg,
|
|
int cell_x,
|
|
int cell_y,
|
|
CastResultStruct & result
|
|
)
|
|
{
|
|
bool retval = false;
|
|
|
|
//
|
|
// Calculate the four indices into the grid that define the four
|
|
// corners of the quad we're testing.
|
|
//
|
|
int start_index = Grid_Index (cell_x, cell_y);
|
|
int v0_index = start_index;
|
|
int v1_index = start_index + 1;
|
|
int v2_index = start_index + GridPointsX + 1;
|
|
int v3_index = start_index + GridPointsX;
|
|
|
|
float min_pz = WWMath::Min (line_seg.Get_P0 ().Z, line_seg.Get_P1 ().Z);
|
|
float max_pz = WWMath::Max (line_seg.Get_P0 ().Z, line_seg.Get_P1 ().Z);
|
|
|
|
if ( Grid[v0_index].Z < min_pz &&
|
|
Grid[v1_index].Z < min_pz &&
|
|
Grid[v2_index].Z < min_pz &&
|
|
Grid[v3_index].Z < min_pz)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Grid[v0_index].Z > max_pz &&
|
|
Grid[v1_index].Z > max_pz &&
|
|
Grid[v2_index].Z > max_pz &&
|
|
Grid[v3_index].Z > max_pz)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Compose the two triangles for the collision check
|
|
//
|
|
TriClass tri1;
|
|
TriClass tri2;
|
|
Vector3 norm1 (0, 0, 0);
|
|
Vector3 norm2 (0, 0, 0);
|
|
tri1.N = &norm1;
|
|
tri2.N = &norm2;
|
|
tri1.V[0] = &Grid[v0_index];
|
|
tri1.V[1] = &Grid[v2_index];
|
|
tri1.V[2] = &Grid[v3_index];
|
|
tri2.V[0] = &Grid[v2_index];
|
|
tri2.V[1] = &Grid[v0_index];
|
|
tri2.V[2] = &Grid[v1_index];
|
|
tri1.Compute_Normal ();
|
|
tri2.Compute_Normal ();
|
|
|
|
//
|
|
// Test the two polygons that form this quad to see if the ray hit
|
|
//
|
|
retval = CollisionMath::Collide (line_seg, tri1, &result);
|
|
retval |= CollisionMath::Collide (line_seg, tri2, &result);
|
|
|
|
//
|
|
// Determine which surface type was hit
|
|
//
|
|
if (retval && MaterialPassList.Count () > 0) {
|
|
int best_pass = 0;
|
|
float best_alpha = 0;
|
|
for (int index = 0; index < MaterialPassList.Count (); index ++) {
|
|
float alpha = MaterialPassList[index]->VertexAlpha[v0_index];
|
|
if (alpha > best_alpha && alpha != 1.0F) {
|
|
best_alpha = alpha;
|
|
best_pass = index;
|
|
}
|
|
}
|
|
if (MaterialPassList[best_pass]->Material != NULL) {
|
|
result.SurfaceType = MaterialPassList[best_pass]->Material->Get_Surface_Type ();
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Set_Vertex_Pos
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE void
|
|
RenegadeTerrainPatchClass::Set_Vertex_Pos (int x, int y, const Vector3 &pos)
|
|
{
|
|
//
|
|
// Update the vertex position
|
|
//
|
|
Grid[Grid_Index (x, y)] = pos;
|
|
|
|
//
|
|
// Do we need to update the bounding volume of the patch?
|
|
//
|
|
if (pos.Z > BoundingBoxMax.Z) {
|
|
BoundingBoxMax.Z = pos.Z;
|
|
}
|
|
|
|
if (pos.Z < BoundingBoxMin.Z) {
|
|
BoundingBoxMin.Z = pos.Z;
|
|
}
|
|
|
|
Invalidate_Cached_Bounding_Volumes ();
|
|
AreBuffersDirty = true;
|
|
return ;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Get_Quad_Index_X
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE int
|
|
RenegadeTerrainPatchClass::Get_Quad_Index_X (float x_pos, bool clamp)
|
|
{
|
|
int quad_x = WWMath::Float_To_Int_Floor ((x_pos - BoundingBoxMin.X) / Density);
|
|
|
|
//
|
|
// Clamp the index to the range of existing quad cells
|
|
//
|
|
if (clamp) {
|
|
quad_x = WWMath::Clamp_Int (quad_x, 0, GridPointsX - 2);
|
|
}
|
|
|
|
return quad_x;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Get_Quad_Index_Y
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE int
|
|
RenegadeTerrainPatchClass::Get_Quad_Index_Y (float y_pos, bool clamp)
|
|
{
|
|
int quad_y = WWMath::Float_To_Int_Floor ((y_pos - BoundingBoxMin.Y) / Density);
|
|
|
|
//
|
|
// Clamp the index to the range of existing quad cells
|
|
//
|
|
if (clamp) {
|
|
quad_y = WWMath::Clamp_Int (quad_y, 0, GridPointsY - 2);
|
|
}
|
|
|
|
return quad_y;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Get_Grid_Line_Pos_X
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE float
|
|
RenegadeTerrainPatchClass::Get_Grid_Line_Pos_X (int grid_line_index)
|
|
{
|
|
return BoundingBoxMin.X + (grid_line_index * Density);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Get_Grid_Line_Pos_Y
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE float
|
|
RenegadeTerrainPatchClass::Get_Grid_Line_Pos_Y (int grid_line_index)
|
|
{
|
|
return BoundingBoxMin.Y + (grid_line_index * Density);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Get_Inverse_Transform
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE void
|
|
RenegadeTerrainPatchClass::Get_Inverse_Transform (Matrix3D &tm)
|
|
{
|
|
Get_Transform ().Get_Orthogonal_Inverse (tm);
|
|
return ;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Is_Valid_Quad
|
|
//////////////////////////////////////////////////////////////////////
|
|
WWINLINE bool
|
|
RenegadeTerrainPatchClass::Is_Valid_Quad (int x, int y)
|
|
{
|
|
bool retval = false;
|
|
|
|
//
|
|
// Simply check to see if the coordinates are inside the patch
|
|
//
|
|
if ( x >= 0 && x < (GridPointsX - 1) &&
|
|
y >= 0 && y < (GridPointsY - 1))
|
|
{
|
|
retval = true;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
#endif //__RENEGADETERRAINPATCH_H
|