public static void OnGUI(MaterialEditor materialEditor, MaterialProperty diffusionProfileAsset, MaterialProperty diffusionProfileHash, int profileIndex) { // We can't cache these fields because of several edge cases like undo/redo or pressing escape in the object picker string guid = HDUtils.ConvertVector4ToGUID(diffusionProfileAsset.vectorValue); DiffusionProfileSettings diffusionProfile = AssetDatabase.LoadAssetAtPath <DiffusionProfileSettings>(AssetDatabase.GUIDToAssetPath(guid)); // is it okay to do this every frame ? EditorGUI.BeginChangeCheck(); diffusionProfile = (DiffusionProfileSettings)EditorGUILayout.ObjectField("Diffusion Profile", diffusionProfile, typeof(DiffusionProfileSettings), false); if (EditorGUI.EndChangeCheck()) { Vector4 newGuid = Vector4.zero; float hash = 0; if (diffusionProfile != null) { guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(diffusionProfile)); newGuid = HDUtils.ConvertGUIDToVector4(guid); hash = HDShadowUtils.Asfloat(diffusionProfile.profile.hash); } // encode back GUID and it's hash diffusionProfileAsset.vectorValue = newGuid; diffusionProfileHash.floatValue = hash; // Update external reference. foreach (var target in materialEditor.targets) { MaterialExternalReferences matExternalRefs = MaterialExternalReferences.GetMaterialExternalReferences(target as Material); matExternalRefs.SetDiffusionProfileReference(profileIndex, diffusionProfile); } } DrawDiffusionProfileWarning(diffusionProfile); }
public static void OnGUI(MaterialProperty diffusionProfileAsset, MaterialProperty diffusionProfileHash) { string guid = HDUtils.ConvertVector4ToGUID(diffusionProfileAsset.vectorValue); DiffusionProfileSettings diffusionProfile = AssetDatabase.LoadAssetAtPath <DiffusionProfileSettings>(AssetDatabase.GUIDToAssetPath(guid)); // is it okay to do this every frame ? EditorGUI.BeginChangeCheck(); diffusionProfile = (DiffusionProfileSettings)EditorGUILayout.ObjectField("Diffusion Profile", diffusionProfile, typeof(DiffusionProfileSettings), false); if (EditorGUI.EndChangeCheck()) { Vector4 newGuid = Vector4.zero; float hash = 0; if (diffusionProfile != null) { guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(diffusionProfile)); newGuid = HDUtils.ConvertGUIDToVector4(guid); hash = HDShadowUtils.Asfloat(diffusionProfile.profile.hash); } // encode back GUID and it's hash diffusionProfileAsset.vectorValue = newGuid; diffusionProfileHash.floatValue = hash; } }
internal override PreviewProperty GetPreviewMaterialProperty() { return(new PreviewProperty(propertyType) { name = referenceName, floatValue = value.isSet ? HDShadowUtils.Asfloat(value.asset.profile.hash) : 0 }); }
public static float Asfloat(uint val) { #if UNITY_2019_3_OR_NEWER object[] parameters = new object[] { val }; MethodInfo method = Type.GetMethod("Asfloat", new Type[] { typeof(uint) }); return((float)method.Invoke(null, parameters)); #else return(HDShadowUtils.Asfloat(val)); #endif }
/// <summary> /// Draws the Shadow Matte settings. This is only available for Unlit materials. /// </summary> protected void DrawShadowMatteToggle() { uint exponent = 0b10000000; // 0 as exponent uint mantissa = 0x007FFFFF; float value = materials[0].GetFloat(HDMaterialProperties.kShadowMatteFilter); uint uValue = HDShadowUtils.Asuint(value); uint filter = uValue & mantissa; bool shadowFilterPoint = (filter & (uint)LightFeatureFlags.Punctual) != 0; bool shadowFilterDir = (filter & (uint)LightFeatureFlags.Directional) != 0; bool shadowFilterRect = (filter & (uint)LightFeatureFlags.Area) != 0; uint finalFlag = 0x00000000; finalFlag |= EditorGUILayout.Toggle("Point/Spot Shadow", shadowFilterPoint) ? (uint)LightFeatureFlags.Punctual : 0x00000000u; finalFlag |= EditorGUILayout.Toggle("Directional Shadow", shadowFilterDir) ? (uint)LightFeatureFlags.Directional : 0x00000000u; finalFlag |= EditorGUILayout.Toggle("Area Shadow", shadowFilterRect) ? (uint)LightFeatureFlags.Area : 0x00000000u; finalFlag &= mantissa; finalFlag |= exponent; materials[0].SetFloat(HDMaterialProperties.kShadowMatteFilter, HDShadowUtils.Asfloat(finalFlag)); }
private static void SetDefaultDiffusionProfile(Material mat) { string matDiffProfile = HDUtils.ConvertVector4ToGUID(mat.GetVector("Diffusion_Profile_Asset")); string guid = ""; long localID; uint diffusionProfileHash = 0; foreach (var diffusionProfileAsset in HDRenderPipelineGlobalSettings.instance.diffusionProfileSettingsList) { if (diffusionProfileAsset != null) { bool gotGuid = AssetDatabase.TryGetGUIDAndLocalFileIdentifier <DiffusionProfileSettings>(diffusionProfileAsset, out guid, out localID); if (gotGuid && (diffusionProfileAsset.name.Equals(kDefaultDiffusionProfileName) || guid.Equals(matDiffProfile))) { diffusionProfileHash = diffusionProfileAsset.profile.hash; break; } } } if (diffusionProfileHash == 0) { // If the user doesn't have a foliage diffusion profile defined, grab the foliage diffusion profile that comes with HD. // This won't work until the user adds it to their default diffusion profiles list, // but there is a nice "fix" button on the material to help with that. DiffusionProfileSettings foliageSettings = AssetDatabase.LoadAssetAtPath <DiffusionProfileSettings>(HDUtils.GetHDRenderPipelinePath() + kFoliageDiffusionProfilePath); if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier <DiffusionProfileSettings>(foliageSettings, out guid, out localID)) { diffusionProfileHash = foliageSettings.profile.hash; } } if (diffusionProfileHash != 0) { mat.SetVector("Diffusion_Profile_Asset", HDUtils.ConvertGUIDToVector4(guid)); mat.SetFloat("Diffusion_Profile", HDShadowUtils.Asfloat(diffusionProfileHash)); } }
internal override string GetPropertyBlockString() { uint hash = 0; Vector4 asset = Vector4.zero; if (value.isSet) { hash = value.asset.profile.hash; asset = HDUtils.ConvertGUIDToVector4(AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(value.asset))); } /// <summary>Float to string convertion function without any loss of precision</summary> string f2s(float f) => System.Convert.ToDouble(f).ToString("0." + new string('#', 339), CultureInfo.InvariantCulture); return ($@"[DiffusionProfile]{referenceName}(""{displayName}"", Float) = {f2s(HDShadowUtils.Asfloat(hash))} [HideInInspector]{assetReferenceName}(""{displayName}"", Vector) = ({f2s(asset.x)}, {f2s(asset.y)}, {f2s(asset.z)}, {f2s(asset.w)})"); }
void ShaderSSSAndTransmissionInputGUI() { var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline; if (hdPipeline == null) { return; } using (var scope = new EditorGUI.ChangeCheckScope()) { using (new EditorGUILayout.HorizontalScope()) { // We can't cache these fields because of several edge cases like undo/redo or pressing escape in the object picker string guid = HDUtils.ConvertVector4ToGUID(diffusionProfileAsset[m_LayerIndex].vectorValue); DiffusionProfileSettings diffusionProfile = AssetDatabase.LoadAssetAtPath <DiffusionProfileSettings>(AssetDatabase.GUIDToAssetPath(guid)); // is it okay to do this every frame ? using (var changeScope = new EditorGUI.ChangeCheckScope()) { diffusionProfile = (DiffusionProfileSettings)EditorGUILayout.ObjectField(Styles.diffusionProfileText, diffusionProfile, typeof(DiffusionProfileSettings), false); if (changeScope.changed) { Vector4 newGuid = Vector4.zero; float hash = 0; if (diffusionProfile != null) { guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(diffusionProfile)); newGuid = HDUtils.ConvertGUIDToVector4(guid); hash = HDShadowUtils.Asfloat(diffusionProfile.profile.hash); } // encode back GUID and it's hash diffusionProfileAsset[m_LayerIndex].vectorValue = newGuid; diffusionProfileHash[m_LayerIndex].floatValue = hash; } } } } // TODO: does not work with multi-selection if ((int)materialID.floatValue == (int)MaterialId.LitSSS && materials[0].GetSurfaceType() != SurfaceType.Transparent) { materialEditor.ShaderProperty(subsurfaceMask[m_LayerIndex], Styles.subsurfaceMaskText); materialEditor.TexturePropertySingleLine(Styles.subsurfaceMaskMapText, subsurfaceMaskMap[m_LayerIndex]); } if ((int)materialID.floatValue == (int)MaterialId.LitTranslucent || ((int)materialID.floatValue == (int)MaterialId.LitSSS && transmissionEnable.floatValue > 0.0f)) { materialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap[m_LayerIndex]); if (thicknessMap[m_LayerIndex].textureValue != null) { // Display the remap of texture values. Vector2 remap = thicknessRemap[m_LayerIndex].vectorValue; EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(Styles.thicknessRemapText, ref remap.x, ref remap.y, 0.0f, 1.0f); if (EditorGUI.EndChangeCheck()) { thicknessRemap[m_LayerIndex].vectorValue = remap; } } else { // Allow the user to set the constant value of thickness if no thickness map is provided. materialEditor.ShaderProperty(thickness[m_LayerIndex], Styles.thicknessText); } } }
public void Denoise(CommandBuffer cmd, HDCamera hdCamera, RTHandle noisyBuffer, RTHandle outputBuffer, bool halfResolution = false, float historyValidity = 1.0f) { // Grab the global illumination volume component var giSettings = hdCamera.volumeStack.GetComponent <UnityEngine.Rendering.HighDefinition.GlobalIllumination>(); var historyDepthBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth); var historyDepthBuffer1 = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth1); // If the depth textures are not available, we can't denoise if (historyDepthBuffer == null || historyDepthBuffer1 == null) { HDUtils.BlitCameraTexture(cmd, noisyBuffer, outputBuffer); return; } // Compute the dispatch parameters based on if we are half res or not int tileSize = 8; int numTilesX, numTilesY; Vector4 halfScreenSize; EvaluateDispatchParameters(hdCamera, halfResolution, tileSize, out numTilesX, out numTilesY, out halfScreenSize); // Pick the right kernel to use int m_KernelFilter = halfResolution ? m_SpatialFilterHalfKernel : m_SpatialFilterKernel; // Bind the input scalars var info = m_SharedRTManager.GetDepthBufferMipChainInfo(); firstMipOffset.Set(HDShadowUtils.Asfloat((uint)info.mipLevelOffsets[1].x), HDShadowUtils.Asfloat((uint)info.mipLevelOffsets[1].y)); cmd.SetComputeVectorParam(m_SSGIDenoiserCS, HDShaderIDs._DepthPyramidFirstMipLevelOffset, firstMipOffset); cmd.SetComputeIntParam(m_SSGIDenoiserCS, HDShaderIDs._IndirectDiffuseSpatialFilter, giSettings.filterRadius); // Inject half screen size if required if (halfResolution) { cmd.SetComputeVectorParam(m_SSGIDenoiserCS, HDShaderIDs._HalfScreenSize, halfScreenSize); } // Bind the input buffers cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthTexture()); cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._InputNoisyBuffer, noisyBuffer); // Bind the output buffer cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._OutputFilteredBuffer, outputBuffer); // Do the spatial pass cmd.DispatchCompute(m_SSGIDenoiserCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); // Grab the history buffer RTHandle indirectDiffuseHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedIndirectDiffuseHF); if (indirectDiffuseHistory == null) { indirectDiffuseHistory = hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedIndirectDiffuseHF, IndirectDiffuseHistoryBufferAllocatorFunction, 1); // clear it to black if this is the first pass to avoid nans CoreUtils.SetRenderTarget(cmd, indirectDiffuseHistory, m_SharedRTManager.GetDepthStencilBuffer(), ClearFlag.Color, clearColor: Color.black); } // Pick the right kernel to use m_KernelFilter = halfResolution ? m_TemporalFilterHalfKernel : m_TemporalFilterKernel; // Bind the input buffers cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthTexture()); cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); cmd.SetComputeFloatParam(m_SSGIDenoiserCS, HDShaderIDs._HistoryValidity, historyValidity); if (halfResolution) { cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._HistoryDepthTexture, historyDepthBuffer1); cmd.SetComputeVectorParam(m_SSGIDenoiserCS, HDShaderIDs._DepthPyramidFirstMipLevelOffset, firstMipOffset); } else { cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._HistoryDepthTexture, historyDepthBuffer); } cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._HistoryBuffer, indirectDiffuseHistory); cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._InputNoisyBuffer, outputBuffer); // Bind the output buffer cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_KernelFilter, HDShaderIDs._OutputFilteredBuffer, noisyBuffer); // Do the temporal pass cmd.DispatchCompute(m_SSGIDenoiserCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); // Copy the new version into the history buffer cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_CopyHistory, HDShaderIDs._InputNoisyBuffer, noisyBuffer); cmd.SetComputeTextureParam(m_SSGIDenoiserCS, m_CopyHistory, HDShaderIDs._OutputFilteredBuffer, indirectDiffuseHistory); cmd.DispatchCompute(m_SSGIDenoiserCS, m_CopyHistory, numTilesX, numTilesY, hdCamera.viewCount); }