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