noctra/CnC_Renegade
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Renegade.git synced 2026-06-17 18:57:44 +02:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit of Command & Conquer Renegade source code.

Browse Source
This commit is contained in:
LFeenanEA
2025-02-27 16:39:46 +00:00
parent 74ab8fa5e0
commit 58ed459113
4918 changed files with 1366710 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

255
Code/ww3d2/scene.h Normal file
View File

@@ -0,0 +1,255 @@
/*
** 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:: /VSS_Sync/ww3d2/scene.h $*
* *
* $Author:: Vss_sync $*
* *
* $Modtime:: 8/29/01 7:29p $*
* *
* $Revision:: 10 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef SCENE_H
#define SCENE_H
#include "always.h"
#include "refcount.h"
#include "vector3.h"
#include "robjlist.h"
#include "wwdebug.h"
class RenderObjClass;
class RenderInfoClass;
class CameraClass;
class ChunkLoadClass;
class ChunkSaveClass;
/*
** SceneIterator
** This object is used to iterate through the render objects
** in a scene.
*/
class SceneIterator
{
public:
virtual ~SceneIterator(void) { };
virtual void First(void) = 0;
virtual void Next(void) = 0;
virtual bool Is_Done(void) = 0;
virtual RenderObjClass * Current_Item(void) = 0;
protected:
SceneIterator(void) { };
};
/**
** SceneClass
** This is a bunch of render objects that define a 3D scene.
** The requirements of a SceneClass are:
** - The ablility to pass its renderobject's internal surrender representation
** to surrender when asked in the Render method.
** - The ability to add and remove render objects from the scene
** - The ability to create an iterator for the user which uses the
** SceneIterator interface and allows the user to iterate through
** all render objects or visible render objects in the scene.
**
** The "registration" interface is used by certain render objects to enable
** extra processing. For example, particle emmitters/buffers need to be updated
** each frame regardless of whether they are visible so they are registered
** for "ON_FRAME_UPDATE" processing.
*/
class SceneClass : public RefCountClass
{
public:
SceneClass(void);
virtual ~SceneClass(void);
virtual void Add_Render_Object(RenderObjClass * obj);
virtual void Remove_Render_Object(RenderObjClass * obj);
virtual SceneIterator * Create_Iterator(bool onlyvisible = false) = 0;
virtual void Destroy_Iterator(SceneIterator * it) = 0;
virtual void Set_Ambient_Light(const Vector3 & color) { AmbientLight = color; }
virtual const Vector3 & Get_Ambient_Light(void) { return AmbientLight; }
///////////////////////////////////////////////////////////////////////////////////
// Fog methods
///////////////////////////////////////////////////////////////////////////////////
virtual void Set_Fog_Enable(bool set) { FogEnabled = set; }
virtual bool Get_Fog_Enable(void) { return FogEnabled; }
virtual void Set_Fog_Color(const Vector3 & color) { FogColor = color; }
virtual const Vector3 & Get_Fog_Color(void) { return FogColor; }
virtual void Set_Fog_Range( float start, float end ) { FogStart = start; FogEnd = end; }
virtual void Get_Fog_Range( float * start, float * end ) { *start = FogStart; *end = FogEnd; }
///////////////////////////////////////////////////////////////////////////////////
// Render Modes
///////////////////////////////////////////////////////////////////////////////////
enum PolyRenderType
{
POINT,
LINE,
FILL
};
void Set_Polygon_Mode(PolyRenderType mode) { PolyRenderMode = mode; }
PolyRenderType Get_Polygon_Mode(void) { return PolyRenderMode; }
///////////////////////////////////////////////////////////////////////////////////
// Second pass render mode is a debug feature which renders the whole scene twice.
///////////////////////////////////////////////////////////////////////////////////
enum ExtraPassPolyRenderType
{
EXTRA_PASS_DISABLE,
EXTRA_PASS_LINE,
EXTRA_PASS_CLEAR_LINE
};
void Set_Extra_Pass_Polygon_Mode(ExtraPassPolyRenderType mode) { ExtraPassPolyRenderMode = mode; }
ExtraPassPolyRenderType Get_Extra_Pass_Polygon_Mode(void) { return ExtraPassPolyRenderMode; }
///////////////////////////////////////////////////////////////////////////////////
// Object processing registration
///////////////////////////////////////////////////////////////////////////////////
enum RegType
{
ON_FRAME_UPDATE = 0,
LIGHT,
RELEASE,
};
virtual void Register(RenderObjClass * obj,RegType for_what) = 0;
virtual void Unregister(RenderObjClass * obj,RegType for_what) = 0;
///////////////////////////////////////////////////////////////////////////////////
// Point visibility - used by DazzleRenderObj when no custom handler is installed
///////////////////////////////////////////////////////////////////////////////////
virtual float Compute_Point_Visibility( RenderInfoClass & rinfo,
const Vector3 & point) { return 1.0f; }
///////////////////////////////////////////////////////////////////////////////////
// Save-Load, records the fog, depth cue, etc settings into a chunk
///////////////////////////////////////////////////////////////////////////////////
virtual void Save(ChunkSaveClass & csave);
virtual void Load(ChunkLoadClass & cload);
protected:
void Render(RenderInfoClass & rinfo);
Vector3 AmbientLight;
PolyRenderType PolyRenderMode;
ExtraPassPolyRenderType ExtraPassPolyRenderMode;
bool FogEnabled;
Vector3 FogColor;
float FogStart;
float FogEnd;
friend class WW3D;
/*
** Not implemented!
*/
SceneClass (const SceneClass &);
SceneClass & operator == (const SceneClass &);
private:
virtual void Customized_Render(RenderInfoClass & rinfo)=0;
virtual void Pre_Render_Processing(RenderInfoClass & rinfo) {}
virtual void Post_Render_Processing(RenderInfoClass & rinfo) {}
};
/**
** SimpleSceneClass
** This is an example of a simple way to implement a scene class which
** can be rendered by WW3D. Basically it stores a list of render objects
** When the Render function is called, it checks each object against the
** view frustum an marks it as visible or invisible. Then it performs
** some LOD calculations on all of the visible objects, then has each
** render object add its internal (surrender) representation to the
** internal (surrender) representation of the scene.
*/
class SimpleSceneClass : public SceneClass
{
public:
SimpleSceneClass(void);
virtual ~SimpleSceneClass(void);
virtual void Add_Render_Object(RenderObjClass * obj);
virtual void Remove_Render_Object(RenderObjClass * obj);
virtual void Remove_All_Render_Objects(void);
virtual void Register(RenderObjClass * obj,RegType for_what);
virtual void Unregister(RenderObjClass * obj,RegType for_what);
virtual SceneIterator * Create_Iterator(bool onlyvisible = false);
virtual void Destroy_Iterator(SceneIterator * it);
// Set visibility status for my render objects. If not called explicitly
// beforehand, will be called inside Render().
virtual void Visibility_Check(CameraClass * camera);
///////////////////////////////////////////////////////////////////////////////////
// Point visibility - used by DazzleRenderObj when no custom handler is installed
///////////////////////////////////////////////////////////////////////////////////
virtual float Compute_Point_Visibility( RenderInfoClass & rinfo,
const Vector3 & point);
protected:
// Has a visibility check been performed since scene was last rendered?
bool Visibility_Checked;
RefRenderObjListClass RenderList;
RefRenderObjListClass UpdateList;
RefRenderObjListClass LightList;
RefRenderObjListClass ReleaseList;
friend class SimpleSceneIterator;
virtual void Customized_Render(RenderInfoClass & rinfo);
virtual void Post_Render_Processing(RenderInfoClass& rinfo);
};
#endif