public static Texture BeginGetTempTexture(Type type) { if (type == typeof(Texture)) type = typeof(Texture2D); for (int i = 0; i < textureCache.Count; i++) { if (textureCache[i].GetType() == type) { Texture t = textureCache[i]; textureCache.RemoveAt(i); return t; } } //create. SurfaceFormat format = SurfaceFormat.HalfSingle; Texture texture = null; if (type == typeof(Texture2D)) texture = new Texture2D(GraphicsDevice, 2, 2, false, format); if (type == typeof(Texture3D)) texture = new Texture3D(GraphicsDevice, 2, 2, 2, false, format); if (type == typeof(TextureCube)) texture = new TextureCube(GraphicsDevice, 2, false, format); return texture; }
public ShaderResourceView GenerateNoiseTexture(Buffer constantBuffer, DirectComputeConstantBuffer container) { Texture3D noiseTexture = new Texture3D(graphicsDevice, new Texture3DDescription() { BindFlags = BindFlags.ShaderResource | BindFlags.UnorderedAccess, CpuAccessFlags = CpuAccessFlags.None, Format = Format.R32_Float, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, Usage = ResourceUsage.Default, Width = container.Width, Height = container.Height, Depth = container.Depth }); UnorderedAccessView noiseTextureUAV = new UnorderedAccessView(graphicsDevice, noiseTexture); DataBox data = graphicsDevice.ImmediateContext.MapSubresource(constantBuffer, MapMode.WriteDiscard, MapFlags.None); data.Data.Write<DirectComputeConstantBuffer>(container); graphicsDevice.ImmediateContext.UnmapSubresource(constantBuffer, 0); graphicsDevice.ImmediateContext.ComputeShader.Set(computeFillNoiseTexture); graphicsDevice.ImmediateContext.ComputeShader.SetConstantBuffer(constantBuffer, 0); graphicsDevice.ImmediateContext.ComputeShader.SetUnorderedAccessView(noiseTextureUAV, 0); Vector3 gridDim = new Vector3((float)Math.Ceiling(container.Width / 8.0f), (float)Math.Ceiling(container.Height / 8.0f), (float)Math.Ceiling(container.Depth / 8.0f)); graphicsDevice.ImmediateContext.Dispatch((int)gridDim.X, (int)gridDim.Y, (int)gridDim.Z); noiseTextureUAV.Dispose(); return new ShaderResourceView(graphicsDevice, noiseTexture); }
// Primitive m_Prim_Cube; public ViewerForm( BImage _Image ) { InitializeComponent(); //TransparencyKey = SystemColors.Control; // Setup device m_Device = new Device(); m_Device.Init( Handle, false, true ); m_CB_Global = new ConstantBuffer< CB_Global >( m_Device, 0 ); // Create shaders m_Shader_Render2D = new Shader( m_Device, new ShaderFile( new System.IO.FileInfo( @"./Shaders/Render2D.hlsl" ) ), VERTEX_FORMAT.Pt4, "VS", null, "PS", null ); // Create the texture try { if ( _Image.m_Opts.m_type == BImage.ImageOptions.TYPE.TT_2D ) { m_Tex2D = _Image.CreateTexture2D( m_Device ); m_CB_Global.m.m_ImageWidth = (uint) m_Tex2D.Width; m_CB_Global.m.m_ImageHeight = (uint) m_Tex2D.Height; m_CB_Global.m.m_ImageDepth = (uint) m_Tex2D.ArraySize; m_CB_Global.m.m_ImageType = 0; integerTrackbarControlMipLevel.RangeMax = m_Tex2D.MipLevelsCount; integerTrackbarControlMipLevel.VisibleRangeMax = m_Tex2D.MipLevelsCount; } else if ( _Image.m_Opts.m_type == BImage.ImageOptions.TYPE.TT_CUBIC ) { m_TexCube = _Image.CreateTextureCube( m_Device ); m_CB_Global.m.m_ImageWidth = (uint) m_TexCube.Width; m_CB_Global.m.m_ImageHeight = (uint) m_TexCube.Height; m_CB_Global.m.m_ImageDepth = (uint) m_TexCube.ArraySize; m_CB_Global.m.m_ImageType = 1; integerTrackbarControlMipLevel.RangeMax = m_TexCube.MipLevelsCount; integerTrackbarControlMipLevel.VisibleRangeMax = m_TexCube.MipLevelsCount; } else if ( _Image.m_Opts.m_type == BImage.ImageOptions.TYPE.TT_3D ) { m_Tex3D = _Image.CreateTexture3D( m_Device ); } // Enable EV manipulation for HDR images bool showExposure = _Image.m_Opts.m_format.m_type == BImage.PixelFormat.Type.FLOAT; labelEV.Visible = showExposure; floatTrackbarControlEV.Visible = showExposure; } catch ( Exception _e ) { MessageBox.Show( this, "Failed to create a valid texture from the image:\r\n\r\n" + _e.Message, "BImage Viewer", MessageBoxButtons.OK, MessageBoxIcon.Error ); } Application.Idle += new EventHandler( Application_Idle ); }
public DX11RenderTexture3D(DX11RenderContext context, Texture3D tex, ShaderResourceView srv, UnorderedAccessView uav) : base(context) { this.Resource = tex; this.SRV = srv; this.UAV = uav; }
public DX11RenderTexture3D(DX11RenderContext context, Texture3D tex) : base(context) { this.Resource = tex; this.SRV = new ShaderResourceView(context.Device, tex); this.UAV = new UnorderedAccessView(context.Device, tex); }
public cFlameEffect(GraphicsDevice gd, ContentManager cm, int w, int h) : base(w, h, 1) { this.RigidBody.IsStatic = true; Width = w; Height = h; _effect = cm.Load<Effect>(@"Resources/Shaders/Fire/FlameEffect"); _flameTex = cm.Load<Texture2D>(@"Resources/Textures/flame2"); _noiseTex = Texture3D.FromFile(gd, @"Resources/Textures/NoiseVolume.dds"); this.RigidBody.setCollisionListner(this, "fire"); }
void IResource.Destroy() { if (texture2D != null) texture2D.Dispose(); texture2D = null; if (texture3D != null) texture3D.Dispose(); texture3D = null; if (textureCube != null) textureCube.Dispose(); textureCube = null; }
public static Texture3D CreateRotatedPoissonDiskTexture(GraphicsDevice graphicsDevice) { const int size = 32; var result = new Texture3D(graphicsDevice, size, size, size, false, SurfaceFormat.Rg32); result.SetData(CreateRandomRotations(size * size * size).ToArray()); return result; }
public VolumeRaycaster(Game game, Volume<byte> volume) : base(game) { _bbox = new BoundingBox(new Vector3(-1), new Vector3(1)); _volume = volume; _alpha = 1.0f; IGraphicsDeviceService graphicsservice = Game.Services.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService; _graphicDevice = graphicsservice.GraphicsDevice; _volTexture = new Texture3D(_graphicDevice, _volume.Dim.Width, _volume.Dim.Height, _volume.Dim.Depth, 1, TextureUsage.None, SurfaceFormat.Alpha8); _tfTexture = new Texture2D(_graphicDevice, 256, 1, 1, TextureUsage.None, SurfaceFormat.Color); _tfPreIntTexture = new Texture2D(_graphicDevice, 256, 256, 1, TextureUsage.None, SurfaceFormat.Color); Viewport viewport = _graphicDevice.Viewport; _entryPointRt = new RenderTarget2D(_graphicDevice, viewport.Width, viewport.Height, 1, SurfaceFormat.Vector4); _exitPointRt = new RenderTarget2D(_graphicDevice, viewport.Width, viewport.Height, 1, SurfaceFormat.Vector4); _tempRt = new RenderTarget2D(_graphicDevice, viewport.Width, viewport.Height, 1, SurfaceFormat.Vector4); }
// Functions public TextureObject() { m_Width = m_Height = 1; m_Mips = 1; m_Depth = 1; m_ArraySize = 1; m_IsCube = false; m_TexFormat = Format.Unknown; m_TextureObject2D = null; m_TextureObject3D = null; m_RenderTargetView = null; m_ShaderResourceView = null; m_DepthStencilView = null; m_UnorderedAccessView = null; m_ArrayRenderTargetViews = null; m_ArrayShaderResourceViews = null; m_ArrayDepthStencilViews = null; m_ArrayUnorderedAccessViews = null; }
public void ShouldSetAndGetData(int width, int height, int depth) { Game.DrawWith += (sender, e) => { var dataSize = width * height * depth; var texture3D = new Texture3D(Game.GraphicsDevice, width, height, depth, false, SurfaceFormat.Color); var savedData = new Color[dataSize]; for (var index = 0; index < dataSize; index++) savedData[index] = new Color(index, index, index); texture3D.SetData(savedData); var readData = new Color[dataSize]; texture3D.GetData(readData); Assert.AreEqual(savedData, readData); }; Game.RunOneFrame(); }
private static void Internal_Create(Texture3D mono, int width, int height, int depth, TextureFormat format, bool mipmap){}
/// <summary> /// Open a dds from a stream. /// (Supported formats : Dxt1,Dxt2,Dxt3,Dxt4,Dxt5,A8R8G8B8/Color,X8R8G8B8,R8G8B8,A4R4G4B4,A1R5G5B5,R5G6B5,A8, /// FP32/Single,FP16/HalfSingle,FP32x4/Vector4,FP16x4/HalfVector4,CxV8U8/NormalizedByte2/CxVU,Q8VW8V8U8/NormalizedByte4/8888QWVU /// ,HalfVector2/G16R16F/16.16fGR,Vector2/G32R32F,G16R16/RG32/1616GB,B8G8R8,X8B8G8R8,A8B8G8R8/Color,L8,A2B10G10R10/Rgba1010102,A16B16G16R16/Rgba64) /// </summary> /// <param name="stream">Stream containing the data.</param> /// <param name="device">Graphic device where you want the texture to be loaded.</param> /// <param name="texture">The reference to the loaded texture.</param> /// <param name="streamOffset">Offset in the stream to where the DDS is located.</param> /// <param name="loadMipMap">If true it will load the mip-map chain for this texture.</param> public static void DDSFromStream(Stream stream, GraphicsDevice device, int streamOffset, bool loadMipMap, out Texture3D texture) { Texture tex; InternalDDSFromStream(stream, device, streamOffset, loadMipMap, out tex); texture = tex as Texture3D; if (texture == null) { throw new Exception("The data in the stream contains a Texture2D not TextureCube"); } }
static void loadTextures() { groundTexture = new Dictionary<BiomeType, Texture2D>(); elementInterface = new Dictionary<string, Texture2D>(); groundTexture.Add(BiomeType.None, content.Load<Texture2D>("Textures/Sand")); groundTexture.Add(BiomeType.Water, content.Load<Texture2D>("Textures/Sand")); groundTexture.Add(BiomeType.SubtropicalDesert, content.Load<Texture2D>("Textures/Sand")); groundTexture.Add(BiomeType.GrasslandDesert, content.Load<Texture2D>("Textures/Grass")); groundTexture.Add(BiomeType.Savanna, content.Load<Texture2D>("Textures/Gravel")); groundTexture.Add(BiomeType.Shrubland, content.Load<Texture2D>("Textures\\dirt3")); groundTexture.Add(BiomeType.Taiga, content.Load<Texture2D>("Textures/stone")); groundTexture.Add(BiomeType.Tundra, content.Load<Texture2D>("Textures/stone2")); groundTexture.Add(BiomeType.TemperateForest, content.Load<Texture2D>("Textures/Grass2")); groundTexture.Add(BiomeType.TropicalRainforest, content.Load<Texture2D>("Textures/Grass2")); groundTexture.Add(BiomeType.TemperateRainforest, content.Load<Texture2D>("Textures/Grass2")); biomeTextures = new Texture2D[groundTexture.Count]; biome3D = new Texture3D(device, 256, 256, groundTexture.Count, false, groundTexture[0].Format); Color[] texData = new Color[256 * 256*11]; foreach (BiomeType t in groundTexture.Keys) { biomeTextures[(int)t] = groundTexture[t]; biomeTextures[(int)t].GetData(texData, 256*256*((int)t), 256*256); } biome3D.SetData(texData); //biomeAtlas = content.Load<Texture2D>("Texture/biomeAtlas"); }
/// <summary> /// Generates the mip maps. /// </summary> /// <param name="device">The device.</param> /// <param name="texture">The texture.</param> /// <param name="textMip">Returns a new texture with mipmaps if succeeded. Otherwise returns the input texture</param> /// <returns>True succeed. False: Format not supported.</returns> /// <exception cref="InvalidDataException">Input texture is invalid.</exception> public static bool GenerateMipMaps(Device device, global::SharpDX.Toolkit.Graphics.Texture texture, out Resource textMip) { textMip = null; //Check texture format support: https://msdn.microsoft.com/en-us/library/windows/desktop/ff476426(v=vs.85).aspx switch (texture.Description.Format) { case global::SharpDX.DXGI.Format.R8G8B8A8_UNorm: case global::SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb: case global::SharpDX.DXGI.Format.B5G6R5_UNorm: case global::SharpDX.DXGI.Format.B8G8R8A8_UNorm: case global::SharpDX.DXGI.Format.B8G8R8A8_UNorm_SRgb: case global::SharpDX.DXGI.Format.B8G8R8X8_UNorm: case global::SharpDX.DXGI.Format.B8G8R8X8_UNorm_SRgb: case global::SharpDX.DXGI.Format.R16G16B16A16_Float: case global::SharpDX.DXGI.Format.R16G16B16A16_UNorm: case global::SharpDX.DXGI.Format.R16G16_Float: case global::SharpDX.DXGI.Format.R16G16_UNorm: case global::SharpDX.DXGI.Format.R32_Float: case global::SharpDX.DXGI.Format.R32G32B32A32_Float: case global::SharpDX.DXGI.Format.B4G4R4A4_UNorm: case global::SharpDX.DXGI.Format.R32G32B32_Float: case global::SharpDX.DXGI.Format.R16G16B16A16_SNorm: case global::SharpDX.DXGI.Format.R32G32_Float: case global::SharpDX.DXGI.Format.R10G10B10A2_UNorm: case global::SharpDX.DXGI.Format.R11G11B10_Float: case global::SharpDX.DXGI.Format.R8G8B8A8_SNorm: case global::SharpDX.DXGI.Format.R16G16_SNorm: case global::SharpDX.DXGI.Format.R8G8_UNorm: case global::SharpDX.DXGI.Format.R8G8_SNorm: case global::SharpDX.DXGI.Format.R16_Float: case global::SharpDX.DXGI.Format.R16_UNorm: case global::SharpDX.DXGI.Format.R16_SNorm: case global::SharpDX.DXGI.Format.R8_UNorm: case global::SharpDX.DXGI.Format.R8_SNorm: case global::SharpDX.DXGI.Format.A8_UNorm: case global::SharpDX.DXGI.Format.B5G5R5A1_UNorm: break; default: textMip = texture.Resource.QueryInterface <Resource>(); //Format not support, return the original texture. return(false); } var sliceCount = 1; var mipLevels = 0; switch (texture.Description.Dimension) { case global::SharpDX.Toolkit.Graphics.TextureDimension.Texture1D: var desc1D = new Texture1DDescription() { Width = texture.Description.Width, MipLevels = 0, ArraySize = 1, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Usage = ResourceUsage.Default, OptionFlags = ResourceOptionFlags.GenerateMipMaps, Format = texture.Description.Format }; textMip = new Texture1D(device, desc1D); mipLevels = (textMip as Texture1D).Description.MipLevels; break; case global::SharpDX.Toolkit.Graphics.TextureDimension.Texture2D: var desc2D = new Texture2DDescription() { Width = texture.Description.Width, Height = texture.Description.Height, MipLevels = 0, ArraySize = 1, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Usage = ResourceUsage.Default, SampleDescription = texture.Description.SampleDescription, OptionFlags = ResourceOptionFlags.GenerateMipMaps, Format = texture.Description.Format }; textMip = new Texture2D(device, desc2D); mipLevels = (textMip as Texture2D).Description.MipLevels; break; case global::SharpDX.Toolkit.Graphics.TextureDimension.Texture3D: var desc3D = new Texture3DDescription() { Width = texture.Description.Width, Height = texture.Description.Height, Depth = texture.Description.Depth, MipLevels = 0, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Usage = ResourceUsage.Default, OptionFlags = ResourceOptionFlags.GenerateMipMaps, Format = texture.Description.Format }; textMip = new Texture3D(device, desc3D); sliceCount = texture.Description.Depth; mipLevels = (textMip as Texture3D).Description.MipLevels; break; case global::SharpDX.Toolkit.Graphics.TextureDimension.TextureCube: var descCube = new Texture2DDescription() { Width = texture.Description.Width, Height = texture.Description.Height, ArraySize = texture.Description.ArraySize, MipLevels = 0, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, SampleDescription = new global::SharpDX.DXGI.SampleDescription(1, 0), Usage = ResourceUsage.Default, OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube, Format = texture.Description.Format }; textMip = new Texture2D(device, descCube); sliceCount = texture.Description.ArraySize; mipLevels = (textMip as Texture2D).Description.MipLevels; break; default: throw new InvalidDataException("Input texture is invalid."); } using (var shaderRes = new ShaderResourceView(device, textMip)) { for (var i = 0; i < sliceCount; ++i) { var idx = texture.GetSubResourceIndex(i, 0); var targetIdx = GetSubResourceIndex(i, mipLevels, 0); device.ImmediateContext.CopySubresourceRegion(texture, idx, null, textMip, targetIdx); } device.ImmediateContext.GenerateMips(shaderRes); } return(true); }
void GenerateFloatingIslands(int size) { DensityFieldWidth = size + 1; DensityFieldHeight = size/2 + 1; DensityFieldDepth = DensityFieldWidth; InitializeFieldData(); //Here we generate our noise textures int nSize = 16; noiseTextures = new Texture3D[4]; float[] noiseData = new float[nSize * nSize * nSize]; Random rand = new Random(); for (int i = 0; i < noiseTextures.Length; i++) { noiseTextures[i] = new Texture3D(GFX.Device, nSize, nSize, nSize, 1, TextureUsage.None, SurfaceFormat.Single); for (int j = 0; j < noiseData.Length; j++) { noiseData[j] = (float)(rand.NextDouble() * 2 - 1); } noiseTextures[i].SetData<float>(noiseData); } noiseData = null; //The program we'll be using Shader islandShader = ResourceManager.Inst.GetShader("ProceduralIsland"); islandShader.SetupShader(); GFX.Device.SetPixelShaderConstant(0, Vector3.One / new Vector3(DensityFieldWidth, DensityFieldHeight, DensityFieldDepth)); //Lets activate our textures for (int i = 0; i < noiseTextures.Length; i++) GFX.Device.Textures[i] = noiseTextures[i]; GFX.Device.SetVertexShaderConstant(1, textureMatrix); //Set swizzle axis to the z axis GFX.Device.SetPixelShaderConstant(1, Vector4.One * 2); //Here we setup our render target. //This is used to fetch what is rendered to our screen and store it in a texture. srcTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldHeight, 1, GFX.Inst.ByteSurfaceFormat); DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer; GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge; for (int z = 0; z < DensityFieldDepth; z++) { Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1); GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth GFX.Device.SetRenderTarget(0, srcTarget); GFX.Device.Clear(Color.TransparentBlack); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); //Now the copying stage. ExtractDensityTextureData(ref DensityField, z); } GFX.Device.DepthStencilBuffer = dsOld; InitializeSurfaceIndices(); InitializeVoxels(); }
///<summary> /// Call this to associate a Xna Texture3D with this pixel buffer ///</summary> public void Bind( GraphicsDevice device, Texture3D volume, bool update ) { this.device = device; this.volume = volume; width = volume.Width; height = volume.Height; depth = volume.Depth; format = XnaHelper.Convert( volume.Format ); // Default rowPitch = Width; slicePitch = Height*Width; sizeInBytes = PixelUtil.GetMemorySize( Width, Height, Depth, Format ); if ( ( (int)usage & (int)TextureUsage.RenderTarget ) != 0 ) CreateRenderTextures( update ); }
public void RemakeTexture() { GetData(); _texture = MakeTexture(values); }
/// <summary> /// Bind to a pixel shader for rendering. /// </summary> public void BindToMaterial(Material mat) { if (UseLuminance == LUMINANCE.NONE) { mat.EnableKeyword("RADIANCE_API_ENABLED"); } else { mat.DisableKeyword("RADIANCE_API_ENABLED"); } if (CombineScatteringTextures) { mat.EnableKeyword("COMBINED_SCATTERING_TEXTURES"); } else { mat.DisableKeyword("COMBINED_SCATTERING_TEXTURES"); } string path = "Assets/BrunetonsImprovedAtmosphere/Textures/"; Texture2D t = TransmittanceTexture.ToTexture2D(); AssetDatabase.CreateAsset(t, path + "transmittance.Texture2D"); Texture3D s = ScatteringTexture.ToTexture3D(); AssetDatabase.CreateAsset(s, path + "scattering.Texture3D"); Texture2D i = IrradianceTexture.ToTexture2D(); AssetDatabase.CreateAsset(i, path + "irradiance.Texture2D"); mat.SetTexture("transmittance_texture", t); mat.SetTexture("scattering_texture", s); mat.SetTexture("irradiance_texture", i); if (CombineScatteringTextures) { mat.SetTexture("single_mie_scattering_texture", TextureUtilities.blackTexture3D()); } else { Texture3D m = OptionalSingleMieScatteringTexture.ToTexture3D(); AssetDatabase.CreateAsset(m, path + "optional_mie.Texture3D"); mat.SetTexture("single_mie_scattering_texture", m); } mat.SetInt("TRANSMITTANCE_TEXTURE_WIDTH", CONSTANTS.TRANSMITTANCE_WIDTH); mat.SetInt("TRANSMITTANCE_TEXTURE_HEIGHT", CONSTANTS.TRANSMITTANCE_HEIGHT); mat.SetInt("SCATTERING_TEXTURE_R_SIZE", CONSTANTS.SCATTERING_R); mat.SetInt("SCATTERING_TEXTURE_MU_SIZE", CONSTANTS.SCATTERING_MU); mat.SetInt("SCATTERING_TEXTURE_MU_S_SIZE", CONSTANTS.SCATTERING_MU_S); mat.SetInt("SCATTERING_TEXTURE_NU_SIZE", CONSTANTS.SCATTERING_NU); mat.SetInt("SCATTERING_TEXTURE_WIDTH", CONSTANTS.SCATTERING_WIDTH); mat.SetInt("SCATTERING_TEXTURE_HEIGHT", CONSTANTS.SCATTERING_HEIGHT); mat.SetInt("SCATTERING_TEXTURE_DEPTH", CONSTANTS.SCATTERING_DEPTH); mat.SetInt("IRRADIANCE_TEXTURE_WIDTH", CONSTANTS.IRRADIANCE_WIDTH); mat.SetInt("IRRADIANCE_TEXTURE_HEIGHT", CONSTANTS.IRRADIANCE_HEIGHT); mat.SetFloat("sun_angular_radius", (float)SunAngularRadius); mat.SetFloat("bottom_radius", (float)(BottomRadius / LengthUnitInMeters)); mat.SetFloat("top_radius", (float)(TopRadius / LengthUnitInMeters)); mat.SetFloat("mie_phase_function_g", (float)MiePhaseFunctionG); mat.SetFloat("mu_s_min", (float)Math.Cos(MaxSunZenithAngle)); Vector3 skySpectralRadianceToLuminance, sunSpectralRadianceToLuminance; SkySunRadianceToLuminance(out skySpectralRadianceToLuminance, out sunSpectralRadianceToLuminance); mat.SetVector("SKY_SPECTRAL_RADIANCE_TO_LUMINANCE", skySpectralRadianceToLuminance); mat.SetVector("SUN_SPECTRAL_RADIANCE_TO_LUMINANCE", sunSpectralRadianceToLuminance); double[] lambdas = new double[] { kLambdaR, kLambdaG, kLambdaB }; Vector3 solarIrradiance = ToVector(Wavelengths, SolarIrradiance, lambdas, 1.0); mat.SetVector("solar_irradiance", solarIrradiance); Vector3 rayleighScattering = ToVector(Wavelengths, RayleighScattering, lambdas, LengthUnitInMeters); mat.SetVector("rayleigh_scattering", rayleighScattering); Vector3 mieScattering = ToVector(Wavelengths, MieScattering, lambdas, LengthUnitInMeters); mat.SetVector("mie_scattering", mieScattering); }
void GenerateNoise_3D() { Texture3D tex3D = new Texture3D(mTexSize, mTexSize, mTexSize, TextureFormat.RGBA32, false); Color[] cols = tex3D.GetPixels(); var buffer = new ComputeBuffer(mTexSize * mTexSize * mTexSize, sizeof(float)); float[] datas = new float[mTexSize * mTexSize * mTexSize]; if (SetNoiseCS_3D(noises[0], buffer) == true) { buffer.GetData(datas); for (int i = 0; i < datas.Length; ++i) { cols[i].r = datas[i]; } } else { for (int i = 0; i < datas.Length; ++i) { cols[i].r = 0f; } } if (SetNoiseCS_3D(noises[1], buffer) == true) { buffer.GetData(datas); for (int i = 0; i < datas.Length; ++i) { cols[i].g = datas[i]; } } else { for (int i = 0; i < datas.Length; ++i) { cols[i].g = 0f; } } if (SetNoiseCS_3D(noises[2], buffer) == true) { buffer.GetData(datas); for (int i = 0; i < datas.Length; ++i) { cols[i].b = datas[i]; } } else { for (int i = 0; i < datas.Length; ++i) { cols[i].b = 0f; } } if (SetNoiseCS_3D(noises[3], buffer) == true) { buffer.GetData(datas); for (int i = 0; i < datas.Length; ++i) { cols[i].a = datas[i]; } } else { for (int i = 0; i < datas.Length; ++i) { cols[i].a = 0f; } } buffer.Release(); tex3D.SetPixels(cols); tex3D.Apply(); SaveTexture <Texture3D>(tex3D); }
void Start() { texture = CreateTexture3D(256); }
public void VolumeVoxelizationPass(HDCamera hdCamera, CommandBuffer cmd, uint frameIndex, DensityVolumeList densityVolumes, LightLoop lightLoop) { if (!hdCamera.frameSettings.enableVolumetrics) { return; } var visualEnvironment = VolumeManager.instance.stack.GetComponent <VisualEnvironment>(); if (visualEnvironment.fogType.value != FogType.Volumetric) { return; } using (new ProfilingSample(cmd, "Volume Voxelization")) { int numVisibleVolumes = m_VisibleVolumeBounds.Count; bool tiledLighting = hdCamera.frameSettings.lightLoopSettings.enableBigTilePrepass; bool highQuality = preset == VolumetricLightingPreset.High; int kernel = (tiledLighting ? 1 : 0) | (highQuality ? 2 : 0); var currFrameParams = hdCamera.vBufferParams[0]; var cvp = currFrameParams.viewportSize; Vector4 resolution = new Vector4(cvp.x, cvp.y, 1.0f / cvp.x, 1.0f / cvp.y); #if UNITY_2019_1_OR_NEWER var vFoV = hdCamera.camera.GetGateFittedFieldOfView() * Mathf.Deg2Rad; var lensShift = hdCamera.camera.GetGateFittedLensShift(); #else var vFoV = hdCamera.camera.fieldOfView * Mathf.Deg2Rad; var lensShift = Vector2.zero; #endif // Compose the matrix which allows us to compute the world space view direction. Matrix4x4 transform = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, lensShift, resolution, hdCamera.viewMatrix, false); // Compute texel spacing at the depth of 1 meter. float unitDepthTexelSpacing = HDUtils.ComputZPlaneTexelSpacing(1.0f, vFoV, resolution.y); Texture3D volumeAtlas = DensityVolumeManager.manager.volumeAtlas.GetAtlas(); Vector4 volumeAtlasDimensions = new Vector4(0.0f, 0.0f, 0.0f, 0.0f); if (volumeAtlas != null) { volumeAtlasDimensions.x = (float)volumeAtlas.width / volumeAtlas.depth; // 1 / number of textures volumeAtlasDimensions.y = volumeAtlas.width; volumeAtlasDimensions.z = volumeAtlas.depth; volumeAtlasDimensions.w = Mathf.Log(volumeAtlas.width, 2); // Max LoD } else { volumeAtlas = CoreUtils.blackVolumeTexture; } if (hdCamera.frameSettings.VolumeVoxelizationRunsAsync()) { // We explicitly set the big tile info even though it is set globally, since this could be running async before the PushGlobalParams cmd.SetComputeIntParam(m_VolumeVoxelizationCS, HDShaderIDs._NumTileBigTileX, lightLoop.GetNumTileBigTileX(hdCamera)); cmd.SetComputeIntParam(m_VolumeVoxelizationCS, HDShaderIDs._NumTileBigTileY, lightLoop.GetNumTileBigTileY(hdCamera)); if (hdCamera.frameSettings.lightLoopSettings.enableBigTilePrepass) { cmd.SetComputeBufferParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs.g_vBigTileLightList, lightLoop.GetBigTileLightList()); } } cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity, m_DensityBufferHandle); cmd.SetComputeBufferParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeBounds, s_VisibleVolumeBoundsBuffer); cmd.SetComputeBufferParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeData, s_VisibleVolumeDataBuffer); cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeMaskAtlas, volumeAtlas); // TODO: set the constant buffer data only once. cmd.SetComputeMatrixParam(m_VolumeVoxelizationCS, HDShaderIDs._VBufferCoordToViewDirWS, transform); cmd.SetComputeFloatParam(m_VolumeVoxelizationCS, HDShaderIDs._VBufferUnitDepthTexelSpacing, unitDepthTexelSpacing); cmd.SetComputeIntParam(m_VolumeVoxelizationCS, HDShaderIDs._NumVisibleDensityVolumes, numVisibleVolumes); cmd.SetComputeVectorParam(m_VolumeVoxelizationCS, HDShaderIDs._VolumeMaskDimensions, volumeAtlasDimensions); int w = (int)resolution.x; int h = (int)resolution.y; // The shader defines GROUP_SIZE_1D = 8. cmd.DispatchCompute(m_VolumeVoxelizationCS, kernel, (w + 7) / 8, (h + 7) / 8, 1); } }
public int GetTextureIndex(Texture3D tex) { return(textures.IndexOf(tex)); }
public Texture3D Convert(Texture2D temp2DTex, Texture3D cv3D) { int dim = 256 * 16; if (temp2DTex) { dim = temp2DTex.width * temp2DTex.height; dim = temp2DTex.height; if (!ValidDimensions(temp2DTex)) { Debug.LogWarning("The given 2D texture " + temp2DTex.name + " cannot be used as a 3D LUT."); return(cv3D); } } #if UNITY_EDITOR if (Application.isPlaying != true) { string path = AssetDatabase.GetAssetPath(LutTexture); MemoPath = path; TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter; if (!textureImporter.isReadable) { textureImporter.isReadable = true; textureImporter.mipmapEnabled = false; AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); } string path2 = AssetDatabase.GetAssetPath(LutTexture2); MemoPath2 = path2; TextureImporter textureImporter2 = AssetImporter.GetAtPath(path2) as TextureImporter; if (!textureImporter2.isReadable) { textureImporter2.isReadable = true; textureImporter2.mipmapEnabled = false; AssetDatabase.ImportAsset(path2, ImportAssetOptions.ForceUpdate); } } #endif var c = temp2DTex.GetPixels(); var newC = new Color[c.Length]; for (int i = 0; i < dim; i++) { for (int j = 0; j < dim; j++) { for (int k = 0; k < dim; k++) { int j_ = dim - j - 1; newC[i + (j * dim) + (k * dim * dim)] = c[k * dim + i + j_ * dim * dim]; } } } if (cv3D) { DestroyImmediate(cv3D); } cv3D = new Texture3D(dim, dim, dim, TextureFormat.ARGB32, false); cv3D.SetPixels(newC); cv3D.Apply(); return(cv3D); }
protected override void LoadContent() { base.LoadContent(); // Create a step size based on the largest side length and create a scale factor // for the shader float maxSideLength = (float)Math.Max(width, Math.Max(height, depth)); Vector3 stepSize = new Vector3(1.0f / maxSideLength, 1.0f / maxSideLength, 1.0f / maxSideLength); effect.Parameters["StepSize"].SetValue(stepSize * stepScale); effect.Parameters["ActualSampleDist"].SetValue(stepScale); effect.Parameters["Iterations"].SetValue((int)maxSideLength * (1.0f / stepScale) * 2.0f); Vector3 sizes = new Vector3(width, height, depth); Vector3 scaleFactor = Vector3.One / ((Vector3.One * maxSideLength) / (sizes * Vector3.One)); effect.Parameters["ScaleFactor"].SetValue(new Vector4(scaleFactor, 1.0f)); // Get the scaled volume data. float[] volumeData; RawFileReader tempFileReader = new RawFileReader(); tempFileReader.Open(volumeAssetName, width, height, depth); tempFileReader.GetRawData(out volumeData); tempFileReader.Close(); // Compute the gradient at each voxel and combine them with the isovalues. HalfVector4[] textureData; CreateTextureData(volumeData, out textureData); // Set the data into our Texture3D object, for use in the shader. volumeTexture = new Texture3D(VolumetricRenderer.Game.GraphicsDevice, width, height, depth, 0, TextureUsage.None, SurfaceFormat.HalfVector4); volumeTexture.SetData<HalfVector4>(textureData); effect.Parameters["Volume"].SetValue(volumeTexture); if (transfer2DTex != null) { effect.Parameters["Transfer"].SetValue(transfer2DTex); } }
public void VolumeVoxelizationPass(HDCamera hdCamera, CommandBuffer cmd, uint frameIndex, DensityVolumeList densityVolumes) { if (!hdCamera.frameSettings.enableVolumetrics) { return; } var visualEnvironment = VolumeManager.instance.stack.GetComponent <VisualEnvironment>(); if (visualEnvironment.fogType.value != FogType.Volumetric) { return; } using (new ProfilingSample(cmd, "Volume Voxelization")) { int numVisibleVolumes = m_VisibleVolumeBounds.Count; bool highQuality = preset == VolumetricLightingPreset.High; bool enableClustered = hdCamera.frameSettings.lightLoopSettings.enableTileAndCluster; int kernel; if (highQuality) { kernel = m_VolumeVoxelizationCS.FindKernel(enableClustered ? "VolumeVoxelizationClusteredHQ" : "VolumeVoxelizationBruteforceHQ"); } else { kernel = m_VolumeVoxelizationCS.FindKernel(enableClustered ? "VolumeVoxelizationClusteredMQ" : "VolumeVoxelizationBruteforceMQ"); } var frameParams = hdCamera.vBufferParams[0]; Vector4 resolution = frameParams.resolution; float vFoV = hdCamera.camera.fieldOfView * Mathf.Deg2Rad; // Compose the matrix which allows us to compute the world space view direction. Matrix4x4 transform = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, resolution, hdCamera.viewMatrix, false); Texture3D volumeAtlas = DensityVolumeManager.manager.volumeAtlas.volumeAtlas; Vector4 volumeAtlasDimensions = new Vector4(0.0f, 0.0f, 0.0f, 0.0f); if (volumeAtlas != null) { volumeAtlasDimensions.x = (float)volumeAtlas.width / volumeAtlas.depth; // 1 / number of textures volumeAtlasDimensions.y = volumeAtlas.width; volumeAtlasDimensions.z = volumeAtlas.depth; volumeAtlasDimensions.w = Mathf.Log(volumeAtlas.width, 2); // Max LoD } else { volumeAtlas = CoreUtils.blackVolumeTexture; } cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity, m_DensityBufferHandle); cmd.SetComputeBufferParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeBounds, s_VisibleVolumeBoundsBuffer); cmd.SetComputeBufferParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeData, s_VisibleVolumeDataBuffer); cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeMaskAtlas, volumeAtlas); // TODO: set the constant buffer data only once. cmd.SetComputeMatrixParam(m_VolumeVoxelizationCS, HDShaderIDs._VBufferCoordToViewDirWS, transform); cmd.SetComputeIntParam(m_VolumeVoxelizationCS, HDShaderIDs._NumVisibleDensityVolumes, numVisibleVolumes); cmd.SetComputeVectorParam(m_VolumeVoxelizationCS, HDShaderIDs._VolumeMaskDimensions, volumeAtlasDimensions); int w = (int)resolution.x; int h = (int)resolution.y; // The shader defines GROUP_SIZE_1D = 8. cmd.DispatchCompute(m_VolumeVoxelizationCS, kernel, (w + 7) / 8, (h + 7) / 8, 1); } }
void AssembleTextureAtlas(Texture3D target, Texture2D[] srcTextures, int textureSize, int mipCount) { Shader imageShader = ResourceManager.Inst.GetShader("Generic2D"); RenderTarget2D rtTarget = new RenderTarget2D(GFX.Device, textureSize, textureSize, 1, SurfaceFormat.Color); target = new Texture3D(GFX.Device, textureSize, textureSize, srcTextures.Length, mipCount, TextureUsage.AutoGenerateMipMap, SurfaceFormat.Color); Color[] colorBuffer = new Color[textureSize * textureSize]; GFX.Device.SamplerStates[0].MagFilter = TextureFilter.Linear; GFX.Device.SamplerStates[0].MinFilter = TextureFilter.Linear; GFX.Device.SamplerStates[0].MipFilter = TextureFilter.Linear; imageShader.SetupShader(); for (int i = 0; i < srcTextures.Length; i++) { GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, Vector2.One / new Vector2(srcTextures[i].Width, srcTextures[i].Height)); GFX.Device.Textures[0] = srcTextures[i]; GFX.Device.SetRenderTarget(0, rtTarget); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); rtTarget.GetTexture().GetData<Color>(colorBuffer); target.SetData<Color>(colorBuffer, colorBuffer.Length * i, colorBuffer.Length, SetDataOptions.None); } target.GenerateMipMaps(TextureFilter.Linear); }
protected override void OnProcess(RenderContext context) { var graphicsDevice = GraphicsService.GraphicsDevice; if (TextureHelper.IsFloatingPointFormat(context.SourceTexture.Format)) { graphicsDevice.SamplerStates[0] = SamplerState.PointClamp; } else { graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; } graphicsDevice.SetRenderTarget(context.RenderTarget); graphicsDevice.Viewport = context.Viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sourceTextureParameter.SetValue(context.SourceTexture); _strengthParameter.SetValue(new Vector2(Strength, InterpolationParameter)); if (LookupTextureA == null && LookupTextureB == null) { if (_defaultLookupTexture == null) { _defaultLookupTexture = ConvertLookupTexture(CreateLookupTexture2D(graphicsDevice)); } Debug.Assert(_defaultLookupTexture != null, "Failed to create 3D lookup texture."); _lookupTexture0Parameter.SetValue(_defaultLookupTexture); _lookupTableSizeParameter.SetValue(_defaultLookupTexture.Width); _fullColorLookupPass.Apply(); } else if (LookupTextureA == null) { ApplyPassWithOneLookupTexture(LookupTextureB); } else if (LookupTextureB == null) { ApplyPassWithOneLookupTexture(LookupTextureA); } else { if (Numeric.AreEqual(InterpolationParameter, 0)) { ApplyPassWithOneLookupTexture(LookupTextureA); } else if (Numeric.AreEqual(InterpolationParameter, 1)) { ApplyPassWithOneLookupTexture(LookupTextureB); } else { _lookupTexture0Parameter.SetValue(LookupTextureA); _lookupTexture1Parameter.SetValue(LookupTextureB); _lookupTableSizeParameter.SetValue(LookupTextureA.Width); _lerpColorLookupPass.Apply(); } } graphicsDevice.DrawFullScreenQuad(); _sourceTextureParameter.SetValue((Texture2D)null); _lookupTexture0Parameter.SetValue((Texture2D)null); _lookupTexture1Parameter.SetValue((Texture2D)null); }
void PerformBlur(Texture2D heightmap) { Shader heightBlur2DShader = ResourceManager.Inst.GetShader("HeightmapBlurMinMax"); RenderTarget2D paramTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldDepth, 1, SurfaceFormat.Vector4); GFX.Device.SetPixelShaderConstant(GFXShaderConstants.VC_INVTEXRES, Vector2.One / new Vector2(DensityFieldWidth, DensityFieldDepth)); GFX.Device.SetPixelShaderConstant(0, Vector2.One / new Vector2(DensityFieldWidth, DensityFieldDepth)); heightBlur2DShader.SetupShader(); GFX.Device.Textures[0] = heightmap; GFX.Device.SetRenderTarget(0, paramTarget); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); Shader gradShader = ResourceManager.Inst.GetShader("GradientHeightmap"); GFX.Device.Textures[0] = paramTarget.GetTexture(); gradShader.SetupShader(); RenderTarget2D gradTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldDepth, 1, SurfaceFormat.Single); GFX.Device.SetRenderTarget(0, gradTarget); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); GFX.Device.Textures[0] = null; Shader blurShader = ResourceManager.Inst.GetShader("VoxelBlur3x3x3"); srcTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldHeight, 1, GFX.Inst.ByteSurfaceFormat); DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer; GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge; blurShader.SetupShader(); GFX.Device.SetPixelShaderConstant(0, Vector3.One / new Vector3(DensityFieldWidth, DensityFieldHeight, DensityFieldDepth)); GFX.Device.SamplerStates[0].AddressU = TextureAddressMode.Clamp; GFX.Device.SamplerStates[0].AddressV = TextureAddressMode.Clamp; GFX.Device.SamplerStates[0].AddressW = TextureAddressMode.Clamp; GFX.Device.RenderState.DepthBufferEnable = false; GFX.Device.RenderState.DepthBufferWriteEnable = false; //Here we generate our noise textures int nSize = 32; noiseTextures = new Texture3D[4]; float[] noiseData = new float[nSize * nSize * nSize]; Random rand = new Random(); for (int i = 0; i < noiseTextures.Length; i++) { noiseTextures[i] = new Texture3D(GFX.Device, nSize, nSize, nSize, 1, TextureUsage.None, SurfaceFormat.Single); for (int j = 0; j < noiseData.Length; j++) { noiseData[j] = (float)(rand.NextDouble() * 2 - 1); } noiseTextures[i].SetData<float>(noiseData); } noiseData = null; //Lets activate our textures for (int i = 0; i < noiseTextures.Length; i++) GFX.Device.Textures[i+3] = noiseTextures[i]; //CopyDensityTextureData(ref DensityField, currDensityField); GFX.Device.Textures[0] = heightmap; GFX.Device.Textures[1] = paramTarget.GetTexture(); GFX.Device.Textures[2] = gradTarget.GetTexture(); for (int z = 0; z < DensityFieldDepth; z++) { Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1); GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth GFX.Device.SetRenderTarget(0, srcTarget); //GFX.Device.Clear(Color.TransparentBlack); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); //Now the copying stage. ExtractDensityTextureData(ref DensityField, z); } GFX.Device.Textures[0] = null; /* Texture3D voxelTexture = new Texture3D(GFX.Device, DensityFieldWidth, DensityFieldHeight, DensityFieldDepth, 1, TextureUsage.None, GFX.Inst.ByteSurfaceFormat); switch (GFX.Inst.ByteSurfaceDataType) { case GFXTextureDataType.BYTE: voxelTexture.SetData<byte>(DensityField); break; case GFXTextureDataType.COLOR: Color[] tempColor = new Color[DensityField.Length]; for(int i = 0; i < tempColor.Length; i++) tempColor[i] = new Color(DensityField[i], DensityField[i], DensityField[i], DensityField[i]); voxelTexture.SetData<Color>(tempColor); tempColor = null; break; case GFXTextureDataType.SINGLE: float[] tempFloat = new float[DensityField.Length]; float invScale = 1.0f / 255.0f; for (int i = 0; i < tempFloat.Length; i++) tempFloat[i] = (float)DensityField[i] * invScale; voxelTexture.SetData<float>(tempFloat); tempFloat = null; break; } Shader blurShaderGeneric = ResourceManager.Inst.GetShader("VoxelBlurGeneric"); blurShaderGeneric.SetupShader(); GFX.Device.Textures[0] = voxelTexture; for (int z = 0; z < DensityFieldDepth; z++) { Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1); GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth GFX.Device.SetRenderTarget(0, srcTarget); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); //Now the copying stage. ExtractDensityTextureData(ref DensityField, z); } GFX.Device.Textures[0] = null; voxelTexture.Dispose(); */ GFX.Device.DepthStencilBuffer = dsOld; GFX.Device.RenderState.DepthBufferEnable = true; GFX.Device.RenderState.DepthBufferWriteEnable = true; }
protected Texture3D CreateTexture3D() { var texture = new Texture3D(); texture.Storage(Format, dimensions); return(texture); }
public ShaderResourceView ToTexture3D(Device graphicsDevice, Format format) { int sizeInBytes = sizeof(float) * width * height * depth; DataStream stream = new DataStream(sizeInBytes, true, true); for (int x = 0; x < width; x++) for (int y = 0; y < height; y++) for (int z = 0; z < depth; z++) stream.Write(values[x, y, z]); stream.Position = 0; DataBox dataBox = new DataBox(sizeof(float) * width, sizeof(float) * width * height, stream); Texture3DDescription description = new Texture3DDescription() { BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Depth = depth, Format = format, Height = height, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, Usage = ResourceUsage.Default, Width = width }; Texture3D texture = new Texture3D(graphicsDevice, description, dataBox); stream.Dispose(); return new ShaderResourceView(graphicsDevice, texture); }
/// <summary> /// /// </summary> void LoadNoise3dTexture() { // basic dds loader for 3d texture - !not very robust! TextAsset data = Resources.Load("NoiseVolume") as TextAsset; byte[] bytes = data.bytes; uint height = BitConverter.ToUInt32(data.bytes, 12); uint width = BitConverter.ToUInt32(data.bytes, 16); uint pitch = BitConverter.ToUInt32(data.bytes, 20); uint depth = BitConverter.ToUInt32(data.bytes, 24); uint formatFlags = BitConverter.ToUInt32(data.bytes, 20 * 4); uint fourCC = BitConverter.ToUInt32(data.bytes, 21 * 4); uint bitdepth = BitConverter.ToUInt32(data.bytes, 22 * 4); if (bitdepth == 0) { bitdepth = pitch / width * 8; } // doesn't work with TextureFormat.Alpha8 for some reason _noiseTexture = new Texture3D((int)width, (int)height, (int)depth, TextureFormat.RGBA32, false); _noiseTexture.name = "3D Noise"; Color[] c = new Color[width * height * depth]; uint index = 128; if (data.bytes[21 * 4] == 'D' && data.bytes[21 * 4 + 1] == 'X' && data.bytes[21 * 4 + 2] == '1' && data.bytes[21 * 4 + 3] == '0' && (formatFlags & 0x4) != 0) { uint format = BitConverter.ToUInt32(data.bytes, (int)index); if (format >= 60 && format <= 65) { bitdepth = 8; } else if (format >= 48 && format <= 52) { bitdepth = 16; } else if (format >= 27 && format <= 32) { bitdepth = 32; } //Debug.Log("DXGI format: " + format); // dx10 format, skip dx10 header //Debug.Log("DX10 format"); index += 20; } uint byteDepth = bitdepth / 8; pitch = (width * bitdepth + 7) / 8; for (int d = 0; d < depth; ++d) { //index = 128; for (int h = 0; h < height; ++h) { for (int w = 0; w < width; ++w) { float v = (bytes[index + w * byteDepth] / 255.0f); c[w + h * width + d * width * height] = new Color(v, v, v, v); } index += pitch; } } _noiseTexture.SetPixels(c); _noiseTexture.Apply(); }
public void SetTexture(TextureResourceType type, Texture texture) { textureType = type; switch (textureType) { case TextureResourceType.Texture3D: texture3D = (Texture3D)texture; break; case TextureResourceType.TextureCube: textureCube = (TextureCube)texture; break; default: texture2D = (Texture2D)texture; break; } }
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx) { byte[] bytes = File.ReadAllBytes(ctx.assetPath); int width = 1, height = 1, depth = 1; try { int channels = 0; string fourcc = Encoding.UTF8.GetString(SubArray <byte>(bytes, 0, 4)); if (fourcc != "VF_F" && fourcc != "VF_V") { throw new Exception("Invalid VF File Header. Need VF_F or VF_V, found :" + fourcc); } else { if (fourcc == "VF_F") { channels = 1; } if (fourcc == "VF_V") { channels = 3; } } TextureFormat outFormat = TextureFormat.Alpha8; switch (m_OutputFormat) { case VectorFieldOutputFormat.Byte: outFormat = channels == 3 ? TextureFormat.RGBA32 : TextureFormat.Alpha8; break; case VectorFieldOutputFormat.Half: outFormat = channels == 3 ? TextureFormat.RGBAHalf : TextureFormat.RHalf; break; case VectorFieldOutputFormat.Float: outFormat = channels == 3 ? TextureFormat.RGBAFloat : TextureFormat.RFloat; break; } if (bytes.Length < 10) { throw new Exception("Malformed VF File, invalid header (less than 10 bytes)"); } width = BitConverter.ToUInt16(bytes, 4); height = BitConverter.ToUInt16(bytes, 6); depth = BitConverter.ToUInt16(bytes, 8); int requiredLength = 10 + (4 * channels * (width * height * depth)); if (bytes.Length != requiredLength) { throw new Exception("Malformed VF File, invalid length (expected :" + requiredLength + ", found :" + bytes.Length + ")"); } Texture3D texture = new Texture3D(width, height, depth, outFormat, m_GenerateMipMaps); texture.wrapMode = m_WrapMode; texture.filterMode = m_FilterMode; texture.anisoLevel = m_AnisoLevel; int count = width * height * depth; Color[] colors = new Color[count]; for (int i = 0; i < count; i++) { Color c; if (channels == 1) { float x = BitConverter.ToSingle(bytes, 10 + (i * 4 * channels)); c = new Color(x, 0, 0); } else { float x = BitConverter.ToSingle(bytes, 10 + (i * 4 * channels)); float y = BitConverter.ToSingle(bytes, 14 + (i * 4 * channels)); float z = BitConverter.ToSingle(bytes, 18 + (i * 4 * channels)); c = new Color(x, y, z); } colors[i] = c; } texture.SetPixels(colors); texture.Apply(true, true); ctx.AddObjectToAsset("VectorField", texture); ctx.SetMainObject(texture); } catch (System.Exception e) { Debug.LogException(e); } }
/// <summary> /// Save current settings to default settings /// </summary> public void SaveCurrentToDefault() { defaultIsProceduralSkybox = isProceduralSkybox; defaultShowSettings = showSettings; defaultSkyboxExposure = skyboxExposure; defaultSkyboxGroundIntensity = skyboxGroundIntensity; defaultSkyboxRotation = skyboxRotation; defaultSkyboxPitch = skyboxPitch; defaultSkyboxTint = skyboxTint; defaultCustomSkybox = customSkybox; defaultSunColor = sunColor; defaultShadowDistance = shadowDistance; defaultShadowType = shadowType; defaultFogColor = fogColor; defaultFogDistance = fogDistance; defaultFogDensity = fogDensity; defaultSunIntensity = sunIntensity; defaultLWRPSunIntensity = LWRPSunIntensity; defaultHDRPSunIntensity = HDRPSunIntensity; defaultShadowStrength = shadowStrength; defaultIndirectLightMultiplier = indirectLightMultiplier; defaultSunRotation = sunRotation; defaultTemperature = temperature; defaultUseTempature = useTempature; defaultScaleHorizonObjectWithFog = scaleHorizonObjectWithFog; defaultHorizonSkyEnabled = horizonSkyEnabled; defaultHorizonBlend = horizonBlend; defaultHorizonFalloff = horizonFalloff; defaultHorizonFogDensity = horizonFogDensity; defaultHorizonScattering = horizonScattering; defaultNearFogDistance = nearFogDistance; defaultHorizonSize = horizonSize; defaultFollowPlayer = followPlayer; defaultHorizonPosition = horizonPosition; defaultHorizonUpdateTime = horizonUpdateTime; defaultAmbientMode = ambientMode; defaultSkyColor = skyColor; defaultEquatorColor = equatorColor; defaultGroundColor = groundColor; defaultLWRPSkyColor = lwrpSkyColor; defaultLWRPEquatorColor = lwrpEquatorColor; defaultLWRPGroundColor = lwrpGroundColor; defaultHDRISkybox = hDRISkybox; defaultShadowQuality = shadowQuality; defaultShadowmaskMode = shadowmaskMode; defaultShadowQuality = shadowQuality; defaultShadowResolution = shadowResolution; defaultShadowProjection = shadowProjection; defaultCascadeCount = cascadeCount; defaultEnableSunDisk = enableSunDisk; defaultSkyMultiplier = skyMultiplier; defaultHDRPFogDistance = hDRPFogDistance; defaultIsGlobal = isGlobal; defaultBlendDistance = blendDistance; defaultWeight = weight; defaultPriority = priority; defaultFogType = fogType; defaultHDRIExposure = hDRIExposure; defaultHDRIMultiplier = hDRIMultiplier; defaultHDRIUpdateMode = hDRIUpdateMode; defaultHDRIRotation = hDRIRotation; defaultMaxShadowDistance = maxShadowDistance; defaultCascadeSplit1 = cascadeSplit1; defaultCascadeSplit2 = cascadeSplit2; defaultCascadeSplit3 = cascadeSplit3; defaultUseContactShadows = useContactShadows; defaultContactShadowsLength = contactShadowsLength; defaultContactShadowsDistanceScaleFactor = contactShadowsDistanceScaleFactor; defaultContactShadowsMaxDistance = contactShadowsMaxDistance; defaultContactShadowsFadeDistance = contactShadowsFadeDistance; defaultContactShadowsSampleCount = contactShadowsSampleCount; defaultContactShadowsOpacity = contactShadowsOpacity; defaultUseMicroShadowing = useMicroShadowing; defaultMicroShadowOpacity = microShadowOpacity; defaultVolumetricSingleScatteringAlbedo = volumetricSingleScatteringAlbedo; defaultVolumetricBaseFogDistance = volumetricBaseFogDistance; defaultVolumetricBaseFogHeight = volumetricBaseFogHeight; defaultVolumetricMeanHeight = volumetricMeanHeight; defaultVolumetricGlobalAnisotropy = volumetricGlobalAnisotropy; defaultVolumetricGlobalLightProbeDimmer = volumetricGlobalLightProbeDimmer; defaultVolumetricMaxFogDistance = volumetricMaxFogDistance; defaultVolumetricEnableDistanceFog = volumetricEnableDistanceFog; defaultVolumetricConstFogColor = volumetricConstFogColor; defaultVolumetricMipFogNear = volumetricMipFogNear; defaultVolumetricMipFogFar = volumetricMipFogFar; defaultVolumetricMipFogMaxMip = volumetricMipFogMaxMip; defaultExponentialFogDensity = exponentialFogDensity; defaultExponentialBaseHeight = exponentialBaseHeight; defaultExponentialHeightAttenuation = exponentialHeightAttenuation; defaultExponentialMaxFogDistance = exponentialMaxFogDistance; defaultExponentialMipFogNear = exponentialMipFogNear; defaultExponentialMipFogFar = exponentialMipFogFar; defaultExponentialMipFogMaxMip = exponentialMipFogMaxMip; defaultLinearFogDensity = linearFogDensity; defaultLinearHeightStart = linearHeightStart; defaultLinearHeightEnd = linearHeightEnd; defaultLinearMaxFogDistance = linearMaxFogDistance; defaultLinearMipFogNear = linearMipFogNear; defaultLinearMipFogFar = linearMipFogFar; defaultLinearMipFogMaxMip = linearMipFogMaxMip; defaultVolumetricDistanceRange = volumetricDistanceRange; defaultVolumetricSliceDistributionUniformity = volumetricSliceDistributionUniformity; defaultIndirectDiffuseIntensity = indirectDiffuseIntensity; defaultIndirectSpecularIntensity = indirectSpecularIntensity; defaultEnableScreenSpaceReflections = enableScreenSpaceReflections; defaultScreenEdgeFadeDistance = screenEdgeFadeDistance; defaultMaxNumberOfRaySteps = maxNumberOfRaySteps; defaultObjectThickness = objectThickness; defaultMinSmoothness = minSmoothness; defaultSmoothnessFadeStart = smoothnessFadeStart; defaultReflectSky = reflectSky; defaultEnableScreenSpaceRefractions = enableScreenSpaceRefractions; defaultScreenWeightDistance = screenWeightDistance; defaultUseBakingSky = useBakingSky; defaultUseFogDensityVolume = useFogDensityVolume; defaultSingleScatteringAlbedo = singleScatteringAlbedo; defaultDensityVolumeFogDistance = densityVolumeFogDistance; defaultFogDensityMaskTexture = fogDensityMaskTexture; defaultDensityMaskTiling = densityMaskTiling; defaultDensityScale = densityScale; #if HDPipeline #if UNITY_2018_3_OR_NEWER defaultVolumeProfile = volumeProfile; defaultFogColorMode = fogColorMode; defaultHDRISkyIntensityMode = hDRISkyIntensityMode; defaultVolumetricFogColorMode = volumetricFogColorMode; #endif #endif }
public void EnsureSetup() { if (this.mRenderer == null) { this.mRenderer = this.GetComponent <MeshRenderer> (); } if (this.IsSlowerPlatform()) { this.mRenderer.enabled = false; return; } if (this.VolumeTexture != null) { return; } var coreSize = DefaultVoxelWidth; //64; //32 // 16 var cc = this.gameObject.GetComponentInParent <ChakraControl>(); if (cc != null) { coreSize = cc.VoxelResolution; } this.VolumeSize = new Cubic <int> (coreSize, coreSize, coreSize); Texture3D tex = new Texture3D( coreSize, coreSize, coreSize, TextureFormat.ARGB32, true); this.VolumeTexture = tex; var numColors = coreSize * coreSize * coreSize; var colors = new Color[numColors]; for (int i = 0; i < numColors; i++) { //var ix = (i % coreSize); //var iy = ((i / coreSize) % coreSize); //var iz = ((i / (coreSize * coreSize)) % coreSize); var c = Color.black; // (((ix + iz) < iy) ? Color.grey : Color.blue); colors[i] = c; } colors[0] = Color.red; colors [(coreSize * coreSize) * 1] = Color.red; colors [(coreSize * coreSize) * 2] = Color.red; colors [(coreSize * coreSize) * 3] = Color.red; colors[numColors - 1] = Color.green; tex.SetPixels(colors); //tex.filterMode = FilterMode.Point; tex.filterMode = FilterMode.Trilinear; tex.wrapMode = TextureWrapMode.Clamp; tex.Apply(); this.mMaterial = this.GetComponent <Renderer> ().material; this.mMaterial.SetTexture("_MainVol", tex); Texture2D tex2 = new Texture2D(coreSize, coreSize); tex2.SetPixels(colors); tex2.Apply(); //this.GetComponent<Renderer> ().material.SetTexture ("_MainTex", tex2); }
/// <summary> /// Open a dds from file. /// (Supported formats : Dxt1,Dxt2,Dxt3,Dxt4,Dxt5,A8R8G8B8/Color,X8R8G8B8,R8G8B8,A4R4G4B4,A1R5G5B5,R5G6B5,A8, /// FP32/Single,FP16/HalfSingle,FP32x4/Vector4,FP16x4/HalfVector4,CxV8U8/NormalizedByte2/CxVU,Q8VW8V8U8/NormalizedByte4/8888QWVU /// ,HalfVector2/G16R16F/16.16fGR,Vector2/G32R32F,G16R16/RG32/1616GB,B8G8R8,X8B8G8R8,A8B8G8R8/Color,L8,A2B10G10R10/Rgba1010102,A16B16G16R16/Rgba64) /// </summary> /// <param name="fileName">File containing the data.</param> /// <param name="device">Graphic device where you want the texture to be loaded.</param> /// <param name="texture">The reference to the loaded texture.</param> /// <param name="streamOffset">Offset in the stream to where the DDS is located.</param> /// <param name="loadMipMap">If true it will load the mip-map chain for this texture.</param> public static void DDSFromFile(string fileName, GraphicsDevice device, bool loadMipMap, out Texture3D texture) { Stream stream = File.OpenRead(fileName); Texture tex; InternalDDSFromStream(stream, device, 0, loadMipMap, out tex); stream.Close(); texture = tex as Texture3D; if (texture == null) { throw new Exception("The data in the stream contains a Texture2D not TextureCube"); } }
public Texture3D GetDataTexture() { dataTexture = CreateTextureInternal(); return(dataTexture); }
//new 3d-map texture private static Texture3D GenerateNewTexture3D(LoadSurfaceFormat loadSurfaceFormat, FourCC compressionFormat, GraphicsDevice device, int width, int height, int depth, bool hasMipMaps, uint pixelFlags, int rgbBitCount) { SurfaceFormat surfaceFormat = SurfaceFormatFromLoadFormat(loadSurfaceFormat, compressionFormat, pixelFlags, rgbBitCount); Texture3D tx = new Texture3D(device, width, height, depth, hasMipMaps, surfaceFormat); if (tx.Format != surfaceFormat) { throw new Exception("Can't generate a " + surfaceFormat.ToString() + " surface."); } return tx; }
public Texture3D GetGradientTexture() { gradientTexture = CreateGradientTextureInternal(); return(gradientTexture); }
public void SetTexture3D(FramebufferAttachment attachment, int miplevel, int zOffset, Texture3D texture) { GL.BindFramebuffer(FramebufferType.Framebuffer, framebuffer); GL.FramebufferTexture3D(FramebufferType.Framebuffer, attachment, TextureTarget.Texture3D, texture == null ? 0 : texture.Handle, miplevel, zOffset); SetTextureAttachment(attachment, texture); }
// Basic CUBE lut parser // Specs: http://wwwimages.adobe.com/content/dam/Adobe/en/products/speedgrade/cc/pdfs/cube-lut-specification-1.0.pdf private static void ImportCubeLut(string path) { // Remove the 'Assets' part of the path & build absolute path var fullpath = path.Substring(7); fullpath = Path.Combine(Application.dataPath, fullpath); // Read the lut data var lines = File.ReadAllLines(fullpath); // Start parsing var i = 0; var size = -1; var sizeCube = -1; var table = new List <Color>(); var domainMin = Color.black; var domainMax = Color.white; while (true) { if (i >= lines.Length) { if (table.Count != sizeCube) { Debug.LogError("Premature end of file"); } break; } var line = FilterLine(lines[i]); if (string.IsNullOrEmpty(line)) { goto next; } // Header data if (line.StartsWith("TITLE")) { goto next; // Skip the title tag, we don't need it } if (line.StartsWith("LUT_3D_SIZE")) { var sizeStr = line.Substring(11).TrimStart(); if (!int.TryParse(sizeStr, out size)) { Debug.LogError("Invalid data on line " + i); break; } if (size < 2 || size > 256) { Debug.LogError("LUT size out of range"); break; } sizeCube = size * size * size; goto next; } if (line.StartsWith("DOMAIN_MIN")) { if (!ParseDomain(i, line, ref domainMin)) { break; } goto next; } if (line.StartsWith("DOMAIN_MAX")) { if (!ParseDomain(i, line, ref domainMax)) { break; } goto next; } // Table var row = line.Split(); if (row.Length != 3) { Debug.LogError("Invalid data on line " + i); break; } var color = Color.black; for (var j = 0; j < 3; j++) { float d; if (!float.TryParse(row[j], out d)) { Debug.LogError("Invalid data on line " + i); break; } color[j] = d; } table.Add(color); next: i++; } if (sizeCube != table.Count) { Debug.LogError("Wrong table size - Expected " + sizeCube + " elements, got " + table.Count); return; } // Check if the Texture3D already exists, update it in this case (better workflow for // the user) var assetPath = Path.ChangeExtension(path, ".asset"); var tex = AssetDatabase.LoadAssetAtPath <Texture3D>(assetPath); if (tex != null) { tex.SetPixels(table.ToArray(), 0); tex.Apply(); } else { // Generate a new Texture3D tex = new Texture3D(size, size, size, TextureFormat.RGBAHalf, false) { anisoLevel = 0, filterMode = FilterMode.Bilinear, wrapMode = TextureWrapMode.Clamp }; tex.SetPixels(table.ToArray(), 0); tex.Apply(); // Save to disk AssetDatabase.CreateAsset(tex, assetPath); } AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); }
void DoneUpdatingColormap() { isUpdatingColormap = false; colormap = calculator.colormap; Apply(); }
private Texture3D ComputeSDF() { // Create the voxel texture and get an array of pixels from it. Texture3D voxels = new Texture3D(m_resolution, m_resolution, m_resolution, TextureFormat.RGBAHalf, false); voxels.anisoLevel = 1; voxels.filterMode = FilterMode.Bilinear; voxels.wrapMode = TextureWrapMode.Clamp; Color[] pixelArray = voxels.GetPixels(0); ComputeBuffer pixelBuffer = new ComputeBuffer(pixelArray.Length, sizeof(float) * 4); pixelBuffer.SetData(pixelArray); // Create the triangle array and buffer from the mesh. Vector3[] meshVertices = m_mesh.vertices; int[] meshTriangles = m_mesh.GetTriangles(m_submeshIndex); Triangle[] triangleArray = new Triangle[meshTriangles.Length / 3]; for (int t = 0; t < triangleArray.Length; t++) { triangleArray[t].a = meshVertices[meshTriangles[3 * t + 0]] - m_mesh.bounds.center; triangleArray[t].b = meshVertices[meshTriangles[3 * t + 1]] - m_mesh.bounds.center; triangleArray[t].c = meshVertices[meshTriangles[3 * t + 2]] - m_mesh.bounds.center; } ComputeBuffer triangleBuffer = new ComputeBuffer(triangleArray.Length, sizeof(float) * 3 * 3); triangleBuffer.SetData(triangleArray); // Instantiate the compute shader from resources. ComputeShader compute = (ComputeShader)Instantiate(Resources.Load("SDFCompute")); int kernel = compute.FindKernel("CSMain"); // Upload the pixel buffer to the GPU. compute.SetBuffer(kernel, "pixelBuffer", pixelBuffer); compute.SetInt("pixelBufferSize", pixelArray.Length); // Upload the triangle buffer to the GPU. compute.SetBuffer(kernel, "triangleBuffer", triangleBuffer); compute.SetInt("triangleBufferSize", triangleArray.Length); // Calculate and upload the other necessary parameters. float maxMeshSize = Mathf.Max(Mathf.Max(m_mesh.bounds.size.x, m_mesh.bounds.size.y), m_mesh.bounds.size.z); float totalUnitsInTexture = maxMeshSize + 2.0f * m_padding; compute.SetInt("textureSize", m_resolution); compute.SetFloat("totalUnitsInTexture", totalUnitsInTexture); compute.SetInt("useIntersectionCounter", (m_signComputationMethod == SignComputationMethod.IntersectionCounter) ? 1 : 0); // Compute the SDF. compute.Dispatch(kernel, pixelArray.Length / 256 + 1, 1, 1); // Destroy the compute shader and release the triangle buffer. DestroyImmediate(compute); triangleBuffer.Release(); // Retrieve the pixel buffer and reapply it to the voxels texture. pixelBuffer.GetData(pixelArray); pixelBuffer.Release(); voxels.SetPixels(pixelArray, 0); voxels.Apply(); // Return the voxels texture. return(voxels); }
void CopyDensityTextureData(ref byte[] byteField, Texture3D texture) { //In the lines below, we copy the texture data into the density field buffer if (GFX.Inst.ByteSurfaceDataType == GFXTextureDataType.BYTE) texture.SetData<byte>(byteField); else { int elementCount = texture.Width * texture.Height * texture.Depth; switch (GFX.Inst.ByteSurfaceDataType) { case GFXTextureDataType.COLOR: Color[] colorData = new Color[elementCount]; srcTarget.GetTexture().GetData<Color>(colorData); for (int i = 0; i < colorData.Length; i++) { colorData[i].R = byteField[i]; colorData[i].G = byteField[i]; colorData[i].B = byteField[i]; colorData[i].A = byteField[i]; } texture.SetData<Color>(colorData); break; case GFXTextureDataType.HALFSINGLE: HalfSingle[] hsingData = new HalfSingle[elementCount]; for (int i = 0; i < hsingData.Length; i++) hsingData[i] = new HalfSingle((float)byteField[i] / 255.0f); texture.SetData<HalfSingle>(hsingData); break; case GFXTextureDataType.SINGLE: float[] singData = new float[elementCount]; for (int i = 0; i < singData.Length; i++) singData[i] = (float)byteField[i] / 255.0f; texture.SetData<float>(singData); break; } } }
void ApplySymmetry(ref Texture3D texture, SymmetryDirection3D direction, SymmetryOutcome3D symmetryOutcome) { var halfwayPoint = texture.width / 2; var lowDominant = symmetryOutcome.lowerIsDominant; for (var x = 0; x < texture.height; x++) { for (var z = 0; z < texture.depth; z++) { for (var y = 0; y < texture.width; y++) { switch (direction) { //case SymmetryDirection.Horizontal: // referenceValue = symmetryOutcome.quarterHorizontalSymmetryResult ? columnIndex : rowIndex; // if ((symmetryOutcome.lowerIsDominant && referenceValue >= halfwayPoint - 1) || // (!symmetryOutcome.lowerIsDominant && referenceValue <= halfwayPoint + 1)) // SetSymmetricalVoxel(texture, direction, columnIndex, rowIndex, depthIndex, halfwayPoint); // break; //case SymmetryDirection.Vertical: // referenceValue = symmetryOutcome.quarterVerticalSymmetryResult ? rowIndex : columnIndex; // if ((symmetryOutcome.lowerIsDominant && referenceValue >= halfwayPoint - 1) || // (!symmetryOutcome.lowerIsDominant && referenceValue <= halfwayPoint + 1)) // SetSymmetricalVoxel(texture, direction, columnIndex, rowIndex, depthIndex, halfwayPoint); // break; //case SymmetryDirection.ForwardDiagonal: // if (symmetryOutcome.quarterForwardDiagonalSymmetryResult) { // if (symmetryOutcome.lowerIsDominant && columnIndex > rowIndex || // !symmetryOutcome.lowerIsDominant && columnIndex < rowIndex) // texture.SetPixel(columnIndex, rowIndex, depthIndex, // texture.GetPixel( // texture.width - rowIndex, // texture.width - columnIndex, // texture.depth - depthIndex)); // } else { // if (symmetryOutcome.lowerIsDominant && rowIndex < texture.width - columnIndex || // !symmetryOutcome.lowerIsDominant && rowIndex > texture.width - columnIndex) // texture.SetPixel(columnIndex, rowIndex, depthIndex, // texture.GetPixel( // texture.width - rowIndex, // texture.width - columnIndex, // texture.depth - depthIndex)); // } // // break; //case SymmetryDirection.BackwardDiagonal: // if (symmetryOutcome.quarterBackwardDiagonalSymmetryResult) { // if (symmetryOutcome.lowerIsDominant && rowIndex < texture.width - columnIndex || // !symmetryOutcome.lowerIsDominant && rowIndex > texture.width - columnIndex) // texture.SetPixel(columnIndex, rowIndex, depthIndex, // texture.GetPixel(rowIndex, columnIndex, depthIndex)); // } else if (symmetryOutcome.lowerIsDominant && columnIndex > rowIndex || // !symmetryOutcome.lowerIsDominant && columnIndex < rowIndex) // texture.SetPixel(columnIndex, rowIndex, depthIndex, // texture.GetPixel(rowIndex, columnIndex, depthIndex)); // // break; case SymmetryDirection3D.TopLeftToBottomRight: if (x < y) //(lowDominant && x < y || !lowDominant && x > y) { SetSymmetricalVoxel(texture, direction, y, x, z, halfwayPoint); } break; case SymmetryDirection3D.FrontBottomToTopBack: break; case SymmetryDirection3D.BottomLeftToTopRight: if (lowDominant && x > y || !lowDominant && x < y) { SetSymmetricalVoxel(texture, direction, y, x, z, halfwayPoint); } break; case SymmetryDirection3D.FrontTopToBottomBack: break; case SymmetryDirection3D.FrontRightToBackLeft: break; case SymmetryDirection3D.FrontLeftToBackRight: break; case SymmetryDirection3D.FrontCenterToBackCenterVertical: if (lowDominant && y > halfwayPoint || !lowDominant && y < halfwayPoint) { SetSymmetricalVoxel(texture, direction, y, x, z, halfwayPoint); } break; case SymmetryDirection3D.FrontCenterToBackCenterHorizontal: if (lowDominant && x > halfwayPoint || !lowDominant && x < halfwayPoint) { SetSymmetricalVoxel(texture, direction, y, x, z, halfwayPoint); } break; case SymmetryDirection3D.MiddleTopToMiddleBottomVertical: if (lowDominant && z > halfwayPoint || !lowDominant && z < halfwayPoint) { SetSymmetricalVoxel(texture, direction, y, x, z, halfwayPoint); } break; default: throw new ArgumentOutOfRangeException(nameof(direction), direction, null); } } } } }
/* void InitializeMaterial() { terrainMaterial.SetTexture(0, climate.BaseMapAtlas); terrainMaterial.SetTexture(1, climate.NormalMapAtlas); TextureResource blendTex = new TextureResource(); blendTex.SetTexture(TextureResourceType.Texture3D, blendTexture); TextureResource blendIDTex = new TextureResource(); blendIDTex.SetTexture(TextureResourceType.Texture3D, blendIDTexture); terrainMaterial.SetTexture(2, blendTex); terrainMaterial.SetTexture(3, blendIDTex); terrainMaterial.kAmbient = climate.GetInverseResolution(); terrainMaterial.kDiffuse = Vector3.One / new Vector3(blendMapWidth, blendMapHeight, blendMapDepth); } */ void InitializeClimateMap() { Texture3D densityFieldTexture = new Texture3D(GFX.Device, DensityFieldWidth, DensityFieldHeight, DensityFieldDepth, 1, TextureUsage.None, GFX.Inst.ByteSurfaceFormat); CopyDensityTextureData(ref DensityField, densityFieldTexture); GFX.Device.Textures[0] = densityFieldTexture; RenderTarget2D rtClimateMap = new RenderTarget2D(GFX.Device, blendMapWidth, blendMapHeight, 1, SurfaceFormat.Color); RenderTarget2D rtIDMap = new RenderTarget2D(GFX.Device, blendMapWidth, blendMapHeight, 1, SurfaceFormat.Color); int stride = blendMapWidth * blendMapHeight; Color[] colorData = new Color[stride * blendMapDepth]; Color[] blendIDData = new Color[stride * blendMapDepth]; Vector4[] climateParams = new Vector4[4]; Vector4[] climateParams2 = new Vector4[4]; for (int i = 0; i < climate.heightCoeffs.Length; i++) { climateParams[i] = new Vector4(climate.heightCoeffs[i], climate.gradientCoeffs[i], climate.curvatureCoeffs[i], climate.baseScores[i]); climateParams2[i] = Vector4.One * climate.blendZones[i]; } GFX.Device.SetPixelShaderConstant(0, Vector3.One / new Vector3(DensityFieldWidth, DensityFieldHeight, DensityFieldDepth)); RenderTarget2D rtGradientMap = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldHeight, 1, SurfaceFormat.Single); int gradStride = DensityFieldWidth * DensityFieldHeight; float[] gradientValues = new float[gradStride * DensityFieldDepth]; Texture3D gradientTexture = new Texture3D(GFX.Device, DensityFieldWidth, DensityFieldHeight, DensityFieldDepth, 1, TextureUsage.None, SurfaceFormat.Single); Shader gradientShader = ResourceManager.Inst.GetShader("GradientShader"); gradientShader.SetupShader(); for (int z = 0; z < DensityFieldDepth; z++) { Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1); GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth GFX.Device.SetRenderTarget(0, rtGradientMap); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); rtGradientMap.GetTexture().GetData<float>(gradientValues, z * gradStride, gradStride); } gradientTexture.SetData<float>(gradientValues); GFX.Device.Textures[1] = gradientTexture; GFX.Device.SetPixelShaderConstant(1, climateParams); GFX.Device.SetPixelShaderConstant(5, climateParams2); Shader climateShader = ResourceManager.Inst.GetShader("ClimateShader"); climateShader.SetupShader(); for (int z = 0; z < blendMapDepth; z++) { Vector4 depth = Vector4.One * (float)z / (float)(blendMapDepth - 1); GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth GFX.Device.SetRenderTarget(0, rtClimateMap); GFX.Device.SetRenderTarget(1, rtIDMap); GFXPrimitives.Quad.Render(); GFX.Device.SetRenderTarget(0, null); GFX.Device.SetRenderTarget(1, null); rtClimateMap.GetTexture().GetData<Color>(colorData, z * stride, stride); rtIDMap.GetTexture().GetData<Color>(blendIDData, z * stride, stride); } GFX.Device.Textures[0] = null; GFX.Device.Textures[1] = null; gradientTexture.Dispose(); blendTexture = new Texture3D(GFX.Device, blendMapWidth, blendMapHeight, blendMapDepth, 1, TextureUsage.None, SurfaceFormat.Color); blendTexture.SetData<Color>(colorData); blendIDTexture = new Texture3D(GFX.Device, blendMapWidth, blendMapHeight, blendMapDepth, 1, TextureUsage.None, SurfaceFormat.Color); blendIDTexture.SetData<Color>(blendIDData); blendTexture.Save("TestClimateMap.dds", ImageFileFormat.Dds); blendIDTexture.Save("TestClimateMapID.dds", ImageFileFormat.Dds); }
public void Allocate_Uninitialized_Fail(Device device, Type textureType, int width, int height, int depth) { using Texture3D <float> texture = device.Get().AllocateTexture3D <float>(textureType, width, height, depth); }
public XnaHardwarePixelBuffer( BufferUsage usage ) : base( 0, 0, 0, PixelFormat.Unknown, usage, false, false ) { device = null; surface = null; tempSurface = null; #if !SILVERLIGHT volume = null; tempVolume = null; #endif doMipmapGen = false; HWMipmaps = false; mipTex = null; sliceTRT = new List<RenderTexture>(); }
public DataBox MapSubresource(Texture3D resource, int mipSlice, int arraySlice, MapMode mode, MapFlags flags, out DataStream stream) { return(deviceContext.MapSubresource(resource, mipSlice, arraySlice, mode, flags, out stream)); }
public void SetColorGradeTexture(Texture3D colourGradeTexture) { _ColorGradeTexture = colourGradeTexture; }
public Texture3D Generate() { if (mesh == null) { throw new System.ArgumentException("Mesh must have been assigned"); } // Create the voxel texture. Texture3D voxels = new Texture3D(resolution, resolution, resolution, TextureFormat.RGBAHalf, false); voxels.anisoLevel = 1; voxels.filterMode = FilterMode.Bilinear; voxels.wrapMode = TextureWrapMode.Clamp; // Get an array of pixels from the voxel texture, create a buffer to // hold them, and upload the pixels to the buffer. Color[] pixelArray = voxels.GetPixels(0); ComputeBuffer pixelBuffer = new ComputeBuffer(pixelArray.Length, sizeof(float) * 4); pixelBuffer.SetData(pixelArray); // Get an array of triangles from the mesh. Vector3[] meshVertices = mesh.vertices; int[] meshTriangles = mesh.GetTriangles(subMeshIndex); Triangle[] triangleArray = new Triangle[meshTriangles.Length / 3]; for (int t = 0; t < triangleArray.Length; t++) { triangleArray[t].a = meshVertices[meshTriangles[3 * t + 0]]; // - mesh.bounds.center; triangleArray[t].b = meshVertices[meshTriangles[3 * t + 1]]; // - mesh.bounds.center; triangleArray[t].c = meshVertices[meshTriangles[3 * t + 2]]; // - mesh.bounds.center; } // Create a buffer to hold the triangles, and upload them to the buffer. ComputeBuffer triangleBuffer = new ComputeBuffer(triangleArray.Length, sizeof(float) * 3 * 3); triangleBuffer.SetData(triangleArray); // Instantiate the compute shader from resources. ComputeShader compute = Instantiate(Resources.Load("GenerateSDF")) as ComputeShader; int kernel = compute.FindKernel("CSMain"); // Upload the pixel buffer to the GPU. compute.SetBuffer(kernel, "pixelBuffer", pixelBuffer); compute.SetInt("pixelBufferSize", pixelArray.Length); // Upload the triangle buffer to the GPU. compute.SetBuffer(kernel, "triangleBuffer", triangleBuffer); compute.SetInt("triangleBufferSize", triangleArray.Length); // Calculate and upload the other necessary parameters. compute.SetInt("textureSize", resolution); Vector3 minExtents = Vector3.zero; Vector3 maxExtents = Vector3.zero; foreach (Vector3 v in mesh.vertices) { for (int i = 0; i < 3; i++) { minExtents[i] = Mathf.Min(minExtents[i], v[i]); maxExtents[i] = Mathf.Max(maxExtents[i], v[i]); } } compute.SetVector("minExtents", minExtents - Vector3.one*padding); compute.SetVector("maxExtents", maxExtents + Vector3.one*padding); // Compute the SDF. compute.Dispatch(kernel, pixelArray.Length / 256 + 1, 1, 1); // Destroy the compute shader and release the triangle buffer. DestroyImmediate(compute); triangleBuffer.Release(); // Retrieve the pixel buffer and reapply it to the voxels texture. pixelBuffer.GetData(pixelArray); pixelBuffer.Release(); voxels.SetPixels(pixelArray, 0); voxels.Apply(); // Return the voxel texture. return voxels; }
private void DestroyColorGrade() { _ColorGradeTexture = null; }
void OnEnable() { // debug information, check if the stride we set corresponds with actual struct size int size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(VolumeData)); Debug.Log("Struct size check: " + (size == VolumeDataStride ? "Pass" : "Fail")); // get all objects that have a SDFBaker component: SDFBaker[] bakers = GameObject.FindObjectsOfType <SDFBaker>() as SDFBaker[]; texCollection = new List <Texture3D>(); gameObjCollection = new List <GameObject>(); gameObjectStatus = new List <bool>(); volumeData = new List <VolumeData>(); foreach (SDFBaker v in bakers) { // store reference to game objects that have SDF data GameObject obj = v.gameObject; // set transformation changed flag as true to trigger texture update obj.transform.hasChanged = true; gameObjectStatus.Add(obj.activeSelf); gameObjCollection.Add(obj); // prepare transform data of objects for passing to shaders VolumeData vd = new VolumeData(); vd.WorldToLocal = obj.transform.worldToLocalMatrix; vd.Extents = v.sdfData.bounds.extents; vd.Center = v.sdfData.bounds.center; //Debug.Log(obj.name + " " + vd.Center + " " + vd.Extents); //Debug.Log(obj.name + "\n" + vd.WorldToLocal); // if there are multiple objects sharing the same SDF texture, // only save one copy in the texture atlas, and assign the index to per-object data Texture3D tex = v.sdfData.sdfTexture; int tempId = texCollection.FindIndex(x => x.name == tex.name); if (tempId < 0) { vd.TextureIndex = texCollection.Count; texCollection.Add(tex); } else { vd.TextureIndex = tempId; } //Debug.Log(obj.name + " texIdx: " + vd.TextureIndex); volumeData.Add(vd); } // copy the listed volume transform data to the computer buffer, // Shader.setBuffer() or _material.setBuffer() would copy the buffer to GPU side volumeDataBuffer = new ComputeBuffer(volumeData.Count, VolumeDataStride); volumeDataBuffer.SetData(volumeData); // the texture atlas is of same with & height with local SDF's, // while its depth is (#SDF * depth), hence it's not cubed and doesn't support LOD operations textureAtlas = new Texture3D(DistanceFieldDepth, DistanceFieldDepth, DistanceFieldDepth * texCollection.Count, TextureFormat.RHalf, false); Debug.Log("Atlas Depth: " + textureAtlas.depth); if (SystemInfo.copyTextureSupport == CopyTextureSupport.Copy3D) { Debug.Log("Don't support Copy3d"); } else { Debug.Log("Support copy 3d"); } // f**k this // should be replaced by a computer shader later for (int i = 0; i < texCollection.Count; i++) { for (int d = 0; d < texCollection[i].depth; d++) { for (int y = 0; y < texCollection[i].height; y++) { for (int x = 0; x < texCollection[i].width; x++) { int depth = i * DistanceFieldDepth + d; textureAtlas.SetPixel(x, y, depth, texCollection[i].GetPixel(x, y, d, 0)); } } // doesnot work //Graphics.CopyTexture(texCollection[i], d, 0, textureAtlas, i * DistanceFieldDepth + d, 0); } } // Important: This function does the actual CPU->GPU copy textureAtlas.Apply(); // Global shader properties never change through rendering Shader.SetGlobalVector("_BlitScaleBiasRt", new Vector4(1f, 1f, 0f, 0f)); Shader.SetGlobalVector("_BlitScaleBias", new Vector4(1f, 1f, 0f, 0f)); // in case there isn't new texture genereation at run time Shader.SetGlobalTexture("_TextureAtlas", textureAtlas); // initialize global SDF texture globalDistanceFieldTexture.Initialize(); Shader.SetGlobalTexture("_GlobalDFTex", globalDistanceFieldTexture); }
private void InitializeFromImpl(DataBox[] dataBoxes = null) { if (ParentTexture != null) { NativeDeviceChild = ParentTexture.NativeDeviceChild; } if (NativeDeviceChild == null) { switch (Dimension) { case TextureDimension.Texture1D: NativeDeviceChild = new Texture1D(GraphicsDevice.NativeDevice, ConvertToNativeDescription1D(), ConvertDataBoxes(dataBoxes)); break; case TextureDimension.Texture2D: case TextureDimension.TextureCube: NativeDeviceChild = new Texture2D(GraphicsDevice.NativeDevice, ConvertToNativeDescription2D(), ConvertDataBoxes(dataBoxes)); break; case TextureDimension.Texture3D: NativeDeviceChild = new Texture3D(GraphicsDevice.NativeDevice, ConvertToNativeDescription3D(), ConvertDataBoxes(dataBoxes)); break; } } NativeShaderResourceView = GetShaderResourceView(ViewType, ArraySlice, MipLevel); NativeUnorderedAccessView = GetUnorderedAccessView(ViewType, ArraySlice, MipLevel); NativeRenderTargetView = GetRenderTargetView(ViewType, ArraySlice, MipLevel); NativeDepthStencilView = GetDepthStencilView(out HasStencil); }
public void Convert(Texture2D temp2DTex) { if (temp2DTex) { int dim = temp2DTex.width * temp2DTex.height; dim = temp2DTex.height; if (!ValidDimensions(temp2DTex)) { Debug.LogWarning("The given 2D texture " + temp2DTex.name + " cannot be used as a 3D LUT."); return; } // if (temp2DTex.GetPixel(5, 5) == null) { Debug.Log("bug"); return; } #if UNITY_EDITOR if (Application.isPlaying != true) { string path = AssetDatabase.GetAssetPath(LutTexture); MemoPath = path; TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter; if (!textureImporter.isReadable) { /* * bool doImport = textureImporter.isReadable == false; * if (textureImporter.mipmapEnabled == true) * { * doImport = true; * } * if (textureImporter.textureCompression != TextureImporterCompression.Uncompressed) * { * doImport = true; * }*/ textureImporter.isReadable = true; textureImporter.mipmapEnabled = false; textureImporter.textureCompression = TextureImporterCompression.Uncompressed; AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); } } #endif var c = temp2DTex.GetPixels(); var newC = new Color[c.Length]; for (int i = 0; i < dim; i++) { for (int j = 0; j < dim; j++) { for (int k = 0; k < dim; k++) { int j_ = dim - j - 1; newC[i + (j * dim) + (k * dim * dim)] = c[k * dim + i + j_ * dim * dim]; } } } if (converted3DLut) { DestroyImmediate(converted3DLut); } converted3DLut = new Texture3D(dim, dim, dim, TextureFormat.ARGB32, false); converted3DLut.SetPixels(newC); converted3DLut.Apply(); } else { SetIdentityLut(); } }
void LoadTextureFromFile(string filename) { switch (textureType) { case TextureResourceType.Texture3D: texture3D = Texture3D.FromFile(GFX.Device, filename); break; case TextureResourceType.TextureCube: textureCube = TextureCube.FromFile(GFX.Device, filename); break; default: texture2D = Texture2D.FromFile(GFX.Device, filename); break; } }
protected static void GenerateNoiseTexture(int resolution, int period) { // Set up Texture3D for noise sampling noiseTexture = new Texture3D(graphicsDevice, resolution, resolution, resolution, false, SurfaceFormat.Color); // Fill a Resolution^3 array with values generated using smooth noise // Uses smooth noise instead of pure random numbers because linear filtering // on random values doesn't provide a smooth or consistent enough gradient Color[] noise = new Color[(int)Math.Pow(resolution, 3)]; int index = 0; // how many often does the pattern "cycle" over the texture? float inverseFrequency = (float)period / resolution; for (int i = 0; i < resolution; i++) for (int j = 0; j < resolution; j++) for (int k = 0; k < resolution; k++) { float x = i * inverseFrequency; float y = j * inverseFrequency; float z = k * inverseFrequency; // sample different tiling noise domains for each color channel noise[index].R = SampleNoise(x, y, z, period, 0); noise[index].G = SampleNoise(x, y, z, period, 50); index++; } noiseTexture.SetData<Color>(noise); }
static public VFXValue <Texture> Constant(Texture3D value) { return(new VFXTexture3DValue(value, Mode.Constant)); }
/// <summary> /// Revert current settings back to default settings /// </summary> public void RevertToDefault() { isProceduralSkybox = defaultIsProceduralSkybox; showSettings = defaultShowSettings; fogColor = defaultFogColor; skyboxExposure = defaultSkyboxExposure; skyboxGroundIntensity = defaultSkyboxGroundIntensity; skyboxRotation = defaultSkyboxRotation; skyboxPitch = defaultSkyboxPitch; skyboxTint = defaultSkyboxTint; customSkybox = defaultCustomSkybox; shadowStrength = defaultShadowStrength; indirectLightMultiplier = defaultIndirectLightMultiplier; sunColor = defaultSunColor; shadowDistance = defaultShadowDistance; shadowType = defaultShadowType; fogDistance = defaultFogDistance; fogDensity = defaultFogDensity; sunIntensity = defaultSunIntensity; LWRPSunIntensity = defaultLWRPSunIntensity; HDRPSunIntensity = defaultHDRPSunIntensity; sunRotation = defaultSunRotation; temperature = defaultTemperature; useTempature = defaultUseTempature; scaleHorizonObjectWithFog = defaultScaleHorizonObjectWithFog; horizonSkyEnabled = defaultHorizonSkyEnabled; horizonBlend = defaultHorizonBlend; horizonFalloff = defaultHorizonFalloff; horizonFogDensity = defaultHorizonFogDensity; horizonScattering = defaultHorizonScattering; nearFogDistance = defaultNearFogDistance; horizonSize = defaultHorizonSize; followPlayer = defaultFollowPlayer; horizonPosition = defaultHorizonPosition; horizonUpdateTime = defaultHorizonUpdateTime; ambientMode = defaultAmbientMode; skyColor = defaultSkyColor; equatorColor = defaultEquatorColor; groundColor = defaultGroundColor; lwrpSkyColor = defaultLWRPSkyColor; lwrpEquatorColor = defaultLWRPEquatorColor; lwrpGroundColor = defaultLWRPGroundColor; hDRISkybox = defaultHDRISkybox; shadowQuality = defaultShadowQuality; shadowmaskMode = defaultShadowmaskMode; shadowResolution = defaultShadowResolution; shadowProjection = defaultShadowProjection; cascadeCount = defaultCascadeCount; enableSunDisk = defaultEnableSunDisk; skyMultiplier = defaultSkyMultiplier; hDRPFogDistance = defaultHDRPFogDistance; isGlobal = defaultIsGlobal; blendDistance = defaultBlendDistance; weight = defaultWeight; priority = defaultPriority; hDRIExposure = defaultHDRIExposure; hDRIMultiplier = defaultHDRIMultiplier; hDRIUpdateMode = defaultHDRIUpdateMode; hDRIRotation = defaultHDRIRotation; maxShadowDistance = defaultMaxShadowDistance; cascadeSplit1 = defaultCascadeSplit1; cascadeSplit2 = defaultCascadeSplit2; cascadeSplit3 = defaultCascadeSplit3; useContactShadows = defaultUseContactShadows; contactShadowsLength = defaultContactShadowsLength; contactShadowsDistanceScaleFactor = defaultContactShadowsDistanceScaleFactor; contactShadowsMaxDistance = defaultContactShadowsMaxDistance; contactShadowsFadeDistance = defaultContactShadowsFadeDistance; contactShadowsSampleCount = defaultContactShadowsSampleCount; contactShadowsOpacity = defaultContactShadowsOpacity; useMicroShadowing = defaultUseMicroShadowing; microShadowOpacity = defaultMicroShadowOpacity; volumetricSingleScatteringAlbedo = defaultVolumetricSingleScatteringAlbedo; volumetricBaseFogDistance = defaultVolumetricBaseFogDistance; volumetricBaseFogHeight = defaultVolumetricBaseFogHeight; volumetricMeanHeight = defaultVolumetricMeanHeight; volumetricGlobalAnisotropy = defaultVolumetricGlobalAnisotropy; volumetricGlobalLightProbeDimmer = defaultVolumetricGlobalLightProbeDimmer; volumetricMaxFogDistance = defaultVolumetricMaxFogDistance; volumetricEnableDistanceFog = defaultVolumetricEnableDistanceFog; volumetricConstFogColor = defaultVolumetricConstFogColor; volumetricMipFogNear = defaultVolumetricMipFogNear; volumetricMipFogFar = defaultVolumetricMipFogFar; volumetricMipFogMaxMip = defaultVolumetricMipFogMaxMip; volumetricDistanceRange = defaultVolumetricDistanceRange; volumetricSliceDistributionUniformity = defaultVolumetricSliceDistributionUniformity; exponentialBaseHeight = defaultExponentialBaseHeight; exponentialHeightAttenuation = defaultExponentialHeightAttenuation; exponentialMaxFogDistance = defaultExponentialMaxFogDistance; exponentialMipFogNear = defaultExponentialMipFogNear; exponentialMipFogFar = defaultExponentialMipFogFar; exponentialMipFogMaxMip = defaultExponentialMipFogMaxMip; linearHeightStart = defaultLinearHeightStart; linearHeightEnd = defaultLinearHeightEnd; linearMaxFogDistance = defaultLinearMaxFogDistance; linearMipFogNear = defaultLinearMipFogNear; linearMipFogFar = defaultLinearMipFogFar; linearMipFogMaxMip = defaultLinearMipFogMaxMip; indirectDiffuseIntensity = defaultIndirectDiffuseIntensity; indirectSpecularIntensity = defaultIndirectSpecularIntensity; enableScreenSpaceReflections = defaultEnableScreenSpaceReflections; screenEdgeFadeDistance = defaultScreenEdgeFadeDistance; maxNumberOfRaySteps = defaultMaxNumberOfRaySteps; objectThickness = defaultObjectThickness; minSmoothness = defaultMinSmoothness; smoothnessFadeStart = defaultSmoothnessFadeStart; reflectSky = defaultReflectSky; enableScreenSpaceRefractions = defaultEnableScreenSpaceRefractions; screenWeightDistance = defaultScreenWeightDistance; useBakingSky = defaultUseBakingSky; useFogDensityVolume = defaultUseFogDensityVolume; singleScatteringAlbedo = defaultSingleScatteringAlbedo; densityVolumeFogDistance = defaultDensityVolumeFogDistance; fogDensityMaskTexture = defaultFogDensityMaskTexture; densityMaskTiling = defaultDensityMaskTiling; densityScale = defaultDensityScale; linearFogDensity = defaultLinearFogDensity; exponentialFogDensity = defaultExponentialFogDensity; fogType = defaultFogType; #if HDPipeline #if UNITY_2018_3_OR_NEWER volumeProfile = defaultVolumeProfile; volumetricFogColorMode = defaultVolumetricFogColorMode; fogColorMode = defaultFogColorMode; hDRISkyIntensityMode = defaultHDRISkyIntensityMode; #endif #endif }