//----------------------------------------------------------------------------
//
// rampmat.hpp
//
// Declares classes for ramp material handling.
//
// Copyright (C) Microsoft Corporation, 1997.
//
//----------------------------------------------------------------------------
#ifndef _RAMPMAT_HPP_
#define _RAMPMAT_HPP_
/* -*- c++ -*- */
#include "rampmap.h"
#include "palette.h"
#include "rgbmap.h"
struct ExtMaterial;
struct IntMaterial;
struct RampMaterial;
struct RLDDIRampLightingDriver;
struct AgeList {
CIRCLE_QUEUE_MEMBER(AgeList) list;
LIST_ROOT(alh,IntMaterial) agelist;
};
class RampCommon {
public:
void* operator new(size_t size)
{
void* p;
if (D3DMalloc(&p, size))
return NULL;
return p;
}
void operator delete(void *p)
{
D3DFree(p);
}
};
/*
* An ExtMaterial is the underlying driver object for an LPDIRECT3DMATERIAL.
* When used, it creates IntMaterials which are distinguished by different
* ambient light, fog, D3DMATERIAL value etc.
*
* The ExtMaterials are kept on a list in the driver and if not explicitly
* freed, they are cleaned up when the driver is destroyed.
*
* The IntMaterials can outlive the ExtMaterial in the case that the
* ExtMaterial is destroyed right after use. We add these orphans to a list
* which is emptied at Clear time since after Clear, no pixels are visible
* which were rendered with the IntMaterial and it can be freed.
*/
struct ExtMaterial : public RampCommon {
friend struct IntMaterial;
private:
/*
* Driver object which owns us.
*/
RLDDIRampLightingDriver* driver;
/*
* Current API level material definition.
*/
D3DMATERIAL mat;
/*
* List of internal materials derived from us.
*/
LIST_ROOT(eml,IntMaterial) intlist;
/*
* Generation count. The generation is incremented each time
* the material is changed. This allows us to generate a new internal
* material as needed.
*/
int generation;
/*
* This tracks the generation of any texture used by the material. The
* texture generation is bumped if its palette is changed or it is
* loaded from another texture.
*/
int texture_generation;
/*
* This tracks the underlying texture object represented by the texture
* handle (if any). If texture handles are swapped, we need to know
* so that we can make a new internal material for the new texture.
*/
PD3DI_SPANTEX texture;
/*
* Increment the generation either because the material was set or
* because a texture changed.
*/
void Age();
public:
/*
* Chain for list of external materials created by this driver.
*/
LIST_MEMBER(ExtMaterial) list;
public:
/*
* Constructor/Destructor.
*/
ExtMaterial(RLDDIRampLightingDriver* driver, D3DMATERIALHANDLE hMat);
~ExtMaterial();
/*
* Change the API level material.
*/
void SetMaterial(D3DMATERIAL* mat);
/*
* Accessor to the current API level material.
*/
D3DMATERIAL* GetMaterial() {
return &mat;
}
/*
* Find an internal material which corresponds to the current driver
* object state.
*/
IntMaterial* FindIntMaterial();
/*
* Find what range of values lighting should take. The base is the
* pixel value (in fixed point) of the dark end of the material. The
* shift value is user to convert a 0.16 fixed point shade into the
* range needed for the material. e.g.
*
* pixel = base + (VALTOFX8(shade) << shift);
*
*/
HRESULT FindLightingRange(unsigned long* base,
unsigned long* size,
BOOL* specular,
unsigned long** texture_colors);
};
/*
* The IntMaterial is derived from an ExtMaterial taking into account the
* driver state when the ExtMaterial was used. Normally IntMaterials are
* on a list in their owning ExtMaterial. If the external material is
* destroyed, any active internal materials which it owned are
* transferred to an orphans list in the driver. This is cleared out
* next time Clear is called.
*
* The internal material has a list of underlying RampMaterials. For
* a non-textured material, there is exactly one and for a textured
* material, there is one per color in the texture's palette. The
* ramp materials track color sharing between internal materials and
* handle the details of allocating color resources.
*
* Internal materials are also chained onto one of a number of lists
* based on their age. The age of a material is the number of frames
* since it was last used to render something. When a material is
* aged, it is rejuvenated by moving it to the age=0 list. Each
* frame, the lists are rotated by one notch and materials on the
* oldest list are reclaimed.
*
* A material is either active or inactive. Active materials have
* color resources and are either on the age=0 list (active this
* frame) or the age=1 list (active last frame). When an inactive
* material is used, it allocates color resources by attempting to
* activate the underlying ramp materials.
*
* At the end of the frame, on Update, any active materials on the
* age=1 list must be materials which were active last frame but were
* not used this frame. We remove their color resources by
* deactivating the underlying ramp materials.
*/
struct IntMaterial : public RampCommon {
private:
/*
* Driver object which owns us.
*/
RLDDIRampLightingDriver* driver;
/*
* External material which created us.
*/
ExtMaterial* extmat;
public:
/*
* Too annoying to have these private.
*/
/*
* Chain of internal materials created by our external material owner
* which owns us. The chain is also used to place the material on the
* driver's orphans list if appropriate.
*/
LIST_MEMBER(IntMaterial) list;
/*
* Current ageing list which we are on.
*/
AgeList* age;
LIST_MEMBER(IntMaterial) agelist;
private:
/*
* D3DMATERIAL which the external material had when it created us.
*/
D3DMATERIAL mat;
/*
* TRUE if we are active. We are active if we currently have color
* allocation resources assigned to us.
*/
int active;
/*
* Base values of our color allocation resources. Contents are valid
* only when active.
*/
unsigned long* colors;
/*
* Features which distinguish us from other internal materials owned by
* our external material.
*/
float ambient; // ambient shade
unsigned long viewport_id; // viewport which owns it
int fog_enable; // material incorporates fog
unsigned long fog_color; // the fogging color
int generation;
/*
* RampMaterials used by this internal material.
*/
int ramp_count;
RampMaterial** ramps;
public:
/*
* Constructor/Destructor.
*/
IntMaterial(ExtMaterial* extmat);
~IntMaterial();
/*
* Returns TRUE if we match the current settings of our external material
* and driver state.
*/
int Valid();
/*
* See ExtMaterial
*/
HRESULT FindLightingRange(unsigned long* base,
unsigned long* size,
BOOL* specular,
unsigned long** texture_colors);
/*
* Activate the material and allocate color resources for it.
*/
HRESULT Activate();
/*
* Deactivate the material, freeing color resources. Always works.
*/
void Deactivate();
/*
* Returns TRUE if the material is currently active.
*/
int IsActive() {
return active;
}
/*
* Add the material to the driver's orphaned material list. Called when
* the external material is destroyed.
*/
void Orphan();
};
/*
* RampMaterials are used by internal materials to represent ranges of
* colors. They perform low level color allocation by allocating
* color ranges (RLDDIRamps) from a rampmap.
*
* A textured internal material can use many ramp materials.
* Several internal materials can use the same ramp material if the
* colors match. This can happen easily if many textures use the same
* palette. The ramp material maintains a usage of how many internal
* materials are using it and is freed when the last one stops.
*
* Ramp materials, like internal materials are either active or
* inactive. Active materials have color resources and inactive
* materials do not. A ramp material is made active when any of its
* internal material users are active and inactive when none of then
* are active. To track this a count of how many active users is
* maintained.
*
* When a material is made active, it attempts to allocate a color
* range to use. If that is successful, it sets the colors in the
* range to an appropriate ramp of colors. If is no more space in the
* colormap for a new range, it finds the closes active ramp material
* and shares its ramp.
*
* To track active materials and sharing materials, the driver has a
* list of active materials and each material has a list of sharers.
* The sharers list is only valid for materials which are both active
* and which own their ramp.
*/
struct RampMaterial : public RampCommon {
private:
/*
* Driver object which owns us.
*/
RLDDIRampLightingDriver* driver;
/*
* List of materials which have the same hash value.
*/
LIST_MEMBER(RampMaterial) hash;
/*
* Materials sharing this ramp. Only valid for active materials
* with owner == TRUE.
*/
LIST_ROOT(name6,RampMaterial) sharers;
/*
* If the material is active, then it is on the drivers rmactive list
* if it owns the ramp, otherwise it is on the sharers list of the
* material which does own the ramp. Only valid for active materials.
*/
LIST_MEMBER(RampMaterial) list;
/*
* If were sharing a ramp and inherit it from the owner, we need to
* defer setting the colors until the next frame to avoid possible
* palette flashing. The driver has a list of materials for which
* color setting is deferred, chainged through here.
*
* We make sure that deferredlist.le_next is NULL unless we are
* actually on the deferred list so that we can avoid list problems
* if we are destroyed or passed on to another inheritor before the
* list is processed.
*/
LIST_MEMBER(RampMaterial) deferredlist;
/*
* A count of the number of internal materials which use us.
*/
int usage;
/*
* A count of active internal materials which use us.
*/
int active;
/*
* If we are active (active > 0), this is the underlying color
* range for the material.
*/
RLDDIRamp* ramp;
/*
* TRUE if we created or inherited the ramp. FALSE if I am merely
* sharing some other material.
*/
int owner;
/*
* Distinguishing features.
*/
float ambient; /* ambient shade */
D3DMATERIAL mat; /* material we represent */
int fog_enable; /* material incorporates fog */
unsigned long fog_color; /* the fogging color */
private:
/*
* Constructor/Destructor.
* These are private. Callers should use Find/Release.
*/
RampMaterial(RLDDIRampLightingDriver* driver,
D3DMATERIAL* mat, float ambient);
~RampMaterial();
public:
/*
* Find a material which matches the api material and driver state.
* If no such material exists, make one.
*/
static RampMaterial* Find(RLDDIRampLightingDriver* driver,
D3DMATERIAL* mat);
private:
/*
* Next functions are implementation detail of Find.
*/
/*
* Compare two api materials to see if they are identical.
*/
static int MaterialSame(D3DMATERIAL* mat1, D3DMATERIAL* mat2);
/*
* Return a measure of how close two rgb colors are in rgb space.
*/
static int RGBDist(D3DCOLORVALUE* rgb1, D3DCOLORVALUE* rgb2);
/*
* Return a measure of how close two api materials are.
*/
static int CompareMaterials(D3DMATERIAL* mat1, D3DMATERIAL* mat2);
public:
/*
* Called by a user when it is no longer needed.
*/
void Release();
/*
* Called by a user when the material is about to be used.
*/
HRESULT Activate();
/*
* Called by a user when the material has not been used this frame.
*/
void Deactivate();
/*
* Return the base color of an active material.
*/
unsigned long Base();
private:
/*
* Implementation details of Activate and Deactivate.
*/
/*
* Allocate a ramp of colors for us to use.
* May only be called for an inactive material.
*/
HRESULT AllocateColors();
/*
* Free our color allocation. May only be called for an active material.
*/
void FreeColors();
/*
* Set the color values of our color allocation.
*/
private:
void SetColorsStd();
void SetColorsFog();
public:
void SetColors();
};
///*
// * Workspace used when evaluating complex lighting models.
// */
//struct Workspace {
// float diffuse;
// float specular;
//};
//
//struct SpecularTable {
// LIST_MEMBER(SpecularTable) list;
// float power; /* shininess power */
// float table[260]; /* space for overflows */
//};
//
//#define WORKSPACE_SIZE 1024
#define HASH_SIZE 257
/*
* If the app is rendering at 30fps, this means that a material can survive
* for about 5 seconds. This seems like enough to cope with stuff moving
* out of shot and back in again soon after.
*/
#define AGE_MAX (30*5) /* age at which unused materials die */
typedef struct _RLDDISoftLightingDriver {
D3DMATERIAL material;
float ambient;
D3DFOGMODE fog_mode;
float fog_start;
float fog_end;
float fog_density;
D3DMATERIALHANDLE hMat;
D3DCOLORMODEL color_model;
DWORD ambient_save;
} RLDDISoftLightingDriver;
struct RLDDIRampLightingDriver {
RLDDISoftLightingDriver driver; /* common fields */
/*
* Colormap
*/
RLDDIPalette* palette;
RLDDIRGBMap* rgbmap;
unsigned long* pixelmap; /* map color indices to pixels */
PALETTEENTRY ddpalette[256];
int paletteChanged;
RLDDIRampmap* rampmap;
unsigned long viewport_id; /* current viewport */
int fog_enable;
unsigned long fog_color;
/*
* External materials created by this driver.
*/
LIST_ROOT(deml,ExtMaterial) materials;
/*
* Active internal materials orphaned by their owning external material.
*/
LIST_ROOT(diml,IntMaterial) orphans;
AgeList agelists[AGE_MAX];
CIRCLE_QUEUE_ROOT(aqh,AgeList) agequeue; /* age sorted queue of lists */
AgeList* active; /* current active list */
/*
* This is set to TRUE after Clear has advanced the ages one notch and
* cleared on update. It is used to stop multiple calls to Clear from
* confusing the aging system
*/
int already_aged;
LIST_ROOT(name7,RampMaterial) rmactive; /* materials with ramps */
LIST_ROOT(name8,RampMaterial) rmdeferred;
LIST_ROOT(name9,RampMaterial) hash[HASH_SIZE]; /* materials hash table */
/*
* Current material.
*/
ExtMaterial* current_material;
};
typedef struct _RLDDILookupMaterialData {
D3DMATERIALHANDLE hMat; /* material to look up */
unsigned long base; /* base pixel value */
unsigned long size; /* size of index range */
unsigned long texture_index; /* texture table for textures */
} RLDDILookupMaterialData;
#endif // _RAMPMAT_HPP_