mirror/JurassicParkTrespasser
1
0
Fork 0
mirror of https://github.com/OpenTrespasser/JurassicParkTrespasser.git synced 2024-12-19 23:21:56 +00:00
Code Issues Projects Releases Wiki Activity
master
JurassicParkTrespasser/jp2_pc/Source/Lib/Renderer/ScreenRender.hpp

1096 lines
30 KiB
C++
Raw Permalink Normal View History

Initial commit
2018-01-01 22:07:24 +00:00
/***********************************************************************************************
*
* Copyright <EFBFBD> DreamWorks Interactive. 1996
*
* Contents:
* CScreenRender Provides interface to rasterising functions.
* CRenderDesc Describes and creates a CScreenRender.
* CArrayRenderDesc Contains list of all CRenderDescs.
*
* Bugs:
*
* To do:
*
***********************************************************************************************
*
* $Log:: /JP2_PC/Source/Lib/Renderer/ScreenRender.hpp $
*
* 121 98.09.24 1:40a Mmouni
* Shrunk CRenderPolygon by a large amount.
* Multiple list depth sort stuff is now on a compile switch.
*
* 120 98.09.19 12:39a Mmouni
* Added "forceinline" to many small inline functions.
* Inlined some functions for speed.
*
* 119 8/17/98 4:50p Pkeet
* Added the 'ehwFluid' enumeration. The 'FastInit' member function of 'CRenderPolygon' now sets
* the hardware enumeration data member for software by default.
*
* 118 8/16/98 3:09p Pkeet
* Added the 'bTargetMainScreen' member function.
*
* 117 8/03/98 4:31p Pkeet
* Added the 'bPrerasterized' flag.
*
* 116 8/02/98 9:23p Pkeet
* Added the 'u4D3DFog' to 'CRenderVertex.'
*
* 115 8/02/98 8:37p Pkeet
* Added the 'SetHardwareOut' member function.
*
* 114 8/01/98 11:11p Pkeet
* Added the 'fMaxLevel' data member to 'CRenderPolygon.'
*
* 113 8/01/98 4:41p Pkeet
* Added the 'pixSetBackground' member function.
*
* 112 7/29/98 1:56p Pkeet
* Added a parameter to the 'SetMipLevel' member function of 'CRenderPolygon' to reduce the
* burden on the VM loader by making VM requests only when the Direct3D version is required and
* is present.
*
* 111 7/28/98 8:24p Pkeet
* Added the 'EAddressMode' type.
*
* 110 7/24/98 3:08p Pkeet
* Added the 'pshOwningShape' backpointer to 'CRenderPolygon.'
*
* 109 7/23/98 6:22p Pkeet
* Added a member function to detect if the destination target is hardware. Added more hardware
* polygon types.
*
* 108 98.06.18 3:55p Mmouni
* Added software alpha switch.
*
* 107 6/14/98 2:48p Pkeet
* Added the 'fGetFarthestZ' member function.
*
* 106 6/09/98 3:52p Pkeet
* Added a flag to 'SetD3DFlagForPolygons' to use Direct3D or not.
*
* 105 6/08/98 8:08p Pkeet
* Modified the 'SetD3DFlagForPolygons' parameters to work in the pipeline.
*
* 104 6/02/98 11:12a Pkeet
* Added the 'SetD3DFlagForPolygons' member function.
*
* 103 98.05.21 11:31p Mmouni
* Added validate function to CRenderPolygon.
*
* 102 98/03/02 21:42 Speter
* Combined SetAccept() into ReduceFeatures().
*
* 101 98/02/26 13:52 Speter
* Moved seterfFeatures to CTexture from SSurface, removing redundant flags.
*
* 100 98/02/10 13:17 Speter
* Changed original CSArray to CMSArray.
*
* 99 98/02/04 14:44 Speter
* Removed fGetRoughScreenArea().
*
* 98 2/03/98 6:35p Mlange
* Moved assertion failure avoidance to CRenderPolygon::InitFast().
*
* 97 1/25/98 3:39p Pkeet
* Added the 'SetAccept' and 'ReduceFeatures' member functions.
*
* 96 1/23/98 5:40p Pkeet
* Added the 'fArea' member variable and the 'SetArea' member function to the screen polygon
* class.
*
* 95 97/12/08 17:44 Speter
* Made sole virtual function non-virtual, and added Assert for no vtbl (because of fast-init
* polygons).
*
* 94 1/23/96 4:37p Pkeet
* Initializes the 'cvFace' data member to prevent later debug build asserts.
*
* 93 1/23/96 2:00p Pkeet
* Added an 'AlwaysAssert' in place of the pure virtual function 'DrawPolygon' so that an error
* will return control to the debugger instead of crashing.
*
* 92 97/11/19 18:10 Speter
* Added CRenderPolygon::InitFast().
*
* 91 11/09/97 10:07p Gfavor
* Eliminated SetPlane3DX.
*
* 90 97/11/08 4:48p Pkeet
* Removed Z buffer parameters.
*
**********************************************************************************************/
#ifndef LIB_RENDERER_SCREENRENDER_HPP
#define LIB_RENDERER_SCREENRENDER_HPP
#include "Texture.hpp"
#include "Lib/View/RasterVid.hpp"
#include "Lib/GeomDBase/Plane.hpp"
#include "Lib\Math\FastInverse.hpp"
//**********************************************************************************************
//
// Forward class declarations.
//
class CCamera;
class CSortList;
class CSortListNode;
class CShape;
//
// Constants.
//
extern float fMaxAreaCull;
extern float fMaxAreaCullTerrain;
//
// Enumerations.
//
// Enumeration of hardware rendering types.
enum EHWRenderType
{
ehwSoftware, // Non-hardware.
ehwTerrain, // Terrain.
ehwCache, // Cache hardware.
ehwWater, // Water.
ehwAlphaCol, // Alpha colour (e.g., alpha lights).
ehwFill, // Colour fill.
ehwRegularOpaque, // Regular opaque polygon.
ehwRegularTransparent, // Regular transparent polygon.
ehwRegularAlpha, // Regular alpha polygon.
ehwFluid // Vertex blended alpha.
};
// Enumeration of addressing modes for hardware.
enum EAddressMode
{
eamTileNone,
eamTileUV,
eamTileU,
eamTileV,
eamTileDontCare
};
//**********************************************************************************************
//
class CSortKey
//
// Key used for depth sorting polygons.
//
// Prefix: key
//
//**************************************
{
public:
uint32 u4SubKey;
static uint32 u4UniqueSubKeyUp;
static uint32 u4UniqueSubKeyDown;
static uint32 u4UniqueSubKeyStep;
public:
//******************************************************************************************
//
// Member functions.
//
//******************************************************************************************
//
static void Reset
(
uint32 u4_step = 1 << 16,
uint32 u4_start = 1 << 31
)
//
//
//
//**************************************
{
u4UniqueSubKeyStep = u4_step;
u4UniqueSubKeyUp = u4_start + u4_step;
u4UniqueSubKeyDown = u4_start;
}
//******************************************************************************************
//
void SetKeyUp
(
)
//
//
//
//**************************************
{
u4SubKey = u4UniqueSubKeyUp;
u4UniqueSubKeyUp += u4UniqueSubKeyStep;
}
//******************************************************************************************
//
void SetKeyDown
(
)
//
//
//
//**************************************
{
u4SubKey = u4UniqueSubKeyDown;
u4UniqueSubKeyDown -= u4UniqueSubKeyStep;
}
//******************************************************************************************
//
bool bSetKeyMid
(
CSortKey key_0,
CSortKey key_1
)
//
// Sets the key value at the midpoint of the two provide key values, and returns 'true' if
// the key is unique.
//
//**************************************
{
u4SubKey = (key_0.u4SubKey + key_1.u4SubKey) >> 1;
return u4SubKey != key_0.u4SubKey && u4SubKey != key_1.u4SubKey;
}
//******************************************************************************************
//
void SetKeyMid
(
CSortKey key_0,
CSortKey key_1
)
//
// Sets the key value at the midpoint of the two provide key values, and returns 'true' if
// the key is unique.
//
//**************************************
{
u4SubKey = (key_0.u4SubKey + key_1.u4SubKey) >> 1;
}
//**************************************************************************************
//
bool operator()(const CSortKey& key_0, const CSortKey& key_1) const
//
// Returns 'true' if the farthest (smallest) inverse Z value of the first polygon is
// closer (larger) than the farthest inverse z value of the second polygon.
//
//**************************************
{
// Return the results of the comparision.
return key_0.u4SubKey < key_1.u4SubKey;
}
};
//**********************************************************************************************
//
struct SRenderCoord
//
// The coordinate portion of a vertex type internal to the rendering pipeline.
//
// Prefix: rnc
//
// Notes:
// Currently the structure keeps the camera space coordinates for depth sorting and
// occlusion.
//
//**************************************
{
union
{
struct
{
CVector3<> v3Cam; // The position in normalised camera space.
};
struct
{
int iYScr; // Truncated screen coordinate (used in rasteriser only).
};
};
CVector3<> v3Screen; // Screen X, Y and 1/Z coords.
ScreenRender.hpp: add constructor to SRenderCoord, required by parameterless SRenderVertex constructor
2020-04-01 20:11:01 +00:00
ScreenRender.hpp: init v3Cam instead of iYScr - add static_assert to ensure we init the biggest union member
2020-04-03 20:01:31 +00:00
SRenderCoord() : v3Cam()
{
static_assert(sizeof(v3Cam) >= sizeof(iYScr)); //Ensure we init the biggest union member
}
Initial commit
2018-01-01 22:07:24 +00:00
};
//**********************************************************************************************
//
struct SRenderVertex: SRenderCoord
//
// A vertex type internal to the rendering pipeline. It combines the information from various
// stages in one type for quick access and manipulation.
//
// Prefix: rv
//
// Notes:
// Currently the structure keeps the camera space coordinates for depth sorting and
// occlusion.
//
//**************************************
{
union
{
TClutVal cvIntensity; // Clut index value at this point.
struct
{
ptr< CDir3<> > pdir3Normal; // Optional pointer to the vertex normal.
};
};
CTexCoord tcTex; // Texture coords, in range [0,1].
uint32 u4D3DFog; // Direct3D fog value.
//******************************************************************************************
//
// Constructors.
//
SRenderVertex()
{
}
// Interpolation constructor.
SRenderVertex::SRenderVertex
(
const SRenderVertex& rv_0, // Two vertices to interpolate.
const SRenderVertex& rv_1,
TReal r_t, // Interpolation parameter.
bool b_perspective = true // Whether to interpolate the screen coords as projected.
);
};
//**********************************************************************************************
//
// Definitions for CRenderPolygon.
//
// The maximum number of sort lists a polygon can belong to.
#define iMAX_SORT_LISTS (1)
//**********************************************************************************************
class CRenderPolygon
//
// Prefix: rpoly
//
// A general polygon in renderable format. Used by CScreenRender below.
// It can have an arbitrary number of SRenderVertexes, referenced by paprvPolyVertices.
//
//**************************************
{
public:
CPArray<SRenderVertex*> paprvPolyVertices; // Points to a list of vertex pointers.
// This list must be maintained elsewhere.
CSet<ERenderFeature> seterfFace; // Rendering features enabled for this face.
ptr_const<CTexture> ptexTexture; // The texture data.
TClutVal cvFace; // Lighting value for entire face, if not shading.
SBumpLighting Bump;
int iFogBand; // Fog band triangle falls in.
int iMipLevel; // Mip level for the polygon.
float fArea; // Area of the polygon.
//
// Depth sorting variables.
//
CPlane plPlane; // Triangle's plane.
TReal rPlaneTolerance; // Tolerance for clipping to the plane.
CVector2<int> v2ScreenMinInt; // Minimum screen coordinates as an integer.
CVector2<int> v2ScreenMaxInt; // Maximum screen coordinates as an integer.
float fMinZ; // Minimum Z value for the polygon.
float fMaxZ; // Maximum Z value for the polygon.
TReal rMaxLevel; // The maximum Z value for this point in the
// z-sorted list.
// moved in the depth sort list.
CSortKey keySort; // Key value for depth sorting.
void* pvNodeItMain; // Pointer to the node iterator.
bool bMovedInList; // Flag to indicate if the polygon has been moved.
bool bAccept; // Flag to accept or cull polygon.
//
// Hardware rasterizaion support.
//
bool bFullHardware; // Flag for using full hardware acceleration.
bool bPrerasterized; // Indicates a polygon already rasterized in hardware.
EHWRenderType ehwHardwareFlags; // Flags for hardware rendering.
EAddressMode eamAddressMode; // Address mode for filtering.
//
// Stuff used for the partitoning depht sort.
//
#if (iMAX_SORT_LISTS > 1)
int iNumSortLists; // Number of sort lists the polygon belongs to.
CSortList* pslMemberOf[iMAX_SORT_LISTS]; // Sort lists the polygon is a member of.
void* pvNodeIt[iMAX_SORT_LISTS]; // Pointer to the node iterator.
#endif
//
// Stuff that is helpfull for debugging.
//
#if (VER_DEBUG)
bool bClippedByDepthSort; // Flag to indicate polygon was clipped by the
// depth sort routine.
int iClipped; // The number of times this polygon has been
// clipped in the depthsort algorithm.
CShape* pshOwningShape; // Pointer to the shape that owns the polygon.
#endif
//******************************************************************************************
//
// Constructors.
//
// Default constructor.
CRenderPolygon();
//******************************************************************************************
CRenderPolygon& operator =(const CRenderPolygon& rpoly)
{
new(this)CRenderPolygon(rpoly);
return *this;
}
//******************************************************************************************
//
// Member functions.
//
//******************************************************************************************
//
void InitFast()
//
// Initialise the bare minimum necessary for this polygon.
//
// This can be used after creating an uninitialised polygon (i.e. one that hasn't had
// its default constructor invoked). The various stages of the pipeline are then responsible
// for setting those values necessary for the particular rendering features enabled.
//
//**********************************
{
#if VER_DEBUG
// Set everything to a probably invalid value, so we can be sure that anything
// needing initialising is explicitly initialised.
memset(this, 0xFF, sizeof(*this));
// Make sure we don't have a vtbl, by checking the address of the first member.
Assert((char*)&paprvPolyVertices == (char*)this);
// Avoid an assertion failure on the copy constructor. We must make sure we have
// a valid (normalised) plane normal before the copy.
plPlane = CPlane(CDir3<>(1, 0, 0), 1);
#endif
// Prevent an undefined lighting value.
cvFace = 0.0f;
// This must be initialised, or the CDir3<> copy constructor will Assert.
Bump.d3Light = d3ZAxis;
// Software polygon by default.
ehwHardwareFlags = ehwSoftware;
}
//******************************************************************************************
//
void SetPlane
(
);
//
// Sets the plane of the triangle and its tolerance.
//
//**************************************
//******************************************************************************************
//
bool bCalculateScreenExtents
(
bool b_cull_tiny = true // Whether to reject tiny polygons.
);
//
// Initializes the screen space bounding box, and related members.
//
// Returns 'true' if the polygon spans at least a single screen pixel.
//
//**********************************
//******************************************************************************************
//
bool bScreenNoOverlap
(
CRenderPolygon* prpoly // Pointer to the polygon that should lay to the front.
) const
//
// Returns 'true' if the screen space bounding rectangles do not overlap, or if this
// polygon lay entirely behind the polygon given by the argument.
//
// Notes:
// This test incorporates the first two ambiguity resolution steps for depth sorting.
//
//**********************************
{
Assert(prpoly);
Assert(fMinZ >= 0.0f);
Assert(prpoly->fMaxZ >= 0.0f);
// X Overlap.
if (v2ScreenMinInt.tX >= prpoly->v2ScreenMaxInt.tX)
return true;
if (v2ScreenMaxInt.tX <= prpoly->v2ScreenMinInt.tX)
return true;
// Y Overlap.
if (v2ScreenMinInt.tY >= prpoly->v2ScreenMaxInt.tY)
return true;
if (v2ScreenMaxInt.tY <= prpoly->v2ScreenMinInt.tY)
return true;
// Z Overlap.
if (u4FromFloat(fMinZ) >= u4FromFloat(prpoly->fMaxZ))
return true;
// All attempts at trivial rejection failed, return 'true.'
return false;
}
//******************************************************************************************
//
bool bBehind
(
const CRenderPolygon* prpoly // Pointer to the polygon that should lay to the front.
) const;
//
// Returns 'true' if this polygon is behind the polygon referred to by the argument. This
// test assumes that a trivial Z extent test has been done, and only uses the planes of
// the polygons to determine order.
//
// Notes:
// This test incorporates the third and fourth ambiguity resolution steps for depth
// sorting. As a slight optimization, the fourth test is done before the third.
//
//**********************************
//******************************************************************************************
//
bool bInFrontOf
(
const CRenderPolygon* ppoly // Pointer to the polygon that should lay to the back.
) const;
//
// Returns 'true' if this polygon is entirely in front of the polygon referred to by the
// argument.
//
// Notes:
// This test represents the reversed step three and four test for ambiguity resolution
// for depth sorting.
//
//**********************************
//******************************************************************************************
//
void SetArea
(
);
//
// Sets the area of the polygon.
//
//**************************************
//******************************************************************************************
//
void ReduceFeatures
(
);
//
// Turns features off wherever possible. Also sets bAccept and fArea.
//
//**************************************
//**********************************************************************************************
//
void FindBestSlope
(
int& ri_best_vert_a, // Index of first vertex.
int& ri_best_vert_b // Index of second index.
) const;
//
// Finds the pair of vertices that subdivides the polygon with the least horizontal
// slope.
//
//**********************************
//**********************************************************************************************
//
void BuildVertexArray
(
CRenderPolygon& rpoly_new, // Polygon to fill with vertices.
int i_from, // Index of first vertex.
int i_to, // Index of second index.
CPArray<SRenderVertex*> paprv_scratch // Array usable for rpoly's vertices.
) const;
//******************************************************************************************
//
float fGetAverageZ
(
) const;
//
// Returns the average z value for the polygon.
//
//**********************************
//******************************************************************************************
//
float fGetFarthestZ
(
) const;
//
// Returns the average z value for the polygon.
//
//**********************************
//******************************************************************************************
//
void SetMipLevel
(
bool b_target_hardware
);
//
// Determines the mip level for this polygon by setting 'iMipLevel.'
//
//**************************************
//******************************************************************************************
//
void Validate
(
);
//
// Make sure that this polygon is ready to render.
//
//**************************************
//******************************************************************************************
//
void Grow
(
float f_amount // Amount to grow outward by.
);
//
// Grows the polygon outward by a specified amount.
//
//**************************************
};
//******************************************************************************************
//
// Inlined for speed.
//
//******************************************************************************************
forceinline float CRenderPolygon::fGetAverageZ() const
{
float f_average_z = 0.0f;
// Sum the z values of the vertices.
for (int i = 0; i < paprvPolyVertices.size(); ++i)
f_average_z += paprvPolyVertices[i]->v3Cam.tY;
// Return the average value.
return f_average_z * fUnsignedInverseInt(paprvPolyVertices.size());
}
//******************************************************************************************
forceinline void CRenderPolygon::SetArea()
{
Assert(paprvPolyVertices.uLen >= 3);
fArea = 0.0f;
//
// Break the polygon into triangles and sum their area.
//
for (uint u_3 = 2; u_3 < paprvPolyVertices.uLen; ++u_3)
{
uint u_1 = 0;
uint u_2 = u_3 - 1;
//
// Formula:
//
// Area = (x2 - x1) * (x3 - x1) - (y3 - y1) * (y2 - y1)
// ---------------------------------------------
// 2
//
// Note the reverse order of the screen vertices. Also note that the CVector2D cross
// product could be used here.
//
float f_sub_area = (paprvPolyVertices[u_2]->v3Screen.tX - paprvPolyVertices[u_3]->v3Screen.tX) *
(paprvPolyVertices[u_1]->v3Screen.tY - paprvPolyVertices[u_3]->v3Screen.tY) -
(paprvPolyVertices[u_1]->v3Screen.tX - paprvPolyVertices[u_3]->v3Screen.tX) *
(paprvPolyVertices[u_2]->v3Screen.tY - paprvPolyVertices[u_3]->v3Screen.tY);
// Sum the areas.
fArea += fabs(f_sub_area);
}
// Divide by two.
fArea *= 0.5f;
}
//**********************************************************************************************
//
class CScreenRender
//
// Prefix: scren
//
// An interface class for the rasteriser.
// Implemented by a derived class, e.g. our native rasteriser, or Direct3D.
//
//**************************************
{
public:
//**********************************************************************************************
//
struct SSettings
//
// Prefix: screnset
//
// Screen renderer settings.
//
//**************************************
{
// Publicly changeable settings.
CSet<ERenderFeature> seterfState; // Which features currently active.
bool bClearBackground; // Whether to clear the background in BeginFrame.
bool bDrawSky; // The renderer has the sky
CColour clrBackground; // The background colour to clear to.
// Also used as sky colour for water rendering.
bool bTestGamma; // Flag to draw gamma test pattern on background.
bool bHalfScanlines; // Flag to render only the even scanlines.
bool bDoubleVertical; // Flag to double the pixels vertically.
bool bSoftwareAlpha; // Flag to do software alpha blending.
// Scene info.
SBumpLighting bltPrimary; // Bump lighting info for primary lighting.
// Supply default constructor only.
//******************************************************************************************
SSettings();
};
CRaster* prasScreen; // Target raster associated with this renderer.
ptr<SSettings> pSettings; // Render settings used by this renderer
// (changeable).
public:
//******************************************************************************************
//
// Constructor and destructor.
//
//******************************************************************************************
CScreenRender
(
SSettings* pscrenset, // Render settings to use.
rptr<CRaster> pras_screen, // Raster for render output.
rptr<CRaster> pras_zbuffer = rptr0 // Raster for z-buffer output.
);
//
// Constructs an object that renders to the given screen. If pras_zbuffer is 0,
// an appropriate Z-buffer is constructed internally.
//
// Note that some implementations of this class may have restrictions such as not allowing
// a Z buffer to be passed, or requiring pras_screen to be a CRasterWin.
//
//******************************************************************************************
virtual ~CScreenRender()
{
}
//******************************************************************************************
//
// Member functions.
//
//******************************************************************************************
virtual void UpdateSettings()
//
// Handles any changes to the settings.
//
{
}
//******************************************************************************************
virtual CSet<ERenderFeature> seterfModify()
//
// Returns:
// Which features are changeable in this driver.
//
{
return set0;
}
//******************************************************************************************
virtual void BeginFrame()
//
// Perform frame setup activities before rendering.
//
{
}
//******************************************************************************************
//
virtual bool bTargetHardware
(
) const
//
// Returns 'true' if the target renderer supports Direct3D.
//
//**************************************
{
return false;
}
//******************************************************************************************
//
virtual bool bTargetMainScreen
(
) const
//
// Returns 'true' if the target renderer is the main screen.
//
//**************************************
{
return false;
}
//******************************************************************************************
virtual void EndFrame()
//
// Perform frame cleanup activities after rendering, including flipping the screen.
//
{
}
//******************************************************************************************
virtual void ClearMemSurfaces()
//
// Clears the raster memory.
//
{
}
//******************************************************************************************
virtual void DrawPolygons
(
CPArray<CRenderPolygon*> parpoly // Array of polygons to draw.
);
//
// Render these here polys.
// Default version calls DrawPolygon for each one.
//
//******************************************************************************************
//
virtual void SetD3DFlagForPolygons
(
CPArray<CRenderPolygon> parpoly, // Array of polygons to draw.
bool b_d3d
);
//
// Sets software and hardware flag as required.
//
//**************************************
//******************************************************************************************
virtual void DrawPolygon
(
CRenderPolygon& rpoly // Polygon to render.
)
//
// Render this here poly.
// // Disabled default version splits into triangles, calls DrawTriangle.
//
{
AlwaysAssert(0);
}
//******************************************************************************************
//
virtual CScreenRender* psrCreateCompatible
(
rptr<CRaster> pras_screen // Raster for render output.
)
//
// Calls appropriate CScreenRender() constructor.
//
//**********************************
{
return 0;
}
//******************************************************************************************
//
virtual TPixel pixSetBackground
(
TPixel pix_background // The new background colour.
);
//
// Sets the background colour.
//
// Returns the value of the current background colour.
//
//**********************************
//******************************************************************************************
//
virtual void SetHardwareOut
(
bool b_allow_hardware
);
//
// Sets the hardware out flag for this device.
//
//**********************************
protected:
//******************************************************************************************
virtual CSet<ERenderFeature> seterfDefault()
//
// Returns:
// Which features are changeable in this driver.
//
{
return set0;
}
//******************************************************************************************
void CorrectRenderState
(
CSet<ERenderFeature>& seterf // Input render state.
);
//
// Corrects the render state, enforcing internal consistency, and setting any unmodifiable
// flags to their default state.
//
//**********************************************************************************************
//
virtual void ValidatePolygon
(
const CRenderPolygon& rpoly // Polygon to check.
);
//
// Makes sure it's kosher.
//
//**********************************
//**********************************************************************************************
//
virtual void ValidateVertex
(
const SRenderVertex& rv // Vertex to check.
);
//
// Makes sure it's kosher.
//
//**********************************
};
//**********************************************************************************************
//
class CRenderDesc
//
// Prefix: srendesc
//
// Used to describe a particular ScreenRenderer to the main program. Contains a name for the
// renderer, and a function to create it.
//
//**************************************
{
public:
char* strDesc; // Description of the renderer.
//******************************************************************************************
//
// Constructor.
//
CRenderDesc(char* str)
: strDesc(str)
{
}
//******************************************************************************************
//
// Member functions.
//
//******************************************************************************************
//
virtual CScreenRender* pScreenRenderCreate
(
CScreenRender::SSettings* pscrenset, // Render settings to use.
rptr<CRaster> pras_screen // Raster for render output.
) = 0;
//
// Calls appropriate CScreenRender() constructor.
//
//**********************************
};
//**********************************************************************************************
//
class CArrayRenderDesc: public CMSArray<CRenderDesc*, 5>
//
// Prefix: sapRenderDesc (like parent)
//
// A class which is basically just an array of RenderDesc*, with special code to initialise it.
//
//**************************************
{
public:
//******************************************************************************************
//
// Constructor.
//
// When initialised, it fills itself with all known CRenderDescs.
CArrayRenderDesc();
};
//******************************************************************************************
//
// Global variables.
//
// The app looks here to find the list of CRenderDescs, and create CScreenRenderers.
extern CArrayRenderDesc sapRenderDesc;
#endif
Reference in New Issue Copy Permalink