//========= Copyright Valve Corporation, All rights reserved. ============//

//

// Purpose:

//

// $NoKeywords: $

//

//===========================================================================//

#ifndef IMATERIAL_H

#define IMATERIAL_H

#ifdef _WIN32

#pragma once

#endif

#include "bitmap/imageformat.h"

#include "materialsystem/imaterialsystem.h"

//-----------------------------------------------------------------------------

// forward declaraions

//-----------------------------------------------------------------------------

class IMaterialVar;

class ITexture;

class IMaterialProxy;

class Vector;

//-----------------------------------------------------------------------------

// Flags for GetVertexFormat

//-----------------------------------------------------------------------------

#define VERTEX_POSITION 0x0001

#define VERTEX_NORMAL 0x0002

#define VERTEX_COLOR 0x0004

#define VERTEX_SPECULAR 0x0008

#define VERTEX_TANGENT_S 0x0010

#define VERTEX_TANGENT_T 0x0020

#define VERTEX_TANGENT_SPACE ( VERTEX_TANGENT_S | VERTEX_TANGENT_T )

// Indicates we're using wrinkle

#define VERTEX_WRINKLE 0x0040

// Indicates we're using bone indices

#define VERTEX_BONE_INDEX 0x0080

// Indicates this is a vertex shader

#define VERTEX_FORMAT_VERTEX_SHADER 0x0100

// Indicates this format shouldn't be bloated to cache align it

// (only used for VertexUsage)

#define VERTEX_FORMAT_USE_EXACT_FORMAT 0x0200

// Indicates that compressed vertex elements are to be used (see also VertexCompressionType_t)

#define VERTEX_FORMAT_COMPRESSED 0x400

// Update this if you add or remove bits...

#define VERTEX_LAST_BIT 10

#define VERTEX_BONE_WEIGHT_BIT (VERTEX_LAST_BIT + 1)

#define USER_DATA_SIZE_BIT (VERTEX_LAST_BIT + 4)

#define TEX_COORD_SIZE_BIT (VERTEX_LAST_BIT + 7)

#define VERTEX_BONE_WEIGHT_MASK ( 0x7 << VERTEX_BONE_WEIGHT_BIT )

#define USER_DATA_SIZE_MASK ( 0x7 << USER_DATA_SIZE_BIT )

#define VERTEX_FORMAT_FIELD_MASK 0x0FF

// If everything is off, it's an unknown vertex format

#define VERTEX_FORMAT_UNKNOWN 0

//-----------------------------------------------------------------------------

// Macros for construction..

//-----------------------------------------------------------------------------

#define VERTEX_BONEWEIGHT( _n ) ((_n) << VERTEX_BONE_WEIGHT_BIT)

#define VERTEX_USERDATA_SIZE( _n ) ((_n) << USER_DATA_SIZE_BIT)

#define VERTEX_TEXCOORD_MASK( _coord ) (( 0x7ULL ) << ( TEX_COORD_SIZE_BIT + 3 * (_coord) ))

inline VertexFormat_t VERTEX_TEXCOORD_SIZE( int nIndex, int nNumCoords )

}

//-----------------------------------------------------------------------------

// Gets at various vertex format info...

//-----------------------------------------------------------------------------

inline int VertexFlags( VertexFormat_t vertexFormat )

{

return static_cast<int> ( vertexFormat & ( (1 << (VERTEX_LAST_BIT+1)) - 1 ) );

}

inline int NumBoneWeights( VertexFormat_t vertexFormat )

{

return static_cast<int> ( (vertexFormat >> VERTEX_BONE_WEIGHT_BIT) & 0x7 );

}

inline int UserDataSize( VertexFormat_t vertexFormat )

{

return static_cast<int> ( (vertexFormat >> USER_DATA_SIZE_BIT) & 0x7 );

}

inline int TexCoordSize( int nTexCoordIndex, VertexFormat_t vertexFormat )

{

return static_cast<int> ( (vertexFormat >> (TEX_COORD_SIZE_BIT + 3*nTexCoordIndex) ) & 0x7 );

}

inline bool UsesVertexShader( VertexFormat_t vertexFormat )

{

return (vertexFormat & VERTEX_FORMAT_VERTEX_SHADER) != 0;

}

inline VertexCompressionType_t CompressionType( VertexFormat_t vertexFormat )

}

//-----------------------------------------------------------------------------

// VertexElement_t (enumerates all usable vertex elements)

//-----------------------------------------------------------------------------

// FIXME: unify this with VertexFormat_t (i.e. construct the lower bits of VertexFormat_t with "1 << (VertexElement_t)element")

enum VertexElement_t

};

inline void Detect_VertexElement_t_Changes( VertexElement_t element ) // GREPs for VertexElement_t will hit this

}

// We're testing 2 normal compression methods

// One compressed normals+tangents into a SHORT2 each (8 bytes total)

// The other compresses them together, into a single UBYTE4 (4 bytes total)

// FIXME: pick one or the other, compare lighting quality in important cases

#define COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 0

#define COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 1

//#define COMPRESSED_NORMALS_TYPE COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2

#define COMPRESSED_NORMALS_TYPE COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4

inline int GetVertexElementSize( VertexElement_t element, VertexCompressionType_t compressionType )

}

//-----------------------------------------------------------------------------

// Shader state flags can be read from the FLAGS materialvar

// Also can be read or written to with the Set/GetMaterialVarFlags() call

// Also make sure you add/remove a string associated with each flag below to CShaderSystem::ShaderStateString in ShaderSystem.cpp

//-----------------------------------------------------------------------------

enum MaterialVarFlags_t

};

//-----------------------------------------------------------------------------

// Internal flags not accessible from outside the material system. Stored in Flags2

//-----------------------------------------------------------------------------

enum MaterialVarFlags2_t

};

//-----------------------------------------------------------------------------

// Preview image return values

//-----------------------------------------------------------------------------

enum PreviewImageRetVal_t

};

//-----------------------------------------------------------------------------

// material interface

//-----------------------------------------------------------------------------

abstract_class IMaterial

{

public:

// Get the name of the material. This is a full path to

// the vmt file starting from "hl2/materials" (or equivalent) without

// a file extension.

virtual const char * GetName() const = 0;

virtual const char * GetTextureGroupName() const = 0;

// Get the preferred size/bitDepth of a preview image of a material.

// This is the sort of image that you would use for a thumbnail view

// of a material, or in WorldCraft until it uses materials to render.

// separate this for the tools maybe

virtual PreviewImageRetVal_t GetPreviewImageProperties( int *width, int *height,

ImageFormat *imageFormat, bool* isTranslucent ) const = 0;

// Get a preview image at the specified width/height and bitDepth.

// Will do resampling if necessary.(not yet!!! :) )

// Will do color format conversion. (works now.)

virtual PreviewImageRetVal_t GetPreviewImage( unsigned char *data,

int width, int height,

ImageFormat imageFormat ) const = 0;

//

virtual int GetMappingWidth( ) = 0;

virtual int GetMappingHeight( ) = 0;

virtual int GetNumAnimationFrames( ) = 0;

// For material subrects (material pages). Offset(u,v) and scale(u,v) are normalized to texture.

virtual bool InMaterialPage( void ) = 0;

virtual void GetMaterialOffset( float *pOffset ) = 0;

virtual void GetMaterialScale( float *pScale ) = 0;

virtual IMaterial *GetMaterialPage( void ) = 0;

// find a vmt variable.

// This is how game code affects how a material is rendered.

// The game code must know about the params that are used by

// the shader for the material that it is trying to affect.

virtual IMaterialVar * FindVar( const char *varName, bool *found, bool complain = true ) = 0;

// The user never allocates or deallocates materials. Reference counting is

// used instead. Garbage collection is done upon a call to

// IMaterialSystem::UncacheUnusedMaterials.

virtual void IncrementReferenceCount( void ) = 0;

virtual void DecrementReferenceCount( void ) = 0;

inline void AddRef() { IncrementReferenceCount(); }

inline void Release() { DecrementReferenceCount(); }

// Each material is assigned a number that groups it with like materials

// for sorting in the application.

virtual int GetEnumerationID( void ) const = 0;

virtual void GetLowResColorSample( float s, float t, float *color ) const = 0;

// This computes the state snapshots for this material

virtual void RecomputeStateSnapshots() = 0;

// Are we translucent?

virtual bool IsTranslucent() = 0;

// Are we alphatested?

virtual bool IsAlphaTested() = 0;

// Are we vertex lit?

virtual bool IsVertexLit() = 0;

// Gets the vertex format

virtual VertexFormat_t GetVertexFormat() const = 0;

// returns true if this material uses a material proxy

virtual bool HasProxy( void ) const = 0;

virtual bool UsesEnvCubemap( void ) = 0;

virtual bool NeedsTangentSpace( void ) = 0;

virtual bool NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame = true ) = 0;

virtual bool NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame = true ) = 0;

// returns true if the shader doesn't do skinning itself and requires

// the data that is sent to it to be preskinned.

virtual bool NeedsSoftwareSkinning( void ) = 0;

// Apply constant color or alpha modulation

virtual void AlphaModulate( float alpha ) = 0;

virtual void ColorModulate( float r, float g, float b ) = 0;

// Material Var flags...

virtual void SetMaterialVarFlag( MaterialVarFlags_t flag, bool on ) = 0;

virtual bool GetMaterialVarFlag( MaterialVarFlags_t flag ) const = 0;

// Gets material reflectivity

virtual void GetReflectivity( Vector& reflect ) = 0;

// Gets material property flags

virtual bool GetPropertyFlag( MaterialPropertyTypes_t type ) = 0;

// Is the material visible from both sides?

virtual bool IsTwoSided() = 0;

// Sets the shader associated with the material

virtual void SetShader( const char *pShaderName ) = 0;

// Can't be const because the material might have to precache itself.

virtual int GetNumPasses( void ) = 0;

// Can't be const because the material might have to precache itself.

virtual int GetTextureMemoryBytes( void ) = 0;

// Meant to be used with materials created using CreateMaterial

// It updates the materials to reflect the current values stored in the material vars

virtual void Refresh() = 0;

// GR - returns true is material uses lightmap alpha for blending

virtual bool NeedsLightmapBlendAlpha( void ) = 0;

// returns true if the shader doesn't do lighting itself and requires

// the data that is sent to it to be prelighted

virtual bool NeedsSoftwareLighting( void ) = 0;

// Gets at the shader parameters

virtual int ShaderParamCount() const = 0;

virtual IMaterialVar **GetShaderParams( void ) = 0;

// Returns true if this is the error material you get back from IMaterialSystem::FindMaterial if

// the material can't be found.

virtual bool IsErrorMaterial() const = 0;

virtual void SetUseFixedFunctionBakedLighting( bool bEnable ) = 0;

// Gets the current alpha modulation

virtual float GetAlphaModulation() = 0;

virtual void GetColorModulation( float *r, float *g, float *b ) = 0;

// Gets the morph format

virtual MorphFormat_t GetMorphFormat() const = 0;

// fast find that stores the index of the found var in the string table in local cache

virtual IMaterialVar * FindVarFast( char const *pVarName, unsigned int *pToken ) = 0;

// Sets new VMT shader parameters for the material

virtual void SetShaderAndParams( KeyValues *pKeyValues ) = 0;

virtual const char * GetShaderName() const = 0;

virtual void DeleteIfUnreferenced() = 0;

virtual bool IsSpriteCard() = 0;

virtual void CallBindProxy( void *proxyData ) = 0;

virtual IMaterial *CheckProxyReplacement( void *proxyData ) = 0;

virtual void RefreshPreservingMaterialVars() = 0;

virtual bool WasReloadedFromWhitelist() = 0;

virtual bool IsPrecached() const = 0;

};

inline bool IsErrorMaterial( IMaterial *pMat )

{

return !pMat || pMat->IsErrorMaterial();

}

#endif // IMATERIAL_H