213 lines
7.8 KiB
C++
213 lines
7.8 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/visrasterizer.h $*
|
|
* *
|
|
* Original Author:: Greg Hjelstrom *
|
|
* *
|
|
* $Author:: Jani_p $*
|
|
* *
|
|
* $Modtime:: 11/24/01 5:42p $*
|
|
* *
|
|
* $Revision:: 6 $*
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifndef VISRASTERIZER_H
|
|
#define VISRASTERIZER_H
|
|
|
|
#include "always.h"
|
|
#include "matrix3d.h"
|
|
#include "matrix4.h"
|
|
#include "vector3i.h"
|
|
#include "vector3.h"
|
|
#include "simplevec.h"
|
|
#include "bittype.h"
|
|
#include "plane.h"
|
|
#include "meshgeometry.h"
|
|
|
|
|
|
class CameraClass;
|
|
class AABoxClass;
|
|
struct GradientsStruct;
|
|
struct EdgeStruct;
|
|
|
|
/**
|
|
** IDBufferClass
|
|
** This class manages the ID buffer and the Z buffer. It provides the low level
|
|
** rasterization code and stats about how many pixels and triangles are drawn.
|
|
*/
|
|
class IDBufferClass
|
|
{
|
|
public:
|
|
IDBufferClass(void);
|
|
~IDBufferClass(void);
|
|
|
|
/*
|
|
** State interface
|
|
*/
|
|
void Set_Resolution(int w,int h);
|
|
void Get_Resolution(int * get_w,int * get_h);
|
|
|
|
void Set_Backface_ID(uint32 id) { BackfaceID = id; }
|
|
void Set_Frontface_ID(uint32 id) { FrontfaceID = id; }
|
|
uint32 Get_Backface_ID(void) { return BackfaceID; }
|
|
uint32 Get_Frontface_ID(void) { return FrontfaceID; }
|
|
|
|
void Enable_Two_Sided_Rendering(bool onoff) { TwoSidedRenderingEnabled = onoff; }
|
|
bool Is_Two_Sided_Rendering_Enabled(void) { return TwoSidedRenderingEnabled; }
|
|
|
|
enum ModeType { OCCLUDER_MODE = 0, NON_OCCLUDER_MODE };
|
|
void Set_Render_Mode(ModeType mode) { RenderMode = mode; }
|
|
ModeType Get_Render_Mode(void) { return RenderMode; }
|
|
|
|
void Reset_Pixel_Counter(void) { PixelCounter = 0; }
|
|
int Get_Pixel_Counter(void) { return PixelCounter; }
|
|
|
|
/*
|
|
** Rendering interface
|
|
*/
|
|
void Clear(void);
|
|
bool Render_Triangle(const Vector3 & p0,const Vector3 & p1,const Vector3 & p2);
|
|
const uint32 * Get_Pixel_Row(int y,int min_x,int max_x);
|
|
|
|
protected:
|
|
void Reset(void);
|
|
void Allocate_Buffers(void);
|
|
bool Is_Backfacing(const Vector3 & p0,const Vector3 & p1,const Vector3 & p2);
|
|
int Render_Occluder_Scanline(GradientsStruct & grads,EdgeStruct * left,EdgeStruct * right);
|
|
int Render_Non_Occluder_Scanline(GradientsStruct & grads,EdgeStruct * left,EdgeStruct * right);
|
|
int Pixel_Coords_To_Address(int x,int y) { return y*ResWidth + x; }
|
|
|
|
uint32 BackfaceID;
|
|
uint32 FrontfaceID;
|
|
uint32 CurID;
|
|
int PixelCounter;
|
|
ModeType RenderMode;
|
|
bool TwoSidedRenderingEnabled;
|
|
|
|
int ResWidth;
|
|
int ResHeight;
|
|
uint32 * IDBuffer;
|
|
float * ZBuffer; // actually a 1/z buffer...
|
|
};
|
|
|
|
inline const uint32 * IDBufferClass::Get_Pixel_Row(int y,int min_x,int max_x)
|
|
{
|
|
WWASSERT(y>=0);
|
|
WWASSERT(y<ResHeight);
|
|
WWASSERT(min_x>=0);
|
|
WWASSERT(max_x<=ResWidth);
|
|
|
|
int addr = Pixel_Coords_To_Address(min_x,y);
|
|
return &(IDBuffer[addr]);
|
|
}
|
|
|
|
inline bool IDBufferClass::Is_Backfacing(const Vector3 & p0,const Vector3 & p1,const Vector3 & p2)
|
|
{
|
|
float x1=p1[0]-p0[0];
|
|
float y1=p1[1]-p0[1];
|
|
float x2=p2[0]-p0[0];
|
|
float y2=p2[1]-p0[1];
|
|
float r=x1*y2-x2*y1;
|
|
if (r<0.0f) return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
** VisRasterizerClass
|
|
** This class encapsulates the "ID buffer rasterization" code needed by the vis system. Basically
|
|
** it is a floating point z-buffer and an id buffer which is used by the visiblity precalculation system.
|
|
** The VisRasterizer will transform and clip triangles into homogeneous view space; then the clipped
|
|
** triangles will be passed on to the IDBufferClass which will scan convert them.
|
|
*/
|
|
class VisRasterizerClass
|
|
{
|
|
public:
|
|
|
|
VisRasterizerClass(void);
|
|
~VisRasterizerClass(void);
|
|
|
|
/*
|
|
** ID Buffer Interface
|
|
*/
|
|
void Set_Render_Mode(IDBufferClass::ModeType mode) { IDBuffer.Set_Render_Mode(mode); }
|
|
IDBufferClass::ModeType Get_Render_Mode(void) { return IDBuffer.Get_Render_Mode(); }
|
|
|
|
void Set_Backface_ID(uint32 id) { IDBuffer.Set_Backface_ID(id); }
|
|
void Set_Frontface_ID(uint32 id) { IDBuffer.Set_Frontface_ID(id); }
|
|
uint32 Get_Backface_ID(void) { return IDBuffer.Get_Backface_ID(); }
|
|
uint32 Get_Frontface_ID(void) { return IDBuffer.Get_Frontface_ID(); }
|
|
|
|
void Enable_Two_Sided_Rendering(bool onoff) { IDBuffer.Enable_Two_Sided_Rendering(onoff); }
|
|
bool Is_Two_Sided_Rendering_Enabled(void) { return IDBuffer.Is_Two_Sided_Rendering_Enabled(); }
|
|
|
|
void Set_Resolution(int width,int height);
|
|
void Get_Resolution(int * set_width,int * set_height);
|
|
|
|
void Reset_Pixel_Counter(void) { IDBuffer.Reset_Pixel_Counter(); }
|
|
int Get_Pixel_Counter(void) { return IDBuffer.Get_Pixel_Counter(); }
|
|
|
|
/*
|
|
** Rendering Interface
|
|
*/
|
|
void Set_Model_Transform(const Matrix3D & model);
|
|
void Set_Camera(CameraClass * camera);
|
|
|
|
const Matrix3D & Get_Model_Transform(void);
|
|
CameraClass * Get_Camera(void);
|
|
CameraClass * Peek_Camera(void);
|
|
|
|
void Clear(void) { IDBuffer.Clear(); }
|
|
bool Render_Triangles(const Vector3 * verts,int vcount,const TriIndex * tris, int tcount,const AABoxClass & bounds);
|
|
const uint32 * Get_Pixel_Row(int y,int min_x,int max_x) { return IDBuffer.Get_Pixel_Row(y,min_x,max_x); }
|
|
|
|
protected:
|
|
|
|
void Update_MV_Transform(void);
|
|
const Matrix3D & Get_MV_Transform(void);
|
|
Vector3 * Get_Temp_Vertex_Buffer(int count);
|
|
bool Render_Triangles_Clip(const Vector3 * verts,int vcount,const TriIndex * tris, int tcount);
|
|
bool Render_Triangles_No_Clip(const Vector3 * verts,int vcount,const TriIndex * tris, int tcount);
|
|
|
|
Matrix3D ModelTransform; // AKA "World Transform"
|
|
CameraClass * Camera;
|
|
Matrix3D MVTransform;
|
|
|
|
IDBufferClass IDBuffer;
|
|
|
|
SimpleVecClass<Vector3> TempVertexBuffer;
|
|
};
|
|
|
|
#endif //VISRASTERIZER_H
|
|
|