Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.
C++ cmakecnccommand-and-conquercppdirectx11game-enginegame-preservationgeneralsrtssage-enginex64zero-hour
/*
** 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/>.
*/
// Modified 2025-2026 by Olcay Seygan for Zero Hour Reforged; see the git history.
// Modified 2026 by İlyas Akın for the macOS/Linux port; see NOTICE.md and the git history.
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
/***********************************************************************************************
*** 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 : W3DAssetManager *
* *
* $Archive:: $*
* *
* Original Author:: Hector Yee (Enbassetmgr)
* Added/Modified:: Mark Wilczynski
* *
* $Author:: $*
* *
* $Modtime:: $*
* *
* $Revision:: $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include <always.h>
#include "stringex.h"
#include "W3DDevice/GameClient/W3DAssetManager.h"
#include "proto.h"
#include "rendobj.h"
#include <vector3.h>
#include "mesh.h"
#include "hlod.h"
#include "matinfo.h"
#include "meshmdl.h"
#include "part_emt.h"
#include "vertmaterial.h"
#include "dx8wrapper.h"
#include "texture.h"
#include "surfaceclass.h"
#include "textureloader.h"
#include "ww3dformat.h"
#include "colorspace.h"
#include <wwprofile.h>
#include "wwmemlog.h"
#include "ffactory.h"
#include "font3d.h"
#include "render2dsentence.h"
#include <stdio.h>
#include "W3DDevice/GameClient/W3DGranny.h"
#include "Common/PerfTimer.h"
#include "Common/GlobalData.h"
#include "Common/GameCommon.h"
#ifdef _INTERNAL
// for occasional debugging...
//#pragma optimize("", off)
//#pragma MESSAGE("************************************** WARNING, optimization disabled for debugging purposes")
#endif
//---------------------------------------------------------------------
// Constants
//---------------------------------------------------------------------
const float ident_scale(1.0f);
const float scale_epsilon(0.01f);
const Vector3 ident_HSV(0,0,0);
const float H_epsilon(1.0f);
const float S_epsilon(0.01f);
const float V_epsilon(0.01f);
//---------------------------------------------------------------------
// Externs defined somewhere in W3D.
//---------------------------------------------------------------------
unsigned int PixelSize(const SurfaceClass::SurfaceDescription &sd);
void Convert_Pixel(Vector3 &rgb, const SurfaceClass::SurfaceDescription &sd, const unsigned char * pixel);
void Convert_Pixel(unsigned char * pixel,const SurfaceClass::SurfaceDescription &sd, const Vector3 &rgb);
//---------------------------------------------------------------------
// W3DPrototype
//---------------------------------------------------------------------
//---------------------------------------------------------------------
class W3DPrototypeClass : public MemoryPoolObject, public PrototypeClass
{
MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE( W3DPrototypeClass, "W3DPrototypeClass" )
public:
W3DPrototypeClass(RenderObjClass * proto, const AsciiString& name);
virtual const char* Get_Name(void) const { return Name.str(); }
virtual int Get_Class_ID(void) const { return Proto->Class_ID(); }
virtual RenderObjClass * Create(void);
virtual void DeleteSelf() { deleteInstance(); }
protected:
//virtual ~W3DPrototypeClass(void);
private:
RenderObjClass * Proto;
AsciiString Name;
};
//---------------------------------------------------------------------
W3DPrototypeClass::W3DPrototypeClass(RenderObjClass * proto, const AsciiString& name) :
Proto(proto),
Name(name)
{
assert(Proto);
Proto->Add_Ref();
}
//---------------------------------------------------------------------
W3DPrototypeClass::~W3DPrototypeClass(void)
{
if (Proto) {
Proto->Release_Ref();
Proto = NULL;
}
}
//---------------------------------------------------------------------
RenderObjClass * W3DPrototypeClass::Create(void)
{
return (RenderObjClass *)( SET_REF_OWNER( Proto->Clone() ) );
}
//---------------------------------------------------------------------
// W3DAssetManager
//---------------------------------------------------------------------
//---------------------------------------------------------------------
W3DAssetManager::W3DAssetManager(void)
{
#ifdef INCLUDE_GRANNY_IN_BUILD
m_GrannyAnimManager = NEW GrannyAnimManagerClass;
#endif
}
//---------------------------------------------------------------------
W3DAssetManager::~W3DAssetManager(void)
{
#ifdef INCLUDE_GRANNY_IN_BUILD
delete m_GrannyAnimManager;
#endif
}
#ifdef DUMP_PERF_STATS
Int64 Total_Get_Texture_Time=0;
#endif
TextureClass * W3DAssetManager::Get_Texture
(
const char * filename,
MipCountType mip_level_count,
WW3DFormat texture_format,
bool allow_compression,
TextureBaseClass::TexAssetType type,
bool allow_reduction
)
{
//Just call the base implementation after adjusting reduction to deal
//with our special types.
if (filename && *filename && strncasecmp(filename,"ZHC",3) == 0)
allow_reduction = false; //don't allow reduction on our infantry textures.
return WW3DAssetManager::Get_Texture( filename,
mip_level_count,
texture_format,
allow_compression,
type,
allow_reduction
);
}
#if 0 //this function is obsolete in latest C&C3 drop. Use the one above.
//---------------------------------------------------------------------
TextureClass *W3DAssetManager::Get_Texture(
const char * filename,
MipCountType mip_level_count,
WW3DFormat texture_format,
bool allow_compression
)
{
#ifdef DUMP_PERF_STATS
Int64 startTime64,endTime64;
GetPrecisionTimer(&startTime64);
#endif
WWPROFILE( "WW3DAssetManager::Get_Texture 1" );
/*
** Bail if the user isn't really asking for anything
*/
if (!filename || !*filename)
{
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Get_Texture_Time += endTime64-startTime64;
#endif
return NULL;
}
StringClass lower_case_name(filename,true);
_strlwr(lower_case_name.Peek_Buffer());
/*
** See if the texture has already been loaded.
*/
TextureClass* tex = TextureHash.Get(lower_case_name);
if (tex && texture_format != WW3D_FORMAT_UNKNOWN)
{
WWASSERT_PRINT(tex->Get_Texture_Format() == texture_format, ("Texture %s has already been loaded with different format",filename));
}
/*
** Didn't have it so we have to create a new texture
*/
if (!tex)
{
tex = NEW_REF(TextureClass, (lower_case_name, NULL, mip_level_count, texture_format, allow_compression));
TextureHash.Insert(tex->Get_Texture_Name(),tex);
// if (TheGlobalData->m_preloadAssets)
// {
// extern std::vector<std::string> preloadTextureNamesGlobalHack;
// preloadTextureNamesGlobalHack.push_back(tex->Get_Texture_Name());
// }
#if defined(_DEBUG) || defined(_INTERNAL) || defined(_ALLOW_DEBUG_CHEATS_IN_RELEASE)
if (TheGlobalData->m_preloadReport)
{
//loading a new asset and app is requesting a log of all loaded assets.
FILE *logfile=fopen("PreloadedAssets.txt","a+"); //append to log
if (logfile)
{
fprintf(logfile,"TX: %s\n",tex->Get_Texture_Name());
fclose(logfile);
}
}
#endif
}
tex->Add_Ref();
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Get_Texture_Time += endTime64-startTime64;
#endif
return tex;
}
#endif
//---------------------------------------------------------------------
RenderObjClass * W3DAssetManager::Create_Render_Obj(const char* name)
{
return WW3DAssetManager::Create_Render_Obj(name);
}
//---------------------------------------------------------------------
/** 'Generals' specific munging to encode team color and scale in model name */
// Every caller of the four Munge helpers below hands them a buffer of this size, and the helpers
// write straight into it, so the number lives in one place rather than six.
enum { MUNGED_NAME_SIZE = 512 };
static inline void Munge_Render_Obj_Name(char *newname, const char *oldname, float scale, const int color, const char *oldTextureName, const char *textureName)
{
char lower_case_name[255];
strlcpy(lower_case_name, oldname, ARRAY_SIZE(lower_case_name));
_strlwr(lower_case_name);
if (!textureName)
textureName = "";
if (!oldTextureName)
oldTextureName = "";
snprintf(newname, MUNGED_NAME_SIZE, "#%d!%g!%s>%s#%s",color,scale,oldTextureName,textureName,lower_case_name);
}
//---------------------------------------------------------------------
static inline void Munge_Texture_Name(char *newname, const char *oldname, const int color)
{
char lower_case_name[255];
strlcpy(lower_case_name, oldname, ARRAY_SIZE(lower_case_name));
_strlwr(lower_case_name);
snprintf(newname, MUNGED_NAME_SIZE, "#%d#%s", color, lower_case_name);
}
//---------------------------------------------------------------------
int W3DAssetManager::replaceAssetTexture(RenderObjClass *robj, TextureClass *oldTex, TextureClass *newTex)
{
switch (robj->Class_ID()) {
case RenderObjClass::CLASSID_MESH:
return replaceMeshTexture(robj, oldTex, newTex);
break;
case RenderObjClass::CLASSID_HLOD:
return replaceHLODTexture(robj, oldTex, newTex);
break;
}
return 0;
}
//---------------------------------------------------------------------
Int W3DAssetManager::replaceHLODTexture(RenderObjClass *robj, TextureClass *oldTex, TextureClass *newTex)
{
int didReplace=0;
int num_sub = robj->Get_Num_Sub_Objects();
for(int i = 0; i < num_sub; i++) {
RenderObjClass *sub_obj = robj->Get_Sub_Object(i);
didReplace |= replaceAssetTexture(sub_obj, oldTex, newTex);
REF_PTR_RELEASE(sub_obj);
}
return didReplace;
}
//---------------------------------------------------------------------
Int W3DAssetManager::replaceMeshTexture(RenderObjClass *robj, TextureClass *oldTex, TextureClass *newTex)
{
MeshClass *mesh=(MeshClass*) robj;
MaterialInfoClass *material = mesh->Get_Material_Info();
Bool usesOld = FALSE;
for (int i=0; i<material->Texture_Count(); i++)
usesOld |= (material->Peek_Texture(i) == oldTex);
REF_PTR_RELEASE(material);
if (!usesOld)
return 0;
// The model is shared with every other copy of this asset; swap on a copy of our own.
mesh->Make_Unique();
MeshModelClass * model = mesh->Get_Model();
material = mesh->Get_Material_Info();
for (int i=0; i<material->Texture_Count(); i++)
{
if (material->Peek_Texture(i) == oldTex)
material->Replace_Texture(i,newTex);
}
model->Replace_Texture(oldTex,newTex);
REF_PTR_RELEASE(material);
REF_PTR_RELEASE(model);
return 1;
}
//---------------------------------------------------------------------
/** Replaces all references to old texture with new texture on robj alone. Each mesh that
names the old texture gets a model of its own first, so the prototype and every other
instance keep drawing the old one.
*/
int W3DAssetManager::replacePrototypeTexture(RenderObjClass *robj, const char * oldname, const char * newname)
{
//search model for old texture
TextureClass *oldTex=Get_Texture(oldname);
TextureClass *newTex=Get_Texture(newname);
int retCode=replaceAssetTexture(robj,oldTex,newTex);
REF_PTR_RELEASE(oldTex);
REF_PTR_RELEASE(newTex);
return retCode;
}
//---------------------------------------------------------------------
/** Generals specific version that looks for a texture which has been house-color tinted.
Don't use this unless you really need it. For normal textures, use Get_Texture().
*/
TextureClass * W3DAssetManager::Find_Texture(const char * name, const int color)
{
char newname[MUNGED_NAME_SIZE];
Munge_Texture_Name(newname, name, color);
// see if we have a cached copy
TextureClass *newtex = TextureHash.Get(newname);
if (newtex) {
newtex->Add_Ref();
}
return newtex;
}
//---------------------------------------------------------------------
TextureClass * W3DAssetManager::Recolor_Texture(TextureClass *texture, const int color)
{
const char *name=texture->Get_Texture_Name();
TextureClass *newtex = Find_Texture(name, color);
if (newtex) {
return newtex;
}
return Recolor_Texture_One_Time(texture, color);
}
//---------------------------------------------------------------------
const Int TEAM_COLOR_PALETTE_SIZE = 16;
const UnsignedShort houseColorScale[TEAM_COLOR_PALETTE_SIZE] =
{
255,239,223,211,195,174,167,151,135,123,107,91,79,63,47,35
};
//---------------------------------------------------------------------
static void remapPalette16Bit(SurfaceClass::SurfaceDescription *sd, UnsignedShort *palette, unsigned int color)
{
UnsignedShort pal[TEAM_COLOR_PALETTE_SIZE];
Vector3 rgb,v_color((float)((color>>16)&0xff)/255.0f/255.0f,(float)((color>>8)&0xff)/255.0f/255.0f,(float)(color&0xff)/255.0f/255.0f);
//Generate a new color gradient palette based on reference color
for (Int y=0; y<TEAM_COLOR_PALETTE_SIZE; y++)
{
rgb.X=(Real)houseColorScale[y]*v_color.X;
rgb.Y=(Real)houseColorScale[y]*v_color.Y;
rgb.Z=(Real)houseColorScale[y]*v_color.Z;
pal[y]=0xffff; //preset alpha to known value
Convert_Pixel((unsigned char *)&pal[y],*sd,rgb);
}
//check if this pixel is part of team color palette
for (Int p=0; p<TEAM_COLOR_PALETTE_SIZE; p++)
{ palette[p]=pal[p]; //replace color with house color
}
}
//---------------------------------------------------------------------
static void remapTexture16Bit(Int dx, Int dy, Int pitch, SurfaceClass::SurfaceDescription *sd, UnsignedShort *palette, UnsignedShort *data, unsigned int color)
{
UnsignedShort pal[TEAM_COLOR_PALETTE_SIZE];
Vector3 rgb,v_color((float)((color>>16)&0xff)/255.0f/255.0f,(float)((color>>8)&0xff)/255.0f/255.0f,(float)(color&0xff)/255.0f/255.0f);
//Generate a new color gradient palette based on reference color
Int y; // VC6 for-scope leak
for (y=0; y<TEAM_COLOR_PALETTE_SIZE; y++)
{
rgb.X=(Real)houseColorScale[y]*v_color.X;
rgb.Y=(Real)houseColorScale[y]*v_color.Y;
rgb.Z=(Real)houseColorScale[y]*v_color.Z;
pal[y]=0xffff; //preset alpha to known value
Convert_Pixel((unsigned char *)&pal[y],*sd,rgb);
}
for (y=0; y<dy; y++)
{ for (Int x=0; x<dx; x++)
{ //check if this pixel is part of team color palette
for (Int p=0; p<TEAM_COLOR_PALETTE_SIZE; p++)
{ if (palette[p]==data[x])
{ data[x]=pal[p]; //replace color with house color
break;
}
}
}
data += pitch;
}
}
//Use hue shift instead of alpha blend to apply house color to textures
#define DO_HUE_SHIFT
//---------------------------------------------------------------------
//Input texture is assumed to be in ARGB 4444 format.
static void remapAlphaTexture16Bit(Int dx, Int dy, Int pitch, SurfaceClass::SurfaceDescription *sd, UnsignedShort *data, unsigned int color)
{
UnsignedShort pixel;
UnsignedShort pixelAlpha;
#ifndef DO_HUE_SHIFT
float fpixelAlpha,fpixelAlphaInv;
#endif
Vector3 rgb,v_color((float)((color>>16)&0xff)/255.0f,(float)((color>>8)&0xff)/255.0f,(float)(color&0xff)/255.0f);
Int x,y;
#ifdef DO_HUE_SHIFT
Vector3 hsv;
Vector3 hsv_color;
RGB_To_HSV(hsv_color,v_color);
#endif
for (y=0; y<dy; y++)
{
for (x=0; x<dx; x++)
{
pixel=data[x];
pixelAlpha=15-(pixel>>12); //get alpha for house color
if (pixelAlpha)
{ //some house color needs to show through
///@todo: optimize this alpha blend to use fixed point math.
#ifdef DO_HUE_SHIFT
RGB_To_HSV(hsv,Vector3(((pixel>>8)&0xf)/15.0f,((pixel>>4)&0xf)/15.0f,(pixel &0xf)/15.0f));
hsv.X=hsv_color.X;
hsv.Y*=hsv_color.Y;
HSV_To_RGB(rgb,hsv);
#else
fpixelAlpha=pixelAlpha/15.0f;
fpixelAlphaInv=1.0f-fpixelAlpha;
rgb.X=fpixelAlpha * v_color.X + fpixelAlphaInv*(Real)((pixel>>8)&0xf)/15.0f; //red
rgb.Y=fpixelAlpha * v_color.Y + fpixelAlphaInv*(Real)((pixel>>4)&0xf)/15.0f; //green
rgb.Z=fpixelAlpha * v_color.Z + fpixelAlphaInv*(Real)(pixel&0xf)/15.0f; //blue
#endif
data[x] = REAL_TO_INT(rgb.X*15.0f)<<8 | REAL_TO_INT(rgb.Y*15.0f)<<4 | REAL_TO_INT(rgb.Z*15.0f);
}
data[x] |= 0xf000; //force alpha to opaque.
}
data += pitch;
}
}
//---------------------------------------------------------------------
static void remapPalette32Bit(SurfaceClass::SurfaceDescription *sd, UnsignedInt *palette, unsigned int color)
{
UnsignedInt pal[TEAM_COLOR_PALETTE_SIZE];
Vector3 rgb,v_color((float)((color>>16)&0xff)/255.0f/255.0f,(float)((color>>8)&0xff)/255.0f/255.0f,(float)(color&0xff)/255.0f/255.0f);
//Generate a new color gradient palette based on reference color
for (Int y=0; y<TEAM_COLOR_PALETTE_SIZE; y++)
{
rgb.X=(Real)houseColorScale[y]*v_color.X;
rgb.Y=(Real)houseColorScale[y]*v_color.Y;
rgb.Z=(Real)houseColorScale[y]*v_color.Z;
pal[y]=0xffffffff; //preset alpha to known value
Convert_Pixel((unsigned char *)&pal[y],*sd,rgb);
}
//check if this pixel is part of team color palette
for (Int p=0; p<TEAM_COLOR_PALETTE_SIZE; p++)
{ palette[p]=pal[p]; //replace color with house color
}
}
//---------------------------------------------------------------------
static void remapTexture32Bit(Int dx, Int dy, Int pitch, SurfaceClass::SurfaceDescription *sd, UnsignedInt *palette, UnsignedInt *data, unsigned int color)
{
UnsignedInt pal[TEAM_COLOR_PALETTE_SIZE];
Vector3 rgb,v_color((float)((color>>16)&0xff)/255.0f/255.0f,(float)((color>>8)&0xff)/255.0f/255.0f,(float)(color&0xff)/255.0f/255.0f);
//Generate a new color gradient palette based on reference color
Int y; // VC6 for-scope leak
for (y=0; y<TEAM_COLOR_PALETTE_SIZE; y++)
{
rgb.X=(Real)houseColorScale[y]*v_color.X;
rgb.Y=(Real)houseColorScale[y]*v_color.Y;
rgb.Z=(Real)houseColorScale[y]*v_color.Z;
pal[y]=0xffffffff; //preset alpha to known value
Convert_Pixel((unsigned char *)&pal[y],*sd,rgb);
}
for (y=0; y<dy; y++)
{ for (Int x=0; x<dx; x++)
{ //check if this pixel is part of team color palette
for (Int p=0; p<TEAM_COLOR_PALETTE_SIZE; p++)
{ if (palette[p]==data[x])
{ data[x]=pal[p]; //replace color with house color
break;
}
}
}
data += pitch;
}
}
//---------------------------------------------------------------------
static void remapAlphaTexture32Bit(Int dx, Int dy, Int pitch, SurfaceClass::SurfaceDescription *sd, UnsignedInt *data, unsigned int color)
{
UnsignedInt pixel;
UnsignedInt pixelAlpha;
#ifndef DO_HUE_SHIFT
float fpixelAlpha,fpixelAlphaInv;
#endif
Vector3 rgb,v_color((float)((color>>16)&0xff)/255.0f,(float)((color>>8)&0xff)/255.0f,(float)(color&0xff)/255.0f);
Int x,y;
#ifdef DO_HUE_SHIFT
Vector3 hsv;
Vector3 hsv_color;
RGB_To_HSV(hsv_color,v_color);
#endif
for (y=0; y<dy; y++)
{ for (x=0; x<dx; x++)
{
pixel=data[x];
pixelAlpha=255-(pixel>>24); //get alpha for house color
if (pixelAlpha)
{ //some house color needs to show through
#ifdef DO_HUE_SHIFT
RGB_To_HSV(hsv,Vector3(((pixel>>16)&0xff)/255.0f,((pixel>>8)&0xff)/255.0f,(pixel &0xff)/255.0f));
hsv.X=hsv_color.X;
hsv.Y*=hsv_color.Y;
HSV_To_RGB(rgb,hsv);
#else
///@todo: optimize this alpha blend to use fixed point math.
fpixelAlpha=pixelAlpha/255.0f;
fpixelAlphaInv=1.0f-fpixelAlpha;
rgb.X=fpixelAlpha * v_color.X + fpixelAlphaInv*(Real)((pixel>>16)&0xff)/255.0f; //red
rgb.Y=fpixelAlpha * v_color.Y + fpixelAlphaInv*(Real)((pixel>>8)&0xff)/255.0f; //green
rgb.Z=fpixelAlpha * v_color.Z + fpixelAlphaInv*(Real)(pixel&0xff)/255.0f; //blue
#endif
data[x] = REAL_TO_INT(rgb.X*255.0f)<<16 | REAL_TO_INT(rgb.Y*255.0f)<<8 | REAL_TO_INT(rgb.Z*255.0f);
}
data[x] |= 0xff000000; //force alpha to opaque.
}
data += pitch;
}
}
//---------------------------------------------------------------------
/** Surface is assumed to come in the following format:
First 16 pixels are a palette composed of 24-Bit RGB values.
Any pixels in remainder of image that use these 24-bit values
will be remapped using a pre-defined formula.
*/
void W3DAssetManager::Remap_Palette(SurfaceClass *surface, const int color, Bool doPaletteOnly, Bool useAlpha)
{
// unsigned int x;
SurfaceClass::SurfaceDescription sd;
surface->Get_Description(sd);
int pitch,size;
// UnsignedInt newPalette[TEAM_COLOR_PALETTE_SIZE];
size=PixelSize(sd);
unsigned char *bits=(unsigned char*) surface->Lock(&pitch);
if (doPaletteOnly)
{ //only recolor the palette which is stored in top row. Model only references these pixels.
if (size == 2)
remapPalette16Bit(&sd, (UnsignedShort *)bits, color);
else
if (size == 4)
remapPalette32Bit(&sd, (UnsignedInt *)bits,color);
}
else
{
if (useAlpha)
{
if (size == 2)
remapAlphaTexture16Bit(sd.Width, sd.Height, pitch>>1, &sd, (UnsignedShort *)bits,color);
else
if (size == 4)
remapAlphaTexture32Bit(sd.Width, sd.Height, pitch>>2, &sd, (UnsignedInt *)bits,color);
}
else
{ //Recolor the image using the palette stored in top row
if (size == 2)
remapTexture16Bit(sd.Width, sd.Height-1, pitch>>1, &sd, (UnsignedShort *)bits, (UnsignedShort *)(bits+pitch), color);
else
if (size == 4)
remapTexture32Bit(sd.Width, sd.Height-1, pitch>>2, &sd, (UnsignedInt *)bits, (UnsignedInt *)(bits+pitch),color);
}
}
surface->Unlock();
}
//---------------------------------------------------------------------
TextureClass * W3DAssetManager::Recolor_Texture_One_Time(TextureClass *texture, const int color)
{
const char *name=texture->Get_Texture_Name();
// if texture is procedural return NULL
if (name && name[0]=='!') return NULL;
// and under -nodevice there is no surface to copy and recolour, so there is no house-coloured
// texture either. Callers already cope with nothing coming back - see the line above.
if (TheGlobalData && TheGlobalData->m_noRenderDevice) return NULL;
// make sure texture is loaded
if (!texture->Is_Initialized())
TextureLoader::Request_Foreground_Loading(texture);
SurfaceClass::SurfaceDescription desc = {};
SurfaceClass *newsurf, *oldsurf;
// A lost device (alt-tab) leaves the texture without a source level and fails
// CreateOffscreenPlainSurface without a word, and Copy would dereference the missing surface.
// The unit keeps the texture uncoloured.
oldsurf=texture->Get_Surface_Level();
if (oldsurf == NULL)
{
DEBUG_LOG(("Can't recolor texture %s: no surface, device lost?\n", name));
return NULL;
}
texture->Get_Level_Description(desc);
Int psize;
psize=PixelSize(desc);
// The palette remap reads 16- and 32-bit pixels and nothing else. A house-colour texture
// shipped compressed (DXT) or in another format has nothing it can remap, and Direct3D 9 refuses
// the scratch surface for some of them (a DXT image whose sides are not multiples of 4), which
// left newsurf without a surface for Copy to crash on. The unit keeps the texture uncoloured.
if (psize != 2 && psize != 4)
{
DEBUG_LOG(("Can't recolor texture %s: format %d is not 16 or 32 bit\n", name, (Int)desc.Format));
REF_PTR_RELEASE(oldsurf);
return NULL;
}
newsurf=NEW_REF(SurfaceClass,(desc.Width,desc.Height,desc.Format));
if (newsurf->Peek_D3D_Surface() == NULL)
{
DEBUG_LOG(("Can't recolor texture %s: no surface, device lost?\n", name));
REF_PTR_RELEASE(oldsurf);
REF_PTR_RELEASE(newsurf);
return NULL;
}
newsurf->Copy(0,0,0,0,desc.Width,desc.Height,oldsurf);
if (*(name+3) == 'D' || *(name+3) == 'd')
Remap_Palette(newsurf,color, true, false ); //texture only contains a palette stored in top row.
else
if (*(name+3) == 'A' || *(name+3) == 'a')
Remap_Palette(newsurf,color, false, true ); //texture only contains a palette stored in top row.
TextureClass * newtex=NEW_REF(TextureClass,(newsurf,(MipCountType)texture->Get_Mip_Level_Count()));
newtex->Get_Filter().Set_Mag_Filter(texture->Get_Filter().Get_Mag_Filter());
newtex->Get_Filter().Set_Min_Filter(texture->Get_Filter().Get_Min_Filter());
newtex->Get_Filter().Set_Mip_Mapping(texture->Get_Filter().Get_Mip_Mapping());
newtex->Get_Filter().Set_U_Addr_Mode(texture->Get_Filter().Get_U_Addr_Mode());
newtex->Get_Filter().Set_V_Addr_Mode(texture->Get_Filter().Get_V_Addr_Mode());
char newname[MUNGED_NAME_SIZE];
Munge_Texture_Name(newname, name, color);
newtex->Set_Texture_Name(newname);
TextureHash.Insert(newtex->Get_Texture_Name(), newtex);
newtex->Add_Ref();
REF_PTR_RELEASE(oldsurf);
REF_PTR_RELEASE(newsurf);
return newtex;
}
#ifdef DUMP_PERF_STATS
Int64 Total_Create_Render_Obj_Time=0;
#endif
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
Scale==1.0, color==0x00000000, and oldTexure==NULL are defaults that do nothing.
*/
RenderObjClass * W3DAssetManager::Create_Render_Obj(
const char * name,
float scale,
const int color,
const char *oldTexture,
const char *newTexture
)
{
#ifdef DUMP_PERF_STATS
Int64 startTime64,endTime64;
GetPrecisionTimer(&startTime64);
#endif
#ifdef INCLUDE_GRANNY_IN_BUILD
Bool isGranny = false;
char *pext=strrchr(name,'.'); //find file extension
if (pext)
isGranny=(strncasecmp(pext,".GR2",4) == 0);
#endif
Bool reallyscale = (WWMath::Fabs(scale - ident_scale) > scale_epsilon);
Bool reallycolor = (color & 0xFFFFFF) != 0; //black is not a valid color and assumes no custom coloring.
Bool reallytexture = (oldTexture != NULL && newTexture != NULL);
// base case, no scale or color
if (!reallyscale && !reallycolor && !reallytexture)
{
RenderObjClass *robj=WW3DAssetManager::Create_Render_Obj(name);
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Create_Render_Obj_Time += endTime64-startTime64;
#endif
return robj;
}
char newname[MUNGED_NAME_SIZE];
Munge_Render_Obj_Name(newname, name, scale, color, oldTexture, newTexture);
// see if we got a cached version
RenderObjClass *rendobj = NULL;
#ifdef INCLUDE_GRANNY_IN_BUILD
if (isGranny)
{ //Granny objects share the same prototype since they allow instance scaling.
strcpy(newname,name); //use same name for all granny objects at any scale.
}
#endif
Set_WW3D_Load_On_Demand(false); // munged name will never be found in a file.
rendobj = WW3DAssetManager::Create_Render_Obj(newname);
if (rendobj)
{ //store the color that we used to create asset so we can read it back out
//when we need to save this render object to a file. Used during saving
//of fog of war ghost objects.
rendobj->Set_ObjectColor(color);
#ifdef INCLUDE_GRANNY_IN_BUILD
if (isGranny)
///@todo Granny objects are realtime scaled - fix to scale like W3D.
rendobj->Set_ObjectScale(scale);
#endif
Set_WW3D_Load_On_Demand(true); // Auto Load.
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Create_Render_Obj_Time += endTime64-startTime64;
#endif
return rendobj;
}
// create a new one based on exisiting prototype
WWPROFILE( "WW3DAssetManager::Create_Render_Obj" );
WWMEMLOG(MEM_GEOMETRY);
// Try to find a prototype
PrototypeClass * proto = Find_Prototype(name);
Set_WW3D_Load_On_Demand(true); // Auto Load.
if (WW3D_Load_On_Demand && proto == NULL)
{
// If we didn't find one, try to load on demand
char filename [MAX_PATH];
const char *mesh_name = ::strchr (name, '.');
if (mesh_name != NULL)
{
snprintf(filename, (int)(mesh_name - name) + 1, "%s", name);
#ifdef INCLUDE_GRANNY_IN_BUILD
if (isGranny)
strcat(filename, ".gr2");
else
#endif
strcat(filename, ".w3d");
} else {
snprintf( filename, ARRAY_SIZE(filename), "%s.w3d", name);
}
// If we can't find it, try the parent directory
if ( Load_3D_Assets( filename ) == false )
{
StringClass new_filename = StringClass("..\\") + filename;
if (Load_3D_Assets( new_filename ) == false)
{
#ifdef INCLUDE_GRANNY_IN_BUILD
char *mesh_name = ::strchr (filename, '.');
snprintf (mesh_name, 5, "%s", ".gr2");
Load_3D_Assets( filename );
isGranny=true;
#endif
}
}
proto = Find_Prototype(name); // try again
}
if (proto == NULL)
{
static int warning_count = 0;
if (++warning_count <= 20)
{
WWDEBUG_SAY(("WARNING: Failed to create Render Object: %s\r\n",name));
}
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Create_Render_Obj_Time += endTime64-startTime64;
#endif
return NULL; // Failed to find a prototype
}
rendobj = proto->Create();
if (!rendobj)
{
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Create_Render_Obj_Time += endTime64-startTime64;
#endif
return NULL;
}
#ifdef INCLUDE_GRANNY_IN_BUILD
if (!isGranny)
#endif
{
if (reallyscale)
rendobj->Scale(scale); //this also makes it unique
Make_Unique(rendobj,reallyscale,reallycolor);
if (reallytexture)
{
TextureClass *oldTex = Get_Texture(oldTexture);
TextureClass *newTex = Get_Texture(newTexture);
replaceAssetTexture(rendobj,oldTex,newTex);
REF_PTR_RELEASE(newTex);
REF_PTR_RELEASE(oldTex);
}
if (reallycolor)
Recolor_Asset(rendobj,color);
}
#ifdef INCLUDE_GRANNY_IN_BUILD
else
{
///@todo Granny objects are realtime scaled - fix to scale like W3D.
rendobj->Set_ObjectScale(scale);
return rendobj;
}
#endif
// A recolour while the device is lost (alt-tab) comes back uncoloured. Cached under the
// team-colour name, the model would stay that way all session, so it goes back uncached and
// the next request recolours it again.
if (!(reallycolor && DX8Wrapper::Is_Device_Lost()))
{
W3DPrototypeClass *w3dproto = newInstance(W3DPrototypeClass)(rendobj, newname);
rendobj->Release_Ref();
Add_Prototype(w3dproto);
rendobj = w3dproto->Create();
}
rendobj->Set_ObjectColor(color);
#ifdef DUMP_PERF_STATS
GetPrecisionTimer(&endTime64);
Total_Create_Render_Obj_Time += endTime64-startTime64;
#endif
return rendobj;
}
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
int W3DAssetManager::Recolor_Asset(RenderObjClass *robj, const int color)
{
switch (robj->Class_ID()) {
case RenderObjClass::CLASSID_MESH:
return Recolor_Mesh(robj,color);
break;
case RenderObjClass::CLASSID_HLOD:
return Recolor_HLOD(robj,color);
break;
}
return 0;
}
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
int W3DAssetManager::Recolor_Mesh(RenderObjClass *robj, const int color)
{
int i;
int didRecolor=0;
const char *meshName;
MeshClass *mesh=(MeshClass*) robj;
MeshModelClass * model = mesh->Get_Model();
MaterialInfoClass *material = mesh->Get_Material_Info();
// recolor vertex material (assuming mesh is housecolor)
if ( (( (meshName=strchr(mesh->Get_Name(),'.') ) != 0 && *(meshName++)) || ( (meshName=mesh->Get_Name()) != NULL)) &&
strncasecmp(meshName,"HOUSECOLOR", 10) == 0)
{ for (i=0; i<material->Vertex_Material_Count(); i++)
Recolor_Vertex_Material(material->Peek_Vertex_Material(i),color);
// The whole mesh is the side's colour, so the whole mesh glows (Direct3D 11 only). The model
// is this recoloured prototype's own: Make_Mesh_Unique cloned it.
if (TheGlobalData->m_teamGlow)
model->Set_Flag(MeshGeometryClass::TEAM_GLOW, true);
didRecolor=1;
}
// recolor textures
TextureClass *newtex,*oldtex;
for (i=0; i<material->Texture_Count(); i++)
{
oldtex=material->Peek_Texture(i);
if (strncasecmp(oldtex->Get_Texture_Name(),"ZHC", 3) == 0)
{ //This texture needs to be adjusted for housecolor
newtex=Recolor_Texture(oldtex,color);
if (newtex)
{
model->Replace_Texture(oldtex,newtex);
material->Replace_Texture(i,newtex);
REF_PTR_RELEASE(newtex);
didRecolor=1;
}
}
}
REF_PTR_RELEASE(material);
REF_PTR_RELEASE(model);
return didRecolor;
}
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
int W3DAssetManager::Recolor_HLOD(RenderObjClass *robj, const int color)
{
int didRecolor=0;
int num_sub = robj->Get_Num_Sub_Objects();
for(int i = 0; i < num_sub; i++) {
RenderObjClass *sub_obj = robj->Get_Sub_Object(i);
didRecolor |= Recolor_Asset(sub_obj,color);
REF_PTR_RELEASE(sub_obj);
}
return didRecolor;
}
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
void W3DAssetManager::Recolor_Vertex_Material(VertexMaterialClass *vmat, const int color)
{
Vector3 rgb,rgb2;
rgb.X = (Real)((color >> 16) & 0xff )/255.0f;
rgb.Y = (Real)((color >> 8) & 0xff )/255.0f;
rgb.Z = (Real)(color & 0xff)/255.0f;
//We ignore the existing ambinent/diffuse and assume they were 1.0. We can change
//to scaling them if required.
// vmat->Get_Ambient(&rgb2);
// Recolor(rgb,hsv_shift);
rgb2.X = rgb.X; //scale colors
rgb2.Y = rgb.Y; //scale colors
rgb2.Z = rgb.Z; //scale colors
vmat->Set_Ambient(rgb2);
// vmat->Get_Diffuse(&rgb2);
// Recolor(rgb,hsv_shift);
rgb2.X = rgb.X; //scale colors
rgb2.Y = rgb.Y; //scale colors
rgb2.Z = rgb.Z; //scale colors
vmat->Set_Diffuse(rgb2);
}
#ifdef DUMP_PERF_STATS
Int64 Total_Load_3D_Assets=0;
static Int Load_3D_Asset_Recursions=0;
#endif
//---------------------------------------------------------------------
bool W3DAssetManager::Load_3D_Assets( const char * filename )
{
#ifdef DUMP_PERF_STATS
Load_3D_Asset_Recursions++;
Int64 startTime64,endTime64;
GetPrecisionTimer(&startTime64);
#endif
#ifdef INCLUDE_GRANNY_IN_BUILD
Bool isGranny = false;
char *pext=strrchr(filename,'.'); //find file extension
if (pext)
isGranny=(strncasecmp(pext,".GR2",4) == 0);
if (!isGranny)
#endif
// Try to find an existing prototype
char basename[512];
strcpy(basename, filename);
char *pext = strrchr(basename, '.'); //find file extension
if (pext)
*pext = '\0'; //drop the extension
PrototypeClass * proto = Find_Prototype(basename);
if (proto)
{
#ifdef DUMP_PERF_STATS
if (Load_3D_Asset_Recursions == 1)
{ GetPrecisionTimer(&endTime64);
Total_Load_3D_Assets += endTime64-startTime64;
}
Load_3D_Asset_Recursions--;
#endif
return TRUE; //this file has already been loaded.
}
bool result = WW3DAssetManager::Load_3D_Assets(filename);
#if defined(_DEBUG) || defined(_INTERNAL)
if (result && TheGlobalData->m_preloadReport)
{
//loading a new asset and app is requesting a log of all loaded assets.
FILE *logfile=fopen("PreloadedAssets.txt","a+"); //append to log
if (logfile)
{
StringClass lower_case_name(filename,true);
_strlwr(lower_case_name.Peek_Buffer());
fprintf(logfile,"3D: %s\n",lower_case_name.Peek_Buffer());
fclose(logfile);
}
}
#endif
#ifdef DUMP_PERF_STATS
if (Load_3D_Asset_Recursions == 1)
{ GetPrecisionTimer(&endTime64);
Total_Load_3D_Assets += endTime64-startTime64;
}
Load_3D_Asset_Recursions--;
#endif
return result;
#ifdef INCLUDE_GRANNY_IN_BUILD
//Loading assets for Granny File
PrototypeClass * newproto = NULL;
newproto = _GrannyLoader.Load_W3D(filename);
/*
** Now, see if the prototype that we loaded has a duplicate
** name with any of our currently loaded prototypes (can't have that!)
*/
if (newproto != NULL) {
if (!Render_Obj_Exists(newproto->Get_Name())) {
/*
** Add the new, unique prototype to our list
*/
Add_Prototype(newproto);
} else {
/*
** Warn the user about a name collision with this prototype
** and dump it
*/
WWDEBUG_SAY(("Render Object Name Collision: %s\r\n",newproto->Get_Name()));
delete newproto;
newproto = NULL;
return false;
}
} else {
/*
** Warn user that a prototype was not generated from this
** chunk type
*/
WWDEBUG_SAY(("Could not generate Granny prototype! File = %d\r\n",filename));
return false;
}
return true;
#endif
}
#ifdef DUMP_PERF_STATS
Int64 Total_Get_HAnim_Time=0;
static Int HAnim_Recursions=0;
#endif
//---------------------------------------------------------------------
HAnimClass * W3DAssetManager::Get_HAnim(const char * name)
{
#ifdef DUMP_PERF_STATS
HAnim_Recursions++;
Int64 startTime64,endTime64;
GetPrecisionTimer(&startTime64);
#endif
WWPROFILE( "WW3DAssetManager::Get_HAnim" );
#ifdef INCLUDE_GRANNY_IN_BUILD
Bool isGranny = false;
char *pext=strrchr(name,'.'); //find file extension
if (pext)
isGranny=(strncasecmp(pext,".GR2",4) == 0);
if (!isGranny)
#endif
{
HAnimClass *anim=WW3DAssetManager::Get_HAnim(name); //we only do custom granny processing.
#ifdef DUMP_PERF_STATS
if (HAnim_Recursions == 1)
{
GetPrecisionTimer(&endTime64);
Total_Get_HAnim_Time += endTime64-startTime64;
}
HAnim_Recursions--;
#endif
return anim;
}
#ifdef INCLUDE_GRANNY_IN_BUILD
// Try to find the hanim
HAnimClass * anim = m_GrannyAnimManager->Get_Anim(name);
if (WW3D_Load_On_Demand && anim == NULL) { // If we didn't find it, try to load on demand
if ( !m_GrannyAnimManager->Is_Missing( name ) ) { // if this is NOT a known missing anim
// If we can't find it, try the parent directory
if ( m_GrannyAnimManager->Load_Anim(name) == 1 ) {
StringClass new_filename = StringClass("..\\") + name;
m_GrannyAnimManager->Load_Anim( new_filename );
}
anim = m_GrannyAnimManager->Get_Anim(name); // Try again
if (anim == NULL) {
// WWDEBUG_SAY(("WARNING: Animation %s not found!\n", name));
m_GrannyAnimManager->Register_Missing( name ); // This is now a KNOWN missing anim
}
}
}
return anim;
#endif
}
//---------------------------------------------------------------------
// Uniqing
//---------------------------------------------------------------------
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
void W3DAssetManager::Make_HLOD_Unique(RenderObjClass *robj, Bool geometry, Bool colors)
{
int num_sub = robj->Get_Num_Sub_Objects();
for(int i = 0; i < num_sub; i++) {
RenderObjClass *sub_obj = robj->Get_Sub_Object(i);
Make_Unique(sub_obj, geometry, colors);
REF_PTR_RELEASE(sub_obj);
}
}
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
void W3DAssetManager::Make_Unique(RenderObjClass *robj, Bool geometry, Bool colors)
{
switch (robj->Class_ID()) {
case RenderObjClass::CLASSID_MESH:
Make_Mesh_Unique(robj,geometry,colors);
break;
case RenderObjClass::CLASSID_HLOD:
Make_HLOD_Unique(robj,geometry,colors);
break;
}
}
//---------------------------------------------------------------------
/** Determine what method is used to apply house color to this mesh (if any) */
static Bool getMeshColorMethods(MeshClass *mesh, Bool &vertexColor, Bool &textureColor)
{
vertexColor = false;
textureColor = false;
//Check if mesh is using custom texture containing house color
MaterialInfoClass *material = mesh->Get_Material_Info();
if (material)
{ for (int j=0; j<material->Texture_Count(); j++)
if (strncasecmp(material->Peek_Texture(j)->Get_Texture_Name(),"ZHC",3) == 0)
{ textureColor = true;
break;
}
REF_PTR_RELEASE(material);
}
//Check if mesh is using a custom mesh which contains house color in material.
//Meshes which are part of another model have names in the form "name.name" while
//isolated meshes are just "name". We check for both starting with "HOUSECOLOR".
const char *meshName;
if ( ( (meshName=strchr(mesh->Get_Name(),'.') ) != 0 && *(meshName++)) || ( (meshName=mesh->Get_Name()) != NULL) )
{ //Check if this object has housecolors on mesh
if ( strncasecmp(meshName,"HOUSECOLOR", 10) == 0)
vertexColor = true;
}
return (vertexColor || textureColor);
}
//---------------------------------------------------------------------
/** Generals specific code to generate customized render objects for each team color
*/
void W3DAssetManager::Make_Mesh_Unique(RenderObjClass *robj, Bool geometry, Bool colors)
{
int i;
MeshClass *mesh=(MeshClass*) robj;
Bool isVertexColor, isTextureColor;
//figure out what type of coloring this mesh requires (if any)
if ((colors && getMeshColorMethods(mesh,isVertexColor,isTextureColor)) || geometry)
{ //mesh has some house color applied so make those components unique to mesh.
//Create unique data for this mesh
if (!geometry) //scaling geometry automatically makes it unique so not needed here.
mesh->Make_Unique();
MeshModelClass * model = mesh->Get_Model();
if (colors && isVertexColor)
{
MaterialInfoClass *material=mesh->Get_Material_Info();
for (i=0; i<material->Vertex_Material_Count(); i++)
material->Peek_Vertex_Material(i)->Make_Unique();
REF_PTR_RELEASE(material);
}
REF_PTR_RELEASE(model);
}
}
//---------------------------------------------------------------------
/**Report prototypes that have all assets with reference count
equal to 1*/
void W3DAssetManager::Report_Used_Prototypes(void)
{
int count = Prototypes.Count();
while (count-- > 0) {
PrototypeClass * proto = Prototypes[count];
if (proto->Get_Class_ID() == RenderObjClass::CLASSID_HLOD || proto->Get_Class_ID() == RenderObjClass::CLASSID_MESH)
{
DEBUG_LOG(("**Unfreed Prototype On Map Reset: %s\n",proto->Get_Name()));
}
}
}
//---------------------------------------------------------------------
/**Report any assets with reference counts > 1. This means they are still
referenced by something besides the asset manager.*/
void W3DAssetManager::Report_Used_Assets(void)
{
Report_Used_Prototypes();
///@todo: Report unfreed skeletons and animations
// HAnimManager.Free_All_Anims();
// HTreeManager.Free_All_Trees();
Report_Used_Textures();
Report_Used_Font3DDatas();
Report_Used_FontChars();
}
//---------------------------------------------------------------------
void W3DAssetManager::Report_Used_FontChars(void)
{
Int count=FontCharsList.Count();
while (count-- > 0)
{
if (FontCharsList[count]->Num_Refs() >= 1)
{
DEBUG_LOG(("**Unfreed FontChar On Map Reset: %s\n",FontCharsList[count]->Get_Name()));
//FontCharsList[count]->Release_Ref();
//FontCharsList.Delete(count);
}
}
}
//---------------------------------------------------------------------
/**Report all textures with refcounts >= 1*/
void W3DAssetManager::Report_Used_Textures(void)
{
/*
** for each texture in the list, get it, check it's refcount, and and release ref it if the
** refcount is one.
*/
// unsigned count=0;
// TextureClass* temp_textures[256];
HashTemplateIterator<StringClass,TextureClass*> ite(TextureHash);
for (ite.First();!ite.Is_Done();ite.Next()) {
TextureClass* tex=ite.Peek_Value();
if (tex->Num_Refs() <= 1) {
/* temp_textures[count++]=tex;
if (count==256) {
for (unsigned i=0;i<256;++i) {
TextureHash.Remove(temp_textures[i]->Get_Texture_Name());
temp_textures[i]->Release_Ref();
}
count=0;
ite.First(); // iterator doesn't support modifying the hash table while iterating, so start from the
// beginning.
}*/
}
else
{
DEBUG_LOG(("**Texture \"%s\" referenced %d times on map reset\n",(const char *)tex->Get_Texture_Name(),tex->Num_Refs()-1));
}
}
/* for (unsigned i=0;i<count;++i) {
TextureHash.Remove(temp_textures[i]->Get_Texture_Name());
temp_textures[i]->Release_Ref();
}*/
}
//---------------------------------------------------------------------
/**Report all used fonts*/
void W3DAssetManager::Report_Used_Font3DDatas( void )
{
/*
** for each font data in the list, get it, check it's refcount, and and release ref it if the
** refcount is one.
*/
SLNode<Font3DDataClass> *node, * next;
for ( node = Font3DDatas.Head(); node; node = next) {
next = node->Next();
Font3DDataClass *font = node->Data();
if (font->Num_Refs() == 1) {
/* Font3DDatas.Remove(font);
font->Release_Ref();*/
}
else
{
DEBUG_LOG(("**Unfreed Font3DDatas On Map Reset: %s\n",font->Name));
}
}
}
//---------------------------------------------------------------------
// E&B Coloring Code
//---------------------------------------------------------------------
/*
//---------------------------------------------------------------------
// Uniqing
//---------------------------------------------------------------------
void W3DAssetManager::Make_Mesh_Unique(RenderObjClass *robj, Bool geometry, Bool colors)
{
int i;
MeshClass *mesh=(MeshClass*) robj;
mesh->Make_Unique();
MeshModelClass * model = mesh->Get_Model();
if (colors) {
// make all vertex materials unique
MaterialInfoClass *material = mesh->Get_Material_Info();
for (i=0; i<material->Vertex_Material_Count(); i++)
material->Peek_Vertex_Material(i)->Make_Unique();
REF_PTR_RELEASE(material);
// make all color arrays unique
model->Make_Color_Array_Unique(0);
model->Make_Color_Array_Unique(1);
// do not do textures yet
// because we want to do the color conversion
// for the top mip level and then
// mip filter instead of converting all mip levels
}
if (geometry) {
// make geometry unique
model->Make_Geometry_Unique();
}
REF_PTR_RELEASE(model);
}
void W3DAssetManager::Make_HLOD_Unique(RenderObjClass *robj, Bool geometry, Bool colors)
{
int num_sub = robj->Get_Num_Sub_Objects();
for(int i = 0; i < num_sub; i++) {
RenderObjClass *sub_obj = robj->Get_Sub_Object(i);
Make_Unique(sub_obj,geometry,colors);
REF_PTR_RELEASE(sub_obj);
}
}
void W3DAssetManager::Make_Unique(RenderObjClass *robj, Bool geometry, Bool colors)
{
switch (robj->Class_ID()) {
case RenderObjClass::CLASSID_MESH:
Make_Mesh_Unique(robj,geometry,colors);
break;
case RenderObjClass::CLASSID_HLOD:
Make_HLOD_Unique(robj,geometry,colors);
break;
}
}
static inline void Munge_Render_Obj_Name(char *newname, const char *oldname, float scale, const Vector3 &hsv_shift)
{
char lower_case_name[255];
strlcpy(lower_case_name, oldname, ARRAY_SIZE(lower_case_name));
_strlwr(lower_case_name);
snprintf(newname, MUNGED_NAME_SIZE, "#%s!%gH%gS%gV%g", lower_case_name, scale, hsv_shift.X, hsv_shift.Y, hsv_shift.Z);
}
static inline void Munge_Texture_Name(char *newname, const char *oldname, const Vector3 &hsv_shift)
{
char lower_case_name[255];
strlcpy(lower_case_name, oldname, ARRAY_SIZE(lower_case_name));
_strlwr(lower_case_name);
snprintf(newname, MUNGED_NAME_SIZE, "#%s!H%gS%gV%g", lower_case_name, hsv_shift.X, hsv_shift.Y, hsv_shift.Z);
}
RenderObjClass * W3DAssetManager::Create_Render_Obj(const char * name,float scale, const Vector3 &hsv_shift)
{
Bool isGranny = false;
#ifdef INCLUDE_GRANNY_IN_BUILD
char *pext=strrchr(name,'.'); //find file extension
if (pext)
isGranny=(strncasecmp(pext,".GR2",4) == 0);
#endif
Bool reallyscale = (WWMath::Fabs(scale - ident_scale) > scale_epsilon);
Bool reallyhsv_shift = (WWMath::Fabs(hsv_shift.X - ident_HSV.X) > H_epsilon ||
WWMath::Fabs(hsv_shift.Y - ident_HSV.Y) > S_epsilon || WWMath::Fabs(hsv_shift.Z - ident_HSV.Z) > V_epsilon);
// base case, no scale or hue shifting
if (!reallyscale && !reallyhsv_shift) return WW3DAssetManager::Create_Render_Obj(name);
char newname[MUNGED_NAME_SIZE];
Munge_Render_Obj_Name(newname, name, scale, hsv_shift);
// see if we got a cached version
RenderObjClass *rendobj=NULL;
if (isGranny)
{ //Granny objects share the same prototype since they allow instance scaling.
strcpy(newname,name); //use same name for all granny objects at any scale.
}
Set_WW3D_Load_On_Demand(false); // munged name will never be found in a file.
rendobj=WW3DAssetManager::Create_Render_Obj(newname);
if (rendobj)
{ if (isGranny)
///@todo Granny objects are realtime scaled - fix to scale like W3D.
rendobj->Set_ObjectScale(scale);
Set_WW3D_Load_On_Demand(true); // Auto Load.
return rendobj;
}
// create a new one based on
// exisiting prototype
WWPROFILE( "WW3DAssetManager::Create_Render_Obj" );
WWMEMLOG(MEM_GEOMETRY);
// Try to find a prototype
PrototypeClass * proto = Find_Prototype(name);
Set_WW3D_Load_On_Demand(true); // Auto Load.
if (WW3D_Load_On_Demand && proto == NULL) { // If we didn't find one, try to load on demand
char filename [MAX_PATH];
char *mesh_name = ::strchr (name, '.');
if (mesh_name != NULL) {
snprintf (filename, (int)(mesh_name - name) + 1, "%s", name);
if (isGranny)
strcat (filename, ".gr2");
else
strcat (filename, ".w3d");
} else {
snprintf( filename, ARRAY_SIZE(filename), "%s.w3d", name);
}
// If we can't find it, try the parent directory
if ( Load_3D_Assets( filename ) == false ) {
StringClass new_filename = StringClass("..\\") + filename;
if (Load_3D_Assets( new_filename ) == false)
{
char *mesh_name = ::strchr (filename, '.');
snprintf (mesh_name, 5, "%s", ".gr2");
Load_3D_Assets( filename );
isGranny=true;
}
}
proto = Find_Prototype(name); // try again
}
if (proto == NULL) {
static int warning_count = 0;
if (++warning_count <= 20) {
WWDEBUG_SAY(("WARNING: Failed to create Render Object: %s\r\n",name));
}
return NULL; // Failed to find a prototype
}
rendobj=proto->Create();
if (!rendobj) return NULL;
if (!isGranny)
{ Make_Unique(rendobj,reallyscale,reallyhsv_shift);
if (reallyscale) rendobj->Scale(scale);
if (reallyhsv_shift) Recolor_Asset(rendobj,hsv_shift);
}
else
{ ///@todo Granny objects are realtime scaled - fix to scale like W3D.
rendobj->Set_ObjectScale(scale);
return rendobj;
}
W3DPrototypeClass *w3dproto=NEW W3DPrototypeClass(rendobj,newname);
rendobj->Release_Ref();
Add_Prototype(w3dproto);
return w3dproto->Create();
}
TextureClass * W3DAssetManager::Get_Texture_With_HSV_Shift(const char * filename, const Vector3 &hsv_shift, TextureClass::MipCountType mip_level_count)
{
WWPROFILE( "W3DAssetManager::Get_Texture with HSV shift" );
Bool is_hsv_shift = (WWMath::Fabs(hsv_shift.X - ident_HSV.X) > H_epsilon ||
WWMath::Fabs(hsv_shift.Y - ident_HSV.Y) > S_epsilon || WWMath::Fabs(hsv_shift.Z - ident_HSV.Z) > V_epsilon);
if (!is_hsv_shift) {
return Get_Texture(filename, mip_level_count);
} else {
//
// Bail if the user isn't really asking for anything
//
if ((filename == NULL) || (strlen(filename) == 0)) {
return NULL;
}
TextureClass *newtex = Find_Texture(filename, hsv_shift);
if (!newtex) {
// No cached texture - need to create
char lower_case_name[255];
strcpy(lower_case_name, filename);
_strlwr(lower_case_name);
TextureClass *oldtex = TextureHash.Get(lower_case_name);
if (!oldtex) {
oldtex = NEW_REF(TextureClass,(lower_case_name, NULL, mip_level_count));
TextureHash.Insert(oldtex->Get_Texture_Name(), oldtex);
}
newtex = Recolor_Texture_One_Time(oldtex, hsv_shift);
// If the recolorization failed, return the original texture
if (!newtex) {
newtex = oldtex;
newtex->Add_Ref();
}
}
return newtex;
}
}
void W3DAssetManager::Recolor_Vertex_Material(VertexMaterialClass *vmat, const Vector3 &hsv_shift)
{
Vector3 rgb;
vmat->Get_Ambient(&rgb);
Recolor(rgb,hsv_shift);
vmat->Set_Ambient(rgb);
vmat->Get_Diffuse(&rgb);
Recolor(rgb,hsv_shift);
vmat->Set_Diffuse(rgb);
vmat->Get_Emissive(&rgb);
Recolor(rgb,hsv_shift);
vmat->Set_Emissive(rgb);
vmat->Get_Specular(&rgb);
Recolor(rgb,hsv_shift);
vmat->Set_Specular(rgb);
}
void W3DAssetManager::Recolor_Vertices(unsigned int *color, int count, const Vector3 &hsv_shift)
{
int i;
Vector4 rgba;
for (i=0; i<count; i++)
{
rgba=DX8Wrapper::Convert_Color(color[i]);
Recolor(reinterpret_cast<Vector3&>(rgba),hsv_shift);
color[i]=DX8Wrapper::Convert_Color_Clamp(rgba);
}
}
TextureClass * W3DAssetManager::Recolor_Texture(TextureClass *texture, const Vector3 &hsv_shift)
{
const char *name=texture->Get_Texture_Name();
TextureClass *newtex = Find_Texture(name, hsv_shift);
if (newtex) {
return newtex;
}
return Recolor_Texture_One_Time(texture, hsv_shift);
}
TextureClass * W3DAssetManager::Recolor_Texture_One_Time(TextureClass *texture, const Vector3 &hsv_shift)
{
const char *name=texture->Get_Texture_Name();
// if texture is procedural return NULL
if (name && name[0]=='!') return NULL;
// make sure texture is loaded
if (!texture->Is_Initialized())
TextureLoader::Request_High_Priority_Loading(texture, (TextureClass::MipCountType)texture->Get_Mip_Level_Count());
SurfaceClass::SurfaceDescription desc;
SurfaceClass *newsurf, *oldsurf, *smallsurf;
texture->Get_Level_Description(desc);
// if texture is monochrome and no value shifting
// return NULL
smallsurf=texture->Get_Surface_Level((TextureClass::MipCountType)texture->Get_Mip_Level_Count()-1);
if (smallsurf == NULL)
{
DEBUG_LOG(("Can't recolor texture %s: no surface, device lost?\n", name));
return NULL;
}
if (hsv_shift.Z==0.0f && smallsurf->Is_Monochrome())
{
REF_PTR_RELEASE(smallsurf);
return NULL;
}
REF_PTR_RELEASE(smallsurf);
oldsurf=texture->Get_Surface_Level();
newsurf=NEW_REF(SurfaceClass,(desc.Width,desc.Height,desc.Format));
// Lost device: see the same check in the team-colour Recolor_Texture_One_Time.
if (oldsurf == NULL || newsurf->Peek_D3D_Surface() == NULL)
{
DEBUG_LOG(("Can't recolor texture %s: no surface, device lost?\n", name));
REF_PTR_RELEASE(oldsurf);
REF_PTR_RELEASE(newsurf);
return NULL;
}
newsurf->Copy(0,0,0,0,desc.Width,desc.Height,oldsurf);
newsurf->Hue_Shift(hsv_shift);
TextureClass * newtex=NEW_REF(TextureClass,(newsurf,(TextureClass::MipCountType)texture->Get_Mip_Level_Count()));
newtex->Set_Mag_Filter(texture->Get_Mag_Filter());
newtex->Set_Min_Filter(texture->Get_Min_Filter());
newtex->Set_Mip_Mapping(texture->Get_Mip_Mapping());
newtex->Set_U_Addr_Mode(texture->Get_U_Addr_Mode());
newtex->Set_V_Addr_Mode(texture->Get_V_Addr_Mode());
char newname[MUNGED_NAME_SIZE];
Munge_Texture_Name(newname, name, hsv_shift);
newtex->Set_Texture_Name(newname);
TextureHash.Insert(newtex->Get_Texture_Name(), newtex);
newtex->Add_Ref();
REF_PTR_RELEASE(oldsurf);
REF_PTR_RELEASE(newsurf);
return newtex;
}
TextureClass * W3DAssetManager::Find_Texture(const char * name, const Vector3 &hsv_shift)
{
char newname[MUNGED_NAME_SIZE];
Munge_Texture_Name(newname, name, hsv_shift);
// see if we have a cached copy
TextureClass *newtex = TextureHash.Get(newname);
if (newtex) {
newtex->Add_Ref();
}
return newtex;
}
void W3DAssetManager::Recolor_Mesh(RenderObjClass *robj, const Vector3 &hsv_shift)
{
int i;
MeshClass *mesh=(MeshClass*) robj;
MeshModelClass * model = mesh->Get_Model();
MaterialInfoClass *material = mesh->Get_Material_Info();
// recolor vertex material
for (i=0; i<material->Vertex_Material_Count(); i++)
Recolor_Vertex_Material(material->Peek_Vertex_Material(i),hsv_shift);
// recolor color arrays
unsigned int * color;
color=model->Get_Color_Array(0,false);
if (color) Recolor_Vertices(color,model->Get_Vertex_Count(),hsv_shift);
color=model->Get_Color_Array(1,false);
if (color) Recolor_Vertices(color,model->Get_Vertex_Count(),hsv_shift);
// recolor textures
TextureClass *newtex,*oldtex;
for (i=0; i<material->Texture_Count(); i++)
{
oldtex=material->Peek_Texture(i);
newtex=Recolor_Texture(oldtex,hsv_shift);
if (newtex)
{
model->Replace_Texture(oldtex,newtex);
material->Replace_Texture(i,newtex);
REF_PTR_RELEASE(newtex);
}
}
REF_PTR_RELEASE(material);
REF_PTR_RELEASE(model);
}
void W3DAssetManager::Recolor_HLOD(RenderObjClass *robj, const Vector3 &hsv_shift)
{
int num_sub = robj->Get_Num_Sub_Objects();
for(int i = 0; i < num_sub; i++) {
RenderObjClass *sub_obj = robj->Get_Sub_Object(i);
Recolor_Asset(sub_obj,hsv_shift);
REF_PTR_RELEASE(sub_obj);
}
}
void W3DAssetManager::Recolor_ParticleEmitter(RenderObjClass *robj, const Vector3 &hsv_shift)
{
unsigned int i;
ParticleEmitterClass* emit=(ParticleEmitterClass*) robj;
ParticlePropertyStruct<Vector3> colors;
emit->Get_Color_Key_Frames(colors);
Recolor(colors.Start,hsv_shift);
Recolor(colors.Rand,hsv_shift);
for (i=0; i<colors.NumKeyFrames; i++)
Recolor(colors.Values[i],hsv_shift);
emit->Reset_Colors(colors);
delete colors.Values;
delete colors.KeyTimes;
TextureClass *tex=emit->Get_Texture();
TextureClass *newtex=Recolor_Texture(tex,hsv_shift);
if (newtex)
{
emit->Set_Texture(newtex);
REF_PTR_RELEASE(newtex);
}
REF_PTR_RELEASE(tex);
}
void W3DAssetManager::Recolor_Asset(RenderObjClass *robj, const Vector3 &hsv_shift)
{
switch (robj->Class_ID()) {
case RenderObjClass::CLASSID_MESH:
Recolor_Mesh(robj,hsv_shift);
break;
case RenderObjClass::CLASSID_HLOD:
Recolor_HLOD(robj,hsv_shift);
break;
case RenderObjClass::CLASSID_PARTICLEEMITTER:
Recolor_ParticleEmitter(robj,hsv_shift);
break;
}
}
*/