void ApplyFreeSlip(RenderTexture[] field)
{
float u = 1.0f / (float)TEX_SIZE;
Vector2 offset;
Graphics.Blit(field[READ], field[WRITE]);
offset = new Vector2(u, 0.0f);
m_applyFreeSlipMat.SetVector("_Offset", offset);
RTUtility.Blit(field[READ], field[WRITE], m_applyFreeSlipMat, m_rectLeft, 0, false);
offset = new Vector2(0.0f, u);
m_applyFreeSlipMat.SetVector("_Offset", offset);
RTUtility.Blit(field[READ], field[WRITE], m_applyFreeSlipMat, m_rectBottom, 0, false);
offset = new Vector2(-u, 0.0f);
m_applyFreeSlipMat.SetVector("_Offset", offset);
RTUtility.Blit(field[READ], field[WRITE], m_applyFreeSlipMat, m_rectRight, 0, false);
offset = new Vector2(0.0f, -u);
m_applyFreeSlipMat.SetVector("_Offset", offset);
RTUtility.Blit(field[READ], field[WRITE], m_applyFreeSlipMat, m_rectTop, 0, false);
RTUtility.Swap(field);
}
void ApplySlippage()
{
for (int i = 0; i < TERRAIN_LAYERS; i++)
{
if (m_talusAngle[i] < 90.0f)
{
float talusAngle = (Mathf.PI * m_talusAngle[i]) / 180.0f;
float maxHeightDif = Mathf.Tan(talusAngle) * CELL_LENGTH;
m_slippageHeightMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_slippageHeightMat.SetFloat("_Layers", (float)(i + 1));
m_slippageHeightMat.SetFloat("_MaxHeightDif", maxHeightDif);
m_slippageHeightMat.SetTexture("_TerrainField", m_terrainField[READ]);
Graphics.Blit(null, m_slippageHeight, m_slippageHeightMat);
m_slippageOutflowMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_slippageOutflowMat.SetFloat("_Layers", (float)(i + 1));
m_slippageOutflowMat.SetFloat("T", TIME_STEP);
m_slippageOutflowMat.SetTexture("_MaxSlippageHeights", m_slippageHeight);
m_slippageOutflowMat.SetTexture("_TerrainField", m_terrainField[READ]);
Graphics.Blit(null, m_slippageOutflow, m_slippageOutflowMat);
m_slippageUpdateMat.SetFloat("T", TIME_STEP);
m_slippageUpdateMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_slippageUpdateMat.SetFloat("_Layers", (float)(i + 1));
m_slippageUpdateMat.SetTexture("_SlippageOutflow", m_slippageOutflow);
Graphics.Blit(m_terrainField[READ], m_terrainField[WRITE], m_slippageUpdateMat);
RTUtility.Swap(m_terrainField);
}
}
}
void ErosionAndDeposition()
{
m_tiltAngleMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_tiltAngleMat.SetFloat("_Layers", TERRAIN_LAYERS);
m_tiltAngleMat.SetTexture("_TerrainField", m_terrainField[READ]);
Graphics.Blit(null, m_tiltAngle, m_tiltAngleMat);
m_erosionAndDepositionMat.SetTexture("_TerrainField", m_terrainField[READ]);
m_erosionAndDepositionMat.SetTexture("_SedimentField", m_sedimentField[READ]);
m_erosionAndDepositionMat.SetTexture("_VelocityField", m_waterVelocity[READ]);
m_erosionAndDepositionMat.SetTexture("_TiltAngle", m_tiltAngle);
m_erosionAndDepositionMat.SetFloat("_MinTiltAngle", m_minTiltAngle);
m_erosionAndDepositionMat.SetFloat("_SedimentCapacity", m_sedimentCapacity);
m_erosionAndDepositionMat.SetVector("_DissolvingConstant", m_dissolvingConstant);
m_erosionAndDepositionMat.SetFloat("_DepositionConstant", m_depositionConstant);
m_erosionAndDepositionMat.SetFloat("_Layers", (float)TERRAIN_LAYERS);
RenderTexture[] terrainAndSediment = new RenderTexture[2] {
m_terrainField[WRITE], m_sedimentField[WRITE]
};
RTUtility.MultiTargetBlit(terrainAndSediment, m_erosionAndDepositionMat);
RTUtility.Swap(m_terrainField);
//RTUtility.Swap(m_sedimentField);
}
void WaterInput(Vector2 position)
{
waterInputMat.SetVector("_InputUV", position);
waterInputMat.SetFloat("_Radius", waterInputRadius);
waterInputMat.SetFloat("_Amount", waterInputAmount);
Graphics.Blit(waterMap[READ], waterMap[WRITE], waterInputMat);
RTUtility.Swap(waterMap);
}
public void Tsunami()
{
RTUtility.SetToPoint(m_waterField);
float line = 0f;
m_tsunamiMat.SetFloat("_Z", line);
m_tsunamiMat.SetFloat("_Amount", m_tsunamiAmount);
Graphics.Blit(m_waterField[READ], m_waterField[WRITE], m_tsunamiMat);
RTUtility.SetToBilinear(m_waterField);
RTUtility.Swap(m_waterField);
}
public void addLava(float x, float y)
{
RTUtility.SetToPoint(m_lavaField);
Vector2 m_lavaOutputPoint = new Vector2(x, y);
m_lavaInputMat.SetVector("_Point", m_lavaOutputPoint);
m_lavaInputMat.SetFloat("_Radius", m_terrainOutputRadius);
m_lavaInputMat.SetFloat("_Amount", m_terrainOutputAmount);
Graphics.Blit(m_lavaField[READ], m_lavaField[WRITE], m_lavaInputMat);
RTUtility.SetToBilinear(m_lavaField);
RTUtility.Swap(m_lavaField);
}
void LavaInput()
{
if (m_lavaInputAmount > 0.0f)
{
m_lavaInputMat.SetVector("_Point", m_lavaInputPoint);
m_lavaInputMat.SetFloat("_Radius", m_lavaInputRadius);
m_lavaInputMat.SetFloat("_Amount", m_lavaInputAmount);
Graphics.Blit(m_lavaField[READ], m_lavaField[WRITE], m_lavaInputMat);
RTUtility.Swap(m_lavaField);
}
}
public void grabWater(float x, float y)
{
RTUtility.SetToPoint(m_waterField);
float amnt = -m_terrainOutputAmount;
Vector2 m_waterOutputPoint = new Vector2(x, y);
m_waterInputMat.SetVector("_Point", m_waterOutputPoint);
m_waterInputMat.SetFloat("_Radius", m_terrainOutputRadius);
m_waterInputMat.SetFloat("_Amount", amnt);
Graphics.Blit(m_waterField[READ], m_waterField[WRITE], m_waterInputMat);
RTUtility.SetToBilinear(m_waterField);
RTUtility.Swap(m_waterField);
}
public void grabElement(float x, float y, int layer)
{
RTUtility.SetToPoint(m_terrainField);
Vector2 m_terrainOutputPoint = new Vector2(x, y);
m_terrainOutputMat.SetVector("_Point", m_terrainOutputPoint);
m_terrainOutputMat.SetFloat("_Radius", m_terrainOutputRadius);
m_terrainOutputMat.SetFloat("_Amount", m_terrainOutputAmount);
m_terrainOutputMat.SetFloat("_Layer", layer);
Graphics.Blit(m_terrainField[READ], m_terrainField[WRITE], m_terrainOutputMat);
RTUtility.SetToBilinear(m_terrainField);
RTUtility.Swap(m_terrainField);
}
void DisintegrateAndDeposit()
{
m_disintegrateAndDepositMat.SetFloat("_Layers", (float)TERRAIN_LAYERS);
m_disintegrateAndDepositMat.SetTexture("_TerrainField", m_terrainField[READ]);
m_disintegrateAndDepositMat.SetTexture("_WaterField", m_waterField[READ]);
m_disintegrateAndDepositMat.SetTexture("_RegolithField", m_regolithField[READ]);
m_disintegrateAndDepositMat.SetFloat("_MaxRegolith", m_maxRegolith);
RenderTexture[] terrainAndRegolith = new RenderTexture[2] {
m_terrainField[WRITE], m_regolithField[WRITE]
};
RTUtility.MultiTargetBlit(terrainAndRegolith, m_disintegrateAndDepositMat);
RTUtility.Swap(m_terrainField);
RTUtility.Swap(m_regolithField);
}
void AdvectSediment()
{
m_advectSedimentMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_advectSedimentMat.SetFloat("T", TIME_STEP);
m_advectSedimentMat.SetFloat("_VelocityFactor", 1.0f);
m_advectSedimentMat.SetTexture("_VelocityField", m_waterVelocity[READ]);
Graphics.Blit(m_sedimentField[READ], m_advectSediment[0], m_advectSedimentMat);
m_advectSedimentMat.SetFloat("_VelocityFactor", -1.0f);
Graphics.Blit(m_advectSediment[0], m_advectSediment[1], m_advectSedimentMat);
m_processMacCormackMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_processMacCormackMat.SetFloat("T", TIME_STEP);
m_processMacCormackMat.SetTexture("_VelocityField", m_waterVelocity[READ]);
m_processMacCormackMat.SetTexture("_InterField1", m_advectSediment[0]);
m_processMacCormackMat.SetTexture("_InterField2", m_advectSediment[1]);
Graphics.Blit(m_sedimentField[READ], m_sedimentField[WRITE], m_processMacCormackMat);
RTUtility.Swap(m_sedimentField);
}
void WaterInput()
{
if (Input.GetKey(KeyCode.DownArrow))
{
m_waterInputPoint.y -= m_waterInputSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.UpArrow))
{
m_waterInputPoint.y += m_waterInputSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.LeftArrow))
{
m_waterInputPoint.x -= m_waterInputSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.RightArrow))
{
m_waterInputPoint.x += m_waterInputSpeed * Time.deltaTime;
}
if (m_waterInputAmount > 0.0f)
{
m_waterInputMat.SetVector("_Point", m_waterInputPoint);
m_waterInputMat.SetFloat("_Radius", m_waterInputRadius);
m_waterInputMat.SetFloat("_Amount", m_waterInputAmount);
Graphics.Blit(m_waterField[READ], m_waterField[WRITE], m_waterInputMat);
RTUtility.Swap(m_waterField);
}
if (m_evaporationConstant > 0.0f)
{
m_evaprationMat.SetFloat("_EvaporationConstant", m_evaporationConstant);
Graphics.Blit(m_waterField[READ], m_waterField[WRITE], m_evaprationMat);
RTUtility.Swap(m_waterField);
}
}
void CalculateFlow()
{
updateFlowMat.SetFloat("_TexSize", TEX_SIZE);
updateFlowMat.SetFloat("_TimeStep", Time.deltaTime * TIME_SCALE);
updateFlowMat.SetFloat("_Length", PIPE_LENGTH);
updateFlowMat.SetFloat("_Area", CELL_AREA);
updateFlowMat.SetFloat("_Gravity", GRAVITY);
updateFlowMat.SetFloat("_Viscosity", viscosity);
updateFlowMat.SetTexture("_TerrainMap", terrainMap);
updateFlowMat.SetTexture("_WaterMap", waterMap[READ]);
Graphics.Blit(flowMap[READ], flowMap[WRITE], updateFlowMat);
RTUtility.Swap(flowMap);
updateWaterMat.SetFloat("_TexSize", TEX_SIZE);
updateWaterMat.SetFloat("_TimeStep", Time.deltaTime * TIME_SCALE);
updateWaterMat.SetFloat("_Length", PIPE_LENGTH);
updateWaterMat.SetTexture("_FlowMap", flowMap[READ]);
Graphics.Blit(waterMap[READ], waterMap[WRITE], updateWaterMat);
RTUtility.Swap(waterMap);
}
void WaterVelocity()
{
m_waterVelocityMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_waterVelocityMat.SetFloat("L", CELL_LENGTH);
m_waterVelocityMat.SetTexture("_WaterField", m_waterField[READ]);
m_waterVelocityMat.SetTexture("_WaterFieldOld", m_waterField[WRITE]);
m_waterVelocityMat.SetTexture("_OutFlowField", m_waterOutFlow[READ]);
Graphics.Blit(null, m_waterVelocity[READ], m_waterVelocityMat);
const float viscosity = 10.5f;
const int iterations = 2;
m_diffuseVelocityMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_diffuseVelocityMat.SetFloat("_Alpha", CELL_AREA / (viscosity * TIME_STEP));
for (int i = 0; i < iterations; i++)
{
Graphics.Blit(m_waterVelocity[READ], m_waterVelocity[WRITE], m_diffuseVelocityMat);
RTUtility.Swap(m_waterVelocity);
}
}
void OutFlow(RenderTexture[] field, RenderTexture[] outFlow, float damping)
{
m_outFlowMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_outFlowMat.SetFloat("T", TIME_STEP);
m_outFlowMat.SetFloat("L", PIPE_LENGTH);
m_outFlowMat.SetFloat("A", CELL_AREA);
m_outFlowMat.SetFloat("G", GRAVITY);
m_outFlowMat.SetFloat("_Layers", TERRAIN_LAYERS);
m_outFlowMat.SetFloat("_Damping", 1.0f - damping);
m_outFlowMat.SetTexture("_TerrainField", m_terrainField[READ]);
m_outFlowMat.SetTexture("_Field", field[READ]);
Graphics.Blit(outFlow[READ], outFlow[WRITE], m_outFlowMat);
RTUtility.Swap(outFlow);
m_fieldUpdateMat.SetFloat("_TexSize", (float)TEX_SIZE);
m_fieldUpdateMat.SetFloat("T", TIME_STEP);
m_fieldUpdateMat.SetFloat("L", PIPE_LENGTH);
m_fieldUpdateMat.SetTexture("_OutFlowField", outFlow[READ]);
Graphics.Blit(field[READ], field[WRITE], m_fieldUpdateMat);
RTUtility.Swap(field);
}
public void Calculate(AtmosphereParameters AP)
{
if (step == 0)
{
// computes transmittance texture T (line 1 in algorithm 4.1)
transmittance.SetTexture(0, "transmittanceWrite", transmittanceT);
transmittance.Dispatch(0, AtmosphereConstants.TRANSMITTANCE_W / NUM_THREADS, AtmosphereConstants.TRANSMITTANCE_H / NUM_THREADS, 1);
}
else if (step == 1)
{
// computes irradiance texture deltaE (line 2 in algorithm 4.1)
irradiance1.SetTexture(0, "transmittanceRead", transmittanceT);
irradiance1.SetTexture(0, "deltaEWrite", deltaET);
irradiance1.Dispatch(0, AtmosphereConstants.SKY_W / NUM_THREADS, AtmosphereConstants.SKY_H / NUM_THREADS, 1);
}
else if (step == 2)
{
// computes single scattering texture deltaS (line 3 in algorithm 4.1)
// Rayleigh and Mie separated in deltaSR + deltaSM
inscatter1.SetTexture(0, "transmittanceRead", transmittanceT);
inscatter1.SetTexture(0, "deltaSRWrite", deltaSRT);
inscatter1.SetTexture(0, "deltaSMWrite", deltaSMT);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < AtmosphereConstants.RES_R; i++)
{
inscatter1.SetInt("layer", i);
inscatter1.Dispatch(0, (AtmosphereConstants.RES_MU_S * AtmosphereConstants.RES_NU) / NUM_THREADS, AtmosphereConstants.RES_MU / NUM_THREADS, 1);
}
}
else if (step == 3)
{
// copies deltaE into irradiance texture E (line 4 in algorithm 4.1)
copyIrradiance.SetFloat("k", 0.0f);
copyIrradiance.SetTexture(0, "deltaERead", deltaET);
copyIrradiance.SetTexture(0, "irradianceRead", irradianceT_Read);
copyIrradiance.SetTexture(0, "irradianceWrite", irradianceT_Write);
copyIrradiance.Dispatch(0, AtmosphereConstants.SKY_W / NUM_THREADS, AtmosphereConstants.SKY_H / NUM_THREADS, 1);
//Swap irradianceT_Read - irradianceT_Write
RTUtility.Swap(ref irradianceT_Read, ref irradianceT_Write);
}
else if (step == 4)
{
// copies deltaS into inscatter texture S (line 5 in algorithm 4.1)
copyInscatter1.SetTexture(0, "deltaSRRead", deltaSRT);
copyInscatter1.SetTexture(0, "deltaSMRead", deltaSMT);
copyInscatter1.SetTexture(0, "inscatterWrite", inscatterT_Write);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < AtmosphereConstants.RES_R; i++)
{
copyInscatter1.SetInt("layer", i);
copyInscatter1.Dispatch(0, (AtmosphereConstants.RES_MU_S * AtmosphereConstants.RES_NU) / NUM_THREADS, AtmosphereConstants.RES_MU / NUM_THREADS, 1);
}
//Swap inscatterT_Write - inscatterT_Read
RTUtility.Swap(ref inscatterT_Read, ref inscatterT_Write); //!!!
}
else if (step == 5)
{
//Here Nvidia GTX 430 or lower driver will crash.
//If only ray1 or mie1 calculated - slow, but all is alright.
//But if both - driver crash.
//INSCATTER_SPHERICAL_INTEGRAL_SAMPLES = 8 - limit for GTX 430.
// computes deltaJ (line 7 in algorithm 4.1)
inscatterS.SetInt("first", (order == 2) ? 1 : 0);
inscatterS.SetTexture(0, "transmittanceRead", transmittanceT);
inscatterS.SetTexture(0, "deltaERead", deltaET);
inscatterS.SetTexture(0, "deltaSRRead", deltaSRT);
inscatterS.SetTexture(0, "deltaSMRead", deltaSMT);
inscatterS.SetTexture(0, "deltaJWrite", deltaJT);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < AtmosphereConstants.RES_R; i++)
{
inscatterS.SetInt("layer", i);
inscatterS.Dispatch(0, (AtmosphereConstants.RES_MU_S * AtmosphereConstants.RES_NU) / NUM_THREADS, AtmosphereConstants.RES_MU / NUM_THREADS, 1);
}
}
else if (step == 6)
{
// computes deltaE (line 8 in algorithm 4.1)
irradianceN.SetInt("first", (order == 2) ? 1 : 0);
irradianceN.SetTexture(0, "deltaSRRead", deltaSRT);
irradianceN.SetTexture(0, "deltaSMRead", deltaSMT);
irradianceN.SetTexture(0, "deltaEWrite", deltaET);
irradianceN.Dispatch(0, AtmosphereConstants.SKY_W / NUM_THREADS, AtmosphereConstants.SKY_H / NUM_THREADS, 1);
}
else if (step == 7)
{
// computes deltaS (line 9 in algorithm 4.1)
inscatterN.SetTexture(0, "transmittanceRead", transmittanceT);
inscatterN.SetTexture(0, "deltaJRead", deltaJT);
inscatterN.SetTexture(0, "deltaSRWrite", deltaSRT);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < AtmosphereConstants.RES_R; i++)
{
inscatterN.SetInt("layer", i);
inscatterN.Dispatch(0, (AtmosphereConstants.RES_MU_S * AtmosphereConstants.RES_NU) / NUM_THREADS, AtmosphereConstants.RES_MU / NUM_THREADS, 1);
}
}
else if (step == 8)
{
// adds deltaE into irradiance texture E (line 10 in algorithm 4.1)
copyIrradiance.SetFloat("k", 1.0f);
copyIrradiance.SetTexture(0, "deltaERead", deltaET);
copyIrradiance.SetTexture(0, "irradianceRead", irradianceT_Read);
copyIrradiance.SetTexture(0, "irradianceWrite", irradianceT_Write);
copyIrradiance.Dispatch(0, AtmosphereConstants.SKY_W / NUM_THREADS, AtmosphereConstants.SKY_H / NUM_THREADS, 1);
//Swap irradianceT_Read - irradianceT_Write
RTUtility.Swap(ref irradianceT_Read, ref irradianceT_Write);
}
else if (step == 9)
{
// adds deltaS into inscatter texture S (line 11 in algorithm 4.1)
copyInscatterN.SetTexture(0, "deltaSRead", deltaSRT);
copyInscatterN.SetTexture(0, "inscatterRead", inscatterT_Read);
copyInscatterN.SetTexture(0, "inscatterWrite", inscatterT_Write);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < AtmosphereConstants.RES_R; i++)
{
copyInscatterN.SetInt("layer", i);
copyInscatterN.Dispatch(0, (AtmosphereConstants.RES_MU_S * AtmosphereConstants.RES_NU) / NUM_THREADS, AtmosphereConstants.RES_MU / NUM_THREADS, 1);
}
//Swap inscatterT_Read - inscatterT_Write
RTUtility.Swap(ref inscatterT_Read, ref inscatterT_Write);
if (order < 4)
{
step = 4;
order += 1;
}
}
else if (step == 10)
{
//placeholder
}
else if (step == 11)
{
finished = true;
}
step++;
}
/*void LoadSkyMaps()
* {
* skybox_material = new Material(skybox_shader);
* m_cam = gameObject.GetComponent<Camera>();
* m_cam.depthTextureMode = DepthTextureMode.DepthNormals;
*
* //Transmittance is responsible for the change in the sun color as it moves
* //The raw file is a 2D array of 32 bit floats with a range of 0 to 1
* string path = Application.dataPath + m_filePath + "/transmittance.raw";
*
* rt_transmittanceT = new RenderTexture(TRANSMITTANCE_W, TRANSMITTANCE_H, 0, RenderTextureFormat.ARGBFloat);
* rt_transmittanceT.wrapMode = TextureWrapMode.Clamp;
* rt_transmittanceT.filterMode = FilterMode.Bilinear;
* rt_transmittanceT.enableRandomWrite = true;
* rt_transmittanceT.Create();
*
* ComputeBuffer buffer = new ComputeBuffer(TRANSMITTANCE_W*TRANSMITTANCE_H, sizeof(float)*3);
* CBUtility.WriteIntoRenderTexture(rt_transmittanceT, 3, path, buffer, m_writeData);
* buffer.Release();
*
* //Iirradiance is responsible for the change in the sky color as the sun moves
* //The raw file is a 2D array of 32 bit floats with a range of 0 to 1
* path = Application.dataPath + m_filePath + "/irradiance.raw";
*
* rt_irradianceT[READ] = new RenderTexture(SKY_W, SKY_H, 0, RenderTextureFormat.ARGBFloat);
* rt_irradianceT[READ].wrapMode = TextureWrapMode.Clamp;
* rt_irradianceT[READ].filterMode = FilterMode.Bilinear;
* rt_irradianceT[READ].enableRandomWrite = true;
* rt_irradianceT[READ].Create();
*
* buffer = new ComputeBuffer(SKY_W*SKY_H, sizeof(float)*3);
* CBUtility.WriteIntoRenderTexture(rt_irradianceT[READ], 3, path, buffer, m_writeData);
* buffer.Release();
*
* //Inscatter is responsible for the change in the sky color as the sun moves
* //The raw file is a 4D array of 32 bit floats with a range of 0 to 1.589844
* //As there is not such thing as a 4D texture the data is packed into a 3D texture
* //and the shader manually performs the sample for the 4th dimension
* path = Application.dataPath + m_filePath + "/inscatter.raw";
*
* rt_inscatterT[READ] = new RenderTexture(RES_MU_S * RES_NU, RES_MU, 0, RenderTextureFormat.ARGBFloat);
* rt_inscatterT[READ].volumeDepth = RES_R;
* rt_inscatterT[READ].wrapMode = TextureWrapMode.Clamp;
* rt_inscatterT[READ].filterMode = FilterMode.Bilinear;
* rt_inscatterT[READ].isVolume = true;
* rt_inscatterT[READ].enableRandomWrite = true;
* rt_inscatterT[READ].Create();
*
* buffer = new ComputeBuffer(RES_MU_S*RES_NU*RES_MU*RES_R, sizeof(float)*4);
* CBUtility.WriteIntoRenderTexture(rt_inscatterT[READ], 4, path, buffer, m_writeData);
* buffer.Release();
*
* InitUniforms(skybox_material);
* }
*/
void Preprocess()
{
if (m_step == 0)
{
// computes transmittance texture T (line 1 in algorithm 4.1)
m_transmittance.SetTexture(0, "transmittanceWrite", rt_transmittanceT);
m_transmittance.Dispatch(0, TRANSMITTANCE_W / NUM_THREADS, TRANSMITTANCE_H / NUM_THREADS, 1);
}
else if (m_step == 1)
{
// computes irradiance texture deltaE (line 2 in algorithm 4.1)
m_irradiance1.SetTexture(0, "transmittanceRead", rt_transmittanceT);
m_irradiance1.SetTexture(0, "deltaEWrite", rt_deltaET);
m_irradiance1.Dispatch(0, SKY_W / NUM_THREADS, SKY_H / NUM_THREADS, 1);
//if(WRITE_DEBUG_TEX)
// SaveAs8bit(SKY_W, SKY_H, 4, "/deltaE_debug", rt_deltaET);
}
else if (m_step == 2)
{
// computes single scattering texture deltaS (line 3 in algorithm 4.1)
// Rayleigh and Mie separated in deltaSR + deltaSM
m_inscatter1.SetTexture(0, "transmittanceRead", rt_transmittanceT);
m_inscatter1.SetTexture(0, "deltaSRWrite", rt_deltaSRT);
m_inscatter1.SetTexture(0, "deltaSMWrite", rt_deltaSMT);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < RES_R; i++)
{
m_inscatter1.SetInt("layer", i);
m_inscatter1.Dispatch(0, (RES_MU_S * RES_NU) / NUM_THREADS, RES_MU / NUM_THREADS, 1);
}
/*if(WRITE_DEBUG_TEX)
* SaveAs8bit(RES_MU_S*RES_NU, RES_MU*RES_R, 4, "/deltaSR_debug", rt_deltaSRT);
*
* if(WRITE_DEBUG_TEX)
* SaveAs8bit(RES_MU_S*RES_NU, RES_MU*RES_R, 4, "/deltaSM_debug", rt_deltaSMT);
*/
}
else if (m_step == 3)
{
// copies deltaE into irradiance texture E (line 4 in algorithm 4.1)
m_copyIrradiance.SetFloat("k", 0.0f);
m_copyIrradiance.SetTexture(0, "deltaERead", rt_deltaET);
m_copyIrradiance.SetTexture(0, "irradianceRead", rt_irradianceT[READ]);
m_copyIrradiance.SetTexture(0, "irradianceWrite", rt_irradianceT[WRITE]);
m_copyIrradiance.Dispatch(0, SKY_W / NUM_THREADS, SKY_H / NUM_THREADS, 1);
//RTUtility.Swap(rt_irradianceT);
}
else if (m_step == 4)
{
// copies deltaS into inscatter texture S (line 5 in algorithm 4.1)
m_copyInscatter1.SetTexture(0, "deltaSRRead", rt_deltaSRT);
m_copyInscatter1.SetTexture(0, "deltaSMRead", rt_deltaSMT);
m_copyInscatter1.SetTexture(0, "inscatterWrite", rt_inscatterT[WRITE]);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < RES_R; i++)
{
m_copyInscatter1.SetInt("layer", i);
m_copyInscatter1.Dispatch(0, (RES_MU_S * RES_NU) / NUM_THREADS, RES_MU / NUM_THREADS, 1);
}
RTUtility.Swap(rt_inscatterT);
}
else if (m_step == 5)
{
// computes deltaJ (line 7 in algorithm 4.1)
m_inscatterS.SetInt("first", (m_order == 2) ? 1 : 0);
m_inscatterS.SetTexture(0, "transmittanceRead", rt_transmittanceT);
m_inscatterS.SetTexture(0, "deltaERead", rt_deltaET);
m_inscatterS.SetTexture(0, "deltaSRRead", rt_deltaSRT);
m_inscatterS.SetTexture(0, "deltaSMRead", rt_deltaSMT);
m_inscatterS.SetTexture(0, "deltaJWrite", rt_deltaJT);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < RES_R; i++)
{
m_inscatterS.SetInt("layer", i);
m_inscatterS.Dispatch(0, (RES_MU_S * RES_NU) / NUM_THREADS, RES_MU / NUM_THREADS, 1);
}
}
else if (m_step == 6)
{
// computes deltaE (line 8 in algorithm 4.1)
m_irradianceN.SetInt("first", (m_order == 2) ? 1 : 0);
m_irradianceN.SetTexture(0, "deltaSRRead", rt_deltaSRT);
m_irradianceN.SetTexture(0, "deltaSMRead", rt_deltaSMT);
m_irradianceN.SetTexture(0, "deltaEWrite", rt_deltaET);
m_irradianceN.Dispatch(0, SKY_W / NUM_THREADS, SKY_H / NUM_THREADS, 1);
}
else if (m_step == 7)
{
// computes deltaS (line 9 in algorithm 4.1)
m_inscatterN.SetTexture(0, "transmittanceRead", rt_transmittanceT);
m_inscatterN.SetTexture(0, "deltaJRead", rt_deltaJT);
m_inscatterN.SetTexture(0, "deltaSRWrite", rt_deltaSRT);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < RES_R; i++)
{
m_inscatterN.SetInt("layer", i);
m_inscatterN.Dispatch(0, (RES_MU_S * RES_NU) / NUM_THREADS, RES_MU / NUM_THREADS, 1);
}
}
else if (m_step == 8)
{
// adds deltaE into irradiance texture E (line 10 in algorithm 4.1)
m_copyIrradiance.SetFloat("k", 1.0f);
m_copyIrradiance.SetTexture(0, "deltaERead", rt_deltaET);
m_copyIrradiance.SetTexture(0, "irradianceRead", rt_irradianceT[READ]);
m_copyIrradiance.SetTexture(0, "irradianceWrite", rt_irradianceT[WRITE]);
m_copyIrradiance.Dispatch(0, SKY_W / NUM_THREADS, SKY_H / NUM_THREADS, 1);
//RTUtility.Swap(rt_irradianceT);
}
else if (m_step == 9)
{
// adds deltaS into inscatter texture S (line 11 in algorithm 4.1)
m_copyInscatterN.SetTexture(0, "deltaSRead", rt_deltaSRT);
m_copyInscatterN.SetTexture(0, "inscatterRead", rt_inscatterT[READ]);
m_copyInscatterN.SetTexture(0, "inscatterWrite", rt_inscatterT[WRITE]);
//The inscatter calc's can be quite demanding for some cards so process
//the calc's in layers instead of the whole 3D data set.
for (int i = 0; i < RES_R; i++)
{
m_copyInscatterN.SetInt("layer", i);
m_copyInscatterN.Dispatch(0, (RES_MU_S * RES_NU) / NUM_THREADS, RES_MU / NUM_THREADS, 1);
}
RTUtility.Swap(rt_inscatterT);
if (m_order < 4)
{
m_step = 4;
m_order += 1;
}
}
else if (m_step == 10)
{
ReleaseRT();
m_finished = true;
}
m_step += 1;
}
void InitMaps()
{
RTUtility.ClearColor(m_terrainField);
RTUtility.ClearColor(m_waterOutFlow);
RTUtility.ClearColor(m_waterVelocity);
RTUtility.ClearColor(m_advectSediment);
RTUtility.ClearColor(m_waterField);
RTUtility.ClearColor(m_sedimentField);
RTUtility.ClearColor(m_regolithField);
RTUtility.ClearColor(m_regolithOutFlow);
RTUtility.ClearColor(m_lavaOutFlow);
RTUtility.ClearColor(m_lavaVelocity);
RTUtility.ClearColor(m_lavaField);
RenderTexture[] noiseTex = new RenderTexture[2];
noiseTex[0] = new RenderTexture(TEX_SIZE, TEX_SIZE, 0, RenderTextureFormat.RFloat);
noiseTex[0].wrapMode = TextureWrapMode.Clamp;
noiseTex[0].filterMode = FilterMode.Bilinear;
noiseTex[1] = new RenderTexture(TEX_SIZE, TEX_SIZE, 0, RenderTextureFormat.RFloat);
noiseTex[1].wrapMode = TextureWrapMode.Clamp;
noiseTex[1].filterMode = FilterMode.Bilinear;
m_noiseMat.SetTexture("_PermTable1D", m_perlin.GetPermutationTable1D());
m_noiseMat.SetTexture("_Gradient2D", m_perlin.GetGradient2D());
for (int j = 0; j < 1; j++)
{
m_noiseMat.SetFloat("_Offset", m_offset[j]);
float amp = 0.5f;
float freq = m_frequency[j];
//Must clear noise from last pass
RTUtility.ClearColor(noiseTex);
//write noise into texture with the settings for this layer
for (int i = 0; i < m_octaves[j]; i++)
{
m_noiseMat.SetFloat("_Frequency", freq);
m_noiseMat.SetFloat("_Amp", amp);
m_noiseMat.SetFloat("_Pass", (float)i);
Graphics.Blit(noiseTex[READ], noiseTex[WRITE], m_noiseMat, (int)m_layerStyle[j]);
RTUtility.Swap(noiseTex);
freq *= m_lacunarity[j];
amp *= m_gain[j];
}
float useAbs = 0.0f;
if (m_finalNosieIsAbs[j])
{
useAbs = 1.0f;
}
//Mask the layers that we dont want to write into
Vector4 mask = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
mask[j] = 1.0f;
m_initTerrainMat.SetFloat("_Amp", m_amp[j]);
m_initTerrainMat.SetFloat("_UseAbs", useAbs);
m_initTerrainMat.SetVector("_Mask", mask);
m_initTerrainMat.SetTexture("_NoiseTex", noiseTex[READ]);
m_initTerrainMat.SetFloat("_Height", TERRAIN_HEIGHT);
//Apply the noise for this layer to the terrain field
Graphics.Blit(m_terrainField[READ], m_terrainField[WRITE], m_initTerrainMat);
RTUtility.Swap(m_terrainField);
}
//dont need this tex anymore
noiseTex[0] = null;
noiseTex[1] = null;
/*Texture2D myTexture2D = new Texture2D(1024,1024,TextureFormat.RGBAFloat,false);
* string path = "Assets\\Textures\\terrain.raw";
* myTexture2D.LoadRawTextureData(File.ReadAllBytes(path));
* myTexture2D.Apply();
* m_gridLand[0].AddComponent<GUITexture>();
* m_gridLand[0].GetComponent<GUITexture>().texture = myTexture2D;
* Graphics.Blit(myTexture2D, m_terrainField[READ]);*/
}
