This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/texture.h

313 lines
11 KiB
C++

/*
** 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:: /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