nvstatemanager.h

游戏编程精华02－含有几十个游戏编程例子

		SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
		SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		SetTextureStageState(2, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
		SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
		SetTextureStageState(2, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		SetTextureStageState(2, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(3, D3DTSS_COLOROP, D3DTOP_DISABLE);
		SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
		SetTextureStageState(3, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
		SetTextureStageState(3, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		SetTextureStageState(3, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(4, D3DTSS_COLOROP, D3DTOP_DISABLE);
		SetTextureStageState(4, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		SetTextureStageState(4, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
		SetTextureStageState(4, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
		SetTextureStageState(4, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		SetTextureStageState(4, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(5, D3DTSS_COLOROP, D3DTOP_DISABLE);
		SetTextureStageState(5, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		SetTextureStageState(5, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
		SetTextureStageState(5, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
		SetTextureStageState(5, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		SetTextureStageState(5, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(6, D3DTSS_COLOROP, D3DTOP_DISABLE);
		SetTextureStageState(6, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		SetTextureStageState(6, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
		SetTextureStageState(6, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
		SetTextureStageState(6, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		SetTextureStageState(6, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(7, D3DTSS_COLOROP, D3DTOP_DISABLE);
		SetTextureStageState(7, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		SetTextureStageState(7, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
		SetTextureStageState(7, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
		SetTextureStageState(7, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		SetTextureStageState(7, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
		SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
		SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, 2);
		SetTextureStageState(3, D3DTSS_TEXCOORDINDEX, 3);
		SetTextureStageState(4, D3DTSS_TEXCOORDINDEX, 4);
		SetTextureStageState(5, D3DTSS_TEXCOORDINDEX, 5);
		SetTextureStageState(6, D3DTSS_TEXCOORDINDEX, 6);
		SetTextureStageState(7, D3DTSS_TEXCOORDINDEX, 7);
		
		SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(1, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(1, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(1, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(2, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(2, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(2, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(3, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(3, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(3, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(4, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(4, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(4, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(5, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(5, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(5, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(6, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(6, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(6, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(7, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(7, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
		SetTextureStageState(7, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

		SetTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(3, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(3, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(4, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(4, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(5, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(5, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(6, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(6, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
		SetTextureStageState(7, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
		SetTextureStageState(7, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);

		SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(4, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(5, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(6, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
		SetTextureStageState(7, D3DTSS_TEXTURETRANSFORMFLAGS, 0);

		SetTexture(0, NULL);
		SetTexture(1, NULL);
		SetTexture(2, NULL);
		SetTexture(3, NULL);
		SetTexture(4, NULL);
		SetTexture(5, NULL);
		SetTexture(6, NULL);
		SetTexture(7, NULL);

		SetPixelShader(0);
		SetVertexShader(D3DFVF_XYZ);

		SetVertexShaderConstant(0, D3DXVECTOR4(0.0f, 0.0f, 0.0f, 0.0f), NVSTATEMANAGER_MAX_VCONSTANTS);
		SetPixelShaderConstant(0, D3DXVECTOR4(0.0f, 0.0f, 0.0f, 0.0f), NVSTATEMANAGER_MAX_PCONSTANTS);
	
		FlushState();

		m_bForce = false;
	}

	// Material
	virtual void SaveMaterial(const D3DMATERIAL8* pMaterial)
	{
		// Check that we have set this up before, if not, the default is this.
		m_CopyState.m_D3DMaterial = m_CurrentState.m_D3DMaterial;
		SetMaterial(pMaterial);
	}

	virtual void RestoreMaterial()
	{
		SetMaterial(&m_CopyState.m_D3DMaterial);
	}

	virtual void SetMaterial(const D3DMATERIAL8* pMaterial)
	{
		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_MATERIAL));
		m_CurrentState.m_D3DMaterial = *pMaterial;
	}

	// Renderstates
	virtual void SaveRenderState(D3DRENDERSTATETYPE Type, DWORD dwValue)
	{
		// Check that we have set this up before, if not, the default is this.
		m_CopyState.m_RenderStates[Type] = m_CurrentState.m_RenderStates[Type];
		SetRenderState(Type, dwValue);
	}

	virtual void RestoreRenderState(D3DRENDERSTATETYPE Type)
	{
		SetRenderState(Type, m_CopyState.m_RenderStates[Type]);
	}

	virtual void SetRenderState(D3DRENDERSTATETYPE Type, DWORD Value)
	{
		assert(Type < NVSTATEMANAGER_MAX_RENDERSTATES);
		if (!m_bForce &&  (m_CurrentState.m_RenderStates[Type] == Value))
			return;

		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_RENDER, (DWORD)Type));
		m_CurrentState.m_RenderStates[Type] = Value;
	}

	// Textures
	virtual void SaveTexture(DWORD dwStage, LPDIRECT3DBASETEXTURE8 pTexture)
	{
		// Check that we have set this up before, if not, the default is this.
		m_CopyState.m_Textures[dwStage] = m_CurrentState.m_Textures[dwStage];
		SetTexture(dwStage, pTexture);
	}

	virtual void RestoreTexture(DWORD dwStage)
	{
		SetTexture(dwStage, m_CopyState.m_Textures[dwStage]);
	}

	virtual void SetTexture(DWORD dwStage, LPDIRECT3DBASETEXTURE8 pTexture)
	{
		assert(dwStage < NVSTATEMANAGER_MAX_STAGES);
		if (!m_bForce && (m_CurrentState.m_Textures[dwStage] == pTexture))
			return;

		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_TEXTURE, dwStage));
		m_CurrentState.m_Textures[dwStage] = pTexture;
	}

	// Texture stage states
	virtual void SaveTextureStageState(DWORD dwStage,D3DTEXTURESTAGESTATETYPE Type, DWORD dwValue)
	{
		// Check that we have set this up before, if not, the default is this.
		m_CopyState.m_TextureStates[dwStage][Type] = m_CurrentState.m_TextureStates[dwStage][Type];
		SetTextureStageState(dwStage, Type, dwValue);
	}

	virtual void RestoreTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE Type)
	{
		SetTextureStageState(dwStage, Type, m_CopyState.m_TextureStates[dwStage][Type]);
	}

	virtual void SetTextureStageState(DWORD dwStage,D3DTEXTURESTAGESTATETYPE Type, DWORD dwValue)
	{
		assert(dwStage < NVSTATEMANAGER_MAX_STAGES);
		assert(Type < NVSTATEMANAGER_MAX_TEXTURESTATES);
		if (!m_bForce && m_CurrentState.m_TextureStates[dwStage][Type] == dwValue)
			return;

		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_TEXTURESTAGE, dwStage, (DWORD)Type));
		m_CurrentState.m_TextureStates[dwStage][Type] = dwValue;
	}

	// Vertex Shader
	virtual void SaveVertexShader(DWORD dwShader)
	{
		m_CopyState.m_dwVertexShader = m_CurrentState.m_dwVertexShader;
		SetVertexShader(dwShader);
	}

	virtual void RestoreVertexShader()
	{
		SetVertexShader(m_CopyState.m_dwVertexShader);
	}

	virtual void SetVertexShader(DWORD dwShader)
	{
		if (!m_bForce && m_CurrentState.m_dwVertexShader == dwShader)
			return;

		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_VSHADER));
		m_CurrentState.m_dwVertexShader = dwShader;
	}

	// Pixel Shader
	virtual void SavePixelShader(DWORD dwShader)
	{
		m_CopyState.m_dwPixelShader = m_CurrentState.m_dwPixelShader;
		SetPixelShader(dwShader);
	}

	virtual void RestorePixelShader()
	{
		SetPixelShader(m_CopyState.m_dwPixelShader);
	}

	virtual void SetPixelShader(DWORD dwShader)
	{
		if (!m_bForce && m_CurrentState.m_dwPixelShader == dwShader)
			return;

		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_PSHADER));
		m_CurrentState.m_dwPixelShader = dwShader;
	}

	// *** These states are cached, but not protected from multiple sends of the same value.
	// Transform
	virtual void SaveTransform(D3DTRANSFORMSTATETYPE Transform, const D3DMATRIX* pMatrix)
	{
		m_CopyState.m_Matrices[Transform] = m_CurrentState.m_Matrices[Transform];
		SetTransform(Transform, (D3DXMATRIX*)pMatrix);
	}

	virtual void RestoreTransform(D3DTRANSFORMSTATETYPE Transform)
	{
		SetTransform(Transform, &m_CopyState.m_Matrices[Transform]);
	}

	// Don't cache-check the transform.  To much to do
	virtual void SetTransform(D3DTRANSFORMSTATETYPE Type, const D3DMATRIX* pMatrix)
	{
		assert(Type < NVSTATEMANAGER_MAX_TRANSFORMSTATES);
		assert(pMatrix);

		// Set the renderstate and remember it.
		m_DirtyStates.push_back(NVStateID(STATE_TRANSFORM, (DWORD)Type));
		m_CurrentState.m_Matrices[Type] = *pMatrix;
	}

	// SetVertexShaderConstant
	virtual void SaveVertexShaderConstant(DWORD dwRegister,CONST void* pConstantData,DWORD dwConstantCount)
	{
		DWORD i;
		for (i = 0; i < dwConstantCount; i++)
		{
			assert((dwRegister + i) < NVSTATEMANAGER_MAX_VCONSTANTS);
			
			m_CopyState.m_VertexShaderConstants[dwRegister + i] = m_CurrentState.m_VertexShaderConstants[dwRegister + i];
		}
		SetVertexShaderConstant(dwRegister, pConstantData, dwConstantCount);
	}

	virtual void RestoreVertexShaderConstant(DWORD dwRegister, DWORD dwConstantCount)
	{
		SetVertexShaderConstant(dwRegister, &m_CopyState.m_VertexShaderConstants[dwRegister], dwConstantCount);
	}

	virtual void SetVertexShaderConstant(DWORD dwRegister,CONST void* pConstantData,DWORD dwConstantCount)
	{
		DWORD i;
		
		assert(pConstantData);
		assert(dwRegister < NVSTATEMANAGER_MAX_VCONSTANTS);

		if (!m_bForce)
		{
			for (i = 0; i < dwConstantCount; i++)
			{	
				assert((dwRegister + i) < NVSTATEMANAGER_MAX_VCONSTANTS);
				if (m_CurrentState.m_VertexShaderConstants[dwRegister + i] != *(((D3DXVECTOR4*)pConstantData + i)))
					break;
			}
			if (i == dwConstantCount)
				return;
		}