public void CalculateInitials(RenderDrawContext context, ComputeEffectShader initialSpectrumShader, ComputeEffectShader conjugatedSpectrumShader, WavesSettings wavesSettings, float lengthScale, float cutoffLow, float cutoffHigh)
{
_lambda = wavesSettings.Lambda;
var commandList = context.CommandList;
commandList.ResourceBarrierTransition(_buffer, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(PrecomputedData, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(GaussianNoise, GraphicsResourceState.UnorderedAccess);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.Size, (uint)_size);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.LengthScale, lengthScale);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.CutoffHigh, cutoffHigh);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.CutoffLow, cutoffLow);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.GravityAcceleration, wavesSettings.G);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.Depth, wavesSettings.Depth);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.Spectrums, wavesSettings.Spectrums);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.H0K, _buffer);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.WavesData, PrecomputedData);
initialSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.Noise, GaussianNoise);
initialSpectrumShader.ThreadGroupCounts = new Int3(_size / LOCAL_WORK_GROUPS_X, _size / LOCAL_WORK_GROUPS_Y, 1);
initialSpectrumShader.ThreadNumbers = new Int3(LOCAL_WORK_GROUPS_X, LOCAL_WORK_GROUPS_Y, 1);
initialSpectrumShader.Draw(context);
conjugatedSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.H0, InitialSpectrum);
conjugatedSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.H0K, _buffer);
conjugatedSpectrumShader.Parameters.Set(OceanInitialSpectrumCommonKeys.Size, (uint)_size);
conjugatedSpectrumShader.ThreadGroupCounts = new Int3(_size / LOCAL_WORK_GROUPS_X, _size / LOCAL_WORK_GROUPS_Y, 1);
conjugatedSpectrumShader.ThreadNumbers = new Int3(LOCAL_WORK_GROUPS_X, LOCAL_WORK_GROUPS_Y, 1);
conjugatedSpectrumShader.Draw(context);
}
/// <summary>
/// Create a new instance of the class.
/// </summary>
/// <param name="context">the context</param>
public RadiancePrefilteringGGX(RenderContext context)
: base(context, "RadiancePrefilteringGGX")
{
computeShader = new ComputeEffectShader(context) { ShaderSourceName = "RadiancePrefilteringGGXEffect" };
DoNotFilterHighestLevel = true;
samplingsCount = 1024;
}
public FastFourierTransformShaders(RenderContext context)
{
PrecomputeTwiddleFactorsAndInputIndices = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanPrecomputeTwiddleFactorsAndInputIndices"
};
HorizontalStepFFT = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanHorizontalStepFFT"
};
VerticalStepFFT = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanVerticalStepFFT"
};
HorizontalStepInverseFFT = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanHorizontalStepInverseFFT"
};
VerticalStepInverseFFT = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanVerticalStepInverseFFT"
};
Scale = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanScale"
};
Permute = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanPermute"
};
}
protected override void InitializeCore()
{
base.InitializeCore();
_skyViewLutTexture = Texture.New2D(Context.GraphicsDevice, SkyViewLutSettings.Width, SkyViewLutSettings.Height, SkyViewLutSettings.Format, TextureFlags.RenderTarget | TextureFlags.ShaderResource);
_atmosphereCameraScatteringVolumeTexture = Texture.New3D(Context.GraphicsDevice, AtmosphereCameraScatteringVolumeSettings.Size, AtmosphereCameraScatteringVolumeSettings.Size, AtmosphereCameraScatteringVolumeSettings.Slices, AtmosphereCameraScatteringVolumeSettings.Format, TextureFlags.RenderTarget | TextureFlags.ShaderResource);
_multiScatteringTexture = Texture.New2D(Context.GraphicsDevice, MultiScatteringTextureSettings.Size, MultiScatteringTextureSettings.Size, MultiScatteringTextureSettings.Format, TextureFlags.UnorderedAccess | TextureFlags.ShaderResource);
TransmittanceLutTexture = Texture.New2D(Context.GraphicsDevice, TransmittanceLutSettings.Width, TransmittanceLutSettings.Height, TransmittanceLutSettings.Format, TextureFlags.UnorderedAccess | TextureFlags.RenderTarget | TextureFlags.ShaderResource);
_atmosphereCubeMapRenderTarget = Texture.New2D(Context.GraphicsDevice, 64, 64, PixelFormat.R16G16B16A16_Float, TextureFlags.RenderTarget | TextureFlags.ShaderResource);
_atmosphereCubeMap = Texture.NewCube(Context.GraphicsDevice, 64, PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource);
_atmosphereCubeMapSpecular = Texture.NewCube(Context.GraphicsDevice, 64, MipMapCount.Auto, PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.UnorderedAccess);
_transmittanceLutEffect = new ImageEffectShader("AtmosphereRenderTransmittanceLutEffect");
_skyViewLutEffect = new ImageEffectShader("AtmosphereRenderSkyViewLutEffect");
_renderMultipleScatteringTextureEffect = new ComputeEffectShader(Context)
{
ShaderSourceName = "AtmosphereMultipleScatteringTextureEffect"
};
_renderAtmosphereScatteringVolumeEffect = new DynamicEffectInstance("AtmosphereRenderScatteringCameraVolumeEffect");
_renderAtmosphereScatteringVolumeEffect.Initialize(Context.Services);
_renderAtmosphereScatteringVolumePipelineState = new MutablePipelineState(Context.GraphicsDevice);
_renderAtmosphereScatteringVolumePipelineState.State.SetDefaults();
_renderAtmosphereScatteringVolumePipelineState.State.PrimitiveType = PrimitiveType.TriangleList;
_atmosphereLogicalGroupKey = CreateDrawLogicalGroup("Atmosphere");
_spriteBatch = new SpriteBatch(Context.GraphicsDevice);
}
public LambertianPrefilteringSH(RenderContext context)
: base(context, "LambertianPrefilteringSH")
{
firstPassEffect = new ComputeEffectShader(context) { ShaderSourceName = "LambertianPrefilteringSHEffectPass1" };
secondPassEffect = new ComputeEffectShader(context) { ShaderSourceName = "LambertianPrefilteringSHEffectPass2" };
HarmonicOrder = 3;
}
/// <summary>
/// Create a new instance of the class.
/// </summary>
/// <param name="context">the context</param>
public RadiancePrefilteringGGX(RenderContext context)
: base(context, "RadiancePrefilteringGGX")
{
computeShader = new ComputeEffectShader(context)
{
ShaderSourceName = "RadiancePrefilteringGGXEffect"
};
DoNotFilterHighestLevel = true;
samplingsCount = 1024;
}
protected override async Task LoadContent()
{
await base.LoadContent();
var context = RenderContext.GetShared(Services);
renderHammersley = new ComputeEffectShader(context)
{
ShaderSourceName = "HammersleyTest"
};
output = Texture.New2D(GraphicsDevice, OutputSize, OutputSize, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.UnorderedAccess | TextureFlags.RenderTarget).DisposeBy(this);
}
public LambertianPrefilteringSH(RenderContext context)
: base(context, "LambertianPrefilteringSH")
{
firstPassEffect = new ComputeEffectShader(context)
{
ShaderSourceName = "LambertianPrefilteringSHEffectPass1"
};
secondPassEffect = new ComputeEffectShader(context)
{
ShaderSourceName = "LambertianPrefilteringSHEffectPass2"
};
HarmonicOrder = 3;
}
protected override async Task LoadContent()
{
await base.LoadContent();
CreateBufferData();
inputBuffer = Buffer.Typed.New(GraphicsDevice, inputBufferData, PixelFormat.R32G32B32A32_Float, true);
outputBuffer = Buffer.Typed.New(GraphicsDevice, NbOfCoeffs * nbOfGroups.X * nbOfGroups.Y, PixelFormat.R32G32B32A32_Float, true);
var context = RenderContext.GetShared(Services);
pass2 = new ComputeEffectShader(context)
{
ShaderSourceName = "LambertianPrefilteringSHEffectPass2",
};
}
protected override async Task LoadContent()
{
await base.LoadContent();
spriteBatch = new SpriteBatch(GraphicsDevice);
inputTexture = Content.Load <Texture>("uv");
var groupCounts = new Int3(inputTexture.Width / ReductionRatio, inputTexture.Height / ReductionRatio, 1);
outputTexture = Texture.New2D(GraphicsDevice, groupCounts.X, groupCounts.Y, 1, PixelFormat.R8G8B8A8_UNorm, TextureFlags.UnorderedAccess | TextureFlags.ShaderResource);
displayedTexture = outputTexture;
drawEffectContext = RenderContext.GetShared(Services);
computeShaderEffect = new ComputeEffectShader(drawEffectContext)
{
ShaderSourceName = "ComputeShaderTestEffect", ThreadGroupCounts = groupCounts
};
}
public override void Unload()
{
base.Unload();
_specularRadiancePrefilterGGX?.Dispose();
_specularRadiancePrefilterGGX = null;
_lamberFiltering?.Dispose();
_lamberFiltering = null;
_atmosphereCubeMapRenderTarget?.Dispose();
_atmosphereCubeMapRenderTarget = null;
_atmosphereCubeMap?.Dispose();
_atmosphereCubeMap = null;
_multiScatteringTexture?.Dispose();
_multiScatteringTexture = null;
TransmittanceLutTexture?.Dispose();
TransmittanceLutTexture = null;
_skyViewLutTexture?.Dispose();
_skyViewLutTexture = null;
_atmosphereCameraScatteringVolumeTexture?.Dispose();
_atmosphereCameraScatteringVolumeTexture = null;
_transmittanceLutEffect?.Dispose();
_transmittanceLutEffect = null;
_skyViewLutEffect?.Dispose();
_skyViewLutEffect = null;
_renderMultipleScatteringTextureEffect?.Dispose();
_renderMultipleScatteringTextureEffect = null;
_renderAtmosphereScatteringVolumeEffect?.Dispose();
_renderAtmosphereScatteringVolumeEffect = null;
_spriteBatch?.Dispose();
_spriteBatch = null;
}
public void CalculateWavesAtTime(RenderDrawContext context, ComputeEffectShader timeDependantSpectrumShader, ComputeEffectShader fillResultTexturesShader, ComputeEffectShader generateMipsShader, float time, float deltaTime)
{
var commandList = context.CommandList;
commandList.ResourceBarrierTransition(_dxDz, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(_dyDxz, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(_dyxDyz, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(_dxxDzz, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(Displacement, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(Derivatives, GraphicsResourceState.UnorderedAccess);
commandList.ResourceBarrierTransition(Turbulence, GraphicsResourceState.UnorderedAccess);
// Calculating complex amplitudes
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.Dx_Dz, _dxDz);
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.Dy_Dxz, _dyDxz);
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.Dyx_Dyz, _dyxDyz);
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.Dxx_Dzz, _dxxDzz);
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.H0, InitialSpectrum);
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.WavesData, PrecomputedData);
timeDependantSpectrumShader.Parameters.Set(OceanTimeDependentSpectrumKeys.Time, time);
timeDependantSpectrumShader.ThreadGroupCounts = new Int3(_size / LOCAL_WORK_GROUPS_X, _size / LOCAL_WORK_GROUPS_Y, 1);
timeDependantSpectrumShader.ThreadNumbers = new Int3(LOCAL_WORK_GROUPS_X, LOCAL_WORK_GROUPS_Y, 1);
timeDependantSpectrumShader.Draw(context);
// Calculating IFFTs of complex amplitudes
_fft.IFFT2D(context, _dxDz, _buffer, true, false, true);
_fft.IFFT2D(context, _dyDxz, _buffer, true, false, true);
_fft.IFFT2D(context, _dyxDyz, _buffer, true, false, true);
_fft.IFFT2D(context, _dxxDzz, _buffer, true, false, true);
// Filling displacement and normals textures
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.DeltaTime, deltaTime);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Lambda, _lambda);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Dx_Dz, _dxDz);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Dy_Dxz, _dyDxz);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Dyx_Dyz, _dyxDyz);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Dxx_Dzz, _dxxDzz);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Displacement, Displacement);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Derivatives, Derivatives);
fillResultTexturesShader.Parameters.Set(OceanFillResultTexturesKeys.Turbulence, Turbulence);
fillResultTexturesShader.ThreadGroupCounts = new Int3(_size / LOCAL_WORK_GROUPS_X, _size / LOCAL_WORK_GROUPS_Y, 1);
fillResultTexturesShader.ThreadNumbers = new Int3(LOCAL_WORK_GROUPS_X, LOCAL_WORK_GROUPS_Y, 1);
fillResultTexturesShader.Draw(context);
// TODO: Mipsmaps dont look great, could potentially be used by using better filtering
// Not using them for now, uncomment to enable and switch Sample methods in OceanEmissive.sdsl
//ResetState();
//// Generate mip maps
//GenerateMipsMaps(Derivatives);
//GenerateMipsMaps(Turbulence);
//ResetState();
commandList.ResourceBarrierTransition(Displacement, GraphicsResourceState.PixelShaderResource);
commandList.ResourceBarrierTransition(Derivatives, GraphicsResourceState.PixelShaderResource);
commandList.ResourceBarrierTransition(Turbulence, GraphicsResourceState.PixelShaderResource);
void GenerateMipsMaps(Texture texture)
{
for (var i = 0; i < texture.MipLevels - 1; i++)
{
// Copy source mip to staging texture
commandList.CopyRegion(texture, i, null, _mipStagingTexture, i);
using var targetMip = texture.ToTextureView(ViewType.MipBand, 0, i + 1);
generateMipsShader.Parameters.Set(OceanGenerateMipsKeys.SrcMip, _mipStagingTexture);
generateMipsShader.Parameters.Set(OceanGenerateMipsKeys.OutMip, targetMip);
generateMipsShader.Parameters.Set(OceanGenerateMipsKeys.InvOutTexelSize, new Vector2(1.0f / targetMip.Width, 1.0f / targetMip.Height));
generateMipsShader.Parameters.Set(OceanGenerateMipsKeys.SrcMipIndex, (uint)i);
generateMipsShader.ThreadGroupCounts = new Int3(targetMip.Width / LOCAL_WORK_GROUPS_X, targetMip.Height / LOCAL_WORK_GROUPS_Y, 1);
generateMipsShader.ThreadNumbers = new Int3(LOCAL_WORK_GROUPS_X, LOCAL_WORK_GROUPS_Y, 1);
generateMipsShader.Draw(context);
}
}
void ResetState()
{
// This is to solve an issue where child resources (texture views) bound as UAV wont be properly
// reset when binding the parent texture as an SRV and thus resulting in the SRV potentionally failing to bind
using (context.PushRenderTargetsAndRestore())
commandList.ClearState();
}
}
public override void Draw(RenderContext context)
{
base.Draw(context);
var graphicsDevice = Services.GetService <IGraphicsDeviceService>().GraphicsDevice;
var sceneSystem = context.Services.GetService <SceneSystem>();
var camera = sceneSystem.TryGetMainCamera();
if (camera == null)
{
return;
}
var time = (float)sceneSystem.Game.UpdateTime.Total.TotalSeconds;
var deltaTime = (float)sceneSystem.Game.UpdateTime.Elapsed.TotalSeconds;
if (_calculateInitialSpectrumShader == null)
{
// TODO: DISPOSE AT SYSTEM REMOVAL!
_calculateInitialSpectrumShader = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanCalculateInitialSpectrum", Name = "OceanCalculateInitialSpectrum"
};
_calculateConjugatedSpectrumShader = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanCalculateConjugatedSpectrum", Name = "OceanCalculateConjugatedSpectrum"
};
_timeDependantSpectrumShader = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanTimeDependentSpectrum", Name = "OceanTimeDependentSpectrum"
};
_fillResultTexturesShader = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanFillResultTextures", Name = "OceanFillResultTextures"
};
_generateMipsShader = new ComputeEffectShader(context)
{
ShaderSourceName = "OceanGenerateMips", Name = "OceanGenerateMips"
};
_fastFourierTransformShaders = new FastFourierTransformShaders(context);
}
Dispatcher.ForEach(ComponentDatas, (pair) =>
{
var component = pair.Key;
var data = pair.Value;
var entity = component.Entity;
var renderDrawContext = context.GetThreadContext();
var commandList = renderDrawContext.CommandList;
// Update shader parameters for wave settings
component.WavesSettings.UpdateShaderParameters();
// Create cascades if dirty
var calculateInitials = component.AlwaysRecalculateInitials;
if (data.Size != component.Size || data.Cascades == null)
{
data.DestroyCascades();
data.Size = component.Size;
// Create noise texture
data.GaussianNoise?.Dispose();
var rng = new Random();
var noise = new Vector2[data.Size * data.Size];
for (int y = 0; y < data.Size; y++)
{
for (int x = 0; x < data.Size; x++)
{
var index = y * data.Size + x;
noise[index] = new Vector2(NormalRandom(rng), NormalRandom(rng));
}
}
data.GaussianNoise = Texture.New2D(graphicsDevice, data.Size, data.Size, PixelFormat.R32G32_Float, noise, TextureFlags.ShaderResource | TextureFlags.UnorderedAccess);
