decalsys.h

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(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/decalsys.h                             $*
 *                                                                                             *
 *              Original Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                      $Author:: Greg_h                                                      $*
 *                                                                                             *
 *                     $Modtime:: 6/29/01 11:30a                                              $*
 *                                                                                             *
 *                    $Revision:: 6                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#if defined(_MSC_VER)
#pragma once
#endif
 
#ifndef DECALSYS_H
#define DECALSYS_H
 
#include "always.h"
#include "matrix3d.h"
#include "matrix4.h"
#include "obbox.h"
#include "robjlist.h"
#include "matpass.h"
#include "projector.h"
 
class DecalGeneratorClass;
class DecalMeshClass;

class DecalSystemClass
{
public:
    DecalSystemClass(void);
    virtual ~DecalSystemClass(void);
 
    /*
    **  Create and release DecalGenerators.  Note that this is the point at which the 
    ** decal system can track "logical" decals.  The generator will keep an internal list
    ** of all of the render objects which generated decals which you should copy if you
    ** want to track them (e.g. if you want to cap the maximum number of active decals and
    ** kill the old ones...)
    */
    virtual DecalGeneratorClass *        Lock_Decal_Generator(void);
    virtual void                            Unlock_Decal_Generator(DecalGeneratorClass * generator);
 
    /*
    ** When a decal-mesh is destroyed, it must inform the DecalSystem.  Otherwise, systems 
    ** which track decals can get dangling pointers.
    */
    virtual void                            Decal_Mesh_Destroyed(uint32 decal_id,DecalMeshClass * mesh) { }
 
protected:
 
    /*
    ** This generates the decal ID when a generator is created. This decal system reroutes this
    ** to Generate_Unique_Global_Decal_Id(), but other decal systems may use a different method.
    */
    virtual uint32                            Generate_Decal_Id(void) { return Generate_Unique_Global_Decal_Id(); }
 
    /*
    ** Unique ID generation for decals.  Not all decal systems have to use
    ** this method of generating ids.  Some may wish to assign the id as the 
    ** array index of the logical id or use some other aritrary method.
    */
    static uint32                         Generate_Unique_Global_Decal_Id(void);
 
    static uint32                         DecalIDGenerator;
};
 

class DecalGeneratorClass : public ProjectorClass
{
public:
 
    /*
    ** All meshes that actually generate decal polygons should register themselves in the
    ** list.  Then when the decal generation is finished, this list can be copied so that
    ** we can come back to those meshes and remove the decals if we want to.
    */
    void                                Add_Mesh(RenderObjClass * mesh);
    NonRefRenderObjListClass &  Get_Mesh_List(void);
 
    /*
    ** Decal generator parameters.
    ** see ProjectorClass for control over the coordinate system, projection, etc
    */
    uint32                            Get_Decal_ID(void)                              { return DecalID; }
    DecalSystemClass *          Peek_Decal_System(void)                            { return System; }
 
    /*
    ** Backface rejection thresh-hold.  The dot-product between the projection vector and
    ** the normal of each polygon is taken, if the result is greater than this value the polygon
    ** is accepted into the decal.  Set it to -1 if you want to accept all polygons.
    */
    void                                Set_Backface_Threshhold(float val)           { BackfaceVal = val; }
    float                               Get_Backface_Threshhold(void)                    { return BackfaceVal; }
 
    /*
    ** Normally, decals are not generated on translucent meshes.  This is due to the "floating
    ** decals" that you can get on things like trees.  The user can override this behavior
    ** through the following interface. 
    */
    void                                Apply_To_Translucent_Meshes(bool onoff)  { ApplyToTranslucentMeshes = onoff; }
    bool                                Is_Applied_To_Translucent_Meshes(void)      { return ApplyToTranslucentMeshes; }
 
    /*
    ** Material parameters: just grab a pointer the material pass and modify it.  
    ** Remember to release your ref to it when you are done.
    */
    MaterialPassClass *            Get_Material(void)                              { WWASSERT(Material != NULL); Material->Add_Ref(); return Material; }
 
    /*
    ** Decal generation support.  Call Set_Mesh_Transform for the mesh you want to add 
    ** a decal to.  Then for each vertex, you can call 'Compute_Texture_Coordinate'
    */
    void                                Set_Mesh_Transform(const Matrix3D & tm);
 
protected:
 
    DecalGeneratorClass(uint32 id,DecalSystemClass * system);
    ~DecalGeneratorClass(void);
 
    /*
    ** Logical Decal ID, DecalSystem that this generator is tied to
    */
    DecalSystemClass *          System;       
    uint32                            DecalID;                             // unique ID generated by the DecalSystem
 
    /*
    ** Backface Threshhold, Translucent mesh decal enable
    */
    float                               BackfaceVal;
    bool                                ApplyToTranslucentMeshes;
 
    /*
    ** Material settings
    */
    MaterialPassClass *            Material;                           // material settings for the decal
    
    /*
    ** Results, list of the meshes which actually generated decal polygons for this logical decal.
    */
    NonRefRenderObjListClass    MeshList;       
 
    friend class DecalSystemClass;
};
 

 
class MultiFixedPoolDecalSystemClass : public DecalSystemClass
{
 
public:
 
    MultiFixedPoolDecalSystemClass(uint32 num_pools, const uint32 *pool_sizes);
    MultiFixedPoolDecalSystemClass(const MultiFixedPoolDecalSystemClass & that);
    virtual ~MultiFixedPoolDecalSystemClass(void);
 
    // This clears the slot in addition to locking the generator, thus preventing any decal id
    // collisions (since any decal previously in that slot will have the same id as the new one).
    virtual DecalGeneratorClass *            Lock_Decal_Generator(void);
 
    // This will register the decal in the system in the appropriate pool and slot (determined by
    // the generator's pool and slot ids), removing any decal which may have been there before.
    virtual void                                Unlock_Decal_Generator(DecalGeneratorClass * generator);
 
    // This notifies the system that a mesh which has decals on it was destroyed - therefore we
    // need to remove the mesh from our list to avoid dangling pointers.
    virtual void                                Decal_Mesh_Destroyed(uint32 id,DecalMeshClass * mesh);
 
    // Not part of the DecalSystemClass interface - this function removes any decal currently in
    // the given slot in the given pool.
    void                                            Clear_Decal_Slot(uint32 pool_id, uint32 slot_id);
 
    // This one removes all decals in a given pool.
    void                                            Clear_Pool(uint32 pool_id);
 
    // And this one removes all decals in the system.
    void                                            Clear_All_Decals(void);
 
protected:
 
    /*
    ** This generates the decal ID when a generator is created. This decal system generates the
    ** decal ID from a pool ID and slot ID which are part of the state of the system so someone
    ** can set them before calling Lock_Decal_Generator() (which is where this function is called).
    ** We do it this way to avoid needing to override Lock_Decal_Generator().
    */
    virtual uint32    Generate_Decal_Id(void) { return encode_decal_id(Generator_PoolID, Generator_SlotID); }
    uint32    Generator_PoolID;       // These should be set before calling Lock_Decal_Generator()
    uint32    Generator_SlotID;       // These should be set before calling Lock_Decal_Generator()
 
    class LogicalDecalClass;
 
    // Get a reference to the logical decal at the given pool and slot id (performs range chacking)
    LogicalDecalClass & find_logical_decal(uint32 pool_id, uint32 slot_id);
 
    // Get a reference to the logical decal with the given decal id
    LogicalDecalClass & find_logical_decal(uint32 decal_id);
 
    // The decal ids are formed so that the upper 16 bits are equal to the pool id and the lower
    // 16 bits are equal to the slot id.
    static uint32 encode_decal_id(uint32 pool_id, uint32 slot_id) { return (slot_id & 0xFFFF) | (pool_id << 16); }
    static void decode_decal_id(uint32 decal_id, uint32 & pool_id, uint32 & slot_id) { slot_id = decal_id & 0xFFFF; pool_id = decal_id >> 16; }
 
    // A class to store the meshes to which the decal has been applied (so that they can be removed when needed)
    class LogicalDecalClass
    {
    public:
        LogicalDecalClass(void);
        ~LogicalDecalClass(void);
 
        void                                            Set(DecalGeneratorClass * generator);
 
        // Just clears any existing logical decal information, leaving the decal empty.
        void                                            Clear(uint32 decal_id);
 
        NonRefRenderObjListClass    MeshList;       
    };
 
    class LogicalDecalPoolClass
    {
    public:
        LogicalDecalPoolClass(void);
        ~LogicalDecalPoolClass(void);
 
        void Initialize(uint32 size);
 
        LogicalDecalClass *        Array;
        uint32                        Size;
    };
 
    LogicalDecalPoolClass *                        Pools;
    uint32                                            PoolCount;
 
};
 
 
 
 
#endif //DECALSYS_H