blois.cpp

著名的GPU Gems中的自然效果模拟-水效果的演示程序及全部实现源代码

{
	m_CompCosineParams.m_UTrans[0] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans0");
	m_CompCosineParams.m_UTrans[1] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans1");
	m_CompCosineParams.m_UTrans[2] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans2");
	m_CompCosineParams.m_UTrans[3] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans3");
	m_CompCosineParams.m_UTrans[4] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans4");
	m_CompCosineParams.m_UTrans[5] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans5");
	m_CompCosineParams.m_UTrans[6] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans6");
	m_CompCosineParams.m_UTrans[7] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans7");
	m_CompCosineParams.m_UTrans[8] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans8");
	m_CompCosineParams.m_UTrans[9] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans9");
	m_CompCosineParams.m_UTrans[10] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans10");
	m_CompCosineParams.m_UTrans[11] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans11");
	m_CompCosineParams.m_UTrans[12] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans12");
	m_CompCosineParams.m_UTrans[13] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans13");
	m_CompCosineParams.m_UTrans[14] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans14");
	m_CompCosineParams.m_UTrans[15] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans15");

	m_CompCosineParams.m_Coef[0] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef0");
	m_CompCosineParams.m_Coef[1] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef1");
	m_CompCosineParams.m_Coef[2] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef2");
	m_CompCosineParams.m_Coef[3] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef3");
	m_CompCosineParams.m_Coef[4] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef4");
	m_CompCosineParams.m_Coef[5] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef5");
	m_CompCosineParams.m_Coef[6] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef6");
	m_CompCosineParams.m_Coef[7] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef7");
	m_CompCosineParams.m_Coef[8] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef8");
	m_CompCosineParams.m_Coef[9] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef9");
	m_CompCosineParams.m_Coef[10] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef10");
	m_CompCosineParams.m_Coef[11] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef11");
	m_CompCosineParams.m_Coef[12] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef12");
	m_CompCosineParams.m_Coef[13] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef13");
	m_CompCosineParams.m_Coef[14] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef14");
	m_CompCosineParams.m_Coef[15] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef15");

	m_CompCosineParams.m_ReScale = m_CompCosinesEff->GetParameterByName(NULL, "cReScale");

	m_CompCosineParams.m_NoiseXform[0] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm0_00");
	m_CompCosineParams.m_NoiseXform[1] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm0_10");
	m_CompCosineParams.m_NoiseXform[2] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm1_00");
	m_CompCosineParams.m_NoiseXform[3] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm1_10");

	D3DXVECTOR4 init(20.f, 0.f, 0.f, 0.f);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[0], &init);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[2], &init);
	init.x = 0;
	init.y = 20.f;
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[1], &init);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[3], &init);

	m_CompCosineParams.m_ScaleBias = m_CompCosinesEff->GetParameterByName(NULL, "cScaleBias");

	m_CompCosineParams.m_CosineLUT = m_CompCosinesEff->GetParameterByName(NULL, "tCosineLUT");
	m_CompCosineParams.m_BiasNoise = m_CompCosinesEff->GetParameterByName(NULL, "tBiasNoise");
}

void CMyD3DApplication::SetCompCosineEffParams()
{
	int i;
	for( i = 0; i < 16; i++ )
	{
		D3DXVECTOR4 UTrans(m_TexWaves[i].m_RotScale.x, m_TexWaves[i].m_RotScale.y, 0.f, m_TexWaves[i].m_Phase);
		m_CompCosinesEff->SetVector(m_CompCosineParams.m_UTrans[i], &UTrans);

		float normScale = m_TexWaves[i].m_Fade / float(kNumBumpPasses);
		D3DXVECTOR4 Coef(m_TexWaves[i].m_Dir.x * normScale, m_TexWaves[i].m_Dir.y * normScale, 1.f, 1.f);
		m_CompCosinesEff->SetVector(m_CompCosineParams.m_Coef[i], &Coef);

	}

	D3DXVECTOR4 xform;
	
	const FLOAT kRate = 0.1f;
	m_CompCosinesEff->GetVector(m_CompCosineParams.m_NoiseXform[0], &xform);
	xform.w += m_fElapsedTime * kRate;
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[0], &xform);

	m_CompCosinesEff->GetVector(m_CompCosineParams.m_NoiseXform[3], &xform);
	xform.w += m_fElapsedTime * kRate;
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[3], &xform);

	float s = 0.5f / (float(kNumBumpPerPass) + m_TexState.m_Noise);
	D3DXVECTOR4 reScale(s, s, 1.f, 1.f);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_ReScale, &reScale);

	float scaleBias = 0.5f * m_TexState.m_Noise / (float(kNumBumpPasses) + m_TexState.m_Noise);
	D3DXVECTOR4 scaleBiasVec(scaleBias, scaleBias, 0.f, 1.f);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_ScaleBias, &scaleBiasVec);

	m_CompCosinesEff->SetTexture(m_CompCosineParams.m_CosineLUT, m_CosineLUT);
	m_CompCosinesEff->SetTexture(m_CompCosineParams.m_BiasNoise, m_BiasNoiseMap);
}

void CMyD3DApplication::InitGeoWaves()
{
	int i;
	for( i = 0; i < kNumGeoWaves; i++ )
		InitGeoWave(i);
}

void CMyD3DApplication::InitGeoWave(int i)
{
	m_GeoWaves[i].m_Phase = RandZeroToOne() * D3DX_PI * 2.f;
	m_GeoWaves[i].m_Len = m_GeoState.m_MinLength + RandZeroToOne() * (m_GeoState.m_MaxLength - m_GeoState.m_MinLength);
	m_GeoWaves[i].m_Amp = m_GeoWaves[i].m_Len * m_GeoState.m_AmpOverLen / float(kNumGeoWaves);
	m_GeoWaves[i].m_Freq = 2.f * D3DX_PI / m_GeoWaves[i].m_Len;
	m_GeoWaves[i].m_Fade = 1.f;

	float rotBase = m_GeoState.m_AngleDeviation * D3DX_PI / 180.f;

	float rads = rotBase * RandMinusOneToOne();
	float rx = float(cosf(rads));
	float ry = float(sinf(rads));

	float x = m_GeoState.m_WindDir.x;
	float y = m_GeoState.m_WindDir.y;
	m_GeoWaves[i].m_Dir.x = x * rx + y * ry;
	m_GeoWaves[i].m_Dir.y = x * -ry + y * rx;
}

void CMyD3DApplication::UpdateGeoWave(int i, FLOAT dt)
{
	if( i == m_GeoState.m_TransIdx )
	{
		m_GeoWaves[i].m_Fade += m_GeoState.m_TransDel * dt;
		if( m_GeoWaves[i].m_Fade < 0 )
		{
			// This wave is faded out. Re-init and fade it back up.
			InitGeoWave(i);
			m_GeoWaves[i].m_Fade = 0;
			m_GeoState.m_TransDel = -m_GeoState.m_TransDel;
		}
		else if( m_GeoWaves[i].m_Fade > 1.f )
		{
			// This wave is faded back up. Start fading another down.
			m_GeoWaves[i].m_Fade = 1.f;
			m_GeoState.m_TransDel = -m_GeoState.m_TransDel;
			if( ++m_GeoState.m_TransIdx >= kNumGeoWaves )
				m_GeoState.m_TransIdx = 0;
		}
	}

	const float speed = float(1.0 / sqrt(m_GeoWaves[i].m_Len / (2.f * D3DX_PI * kGravConst)));

	m_GeoWaves[i].m_Phase += speed * dt;
	m_GeoWaves[i].m_Phase = float(fmod(m_GeoWaves[i].m_Phase, 2.f*D3DX_PI));

	m_GeoWaves[i].m_Amp = m_GeoWaves[i].m_Len * m_GeoState.m_AmpOverLen / float(kNumGeoWaves) * m_GeoWaves[i].m_Fade;
}

void CMyD3DApplication::UpdateGeoWaves(FLOAT dt)
{
	int i;
	for( i = 0; i < kNumGeoWaves; i++ )
		UpdateGeoWave(i, dt);
}

void CMyD3DApplication::InitGeoState()
{
	m_GeoState.m_Chop = 2.5f;
	m_GeoState.m_AngleDeviation = 15.f;
	m_GeoState.m_WindDir.x = 0;
	m_GeoState.m_WindDir.y = 1.f;

	m_GeoState.m_MinLength = 15.f;
	m_GeoState.m_MaxLength = 25.f;
	m_GeoState.m_AmpOverLen = 0.1f;

	m_GeoState.m_EnvHeight = -50.f;
	m_GeoState.m_EnvRadius = 100.f;
	m_GeoState.m_WaterLevel = -2.f;

	m_GeoState.m_TransIdx = 0;
	m_GeoState.m_TransDel = -1.f / 6.f;

	m_GeoState.m_SpecAtten = 1.f;
	m_GeoState.m_SpecEnd = 200.f;
	m_GeoState.m_SpecTrans = 100.f;
}

void CMyD3DApplication::GetWaterParams()
{
	m_WaterParams.m_cWorld2NDC = m_WaterEff->GetParameterByName(NULL, "cWorld2NDC");
	m_WaterParams.m_cWaterTint = m_WaterEff->GetParameterByName(NULL, "cWaterTint");
	m_WaterParams.m_cFrequency = m_WaterEff->GetParameterByName(NULL, "cFrequency");
	m_WaterParams.m_cPhase = m_WaterEff->GetParameterByName(NULL, "cPhase");
	m_WaterParams.m_cAmplitude = m_WaterEff->GetParameterByName(NULL, "cAmplitude");
	m_WaterParams.m_cDirX = m_WaterEff->GetParameterByName(NULL, "cDirX");
	m_WaterParams.m_cDirY = m_WaterEff->GetParameterByName(NULL, "cDirY");
	m_WaterParams.m_cSpecAtten = m_WaterEff->GetParameterByName(NULL, "cSpecAtten");
	m_WaterParams.m_cCameraPos = m_WaterEff->GetParameterByName(NULL, "cCameraPos");
	m_WaterParams.m_cEnvAdjust = m_WaterEff->GetParameterByName(NULL, "cEnvAdjust");
	m_WaterParams.m_cEnvTint = m_WaterEff->GetParameterByName(NULL, "cEnvTint");
	m_WaterParams.m_cLocal2World = m_WaterEff->GetParameterByName(NULL, "cLocal2World");
	m_WaterParams.m_cLengths = m_WaterEff->GetParameterByName(NULL, "cLengths");
	m_WaterParams.m_cDepthOffset = m_WaterEff->GetParameterByName(NULL, "cDepthOffset");
	m_WaterParams.m_cDepthScale = m_WaterEff->GetParameterByName(NULL, "cDepthScale");
	m_WaterParams.m_cFogParams = m_WaterEff->GetParameterByName(NULL, "cFogParams");
	m_WaterParams.m_cDirXK = m_WaterEff->GetParameterByName(NULL, "cDirXK");
	m_WaterParams.m_cDirYK = m_WaterEff->GetParameterByName(NULL, "cDirYK");
	m_WaterParams.m_cDirXW = m_WaterEff->GetParameterByName(NULL, "cDirXW");
	m_WaterParams.m_cDirYW = m_WaterEff->GetParameterByName(NULL, "cDirYW");
	m_WaterParams.m_cKW = m_WaterEff->GetParameterByName(NULL, "cKW");
	m_WaterParams.m_cDirXSqKW = m_WaterEff->GetParameterByName(NULL, "cDirXSqKW");
	m_WaterParams.m_cDirXDirYKW = m_WaterEff->GetParameterByName(NULL, "cDirXDirYKW");
	m_WaterParams.m_cDirYSqKW = m_WaterEff->GetParameterByName(NULL, "cDirYSqKW");

	m_WaterParams.m_tEnvMap = m_WaterEff->GetParameterByName(NULL, "tEnvMap");
	m_WaterParams.m_tBumpMap = m_WaterEff->GetParameterByName(NULL, "tBumpMap");
}

void CMyD3DApplication::SetWaterParams()
{
	D3DXMATRIXA16 world2NDC = m_matView * m_matProjection;
	m_WaterEff->SetMatrixTranspose(m_WaterParams.m_cWorld2NDC, &world2NDC);

	D3DXVECTOR4 waterTint(0.05f, 0.1f, 0.1f, 0.5f);
	m_WaterEff->SetVector(m_WaterParams.m_cWaterTint, &waterTint);

	D3DXVECTOR4 freq(m_GeoWaves[0].m_Freq, m_GeoWaves[1].m_Freq, m_GeoWaves[2].m_Freq, m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cFrequency, &freq);

	D3DXVECTOR4 phase(m_GeoWaves[0].m_Phase, m_GeoWaves[1].m_Phase, m_GeoWaves[2].m_Phase, m_GeoWaves[3].m_Phase);
	m_WaterEff->SetVector(m_WaterParams.m_cPhase, &phase);

	D3DXVECTOR4 amp(m_GeoWaves[0].m_Amp, m_GeoWaves[1].m_Amp, m_GeoWaves[2].m_Amp, m_GeoWaves[3].m_Amp);
	m_WaterEff->SetVector(m_WaterParams.m_cAmplitude, &amp);

	D3DXVECTOR4 dirX(m_GeoWaves[0].m_Dir.x, m_GeoWaves[1].m_Dir.x, m_GeoWaves[2].m_Dir.x, m_GeoWaves[3].m_Dir.x);
	m_WaterEff->SetVector(m_WaterParams.m_cDirX, &dirX);

	D3DXVECTOR4 dirY(m_GeoWaves[0].m_Dir.y, m_GeoWaves[1].m_Dir.y, m_GeoWaves[2].m_Dir.y, m_GeoWaves[3].m_Dir.y);
	m_WaterEff->SetVector(m_WaterParams.m_cDirY, &dirY);

	FLOAT normScale = m_GeoState.m_SpecAtten * m_TexState.m_AmpOverLen * 2.f * D3DX_PI;
	normScale *= (float(kNumBumpPasses) + m_TexState.m_Noise);
	normScale *= (m_TexState.m_Chop + 1.f);

	D3DXVECTOR4 specAtten(m_GeoState.m_SpecEnd, 1.f / m_GeoState.m_SpecTrans, normScale, 1.f / m_TexState.m_RippleScale);
	m_WaterEff->SetVector(m_WaterParams.m_cSpecAtten, &specAtten);

	D3DXVECTOR3 camPos(m_matPosition._41, m_matPosition._42, m_matPosition._43);
	m_WaterEff->SetVector(m_WaterParams.m_cCameraPos, &D3DXVECTOR4(camPos.x, camPos.y, camPos.z, 1.f));


	D3DXVECTOR3 envCenter(0.f, 0.f, m_GeoState.m_EnvHeight); // Just happens to be centered at origin.
	D3DXVECTOR3 camToCen = envCenter - camPos;
	float G = D3DXVec3LengthSq(&camToCen) - m_GeoState.m_EnvRadius * m_GeoState.m_EnvRadius;
	m_WaterEff->SetVector(m_WaterParams.m_cEnvAdjust, &D3DXVECTOR4(camToCen.x, camToCen.y, camToCen.z, G));

	D3DXVECTOR4 envTint(1.f, 1.f, 1.f, 1.f);
	m_WaterEff->SetVector(m_WaterParams.m_cEnvTint, &envTint);

	D3DXMATRIXA16 matIdent;
	D3DXMatrixIdentity(&matIdent);
	m_WaterEff->SetMatrixTranspose(m_WaterParams.m_cLocal2World, &matIdent);

	D3DXVECTOR4 lengths(m_GeoWaves[0].m_Len, m_GeoWaves[1].m_Len, m_GeoWaves[2].m_Len, m_GeoWaves[3].m_Len);
	m_WaterEff->SetVector(m_WaterParams.m_cLengths, &lengths);

	D3DXVECTOR4 depthOffset(m_GeoState.m_WaterLevel + 1.f, 
		m_GeoState.m_WaterLevel + 1.f, 
		m_GeoState.m_WaterLevel + 0.f, 
		m_GeoState.m_WaterLevel);
	m_WaterEff->SetVector(m_WaterParams.m_cDepthOffset, &depthOffset);

	D3DXVECTOR4 depthScale(1.f / 2.f, 1.f / 2.f, 1.f / 2.f, 1.f);
	m_WaterEff->SetVector(m_WaterParams.m_cDepthScale, &depthScale);

	D3DXVECTOR4 fogParams(-200.f, 1.f / (100.f - 200.f), 0.f, 1.f);
	m_WaterEff->SetVector(m_WaterParams.m_cFogParams, &fogParams);

	float K = 5.f;
	if( m_GeoState.m_AmpOverLen > m_GeoState.m_Chop / (2.f * D3DX_PI * kNumGeoWaves * K) )
		K = m_GeoState.m_Chop / (2.f*D3DX_PI* m_GeoState.m_AmpOverLen * kNumGeoWaves);
	D3DXVECTOR4 dirXK(m_GeoWaves[0].m_Dir.x * K, 
		m_GeoWaves[1].m_Dir.x * K, 
		m_GeoWaves[2].m_Dir.x * K, 
		m_GeoWaves[3].m_Dir.x * K);
	D3DXVECTOR4 dirYK(m_GeoWaves[0].m_Dir.y * K, 
		m_GeoWaves[1].m_Dir.y * K, 
		m_GeoWaves[2].m_Dir.y * K, 
		m_GeoWaves[3].m_Dir.y * K);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXK, &dirXK);
	m_WaterEff->SetVector(m_WaterParams.m_cDirYK, &dirYK);

	D3DXVECTOR4 dirXW(m_GeoWaves[0].m_Dir.x * m_GeoWaves[0].m_Freq, 
		m_GeoWaves[1].m_Dir.x * m_GeoWaves[1].m_Freq, 
		m_GeoWaves[2].m_Dir.x * m_GeoWaves[2].m_Freq, 
		m_GeoWaves[3].m_Dir.x * m_GeoWaves[3].m_Freq);
	D3DXVECTOR4 dirYW(m_GeoWaves[0].m_Dir.y * m_GeoWaves[0].m_Freq, 
		m_GeoWaves[1].m_Dir.y * m_GeoWaves[1].m_Freq, 
		m_GeoWaves[2].m_Dir.y * m_GeoWaves[2].m_Freq, 
		m_GeoWaves[3].m_Dir.y * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXW, &dirXW);
	m_WaterEff->SetVector(m_WaterParams.m_cDirYW, &dirYW);

	D3DXVECTOR4 KW(K * m_GeoWaves[0].m_Freq,
		K * m_GeoWaves[1].m_Freq,
		K * m_GeoWaves[2].m_Freq,
		K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cKW, &KW);

	D3DXVECTOR4 dirXSqKW(m_GeoWaves[0].m_Dir.x * m_GeoWaves[0].m_Dir.x * K * m_GeoWaves[0].m_Freq,
		m_GeoWaves[1].m_Dir.x * m_GeoWaves[1].m_Dir.x * K * m_GeoWaves[1].m_Freq,
		m_GeoWaves[2].m_Dir.x * m_GeoWaves[2].m_Dir.x * K * m_GeoWaves[2].m_Freq,
		m_GeoWaves[3].m_Dir.x * m_GeoWaves[3].m_Dir.x * K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXSqKW, &dirXSqKW);

	D3DXVECTOR4 dirYSqKW(m_GeoWaves[0].m_Dir.y * m_GeoWaves[0].m_Dir.y * K * m_GeoWaves[0].m_Freq,
		m_GeoWaves[1].m_Dir.y * m_GeoWaves[1].m_Dir.y * K * m_GeoWaves[1].m_Freq,
		m_GeoWaves[2].m_Dir.y * m_GeoWaves[2].m_Dir.y * K * m_GeoWaves[2].m_Freq,
		m_GeoWaves[3].m_Dir.y * m_GeoWaves[3].m_Dir.y * K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirYSqKW, &dirYSqKW);

	D3DXVECTOR4 dirXdirYKW(m_GeoWaves[0].m_Dir.y * m_GeoWaves[0].m_Dir.x * K * m_GeoWaves[0].m_Freq,
		m_GeoWaves[1].m_Dir.x * m_GeoWaves[1].m_Dir.y * K * m_GeoWaves[1].m_Freq,
		m_GeoWaves[2].m_Dir.x * m_GeoWaves[2].m_Dir.y * K * m_GeoWaves[2].m_Freq,
		m_GeoWaves[3].m_Dir.x * m_GeoWaves[3].m_Dir.y * K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXDirYKW, &dirXdirYKW);

	m_WaterEff->SetTexture(m_WaterParams.m_tEnvMap, m_EnvMap);
	m_WaterEff->SetTexture(m_WaterParams.m_tBumpMap, m_BumpTex);
}

void CMyD3DApplication::ResetWater()
{
	InitTexState();
	InitGeoState();

	InitWaves();
}

void CMyD3DApplication::InitWaves()
{
	InitTexWaves();
	InitGeoWaves();
}

void CMyD3DApplication::RenderWater()
{
	SetWaterParams();

	if( m_bSortWater )
		SortWaterMesh();

	UINT nPass;
	m_WaterEff->Begin(&nPass, 0);

	UINT i;
	for( i = 0; i < nPass; i++ )
	{
		m_WaterEff->Pass(i);

		m_WaterMesh->DrawSubset(0);

	}
	m_WaterEff->End();
}

void CMyD3DApplication::RenderTexture()
{
	if( SUCCEEDED(m_BumpRender->BeginScene(m_BumpSurf, NULL)) )
	{

		D3DXMATRIXA16 matIdent;
		D3DXMatrixIdentity(&matIdent);
		m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matIdent);
		m_pd3dDevice->SetTransform(D3DTS_VIEW, &matIdent);
		m_pd3dDevice->SetTransform(D3DTS_WORLD, &matIdent);

		m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE);

		SetCompCosineEffParams();

		UINT nPass;
		m_CompCosinesEff->Begin(&nPass, 0);

		UINT i;
		for( i = 0; i < nPass; i++ )
		{
			m_CompCosinesEff->Pass(i);

			m_pd3dDevice->SetFVF(kClearVertFVF);
			m_pd3dDevice->SetStreamSource(0, m_BumpVBuffer, 0, kVSize);
			m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
		}
		m_CompCosinesEff->End();

		m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

		m_BumpRender->EndScene( 0 );
	}
}