#pragma once
//-
// ===========================================================================
// Copyright 2018 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
//+
//
// CLASS:	MStateManager
//
// ****************************************************************************
//
// CLASS DESCRIPTION (MStateManager)
//
//  MStateManager allows efficient access to GPU state information
//
// ****************************************************************************

#include <maya/MStatus.h>

OPENMAYA_MAJOR_NAMESPACE_OPEN

// ****************************************************************************
// NAMESPACE

namespace MHWRender
{

// ****************************************************************************
// DECLARATIONS


// ****************************************************************************
// CLASS DECLARATION (MStateManager)
//! \ingroup OpenMayaRender
//! \brief Class to allow efficient access to GPU state information
/*!
MStateManager can be used to provide efficient access to GPU state information
when drawing in MPxShaderOverride or MPxDrawOverride. It cannot be created by
the user, only accessed through MDrawContext.

MStateManager works with GPU state in blocks for efficiency. These blocks are:
blend state, rasterizer state, depth stencil state and sampler state. Each
state block is represented by a different class.

Users may acquire immutable instances of such classes by calling the relevant
acquire methods on the state manager using a descriptor object to indicate what
parameters the state block should have. Once acquired a state block may be held
throughout the session and used to set the state where needed. Acquiring state
blocks is relatively slow and expensive so it is recommended to avoid acquiring
them during draw. State blocks are not large and so holding the memory should
not be overly burdensome.

For more details about the specific state block types, see MBlendState,
MRasterizerState, MDepthStencilState and MSamplerState.
*/
class OPENMAYARENDER_EXPORT MStateManager
{
public:
	//! Indicates how to perform comparisons for buffers.
    OPENMAYA_ENUM(CompareMode,
		kCompareNever = 1,			//!< never True.
		kCompareLess = 2,			//!< True if less.
		kCompareEqual = 3,			//!< True if equal.
		kCompareLessEqual = 4,		//!< True if less or equal.
		kCompareGreater = 5,		//!< True if greater.
		kCompareNotEqual = 6,		//!< True if not equal.
		kCompareGreaterEqual = 7,	//!< True if greater or equal.
		kCompareAlways = 8			//!< Always true.
	);

	//! Indicates which shader the sampler applies to.
    OPENMAYA_ENUM(ShaderType,
		kNoShader,			//!< Shader type is unknown at this point
		kVertexShader,		//!< The vertex shader
		kGeometryShader,	//!< The geometry shader
		kPixelShader,		//!< The pixel or fragment shader
		kHullShader,		//!< The hull or pre-tesselation shader
		kDomainShader		//!< The domain or post-tesselation shader
	);

	static const MBlendState* acquireBlendState( const MBlendStateDesc& blendStateDesc, MStatus* ReturnStatus=NULL );
	static void releaseBlendState(const MBlendState* state);
	MStatus setBlendState( const MBlendState* blendState );
	const MBlendState* getBlendState( MStatus* ReturnStatus=NULL ) const;

	static const MRasterizerState* acquireRasterizerState( const MRasterizerStateDesc& rasterizerStateDesc, MStatus* ReturnStatus=NULL );
	static void releaseRasterizerState(const MRasterizerState* state);
	MStatus setRasterizerState( const MRasterizerState* rasterizerState );
	const MRasterizerState* getRasterizerState( MStatus* ReturnStatus=NULL ) const;

	static const MDepthStencilState* acquireDepthStencilState( const MDepthStencilStateDesc& desc, MStatus* ReturnStatus=NULL );
	static void releaseDepthStencilState(const MDepthStencilState* state);
	MStatus setDepthStencilState( const MDepthStencilState* depthStencilState );
	const MDepthStencilState* getDepthStencilState( MStatus* ReturnStatus=NULL ) const;

	static int getMaxSamplerCount();
	static const MSamplerState* acquireSamplerState( const MSamplerStateDesc& samplerStateDesc, MStatus* ReturnStatus=NULL );
	static void releaseSamplerState(const MSamplerState* state);
	MStatus	setSamplerState( ShaderType shader, int samplerIndex, const MSamplerState* samplerState );
	const MSamplerState* getSamplerState( ShaderType shader, int samplerIndex, MStatus* ReturnStatus=NULL ) const;

	static const char* className();

private:
	MStateManager(void* data);
	~MStateManager();

	static void samplerDescriptionFromState( void *state, MSamplerStateDesc & samplerDesc );

	void setData(void* data);
	void* fData;

	friend class MDrawContext;
	friend class MLightParameterInformation;
    friend class MRenderParameters;
};




// ****************************************************************************
// CLASS DECLARATION (MBlendState)
//! \ingroup OpenMayaRender
//! \brief Container class for an acquired GPU blend state.
/*!
MBlendState wraps an acquired composite GPU blend state. This blend state can
be used to set the current GPU blend state using
MStateManager::setBlendState(myBlendState).

Instances of MBlendState cannot be created or modified by users. You can read
the descriptor for an MBlendState using MBlendState::desc(), but you cannot set
or alter the descriptor directly.

MBlendState can only be obtained via MStateManager::acquireBlendState(). To use
MStateManager::acquireBlendState(), create and fill an MBlendStateDesc
instance with the requested state and pass it to
MStateManager::acquireBlendState() which will return the cached unique blend
state of that description. If the unique blend state did not previously exist
in the cache, it is created.

The information included in the blend state includes alpha to coverage enable,
independent blend enable, a global float4 blend factor, and an array of
blending descriptors, one for each target.

The advantages of using this class rather than setting blend states explicitly
are:

1. Since the states are cached internally, state setting is much faster than
setting individual states.
2. Since state is set through the Maya viewport API, Maya can maintain accurate
knowledge of the current GPU state, even in the presence of arbitrary plug-ins.
This also speeds state setup by reducing redundant state setting and OGL
queries.
3. The information is device aware, meaning that it will return the correct
results based on the current active device. For example it will return the
appropriate values for DirectX versus an OpenGL device.
*/
class OPENMAYARENDER_EXPORT MBlendState
{
public:
	//! Blend operations for hardware target blending.
    OPENMAYA_ENUM(BlendOperation,
		kAdd = 0x1,				//!< Add the source and destination together.
		kSubtract = 0x2,		//!< Destination minus source.
		kReverseSubtract = 0x3,	//!< Source minus destination.
		kMin = 0x4,				//!< The minimum of the source and destination.
		kMax = 0x5				//!< The maximum of the source and destination.
	);

	//! Specifies what value to use as blend factor with an optional pre-operation.
    OPENMAYA_ENUM(BlendOption,
		kZero = 1, 					//!< Blend factor is 0.
		kOne = 2, 					//!< Blend factor is 1.
		kSourceColor = 3, 			//!< Blend factor is source color, src.rgb.
		kInvSourceColor = 4, 		//!< Blend factor is the complement of the source color, (1 - src.rgb).
		kSourceAlpha = 5, 			//!< Blend factor is source alpha, src.a.
		kInvSourceAlpha = 6, 		//!< Blend factor is the complement of the source alpha, (1 - src.a).
		kSourceAlphaSat = 11,		//!< Blend factor is (f, f, f, 1); where f = saturate(src.a) between 0 and 1.
		kDestinationColor = 9,		//!< Blend factor is destination color, dst.rgb.
		kInvDestinationColor = 10,	//!< Blend factor is the complement of the destination color, (1 - dst.rgb).
		kDestinationAlpha = 7,		//!< Blend factor is destination alpha, dst.a.
		kInvDestinationAlpha = 8,	//!< Blend factor is the complement of the destination alpha, (1 - dst.a).
		kBothSourceAlpha = 12,		//!< Source blend factor is src.a, destination blend factor is (1- src.a).
		kBothInvSourceAlpha = 13,	//!< Source blend factor is (1- src.a), destination blend factor is src.a.
		kBlendFactor = 14, 			//!< Blend factor is the global blend factor specified by users.
		kInvBlendFactor = 15 		//!< Blend factor is the complement of the global blend factor, (1 - blendFactor.rgba).
	);

	//! A bitfield that indicates which color components(red, green, blue, alpha) are writable.
    OPENMAYA_ENUM(ChannelMask,
		kNoChannels   = 0,		//!< \nop
		kRedChannel   = 0x1,	//!< \nop
		kGreenChannel = 0x2,	//!< \nop
		kBlueChannel  = 0x4,	//!< \nop
		kAlphaChannel = 0x8,	//!< \nop
		kRGBChannels  = 0x7,	//!< \nop
		kRGBAChannels = 0xf 	//!< \nop
	);

	//! Maximum number of simulatanious render targets.
	static const int kMaxTargets = 8;

	const MBlendStateDesc& desc( MStatus* ReturnStatus=NULL ) const;

	static const char* className();

	void * resourceHandle() const;

OPENMAYA_PRIVATE:
    MBlendState( void *GPUBlendState );
	MBlendState();
	~MBlendState();

	void *fData;
	static MBlendStateDesc *fErrorDesc;
};

// ****************************************************************************
// CLASS DECLARATION (MTargetBlendDesc)
//! \ingroup OpenMayaRender
//! \brief Descriptor for a blend state for a single render target
/*!
This class holds the complete blend state for a single render target. The
blended result will be: result = !BlendEnable ? source :
blendOperation(sourceBlendOption(source), destinationBlendOption(destination));

MBlendStateDesc maintains an array of MTargetBlendDesc of size
MBlendState::kMaxTargets.
*/
class OPENMAYARENDER_EXPORT MTargetBlendDesc
{
public :
	bool						blendEnable;			//!< Enable blending on this target, default is false

	// Color blending controls
	MBlendState::BlendOption	sourceBlend;			//!< The blend factor for the source color, default is one
	MBlendState::BlendOption	destinationBlend;		//!< The blend factor for the destination color, default is zero
	MBlendState::BlendOperation	blendOperation;			//!< The blend operation, default is add

	// Alpha blending controls
	MBlendState::BlendOption	alphaSourceBlend;		//!< The blend factor for the source alpha, default is one
	MBlendState::BlendOption	alphaDestinationBlend;	//!< The blend factor for the destination alpha, default is zero
	MBlendState::BlendOperation	alphaBlendOperation;	//!< The blend operation for alpha, default is add

	MBlendState::ChannelMask	targetWriteMask;		//!< Indicates what color components(red, green, blue, alpha) are writable, the default is RGBA.

	MTargetBlendDesc();
	~MTargetBlendDesc();

	void setDefaults();

BEGIN_NO_SCRIPT_SUPPORT:
	//! NO SCRIPT SUPPORT
	MTargetBlendDesc(const MTargetBlendDesc& rDesc);
	//! NO SCRIPT SUPPORT
	MTargetBlendDesc& operator=(const MTargetBlendDesc& rDesc);
END_NO_SCRIPT_SUPPORT:

	static const char* className();
};

// ****************************************************************************
// CLASS DECLARATION (MBlendStateDesc)
//! \ingroup OpenMayaRender
//! \brief Descriptor for a complete blend state
/*!
This class describes a complete blending state, including the blending state
for all targets.
*/
class OPENMAYARENDER_EXPORT MBlendStateDesc
{
public:
	bool				alphaToCoverageEnable;		//!< Enable alpha to coverage. Default false.
	bool				independentBlendEnable;		//!< Use TargetBlends[0] if false or individual blend states if true. Default false.
	float				blendFactor[4];				//!< Global blend factor, default (1,1,1,1).
	unsigned int		multiSampleMask;			/*!< Each bit in this mask, starting at the least significant bit (LSB),
														 controls modification of one of the samples in a multisample render
														 target. Thus, for an 8-sample render target, the low byte contains the eight
														 write enables for each of the eight samples. The actual location of the
														 samples is determined by the GPU sample pattern, which is not in general known
														 or controlled directly by applications. Default 0xffffffff.
														*/
	MTargetBlendDesc	targetBlends[ MBlendState::kMaxTargets ]; //!< An array of 8 MTargetBlendDesc, one for each target.

	MBlendStateDesc();
	~MBlendStateDesc();

	void setDefaults();

BEGIN_NO_SCRIPT_SUPPORT:
	//! NO SCRIPT SUPPORT
	MBlendStateDesc(const MBlendStateDesc& rDesc);
	//! NO SCRIPT SUPPORT
	MBlendStateDesc& operator=(const MBlendStateDesc& rDesc);
END_NO_SCRIPT_SUPPORT:

	static const char* className();
};




// ****************************************************************************
// CLASS DECLARATION (MRasterizerState)
//! \ingroup OpenMayaRender
//! \brief Container class for an acquired complete GPU rasterizer state.
/*!
MRasterizerState wraps an acquired composite GPU rasterizer state. This
rasterizer state can be used to set the current GPU rasterizer state using
MStateManager::setRaserizerState(myRaserizerState).

Instances of MRasterizerState cannot be created or modified by users. You can
read the descriptor for an MRasterizerState using MRasterizerState::desc(),
but you cannot set or alter the descriptor directly.

MRasterizerState can only be obtained via
MStateManager::acquireRaserizerState(). To use
MStateManager::acquireRaserizerState(), create and fill an MRasterizerStateDesc
instance with the requested state and pass it to
MStateManager::acquireRaserizerState() which will return the cached unique
rasterizer state of that description. If the unique rasterizer state did not
previously exist in the cache, it is created.

The information included in the rasterizer state includes fill mode, culling
mode, anti-aliasing enables, depth bias information, depth clipping enable,
scissor clip enable, and whether CW or CCW winding is "front".

The advantages of using this class rather than setting rasterizer states
explicitly are:

1. Since the states are cached internally, state setting is much faster than
setting individual states.
2. Since state is set through the Maya viewport API, Maya can maintain accurate
knowledge of the current GPU state, even in the presence of arbitrary plug-ins.
This also speeds state setup by reducing redundant state setting and OGL
queries.
3. The information is device aware, meaning that it will return the correct
results based on the current active device. For example it will return the
appropriate values for DirectX versus an OpenGL device.
*/
class OPENMAYARENDER_EXPORT MRasterizerState
{
public:
	//! Indicates how to fill various primitives.
    OPENMAYA_ENUM(FillMode,
		kFillSolid = 3,		//!< Primitives are solid filled.
		kFillWireFrame = 2	//!< Primitives have only the wireframe edges drawn.
	);

	//! Indicates how to cull primitive faces during drawing.
    OPENMAYA_ENUM(CullMode,
		kCullNone = 1,		//!< Disables frontface/backface culling.
		kCullFront = 2,		//!< Culls front facing facets.
		kCullBack = 3		//!< Culls back facing facets.
	);

	const MRasterizerStateDesc& desc( MStatus* ReturnStatus=NULL ) const;

	static const char* className();

	void * resourceHandle() const;

OPENMAYA_PRIVATE:
	MRasterizerState( void *GPURasterizerState );
	MRasterizerState();
	~MRasterizerState();

	void *fData;

	static MRasterizerStateDesc* fErrorDesc;
};

// ****************************************************************************
// CLASS DECLARATION (MRasterizerStateDesc)
//! \ingroup OpenMayaRender
//! \brief Descriptor for a complete rasterizer state
/*!
This class describes a complete rasterizer state, like fill mode, cull mode,
depth bias, multisampling, point size, etc.
*/
class OPENMAYARENDER_EXPORT MRasterizerStateDesc
{
public:
	MRasterizerState::FillMode	fillMode;	//!< Select the primitive fill mode, default kFillSolid.
	MRasterizerState::CullMode	cullMode;	//!< Select the face culling mode, default kCullNone.
	bool		frontCounterClockwise;		//!< Select whether CW or CCW winding is used for "front" face, default false.
	bool		depthBiasIsFloat;			//!< Indicates that DepthBias is a float value, default false.
	float 		depthBias;					//!< DepthBias adds the given bias value to the rasterizer z value prior to depth testing.
	float		depthBiasClamp;				//!< Maximum value scaled depth bias can attain, default 0.
	float		slopeScaledDepthBias;		//!< Slope scaled depth bias value, default 0.
	bool		depthClipEnable;			//!< Enables HW automatic depth clipping, default true.
	bool		scissorEnable;				//!< Enables HW scissor clip rectangle, default false.
	bool		multiSampleEnable;			//!< Enables HW full screen multi-sample anti-aliasing, default false.
	bool		antialiasedLineEnable;  	//!< Enables HW anti-aliased lines, auto disabled by multi-sample AA, default false.

	MRasterizerStateDesc();
	~MRasterizerStateDesc();

	void setDefaults();

BEGIN_NO_SCRIPT_SUPPORT:
	//! NO SCRIPT SUPPORT
	MRasterizerStateDesc(const MRasterizerStateDesc& rDesc);
	//! NO SCRIPT SUPPORT
	MRasterizerStateDesc& operator =(const MRasterizerStateDesc& rDesc);
END_NO_SCRIPT_SUPPORT:

	static const char* className();
};




// ****************************************************************************
// CLASS DECLARATION (MDepthStencilState)
//! \ingroup OpenMayaRender
//! \brief Container class for an acquired complete GPU depth stencil state.
/*!
MDepthStencilState wraps an acquired composite GPU depth stencil state. This
depth stencil state can be used to set the current GPU depth stencil state
using MStateManager::setDepthStencilState(myDepthState).

Instances of MDepthStencilState cannot be created or modified by users. You can
read the descriptor for an MDepthStencilState using MDepthStencilState::desc(),
but you cannot set or alter the descriptor directly.

MDepthStencilState can only be obtained via
MStateManager::acquireDepthStencilState(). To use
MStateManager::acquireDepthStencilState(), create and fill an
MDepthStencilStateDesc instance with the requested state and pass it to
MStateManager::acquireDepthStencilState() which will return the cached unique
depth stencil state of that description. If the unique depth stencil state did
not previously exist in the cache, it is created.

The information included in the depth stencil state includes depth buffer
enable, depth buffer write enable, stencil enable, and separate stencil
operations for front faces and back faces.

The advantages of using this class rather than setting depth stencil states
explicitly are:

1. Since the states are cached internally, state setting is much faster than
setting individual states.
2. Since state is set through the Maya viewport API, Maya can maintain accurate
knowledge of the current GPU state, even in the presence of arbitrary plug-ins.
This also speeds state setup by reducing redundant state setting and OGL
queries.
3. The information is device aware, meaning that it will return the correct
results based on the current active device. For example it will return the
appropriate values for DirectX versus an OpenGL device.
*/
class OPENMAYARENDER_EXPORT MDepthStencilState
{
public:
	//! Describes the choices for stencil buffer operations.
    OPENMAYA_ENUM(StencilOperation,
		kKeepStencil = 1,			//!< Do not update the entry in the stencil buffer. This is the default value
		kZeroStencil = 2,			//!< Set the stencil-buffer entry to 0.
		kReplaceStencil = 3,		//!< Replace the stencil-buffer entry with a reference value.
		kIncrementStencilSat = 4,	//!< Increment the stencil buffer entry, clamping to the maximum value.
		kDecrementStencilSat = 5,	//!< Decrement the stencil buffer entry, clamping to zero.
		kInvertStencil = 6,			//!< Invert the bits in the stencil-buffer entry.
		kIncrementStencil = 7,		//!< Increment the stencil buffer entry, wrapping to zero if the new value exceeds the maximum value..
		kDecrementStencil = 8		//!< Decrement the stencil buffer entry, wrapping to the maximum value if the new value is less than zero
	);

	const MDepthStencilStateDesc& desc( MStatus* ReturnStatus=NULL ) const;

	static const char* className();

	void * resourceHandle() const;

OPENMAYA_PRIVATE:
	MDepthStencilState( void *GPUDepthStencilState );
	MDepthStencilState();
	~MDepthStencilState();

	void *fData;

	static MDepthStencilStateDesc*  fErrorDesc;
};

// ****************************************************************************
// CLASS DECLARATION (MStencilOpDesc)
//! \ingroup OpenMayaRender
//! \brief Descriptor for a depth-stencil operation
/*!
This class encapsulates a depth-stencil operation descriptor. There are
separate MStencilOpDesc stencil operation descriptors for front and back faces
in the depth stencil state.
*/
class OPENMAYARENDER_EXPORT MStencilOpDesc
{
public:
	MDepthStencilState::StencilOperation	stencilPassOp;		//!< Stencil op to use when the fragment passes the stencil test, default kKeepStencil.
	MDepthStencilState::StencilOperation	stencilFailOp;		//!< Stencil op to use when the fragment fails the stencil test, default kKeepStencil.
	MDepthStencilState::StencilOperation	stencilDepthFailOp;	//!< Stencil op to use when the fragment passes the depth test, default kKeepStencil.
	MStateManager::CompareMode				stencilFunc;		//!< Sets the stencil buffer comparison function, default kCompareAlways.

	MStencilOpDesc();
	~MStencilOpDesc();

	void setDefaults();

BEGIN_NO_SCRIPT_SUPPORT:
	//! NO SCRIPT SUPPORT
	MStencilOpDesc(const MStencilOpDesc& rDesc);
	//! NO SCRIPT SUPPORT
	MStencilOpDesc& operator=(const MStencilOpDesc& rDesc);
END_NO_SCRIPT_SUPPORT:

	static const char* className();
};

// ****************************************************************************
// CLASS DECLARATION (MStencilOpDesc)
//! \ingroup OpenMayaRender
//! \brief Descriptor for a complete depth-stencil state
/*!
This class encapsulates a complete depth-stencil state, like z buffer enable,
z write enable, z comparison function, stencil enable, stencil masks and
reference values. It also contains MStencilOpDesc stencil operation descriptors
for front and back faces.
*/
class OPENMAYARENDER_EXPORT MDepthStencilStateDesc
{
public:
	bool			depthEnable;		//!< Enables depth buffer reads and compares, default true.
	bool			depthWriteEnable;	//!< Enables depth buffer writes, default true.
	MStateManager::CompareMode depthFunc; //!< Sets the depth buffer comparison function, default less than.
	bool			stencilEnable;		//!< Enables stencil buffer operation.
	unsigned char	stencilReadMask;	//!< Sets a bitwise stencil buffer read mask, default 0xff.
	unsigned char	stencilWriteMask;	//!< Sets a bitwise stencil buffer write mask, default 0xff.
	int				stencilReferenceVal;//!< Sets the stencil reference value.
	MStencilOpDesc frontFace;	//!< Sets the stencil op for the front facing fragments.
	MStencilOpDesc backFace;	//!< Sets the stencil op for the back facing fragments.

	MDepthStencilStateDesc();
	~MDepthStencilStateDesc();

	void setDefaults();

BEGIN_NO_SCRIPT_SUPPORT:
	//! NO SCRIPT SUPPORT
	MDepthStencilStateDesc(const MDepthStencilStateDesc& rDesc);
	//! NO SCRIPT SUPPORT
	MDepthStencilStateDesc& operator =(const MDepthStencilStateDesc& rDesc);
END_NO_SCRIPT_SUPPORT:

	static const char* className();
};




// ****************************************************************************
// CLASS DECLARATION (MSamplerState)
//! \ingroup OpenMayaRender
//! \brief Container class for an acquired complete GPU sampler state.
/*!
MSamplerState wraps an acquired composite GPU sampler state. This sampler state
can be used to set the current GPU sampler state using
MStateManager::setSamplerState(myShader, 0, mySamplerState).

Instances of MSamplerState cannot be created or modified by users. You can read
the descriptor for an MSamplerState using MSamplerState::desc(), but you cannot
set or alter the descriptor directly.

MSamplerState can only be obtained via MStateManager::acquireSamplerState().
To use MStateManager::acquireSamplerState(), create and fill an
MSamplerStateDesc instance with the requested state and pass it to
MStateManager::acquireSamplerState() which will return the cached unique
sampler state of that description. If the unique sampler state did not
previously exist in the cache, it is created.

The information included in the sampler state includes texture filter
selection, texture address mode selection, mip LOD controls,
anisotropy control, and the border color.

Any single given sampler state can be bound to as many GPU sampler stages as
needed.

The advantages of using this class rather than setting sampler states
explicitly are:

1. Since the states are cached internally, state setting is much faster than
setting individual states.
2. Since state is set through the Maya viewport API, Maya can maintain accurate
knowledge of the current GPU state, even in the presence of arbitrary plug-ins.
This also speeds state setup by reducing redundant state setting and OGL
queries.
3. The information is device aware, meaning that it will return the correct
results based on the current active device. For example it will return the
appropriate values for DirectX versus an OpenGL device.
*/
class OPENMAYARENDER_EXPORT MSamplerState
{
public:
	//! Indicates how to filter a texture sample.
    OPENMAYA_ENUM(TextureFilter,
		kMinMagMipPoint = 0,					//!< Use point sampling for minification, magnification, and mip-level sampling.
		kMinMagPoint_MipLinear = 1,				//!< Use point sampling for minification and magnification; use linear interpolation for mip-level sampling.
		kMinPoint_MagLinear_MipPoint = 0x4,		//!< Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling.
		kMinPoint_MagMipLinear = 0x5,			//!< Use point sampling for minification; use linear interpolation for magnification and mip-level sampling.
		kMinLinear_MagMipPoint = 0x10,			//!< Use linear interpolation for minification; use point sampling for magnification and mip-level sampling.
		kMinLinear_MagPoint_MipLinear = 0x11,	//!< Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling.
		kMinMagLinear_MipPoint = 0x14,			//!< Use linear interpolation for minification and magnification; use point sampling for mip-level sampling.
		kMinMagMipLinear = 0x15,				//!< Use linear interpolation for minification, magnification, and mip-level sampling.
		kAnisotropic = 0x55						//!< Use anisotropic filtering for minification, magnification, and mip-level sampling
	);

	//! Indicates how to handle texture addresses beyond the canonical (0..1, 0..1) range.
    OPENMAYA_ENUM(TextureAddress,
		kTexWrap   = 1,	//!< Wrap addresses beyond the [0,1] tile back into the [0.1] range, repeating the texture over the surface.
		kTexMirror = 2,	//!< Similar to wrap, but with odd tiles mirrored in u and v.
		kTexClamp  = 3, //!< Clamp address in the [0, 1] range. Extends edge pixels beyond range.
		kTexBorder = 4  //!< Clamp samples out of [0, 1] range to border color.
	);

	const MSamplerStateDesc& desc( MStatus* ReturnStatus=NULL ) const;

	static const char* className();

	void * resourceHandle() const;

private:
	MSamplerState( void *GPUSamplerState );
	MSamplerState();
	~MSamplerState();

	void *fData;

	friend class MStateManager;
	friend class MShaderInstance;
	static MSamplerStateDesc*  fErrorDesc;
    friend class MRenderParameters;
};

// ****************************************************************************
// CLASS DECLARATION (MStencilOpDesc)
//! \ingroup OpenMayaRender
//! \brief Descriptor for a complete sampler state
/*!
This class encapsulates a complete Sampler state.
*/
class OPENMAYARENDER_EXPORT MSamplerStateDesc
{
public:
	MSamplerState::TextureFilter  filter;		//!< Selects how to filter a texture sample, default kMinMagMipPoint.
	MStateManager::CompareMode    comparisonFn;	//!< Selects the filter comparison function, default kCompareAlways.
	MSamplerState::TextureAddress addressU;		//!< Select the u coordinate addressing mode, default kTexWrap.
	MSamplerState::TextureAddress addressV;		//!< Select the v coordinate addressing mode, default kTexWrap.
	MSamplerState::TextureAddress addressW;		//!< Select the w coordinate addressing mode, default kTexWrap.
	float			borderColor[4];	//!< Set border color used for accesses beyond texture 0..1, default(0,0,0,0).
	float			mipLODBias;		//!< Set a float bias to be added to the computed mip LOD level, default 0.
	unsigned int	minLOD;			//!< Set minimum mip LOD level accessed, default 0.
	unsigned int	maxLOD;			//!< Set maximum mip LOD level accessed, default 16.
	unsigned int	maxAnisotropy;	//!< Set the maximum anisotropy permitted for anisotropic filters. The range is 1..16, default 1.
	unsigned int	coordCount;		//!< Set the number of texture coordinates, default 2.
	unsigned int	elementIndex;	//!< When using texture arrays, selects array element, default 0.

	MSamplerStateDesc();
	~MSamplerStateDesc();

	void setDefaults();

BEGIN_NO_SCRIPT_SUPPORT:
	//! NO SCRIPT SUPPORT
	MSamplerStateDesc(const MSamplerStateDesc& rDesc);
	//! NO SCRIPT SUPPORT
	MSamplerStateDesc& operator=(const MSamplerStateDesc& rDesc);
END_NO_SCRIPT_SUPPORT:

	static const char* className();
OPENMAYA_PRIVATE:
};

} // namespace MHWRender

OPENMAYA_NAMESPACE_CLOSE