/* ** 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 . */ /*********************************************************************************************** *** 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/texture.h $* * * * $Author:: Jani_p $* * * * $Modtime:: 11/09/01 5:16p $* * * * $Revision:: 44 $* * * *---------------------------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #if defined(_MSC_VER) #pragma once #endif #ifndef TEXTURE_H #define TEXTURE_H #include "always.h" #include "refcount.h" #include "chunkio.h" #include "surfaceclass.h" #include "ww3dformat.h" #include "wwstring.h" class DX8Wrapper; struct IDirect3DTexture8; class TextureLoader; class LoaderThreadClass; class DX8TextureManagerClass; class TextureLoadTaskClass; /************************************************************************* ** TextureClass ** ** This is our texture class. For legacy reasons it contains some ** information beyond the D3D texture itself, such as texture addressing ** modes. ** *************************************************************************/ class TextureClass : public RefCountClass { friend DX8Wrapper; friend TextureLoader; friend LoaderThreadClass; friend DX8TextureManagerClass; public: enum PoolType { POOL_DEFAULT=0, POOL_MANAGED, POOL_SYSTEMMEM }; enum FilterType { FILTER_TYPE_NONE, FILTER_TYPE_FAST, FILTER_TYPE_BEST, FILTER_TYPE_DEFAULT, FILTER_TYPE_COUNT }; enum TextureFilterMode { TEXTURE_FILTER_BILINEAR, TEXTURE_FILTER_TRILINEAR, TEXTURE_FILTER_ANISOTROPIC }; enum TxtAddrMode { TEXTURE_ADDRESS_REPEAT=0, TEXTURE_ADDRESS_CLAMP }; enum MipCountType { MIP_LEVELS_ALL=0, // generate all mipmap levels down to 1x1 size MIP_LEVELS_1, // no mipmapping at all (just one mip level) MIP_LEVELS_2, MIP_LEVELS_3, MIP_LEVELS_4, MIP_LEVELS_5, MIP_LEVELS_6, MIP_LEVELS_7, MIP_LEVELS_8, MIP_LEVELS_10, MIP_LEVELS_11, MIP_LEVELS_12, MIP_LEVELS_MAX // This isn't to be used (use MIP_LEVELS_ALL instead), it is just an enum for creating static tables etc. }; // Create texture with desired height, width and format. TextureClass( unsigned width, unsigned height, WW3DFormat format, MipCountType mip_level_count=MIP_LEVELS_ALL, PoolType pool=POOL_MANAGED, bool rendertarget=false); // Create texture from a file. If format is specified the texture is converted to that format. // Note that the format must be supported by the current device and that a texture can't exist // in the system with the same name in multiple formats. TextureClass( const char *name, const char *full_path=NULL, MipCountType mip_level_count=MIP_LEVELS_ALL, WW3DFormat texture_format=WW3D_FORMAT_UNKNOWN, bool allow_compression=true); // Create texture from a surface. TextureClass( SurfaceClass *surface, MipCountType mip_level_count=MIP_LEVELS_ALL); TextureClass(IDirect3DTexture8* d3d_texture); virtual ~TextureClass(void); // Names void Set_Texture_Name(const char * name); void Set_Full_Path(const char * path) { FullPath = path; } const StringClass& Get_Texture_Name(void) const { return Name; } const StringClass& Get_Full_Path(void) const { if (FullPath.Is_Empty ()) return Name; return FullPath; } unsigned Get_ID() const { return texture_id; } // Each textrure has a unique id // The number of Mip levels in the texture unsigned int Get_Mip_Level_Count(void); // Note! Width and Height may be zero and may change if texture uses mipmaps int Get_Width() { return Width; } int Get_Height() { return Height; } void Init(); // Time, after which the texture is invalidated if not used. Set to zero to indicate infinite. // Time is in milliseconds. void Set_Inactivation_Time(unsigned time) { InactivationTime=time; } int Get_Inactivation_Time() const { return InactivationTime; } // Get the surface of one of the mipmap levels (defaults to highest-resolution one) SurfaceClass *Get_Surface_Level(unsigned int level = 0); IDirect3DSurface8 *Get_D3D_Surface_Level(unsigned int level = 0); // Texture priority affects texture management and caching. unsigned int Get_Priority(void); unsigned int Set_Priority(unsigned int priority); // Returns previous priority // Filter and MIPmap settings: FilterType Get_Min_Filter(void) const { return TextureMinFilter; } FilterType Get_Mag_Filter(void) const { return TextureMagFilter; } FilterType Get_Mip_Mapping(void) const { return MipMapFilter; } void Set_Min_Filter(FilterType filter) { TextureMinFilter=filter; } void Set_Mag_Filter(FilterType filter) { TextureMagFilter=filter; } void Set_Mip_Mapping(FilterType mipmap); // Texture address mode TxtAddrMode Get_U_Addr_Mode(void) const { return UAddressMode; } TxtAddrMode Get_V_Addr_Mode(void) const { return VAddressMode; } void Set_U_Addr_Mode(TxtAddrMode mode) { UAddressMode=mode; } void Set_V_Addr_Mode(TxtAddrMode mode) { VAddressMode=mode; } // Debug utility functions for returning the texture memory usage unsigned Get_Texture_Memory_Usage() const; bool Is_Initialized() const { return Initialized; } bool Is_Lightmap() const { return IsLightmap; } bool Is_Procedural() const { return IsProcedural; } static int _Get_Total_Locked_Surface_Size(); static int _Get_Total_Texture_Size(); static int _Get_Total_Lightmap_Texture_Size(); static int _Get_Total_Procedural_Texture_Size(); static int _Get_Total_Locked_Surface_Count(); static int _Get_Total_Texture_Count(); static int _Get_Total_Lightmap_Texture_Count(); static int _Get_Total_Procedural_Texture_Count(); // This needs to be called after device has been created static void _Init_Filters(TextureFilterMode texture_filter); static void _Set_Default_Min_Filter(FilterType filter); static void _Set_Default_Mag_Filter(FilterType filter); static void _Set_Default_Mip_Filter(FilterType filter); // This utility function processes the texture reduction (used during rendering) void Invalidate(); IDirect3DTexture8 *Peek_DX8_Texture() { return D3DTexture; } bool Is_Missing_Texture(); // Support for self managed textures bool Is_Dirty() { WWASSERT(Pool==POOL_DEFAULT); return Dirty; }; void Clean() { Dirty=false; }; unsigned Get_Reduction() const; WW3DFormat Get_Texture_Format() const { return TextureFormat; } bool Is_Compression_Allowed() const { return IsCompressionAllowed; } // Inactivate textures that haven't been used in a while. Pass zero to use textures' // own inactive times (default). In urgent need to free up texture memory, try // calling with relatively small (just few seconds) time override to free up everything // but the currently used textures. static void Invalidate_Old_Unused_Textures(unsigned inactive_time_override); private: // Apply this texture's settings into D3D void Apply(unsigned int stage); void Load_Locked_Surface(); // Apply a Null texture's settings into D3D static void Apply_Null(unsigned int stage); // State not contained in the Direct3D texture object: FilterType TextureMinFilter; FilterType TextureMagFilter; FilterType MipMapFilter; TxtAddrMode UAddressMode; TxtAddrMode VAddressMode; // Direct3D texture object IDirect3DTexture8 *D3DTexture; bool Initialized; // Name StringClass Name; StringClass FullPath; // Unique id unsigned texture_id; // NOTE: Since "texture wrapping" (NOT TEXTURE WRAP MODE - THIS IS // SOMETHING ELSE) is a global state that affects all texture stages, // and this class only affects its own stage, we will not worry about // it for now. Later (probably when we implement world-oriented // environment maps) we will consider where to put it. // For debug purposes the texture sets this true if it is a lightmap texture bool IsLightmap; bool IsProcedural; bool IsCompressionAllowed; unsigned InactivationTime; // In milliseconds unsigned ExtendedInactivationTime; // This is set by the engine, if needed unsigned LastInactivationSyncTime; unsigned LastAccessed; WW3DFormat TextureFormat; int Width; int Height; // Support for self-managed textures PoolType Pool; bool Dirty; public: MipCountType MipLevelCount; private: friend class TextureLoadTaskClass; TextureLoadTaskClass* TextureLoadTask; // kind of a crazy merge point not sure if the public should have // been above the ThumbnailLoadTask or not. TextureLoadTaskClass* ThumbnailLoadTask; public: // Background texture loader will call this when texture has been loaded void Apply_New_Surface(IDirect3DTexture8* tex, bool initialized); // If the parameter is true, the texture will be flagged as initialised }; // Utility functions for loading and saving texture descriptions from/to W3D files TextureClass *Load_Texture(ChunkLoadClass & cload); void Save_Texture(TextureClass * texture, ChunkSaveClass & csave); #endif //TEXTURE_H