This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/seglinerenderer.h

206 lines
9 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 : ww3d *
* *
* $Archive:: /Commando/Code/ww3d2/seglinerenderer.h $*
* *
* Original Author:: Greg Hjelstrom *
* *
* $Author:: Greg_h $*
* *
* $Modtime:: 6/08/01 5:23p $*
* *
* $Revision:: 1 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef SEGLINERENDERER_H
#define SEGLINERENDERER_H
#include "always.h"
#include "shader.h"
#include "texture.h"
#include "matrix3d.h"
#include "vector2.h"
class RenderInfoClass;
class SphereClass;
struct W3dEmitterLinePropertiesStruct;
// The maximum allowable level of subdivision. This should be no more than 7 to avoid increasing
// the chunk buffer size too much
#define MAX_SEGLINE_SUBDIV_LEVELS 7
/**
** SegLineRendererClass
** This class implements the low-level line rendering functionality used by both SegmentedLineClass
** and ParticleBufferClass
*/
class SegLineRendererClass
{
public:
SegLineRendererClass(void);
SegLineRendererClass(const SegLineRendererClass & that);
SegLineRendererClass & operator = (const SegLineRendererClass & that);
~SegLineRendererClass(void);
enum TextureMapMode {
UNIFORM_WIDTH_TEXTURE_MAP = 0x00000000, // Entire line uses one row of texture (constant V)
UNIFORM_LENGTH_TEXTURE_MAP = 0x00000001, // Entire line uses one row of texture stretched length-wise
TILED_TEXTURE_MAP = 0x00000002 // Tiled continuously over line
};
void Init(const W3dEmitterLinePropertiesStruct & props);
// Get properties used to render this line segment
TextureClass * Get_Texture(void) const;
TextureClass * Peek_Texture(void) const { return Texture; }
ShaderClass Get_Shader(void) const { return Shader; }
float Get_Width(void) const { return Width; }
const Vector3 & Get_Color(void) const { return Color; }
float Get_Opacity(void) const { return Opacity; }
float Get_Noise_Amplitude(void) const { return NoiseAmplitude; }
float Get_Merge_Abort_Factor(void) const { return MergeAbortFactor; }
unsigned int Get_Current_Subdivision_Level(void) const { return SubdivisionLevel; }
TextureMapMode Get_Texture_Mapping_Mode(void) const;
float Get_Texture_Tile_Factor(void) const { return TextureTileFactor; }
Vector2 Get_UV_Offset_Rate(void) const;
int Is_Merge_Intersections(void) const { return Bits & MERGE_INTERSECTIONS; }
int Is_Freeze_Random(void) const { return Bits & FREEZE_RANDOM; }
int Is_Sorting_Disabled(void) const { return Bits & DISABLE_SORTING; }
int Are_End_Caps_Enabled(void) const { return Bits & END_CAPS; }
// Set properties used to render this line segment
void Set_Texture(TextureClass *texture);
void Set_Shader(ShaderClass shader) { Shader = shader; }
void Set_Width(float width) { Width = width; }
void Set_Color(const Vector3 &color) { Color = color; }
void Set_Opacity(float opacity) { Opacity = opacity; }
void Set_Noise_Amplitude(float amplitude) { NoiseAmplitude = amplitude; }
void Set_Merge_Abort_Factor(float factor) { MergeAbortFactor = factor; }
void Set_Current_Subdivision_Level(unsigned int lv) { SubdivisionLevel = lv; }
void Set_Texture_Mapping_Mode(TextureMapMode mode);
// WARNING! Do NOT set the tile factor to be too high (should be less than 8) or negative
//performance impact will result!
void Set_Texture_Tile_Factor(float factor);
void Set_Current_UV_Offset(const Vector2 & offset);
void Set_UV_Offset_Rate(const Vector2 &rate);
void Set_Merge_Intersections(int onoff) { if (onoff) { Bits |= MERGE_INTERSECTIONS; } else { Bits &= ~MERGE_INTERSECTIONS; }; }
void Set_Freeze_Random(int onoff) { if (onoff) { Bits |= FREEZE_RANDOM; } else { Bits &= ~FREEZE_RANDOM; }; }
void Set_Disable_Sorting(int onoff) { if (onoff) { Bits |= DISABLE_SORTING; } else { Bits &= ~DISABLE_SORTING; }; }
void Set_End_Caps(int onoff) { if (onoff) { Bits |= END_CAPS; } else { Bits &= ~END_CAPS; }; }
void Render( RenderInfoClass & rinfo,
const Matrix3D & transform,
unsigned int point_count,
Vector3 * points,
const SphereClass & obj_sphere);
void Reset_Line(void);
private:
// Utility functions
void subdivision_util(unsigned int point_cnt, const Vector3 *xformed_pts,
const float *base_tex_v, unsigned int *p_sub_point_cnt,
Vector3 *xformed_subdiv_pts, float *subdiv_tex_v);
// Global properties
TextureClass * Texture;
ShaderClass Shader;
float Width;
Vector3 Color;
float Opacity;
// Subdivision properties
unsigned int SubdivisionLevel;
float NoiseAmplitude;
// If >0, will abort a merge which causes an intersection to move
// farther away than this factor * line radius from the line point.
// (defaults to 1.5, has no affect if intersection merging is disabled).
float MergeAbortFactor;
// Affects tiled texture mapping mode only. If this is set too high, performance (and
// possibly visual) problems will result from excessive tiling over a single polygon, over
// the entire line, or both.
float TextureTileFactor;
// Used for texture coordinate animation
unsigned int LastUsedSyncTime; // Last sync time used
Vector2 CurrentUVOffset; // Current UV offset
Vector2 UVOffsetDeltaPerMS; // Amount to increase offset each millisec
// Various flags
enum BitShiftOffsets {
TEXTURE_MAP_MODE_OFFSET = 24 // By how many bits do I need to shift the texture mapping mode?
};
enum {
MERGE_INTERSECTIONS = 0x00000001, // Merge intersections
FREEZE_RANDOM = 0x00000002, // Freeze random (note: offsets are in camera space)
DISABLE_SORTING = 0x00000004, // Disable sorting (even if shader has alpha-blending)
END_CAPS = 0x00000008, // Draw end caps on the line
// Some bits are used to select the texture mapping mode:
TEXTURE_MAP_MODE_MASK = 0xFF000000, // Must cover all possible TextureMapMode values
DEFAULT_BITS = MERGE_INTERSECTIONS | (UNIFORM_WIDTH_TEXTURE_MAP << TEXTURE_MAP_MODE_OFFSET)
};
unsigned int Bits;
friend class SegmentedLineClass;
};
inline SegLineRendererClass::TextureMapMode SegLineRendererClass::Get_Texture_Mapping_Mode(void) const
{
return (TextureMapMode)((Bits & TEXTURE_MAP_MODE_MASK) >> TEXTURE_MAP_MODE_OFFSET);
}
inline void SegLineRendererClass::Set_Texture_Mapping_Mode(SegLineRendererClass::TextureMapMode mode)
{
Bits &= ~TEXTURE_MAP_MODE_MASK;
Bits |= ((mode << TEXTURE_MAP_MODE_OFFSET) & TEXTURE_MAP_MODE_MASK);
}
inline Vector2 SegLineRendererClass::Get_UV_Offset_Rate(void) const
{
return UVOffsetDeltaPerMS * 1000.0f;
}
inline void SegLineRendererClass::Set_UV_Offset_Rate(const Vector2 &rate)
{
UVOffsetDeltaPerMS = rate * 0.001f;
}
#endif //SEGLINERENDERER_H