public static ProbeCapturePositionSettings ComputeFrom(HDProbe probe, Transform reference)
{
var referencePosition = Vector3.zero;
var referenceRotation = Quaternion.identity;
if (reference != null)
{
referencePosition = reference.position;
referenceRotation = reference.rotation;
}
else
{
if (probe.type == ProbeSettings.ProbeType.PlanarProbe)
{
var planar = (PlanarReflectionProbe)probe;
return(ComputeFromMirroredReference(planar, planar.referencePosition));
}
}
var result = ComputeFrom(probe, referencePosition, referenceRotation);
// In case of probe baking, 99% of the time, orientation of the cubemap doesn't matters
// so, we build one without any rotation, thus we don't have to change the basis
// during sampling the cubemap.
if (probe.type == ProbeSettings.ProbeType.ReflectionProbe)
{
result.proxyRotation = Quaternion.identity;
}
return(result);
}
private static void CreateAndImportDummyBakedTextureIfRequired(HDProbe probe, string bakedTexturePath)
{
var bytes = Texture2D.whiteTexture.EncodeToPNG();
File.WriteAllBytes(bakedTexturePath, bytes);
AssetDatabase.ImportAsset(bakedTexturePath);
ImportAssetAt(probe, bakedTexturePath);
}
internal static void RenderAndWriteToFile(
HDProbe probe, string targetFile,
RenderTexture cubeRT, RenderTexture planarRT
)
{
var settings = probe.settings;
switch (settings.type)
{
case ProbeSettings.ProbeType.ReflectionProbe:
{
var positionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, null);
HDRenderUtilities.Render(probe.settings, positionSettings, cubeRT,
forceFlipY: true,
forceInvertBackfaceCulling: true, // Cubemap have an RHS standard, so we need to invert the face culling
(uint)StaticEditorFlags.ReflectionProbeStatic
);
HDBakingUtilities.CreateParentDirectoryIfMissing(targetFile);
if (Provider.isActive && HDEditorUtils.IsAssetPath(targetFile))
{
Checkout(targetFile, CheckoutMode.Both);
}
HDTextureUtilities.WriteTextureFileToDisk(cubeRT, targetFile);
break;
}
case ProbeSettings.ProbeType.PlanarProbe:
{
var planarProbe = (PlanarReflectionProbe)probe;
var positionSettings = ProbeCapturePositionSettings.ComputeFromMirroredReference(
probe,
planarProbe.referencePosition
);
HDRenderUtilities.Render(
settings,
positionSettings,
planarRT,
out var cameraSettings, out var cameraPositionSettings
);
HDBakingUtilities.CreateParentDirectoryIfMissing(targetFile);
if (Provider.isActive && HDEditorUtils.IsAssetPath(targetFile))
{
Checkout(targetFile, CheckoutMode.Both);
}
HDTextureUtilities.WriteTextureFileToDisk(planarRT, targetFile);
var renderData = new HDProbe.RenderData(cameraSettings, cameraPositionSettings);
var targetRenderDataFile = targetFile + ".renderData";
if (Provider.isActive && HDEditorUtils.IsAssetPath(targetRenderDataFile))
{
Checkout(targetRenderDataFile, CheckoutMode.Both);
}
HDBakingUtilities.TrySerializeToDisk(renderData, targetRenderDataFile);
break;
}
}
}
public static void RenderAndUpdateRealtimeRenderData(
HDProbe probe, Transform viewerTransform
)
{
var target = CreateAndSetRenderTargetIfRequired(probe, ProbeSettings.Mode.Realtime);
Render(probe, viewerTransform, target, out HDProbe.RenderData renderData);
AssignRenderData(probe, renderData, ProbeSettings.Mode.Realtime);
}
public static string GetBakedTextureFilePath(HDProbe probe)
{
return(GetBakedTextureFilePath(
probe.settings.type,
SceneObjectIDMap.GetOrCreateSceneObjectID(
probe.gameObject, SceneObjectCategory.ReflectionProbe
),
probe.gameObject.scene
));
}
internal static void ImportAssetAt(HDProbe probe, string file)
{
var hd = (HDRenderPipeline)RenderPipelineManager.currentPipeline;
switch (probe.settings.type)
{
case ProbeSettings.ProbeType.ReflectionProbe:
{
var importer = AssetImporter.GetAtPath(file) as TextureImporter;
if (importer == null)
{
return;
}
var settings = new TextureImporterSettings();
importer.ReadTextureSettings(settings);
settings.sRGBTexture = false;
settings.filterMode = FilterMode.Bilinear;
settings.generateCubemap = TextureImporterGenerateCubemap.AutoCubemap;
settings.cubemapConvolution = TextureImporterCubemapConvolution.None;
settings.seamlessCubemap = false;
settings.wrapMode = TextureWrapMode.Repeat;
settings.aniso = 1;
importer.SetTextureSettings(settings);
importer.mipmapEnabled = false;
importer.textureCompression = hd.currentPlatformRenderPipelineSettings.lightLoopSettings.reflectionCacheCompressed
? TextureImporterCompression.Compressed
: TextureImporterCompression.Uncompressed;
importer.textureShape = TextureImporterShape.TextureCube;
importer.SaveAndReimport();
break;
}
case ProbeSettings.ProbeType.PlanarProbe:
{
var importer = AssetImporter.GetAtPath(file) as TextureImporter;
if (importer == null)
{
return;
}
importer.sRGBTexture = false;
importer.filterMode = FilterMode.Bilinear;
importer.mipmapEnabled = false;
importer.textureCompression = hd.currentPlatformRenderPipelineSettings.lightLoopSettings.planarReflectionCacheCompressed
? TextureImporterCompression.Compressed
: TextureImporterCompression.Uncompressed;
importer.textureShape = TextureImporterShape.Texture2D;
importer.SaveAndReimport();
break;
}
}
}
public static Texture CreateRenderTargetForMode(HDProbe probe, ProbeSettings.Mode targetMode)
{
Texture target = null;
var hd = (HDRenderPipeline)RenderPipelineManager.currentPipeline;
var settings = probe.settings;
switch (targetMode)
{
case ProbeSettings.Mode.Realtime:
{
switch (settings.type)
{
case ProbeSettings.ProbeType.PlanarProbe:
target = HDRenderUtilities.CreatePlanarProbeRenderTarget(
(int)hd.renderPipelineSettings.lightLoopSettings.planarReflectionTextureSize
);
break;
case ProbeSettings.ProbeType.ReflectionProbe:
target = HDRenderUtilities.CreateReflectionProbeRenderTarget(
(int)hd.renderPipelineSettings.lightLoopSettings.reflectionCubemapSize
);
break;
}
break;
}
case ProbeSettings.Mode.Baked:
case ProbeSettings.Mode.Custom:
{
switch (settings.type)
{
case ProbeSettings.ProbeType.PlanarProbe:
target = HDRenderUtilities.CreatePlanarProbeRenderTarget(
(int)hd.renderPipelineSettings.lightLoopSettings.planarReflectionTextureSize
);
break;
case ProbeSettings.ProbeType.ReflectionProbe:
target = HDRenderUtilities.CreateReflectionProbeTarget(
(int)hd.renderPipelineSettings.lightLoopSettings.reflectionCubemapSize
);
break;
}
break;
}
}
return(target);
}
static ProbeCapturePositionSettings ComputeFrom(
HDProbe probe,
Vector3 referencePosition, Quaternion referenceRotation
)
{
var result = new ProbeCapturePositionSettings();
var proxyToWorld = probe.proxyToWorld;
result.proxyPosition = proxyToWorld.GetColumn(3);
result.proxyRotation = proxyToWorld.rotation;
result.referencePosition = referencePosition;
result.referenceRotation = referenceRotation;
return(result);
}
internal void RegisterProbe(HDProbe probe)
{
var settings = probe.settings;
switch (settings.mode)
{
case ProbeSettings.Mode.Baked:
if (!m_BakedProbes.Contains(probe))
{
m_BakedProbes.Add(probe);
}
break;
case ProbeSettings.Mode.Realtime:
switch (settings.type)
{
case ProbeSettings.ProbeType.PlanarProbe:
if (!m_RealtimeViewDependentProbes.Contains(probe))
{
m_RealtimeViewDependentProbes.Add(probe);
}
break;
case ProbeSettings.ProbeType.ReflectionProbe:
if (!m_RealtimeViewIndependentProbes.Contains(probe))
{
m_RealtimeViewIndependentProbes.Add(probe);
}
break;
}
break;
}
switch (settings.type)
{
case ProbeSettings.ProbeType.PlanarProbe:
{
// Grow the arrays
if (m_PlanarProbeCount == m_PlanarProbes.Length)
{
Array.Resize(ref m_PlanarProbes, m_PlanarProbes.Length * 2);
Array.Resize(ref m_PlanarProbeBounds, m_PlanarProbeBounds.Length * 2);
}
m_PlanarProbes[m_PlanarProbeCount] = (PlanarReflectionProbe)probe;
m_PlanarProbeBounds[m_PlanarProbeCount] = ((PlanarReflectionProbe)probe).boundingSphere;
++m_PlanarProbeCount;
break;
}
}
}
public static void AssignRenderData(
HDProbe probe,
HDProbe.RenderData renderData,
ProbeSettings.Mode targetMode
)
{
switch (targetMode)
{
case ProbeSettings.Mode.Baked: probe.bakedRenderData = renderData; break;
case ProbeSettings.Mode.Custom: probe.customRenderData = renderData; break;
case ProbeSettings.Mode.Realtime: probe.realtimeRenderData = renderData; break;
}
}
static Texture CreateAndSetRenderTargetIfRequired(HDProbe probe, ProbeSettings.Mode targetMode)
{
var settings = probe.settings;
Texture target = probe.GetTexture(targetMode);
if (target != null)
{
return(target);
}
target = CreateRenderTargetForMode(probe, targetMode);
probe.SetTexture(targetMode, target);
return(target);
}
static bool DoesRealtimeProbeNeedToBeUpdated(HDProbe probe)
{
// Discard (real time, every frame) probe already rendered this frame
// Discard (real time, OnEnable) probe already rendered after on enable
if (probe.mode == ProbeSettings.Mode.Realtime)
{
switch (probe.realtimeMode)
{
case ProbeSettings.RealtimeMode.EveryFrame:
return(probe.lastRenderedFrame != Time.frameCount);
case ProbeSettings.RealtimeMode.OnEnable:
return(!probe.wasRenderedAfterOnEnable);
}
}
return(true);
}
public static void Render(
HDProbe probe, Transform viewerTransform,
Texture outTarget, out HDProbe.RenderData outRenderData,
bool forceFlipY = false
)
{
var positionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, viewerTransform);
HDRenderUtilities.Render(
probe.settings,
positionSettings,
outTarget,
out CameraSettings cameraSettings, out CameraPositionSettings cameraPosition,
forceFlipY: forceFlipY
);
outRenderData = new HDProbe.RenderData(cameraSettings, cameraPosition);
}
internal static void RenderAndWriteToFile(
HDProbe probe, string targetFile,
RenderTexture cubeRT, RenderTexture planarRT
)
{
var settings = probe.settings;
switch (settings.type)
{
case ProbeSettings.ProbeType.ReflectionProbe:
{
var positionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, null);
HDRenderUtilities.Render(probe.settings, positionSettings, cubeRT,
forceFlipY: true,
forceInvertBackfaceCulling: true, // TODO: for an unknown reason, we need to invert the backface culling for baked reflection probes, Remove this
(uint)StaticEditorFlags.ReflectionProbeStatic
);
HDBakingUtilities.CreateParentDirectoryIfMissing(targetFile);
HDTextureUtilities.WriteTextureFileToDisk(cubeRT, targetFile);
break;
}
case ProbeSettings.ProbeType.PlanarProbe:
{
var planarProbe = (PlanarReflectionProbe)probe;
var positionSettings = ProbeCapturePositionSettings.ComputeFromMirroredReference(
probe,
planarProbe.referencePosition
);
HDRenderUtilities.Render(
settings,
positionSettings,
planarRT,
out CameraSettings cameraSettings, out CameraPositionSettings cameraPositionSettings
);
HDBakingUtilities.CreateParentDirectoryIfMissing(targetFile);
HDTextureUtilities.WriteTextureFileToDisk(planarRT, targetFile);
var renderData = new HDProbe.RenderData(cameraSettings, cameraPositionSettings);
HDBakingUtilities.TrySerializeToDisk(renderData, targetFile + ".renderData");
break;
}
}
}
public static ProbeCapturePositionSettings ComputeFromMirroredReference(
HDProbe probe, Vector3 referencePosition
)
{
var positionSettings = ComputeFrom(
probe,
referencePosition, Quaternion.identity
);
// Set proper orientation for the reference rotation
var proxyMatrix = Matrix4x4.TRS(
positionSettings.proxyPosition,
positionSettings.proxyRotation,
Vector3.one
);
var mirrorPosition = proxyMatrix.MultiplyPoint(probe.settings.proxySettings.mirrorPositionProxySpace);
positionSettings.referenceRotation = Quaternion.LookRotation(mirrorPosition - positionSettings.referencePosition);
return(positionSettings);
}
internal void UnregisterProbe(HDProbe probe)
{
m_BakedProbes.Remove(probe);
m_RealtimeViewDependentProbes.Remove(probe);
m_RealtimeViewIndependentProbes.Remove(probe);
// Remove swap back
var index = Array.IndexOf(m_PlanarProbes, probe);
if (index != -1)
{
if (index < m_PlanarProbeCount)
{
m_PlanarProbes[index] = m_PlanarProbes[m_PlanarProbeCount - 1];
m_PlanarProbeBounds[index] = m_PlanarProbeBounds[m_PlanarProbeCount - 1];
m_PlanarProbes[m_PlanarProbeCount - 1] = null;
}
--m_PlanarProbeCount;
}
}
internal static void AssignRenderData(HDProbe probe, string bakedTexturePath)
{
switch (probe.settings.type)
{
case ProbeSettings.ProbeType.PlanarProbe:
{
var planarProbe = (PlanarReflectionProbe)probe;
var dataFile = bakedTexturePath + ".renderData";
if (File.Exists(dataFile))
{
if (HDBakingUtilities.TryDeserializeFromDisk(dataFile, out HDProbe.RenderData renderData))
{
HDProbeSystem.AssignRenderData(probe, renderData, ProbeSettings.Mode.Baked);
EditorUtility.SetDirty(probe);
}
}
break;
}
}
}
public static ProbeCapturePositionSettings ComputeFrom(HDProbe probe, Transform reference)
{
var referencePosition = Vector3.zero;
var referenceRotation = Quaternion.identity;
if (reference != null)
{
referencePosition = reference.position;
referenceRotation = reference.rotation;
}
else
{
if (probe.type == ProbeSettings.ProbeType.PlanarProbe)
{
var planar = (PlanarReflectionProbe)probe;
return(ComputeFromMirroredReference(planar, planar.referencePosition));
}
}
return(ComputeFrom(probe, referencePosition, referenceRotation));
}
internal static void RenderAndWriteToFile(
HDProbe probe, string targetFile,
RenderTexture cubeRT, RenderTexture planarRT
)
{
var settings = probe.settings;
switch (settings.type)
{
case ProbeSettings.ProbeType.ReflectionProbe:
{
var positionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, null);
HDRenderUtilities.Render(probe.settings, positionSettings, cubeRT, forceFlipY: true);
HDBakingUtilities.CreateParentDirectoryIfMissing(targetFile);
HDTextureUtilities.WriteTextureFileToDisk(cubeRT, targetFile);
break;
}
case ProbeSettings.ProbeType.PlanarProbe:
{
var planarProbe = (PlanarReflectionProbe)probe;
var positionSettings = ProbeCapturePositionSettings.ComputeFromMirroredReference(
probe,
planarProbe.referencePosition
);
HDRenderUtilities.Render(
settings,
positionSettings,
planarRT,
out CameraSettings cameraSettings, out CameraPositionSettings cameraPositionSettings
);
HDBakingUtilities.CreateParentDirectoryIfMissing(targetFile);
HDTextureUtilities.WriteTextureFileToDisk(planarRT, targetFile);
var renderData = new HDProbe.RenderData(cameraSettings, cameraPositionSettings);
HDBakingUtilities.TrySerializeToDisk(renderData, targetFile + ".renderData");
break;
}
}
}
public static void UnregisterProbe(HDProbe probe) => s_Instance.UnregisterProbe(probe);
internal void Init(HDProbe probe)
{
this.m_Probe = probe;
}
