/// <summary>
/// Bind to a pixel shader for rendering.
/// </summary>
public void BindToMaterial(MaterialPropertyBlock 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");
mat.SetTexture("transmittance_texture", TransmittanceTexture);
mat.SetTexture("scattering_texture", ScatteringTexture);
mat.SetTexture("irradiance_texture", IrradianceTexture);
if (CombineScatteringTextures)
{
mat.SetTexture("single_mie_scattering_texture", Texture2D.blackTexture);
}
else
{
mat.SetTexture("single_mie_scattering_texture", OptionalSingleMieScatteringTexture);
}
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);
}
public void RenderLightVolumes(CommandBuffer cmd, HDCamera hdCamera, CullingResults cullResults, LightingDebugSettings lightDebugSettings, RTHandleSystem.RTHandle finalRT)
{
using (new ProfilingSample(cmd, "Display Light Volumes"))
{
// Clear the buffers
HDUtils.SetRenderTarget(cmd, hdCamera, m_ColorAccumulationBuffer, ClearFlag.Color, Color.black);
HDUtils.SetRenderTarget(cmd, hdCamera, m_LightCountBuffer, ClearFlag.Color, Color.black);
HDUtils.SetRenderTarget(cmd, hdCamera, m_DebugLightVolumesTexture, ClearFlag.Color, Color.black);
// Set the render target array
HDUtils.SetRenderTarget(cmd, hdCamera, m_RTIDs, m_DepthBuffer);
// First of all let's do the regions for the light sources (we only support Punctual and Area)
int numLights = cullResults.visibleLights.Length;
for (int lightIdx = 0; lightIdx < numLights; ++lightIdx)
{
// Let's build the light's bounding sphere matrix
Light currentLegacyLight = cullResults.visibleLights[lightIdx].light;
if (currentLegacyLight == null)
{
continue;
}
HDAdditionalLightData currentHDRLight = currentLegacyLight.GetComponent <HDAdditionalLightData>();
if (currentHDRLight == null)
{
continue;
}
Matrix4x4 positionMat = Matrix4x4.Translate(currentLegacyLight.transform.position);
if (currentLegacyLight.type == LightType.Point || currentLegacyLight.type == LightType.Area)
{
m_MaterialProperty.SetVector(_RangeShaderID, new Vector3(currentLegacyLight.range, currentLegacyLight.range, currentLegacyLight.range));
switch (currentHDRLight.lightTypeExtent)
{
case LightTypeExtent.Punctual:
{
m_MaterialProperty.SetColor(_ColorShaderID, new Color(0.0f, 0.5f, 0.0f, 1.0f));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, 0));
cmd.DrawMesh(DebugShapes.instance.RequestSphereMesh(), positionMat, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
break;
case LightTypeExtent.Rectangle:
{
m_MaterialProperty.SetColor(_ColorShaderID, new Color(0.0f, 1.0f, 1.0f, 1.0f));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, 0));
cmd.DrawMesh(DebugShapes.instance.RequestSphereMesh(), positionMat, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
break;
case LightTypeExtent.Tube:
{
m_MaterialProperty.SetColor(_ColorShaderID, new Color(1.0f, 0.0f, 0.5f, 1.0f));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, 0));
cmd.DrawMesh(DebugShapes.instance.RequestSphereMesh(), positionMat, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
break;
default:
break;
}
}
else if (currentLegacyLight.type == LightType.Spot)
{
if (currentHDRLight.spotLightShape == SpotLightShape.Cone)
{
float bottomRadius = Mathf.Tan(currentLegacyLight.spotAngle * Mathf.PI / 360.0f) * currentLegacyLight.range;
m_MaterialProperty.SetColor(_ColorShaderID, new Color(1.0f, 0.5f, 0.0f, 1.0f));
m_MaterialProperty.SetVector(_RangeShaderID, new Vector3(bottomRadius, bottomRadius, currentLegacyLight.range));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, 0));
cmd.DrawMesh(DebugShapes.instance.RequestConeMesh(), currentLegacyLight.gameObject.transform.localToWorldMatrix, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
else if (currentHDRLight.spotLightShape == SpotLightShape.Box)
{
m_MaterialProperty.SetColor(_ColorShaderID, new Color(1.0f, 0.5f, 0.0f, 1.0f));
m_MaterialProperty.SetVector(_RangeShaderID, new Vector3(currentHDRLight.shapeWidth, currentHDRLight.shapeHeight, currentLegacyLight.range));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, currentLegacyLight.range / 2.0f));
cmd.DrawMesh(DebugShapes.instance.RequestBoxMesh(), currentLegacyLight.gameObject.transform.localToWorldMatrix, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
else if (currentHDRLight.spotLightShape == SpotLightShape.Pyramid)
{
float bottomWidth = Mathf.Tan(currentLegacyLight.spotAngle * Mathf.PI / 360.0f) * currentLegacyLight.range;
m_MaterialProperty.SetColor(_ColorShaderID, new Color(1.0f, 0.5f, 0.0f, 1.0f));
m_MaterialProperty.SetVector(_RangeShaderID, new Vector3(currentHDRLight.aspectRatio * bottomWidth * 2, bottomWidth * 2, currentLegacyLight.range));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, 0));
cmd.DrawMesh(DebugShapes.instance.RequestPyramidMesh(), currentLegacyLight.gameObject.transform.localToWorldMatrix, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
}
}
// Now let's do the same but for reflection probes
int numProbes = cullResults.visibleReflectionProbes.Length;
for (int probeIdx = 0; probeIdx < numProbes; ++probeIdx)
{
// Let's build the light's bounding sphere matrix
ReflectionProbe currentLegacyProbe = cullResults.visibleReflectionProbes[probeIdx].reflectionProbe;
HDAdditionalReflectionData currentHDProbe = currentLegacyProbe.GetComponent <HDAdditionalReflectionData>();
if (!currentHDProbe)
{
continue;
}
MaterialPropertyBlock m_MaterialProperty = new MaterialPropertyBlock();
Mesh targetMesh = null;
if (currentHDProbe.influenceVolume.shape == InfluenceShape.Sphere)
{
m_MaterialProperty.SetVector(_RangeShaderID, new Vector3(currentHDProbe.influenceVolume.sphereRadius, currentHDProbe.influenceVolume.sphereRadius, currentHDProbe.influenceVolume.sphereRadius));
targetMesh = DebugShapes.instance.RequestSphereMesh();
}
else
{
m_MaterialProperty.SetVector(_RangeShaderID, new Vector3(currentHDProbe.influenceVolume.boxSize.x, currentHDProbe.influenceVolume.boxSize.y, currentHDProbe.influenceVolume.boxSize.z));
targetMesh = DebugShapes.instance.RequestBoxMesh();
}
m_MaterialProperty.SetColor(_ColorShaderID, new Color(1.0f, 1.0f, 0.0f, 1.0f));
m_MaterialProperty.SetVector(_OffsetShaderID, new Vector3(0, 0, 0));
Matrix4x4 positionMat = Matrix4x4.Translate(currentLegacyProbe.transform.position);
cmd.DrawMesh(targetMesh, positionMat, m_DebugLightVolumeMaterial, 0, 0, m_MaterialProperty);
}
// Define which kernel to use based on the lightloop options
int targetKernel = lightDebugSettings.lightVolumeDebugByCategory == LightLoop.LightVolumeDebug.ColorAndEdge ? m_DebugLightVolumeColorsKernel : m_DebugLightVolumeGradientKernel;
// Set the input params for the compute
cmd.SetComputeTextureParam(m_DebugLightVolumeCompute, targetKernel, _DebugLightCountBufferShaderID, m_LightCountBuffer);
cmd.SetComputeTextureParam(m_DebugLightVolumeCompute, targetKernel, _DebugColorAccumulationBufferShaderID, m_ColorAccumulationBuffer);
cmd.SetComputeTextureParam(m_DebugLightVolumeCompute, targetKernel, _DebugLightVolumesTextureShaderID, m_DebugLightVolumesTexture);
cmd.SetComputeTextureParam(m_DebugLightVolumeCompute, targetKernel, _ColorGradientTextureShaderID, m_ColorGradientTexture);
cmd.SetComputeIntParam(m_DebugLightVolumeCompute, _MaxDebugLightCountShaderID, (int)lightDebugSettings.maxDebugLightCount);
// Texture dimensions
int texWidth = hdCamera.actualWidth; // m_ColorAccumulationBuffer.rt.width;
int texHeight = hdCamera.actualHeight; // m_ColorAccumulationBuffer.rt.width;
// Dispatch the compute
int lightVolumesTileSize = 8;
int numTilesX = (texWidth + (lightVolumesTileSize - 1)) / lightVolumesTileSize;
int numTilesY = (texHeight + (lightVolumesTileSize - 1)) / lightVolumesTileSize;
cmd.DispatchCompute(m_DebugLightVolumeCompute, targetKernel, numTilesX, numTilesY, hdCamera.computePassCount);
// Blit this into the camera target
HDUtils.SetRenderTarget(cmd, hdCamera, finalRT);
m_MaterialProperty.SetTexture(HDShaderIDs._BlitTexture, m_DebugLightVolumesTexture);
cmd.DrawProcedural(Matrix4x4.identity, m_DebugLightVolumeMaterial, 1, MeshTopology.Triangles, 3, 1, m_MaterialProperty);
}
}
private void DrawNextPaint()
{
if (P3dPaintMaterial.CachedInstances.Count > 0)
{
if (paintIndex >= P3dPaintMaterial.CachedInstances.Count)
{
paintIndex = 0;
}
var paint = P3dPaintMaterial.CachedInstances[paintIndex++];
DestroyImmediate(paint.Thumbnail);
paint.Thumbnail = null;
if (paint != null && paint.Thumbnail == null && paint.Material != null)
{
var tempTextures = new List <RenderTexture>();
if (paintProperties == null)
{
paintProperties = new MaterialPropertyBlock();
}
else
{
paintProperties.Clear();
}
if (paint.Template != null)
{
foreach (var slot in paint.Template.Slots)
{
var slotR = paint.GetSlot(slot.WriteR.SourceGroup);
var slotG = paint.GetSlot(slot.WriteG.SourceGroup);
var slotB = paint.GetSlot(slot.WriteB.SourceGroup);
var slotA = paint.GetSlot(slot.WriteA.SourceGroup);
if (slotR != null || slotG != null || slotB != null || slotA != null)
{
var tempTexture = P3dHelper.GetRenderTexture(new RenderTextureDescriptor(1024, 1024, RenderTextureFormat.ARGB32, 0));
tempTextures.Add(tempTexture);
var textureR = P3dHelper.GetRenderTexture(tempTexture.descriptor);
var textureG = P3dHelper.GetRenderTexture(tempTexture.descriptor);
var textureB = P3dHelper.GetRenderTexture(tempTexture.descriptor);
var textureA = P3dHelper.GetRenderTexture(tempTexture.descriptor);
WriteThumbnailTex(textureR, slotR, slot.WriteR);
WriteThumbnailTex(textureG, slotG, slot.WriteG);
WriteThumbnailTex(textureB, slotB, slot.WriteB);
WriteThumbnailTex(textureA, slotA, slot.WriteA);
var channelR = P3dHelper.IndexToVector((int)slot.WriteR.SourceChannel);
var channelG = P3dHelper.IndexToVector((int)slot.WriteG.SourceChannel);
var channelB = P3dHelper.IndexToVector((int)slot.WriteB.SourceChannel);
var channelA = P3dHelper.IndexToVector((int)slot.WriteA.SourceChannel);
P3dPaintReplaceChannels.Blit(tempTexture, textureR, textureG, textureB, textureA, channelR, channelG, channelB, channelA);
P3dHelper.ReleaseRenderTexture(textureR);
P3dHelper.ReleaseRenderTexture(textureG);
P3dHelper.ReleaseRenderTexture(textureB);
P3dHelper.ReleaseRenderTexture(textureA);
paintProperties.SetTexture(slot.Name, tempTexture);
}
}
}
BeginPreview(thumbnailUtil, new Rect(0, 0, settings.ThumbnailSize, settings.ThumbnailSize));
var probeAnchor = default(Transform);
var probeExists = false;
if (settings.Environment != null)
{
probeAnchor = settings.Environment.transform;
probeExists = true;
}
switch (paint.Style)
{
case P3dPaintMaterial.StyleType.Seamless:
{
thumbnailUtil.DrawMesh(P3dHelper.GetSphereMesh(), Matrix4x4.identity, paint.Material, 0, paintProperties, probeAnchor, probeExists);
}
break;
case P3dPaintMaterial.StyleType.Decal:
{
thumbnailUtil.DrawMesh(P3dHelper.GetQuadMesh(), Matrix4x4.identity, paint.Material, 0, paintProperties, probeAnchor, probeExists);
}
break;
}
paint.Thumbnail = P3dHelper.GetReadableCopy(EndPreview(thumbnailUtil));
foreach (var tempTexture in tempTextures)
{
P3dHelper.ReleaseRenderTexture(tempTexture);
}
}
}
}
public void GenerateMaterialProps(MaterialPropertyBlock props)
{
props.SetTexture("_MainTex", texture);
props.SetVector("_MainTex_UV", uv);
}
// Token: 0x06002DFA RID: 11770 RVA: 0x000E180D File Offset: 0x000DFC0D
public static MaterialPropertyBlock Property(this MaterialPropertyBlock m, string name, Texture texture)
{
m.SetTexture(name, texture);
return(m);
}
void Damage()
{
health--;
propertyBlock.SetTexture("_Emission", emissionMaps[health - 1].texture);
sr.SetPropertyBlock(propertyBlock);
}
public void SetValueOnMaterialPropertyBlock(MaterialPropertyBlock mat)
{
if ((propType == PropertyType.Texture2D || propType == PropertyType.Texture2DArray || propType == PropertyType.Texture3D))
{
if (m_ClassData.textureValue == null)
{
// there's no way to set the texture back to NULL
// and no way to delete the property either
// so instead we set the value to what we know the default will be
// (all textures in ShaderGraph default to white)
mat.SetTexture(name, Texture2D.whiteTexture);
}
else
{
mat.SetTexture(name, m_ClassData.textureValue);
}
}
else if (propType == PropertyType.Cubemap)
{
if (m_ClassData.cubemapValue == null)
{
// there's no way to set the texture back to NULL
// and no way to delete the property either
// so instead we set the value to what we know the default will be
// (all textures in ShaderGraph default to white)
// there's no Cubemap.whiteTexture, but this seems to work
mat.SetTexture(name, Texture2D.whiteTexture);
}
else
{
mat.SetTexture(name, m_ClassData.cubemapValue);
}
}
else if (propType == PropertyType.Color)
{
mat.SetColor(name, m_StructData.colorValue);
}
else if (propType == PropertyType.Vector2 || propType == PropertyType.Vector3 || propType == PropertyType.Vector4)
{
mat.SetVector(name, m_StructData.vector4Value);
}
else if (propType == PropertyType.Float)
{
mat.SetFloat(name, m_StructData.floatValue);
}
else if (propType == PropertyType.Boolean)
{
mat.SetFloat(name, m_StructData.booleanValue ? 1 : 0);
}
else if (propType == PropertyType.Matrix2 || propType == PropertyType.Matrix3 || propType == PropertyType.Matrix4)
{
mat.SetMatrix(name, m_StructData.matrixValue);
}
else if (propType == PropertyType.Gradient)
{
mat.SetFloat(string.Format("{0}_Type", name), (int)m_ClassData.gradientValue.mode);
mat.SetFloat(string.Format("{0}_ColorsLength", name), m_ClassData.gradientValue.colorKeys.Length);
mat.SetFloat(string.Format("{0}_AlphasLength", name), m_ClassData.gradientValue.alphaKeys.Length);
for (int i = 0; i < 8; i++)
{
mat.SetVector(string.Format("{0}_ColorKey{1}", name, i), i < m_ClassData.gradientValue.colorKeys.Length ? GradientUtil.ColorKeyToVector(m_ClassData.gradientValue.colorKeys[i]) : Vector4.zero);
}
for (int i = 0; i < 8; i++)
{
mat.SetVector(string.Format("{0}_AlphaKey{1}", name, i), i < m_ClassData.gradientValue.alphaKeys.Length ? GradientUtil.AlphaKeyToVector(m_ClassData.gradientValue.alphaKeys[i]) : Vector2.zero);
}
}
else if (propType == PropertyType.VirtualTexture)
{
// virtual texture assignments are not supported via the material property block, we must assign them to the materials
}
}
// Called when visible to a camera
void OnWillRenderObject()
{
// Depth texture is used by ocean shader for transparency/depth fog, and for fading out foam at shoreline.
Camera.current.depthTextureMode |= DepthTextureMode.Depth;
// per instance data
if (_mpb == null)
{
_mpb = new MaterialPropertyBlock();
}
_rend.GetPropertyBlock(_mpb);
// blend LOD 0 shape in/out to avoid pop, if the ocean might scale up later (it is smaller than its maximum scale)
bool needToBlendOutShape = _lodIndex == 0 && OceanRenderer.Instance.ScaleCouldIncrease;
float meshScaleLerp = needToBlendOutShape ? OceanRenderer.Instance.ViewerAltitudeLevelAlpha : 0f;
// blend furthest normals scale in/out to avoid pop, if scale could reduce
bool needToBlendOutNormals = _lodIndex == _totalLodCount - 1 && OceanRenderer.Instance.ScaleCouldDecrease;
float farNormalsWeight = needToBlendOutNormals ? OceanRenderer.Instance.ViewerAltitudeLevelAlpha : 1f;
_mpb.SetVector("_InstanceData", new Vector4(meshScaleLerp, farNormalsWeight, _lodIndex));
// geometry data
// compute grid size of geometry. take the long way to get there - make sure we land exactly on a power of two
// and not inherit any of the lossy-ness from lossyScale.
float squareSize = Mathf.Pow(2f, Mathf.Round(Mathf.Log(transform.lossyScale.x) / Mathf.Log(2f))) / _baseVertDensity;
float mul = 1.875f; // fudge 1
float pow = 1.4f; // fudge 2
float normalScrollSpeed0 = Mathf.Pow(Mathf.Log(1f + 2f * squareSize) * mul, pow);
float normalScrollSpeed1 = Mathf.Pow(Mathf.Log(1f + 4f * squareSize) * mul, pow);
_mpb.SetVector("_GeomData", new Vector3(squareSize, normalScrollSpeed0, normalScrollSpeed1));
// assign lod data to ocean shader
var ldaws = OceanRenderer.Instance._lodDataAnimWaves;
var ldsds = OceanRenderer.Instance._lodDataSeaDepths;
var ldfoam = OceanRenderer.Instance._lodDataFoam;
var ldflow = OceanRenderer.Instance._lodDataFlow;
var ldshadows = OceanRenderer.Instance._lodDataShadow;
ldaws.BindResultData(_lodIndex, 0, _mpb);
if (OceanRenderer.Instance._createFlowSim)
{
ldflow.BindResultData(_lodIndex, 0, _mpb);
}
if (OceanRenderer.Instance._createFoamSim)
{
ldfoam.BindResultData(_lodIndex, 0, _mpb);
}
if (OceanRenderer.Instance._createSeaFloorDepthData)
{
ldsds.BindResultData(_lodIndex, 0, _mpb);
}
if (OceanRenderer.Instance._createShadowData)
{
ldshadows.BindResultData(_lodIndex, 0, _mpb);
}
if (_lodIndex + 1 < OceanRenderer.Instance.CurrentLodCount)
{
ldaws.BindResultData(_lodIndex + 1, 1, _mpb);
if (OceanRenderer.Instance._createFlowSim)
{
ldflow.BindResultData(_lodIndex + 1, 1, _mpb);
}
if (OceanRenderer.Instance._createFoamSim)
{
ldfoam.BindResultData(_lodIndex + 1, 1, _mpb);
}
if (OceanRenderer.Instance._createSeaFloorDepthData)
{
ldsds.BindResultData(_lodIndex + 1, 1, _mpb);
}
if (OceanRenderer.Instance._createShadowData)
{
ldshadows.BindResultData(_lodIndex + 1, 1, _mpb);
}
}
if (OceanRenderer.Instance.PlanarReflection && OceanRenderer.Instance.PlanarReflection.ReflectionTexture)
{
_mpb.SetTexture(_reflectionTexId, OceanRenderer.Instance.PlanarReflection.ReflectionTexture);
}
else
{
_mpb.SetTexture(_reflectionTexId, Texture2D.blackTexture);
}
// Hack - due to SV_IsFrontFace occasionally coming through as true for backfaces,
// add a param here that forces ocean to be in undrwater state. I think the root
// cause here might be imprecision or numerical issues at ocean tile boundaries, although
// i'm not sure why cracks are not visible in this case.
float heightOffset = OceanRenderer.Instance.ViewerHeightAboveWater;
_mpb.SetFloat("_ForceUnderwater", heightOffset < -2f ? 1f : 0f);
_rend.SetPropertyBlock(_mpb);
if (_drawRenderBounds)
{
DebugDrawRendererBounds(_rend);
}
}
void SetShaderPropertiesBlock(MaterialPropertyBlock propertyBlock)
{
propertyBlock.SetVector(_idNoiseOffset, _angle);
propertyBlock.SetVector(_idMinBounds, _minBounds);
propertyBlock.SetVector(_idMaxBounds, _maxBounds);
propertyBlock.SetMatrix(_idProjection, _projectionMatrixCached);
propertyBlock.SetMatrix(_idViewWorldLight, _viewWorldLight);
propertyBlock.SetMatrix(_idLocalRotation, _localRotation);
propertyBlock.SetMatrix(_idRotation, _rotation);
propertyBlock.SetColor(_idColorTint, colorTint);
propertyBlock.SetFloat(_idLightMultiplier, lightMultiplier);
propertyBlock.SetVector("_WorldPos", (CachedTransform.position + CachedTransform.forward) * worldScrollAmount);
var lightMaterial = LightMaterial;
if (useSoftBlend)
{
lightMaterial.EnableKeyword("_SOFTBLEND_ON");
}
else
{
lightMaterial.DisableKeyword("_SOFTBLEND_ON");
}
if (useDithering)
{
propertyBlock.SetFloat(_idJitterAmount, ditherAmount);
propertyBlock.SetTexture(_idDitherTex, DitherTexture);
lightMaterial.EnableKeyword("_DITHER_ON");
}
else
{
lightMaterial.DisableKeyword("_DITHER_ON");
}
if (useCurves)
{
propertyBlock.SetTexture(_idFallOffTex, FallOffTexture);
lightMaterial.EnableKeyword("_CURVE_ON");
}
else
{
lightMaterial.DisableKeyword("_CURVE_ON");
}
switch (lightType)
{
case LightTypes.Point:
case LightTypes.Spot:
case LightTypes.Orthographic:
propertyBlock.SetFloat(_idSpotExponent, spotExponent);
propertyBlock.SetFloat(_idConstantAttenuation, constantAttenuation);
propertyBlock.SetFloat(_idLinearAttenuation, linearAttenuation);
propertyBlock.SetFloat(_idQuadraticAttenuation, quadraticAttenuation);
break;
case LightTypes.Area:
Vector4 p = volumeTextureOffset;
p.w = volumeTextureScale;
propertyBlock.SetVector(_idVolumeOffset, p);
propertyBlock.SetFloat(_idVolumeParams, shapeValue);
switch (volumeShape)
{
case VolumeShape.Cube:
lightMaterial.EnableKeyword("_SHAPE_CUBE");
lightMaterial.DisableKeyword("_SHAPE_SPHERE");
lightMaterial.DisableKeyword("_SHAPE_ROUNDED_CUBE");
lightMaterial.DisableKeyword("_SHAPE_CYLINDER");
break;
case VolumeShape.Sphere:
lightMaterial.EnableKeyword("_SHAPE_SPHERE");
lightMaterial.DisableKeyword("_SHAPE_CUBE");
lightMaterial.DisableKeyword("_SHAPE_ROUNDED_CUBE");
lightMaterial.DisableKeyword("_SHAPE_CYLINDER");
break;
case VolumeShape.RoundedCube:
lightMaterial.EnableKeyword("_SHAPE_ROUNDED_CUBE");
lightMaterial.DisableKeyword("_SHAPE_CUBE");
lightMaterial.DisableKeyword("_SHAPE_SPHERE");
lightMaterial.DisableKeyword("_SHAPE_CYLINDER");
break;
case VolumeShape.Cylinder:
lightMaterial.EnableKeyword("_SHAPE_CYLINDER");
lightMaterial.DisableKeyword("_SHAPE_CUBE");
lightMaterial.DisableKeyword("_SHAPE_SPHERE");
lightMaterial.DisableKeyword("_SHAPE_ROUNDED_CUBE");
break;
}
break;
}
switch (lightType)
{
case LightTypes.Area:
propertyBlock.SetTexture("_MainTex", areaVolume != null ? areaVolume : EmptyTexture3D);
break;
case LightTypes.Point:
propertyBlock.SetTexture("_LightColorEmission", pointEmission != null ? pointEmission : EmptyCubemap);
propertyBlock.SetTexture("_NoiseTex", pointNoise != null ? pointNoise : EmptyCubemap);
propertyBlock.SetTexture("_ShadowTexture", pointShadow != null ? pointShadow : EmptyCubemap);
break;
case LightTypes.Spot:
case LightTypes.Orthographic:
propertyBlock.SetTexture("_LightColorEmission", spotEmission != null ? spotEmission : EmptyTexture2D);
propertyBlock.SetTexture("_NoiseTex", spotNoise != null ? spotNoise : EmptyTexture2D);
propertyBlock.SetTexture("_ShadowTexture", spotShadow != null ? spotShadow : EmptyTexture2D);
break;
}
var shouldUseCustomShadowMap = false;
cam.targetTexture = null;
switch (shadowMode)
{
case ShadowMode.Realtime:
if (_depthTexture == null)
{
CreateDepthTexture(lightType);
}
propertyBlock.SetTexture("_ShadowTexture", _depthTexture);
lightMaterial.EnableKeyword("_SHADOW_ON");
shouldUseCustomShadowMap = renderFullShadows;
break;
case ShadowMode.Baked:
lightMaterial.EnableKeyword("_SHADOW_ON");
shouldUseCustomShadowMap = false;
break;
case ShadowMode.None:
lightMaterial.DisableKeyword("_SHADOW_ON");
shouldUseCustomShadowMap = false;
break;
}
if (shouldUseCustomShadowMap)
{
lightMaterial.EnableKeyword("_SHADOW_EXP");
}
else
{
lightMaterial.DisableKeyword("_SHADOW_EXP");
}
float far = cam.farClipPlane;
float near = cam.nearClipPlane;
float fov = cam.fieldOfView;
far = spotRange;
near = Mathf.Max(0.01f, spotNear);
fov = spotAngle;
cam.farClipPlane = far;
if (lightType == LightTypes.Point || lightType == LightTypes.Area)
{
near = -pointLightRadius;
far = pointLightRadius;
}
switch ((lightType))
{
case LightTypes.Point:
case LightTypes.Area:
propertyBlock.SetVector(_idLightParams, new Vector4(near, far, aspect, pointLightRadius));
break;
case LightTypes.Orthographic:
propertyBlock.SetVector(_idLightParams, new Vector4(near, far, aspect, orthoSize));
break;
default:
propertyBlock.SetVector(_idLightParams, new Vector4(near, far, aspect, fov * 0.5f * Mathf.Deg2Rad));
break;
}
}
public override void SetSprite(Sprite sprite)
{
_renderer.GetPropertyBlock(_propBlock);
_propBlock.SetTexture("_ItemTex", sprite.texture);
_renderer.SetPropertyBlock(_propBlock);
}
private void RenderMasks(Camera camera, WaterCamera waterCamera, MaterialPropertyBlock propertyBlock)
{
List <WaterVolumeSubtract> subtractiveVolumesDirect = this._Water.Volume.GetSubtractiveVolumesDirect();
List <WaterVolumeAdd> volumesDirect = this._Water.Volume.GetVolumesDirect();
if (waterCamera == null || !waterCamera.RenderVolumes || (subtractiveVolumesDirect.Count == 0 && volumesDirect.Count == 0 && this._Masks.Count == 0))
{
this.ReleaseTemporaryBuffers();
return;
}
int waterTempLayer = WaterProjectSettings.Instance.WaterTempLayer;
int waterCollidersLayer = WaterProjectSettings.Instance.WaterCollidersLayer;
Camera effectsCamera = waterCamera.EffectsCamera;
if (effectsCamera == null)
{
this.ReleaseTemporaryBuffers();
return;
}
bool flag = false;
bool flag2 = false;
bool flag3 = false;
this.OnSharedSubtractiveMaskRender(ref flag, ref flag2, ref flag3);
effectsCamera.CopyFrom(camera);
effectsCamera.enabled = false;
effectsCamera.GetComponent <WaterCamera>().enabled = false;
effectsCamera.renderingPath = RenderingPath.Forward;
effectsCamera.depthTextureMode = DepthTextureMode.None;
effectsCamera.cullingMask = 1 << waterTempLayer;
if (subtractiveVolumesDirect.Count != 0)
{
if (this._SubtractiveMaskTexture == null)
{
this._SubtractiveMaskTexture = RenderTexture.GetTemporary(camera.pixelWidth, camera.pixelHeight, 24, (!SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat)) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear, 1);
}
Graphics.SetRenderTarget(this._SubtractiveMaskTexture);
int count = subtractiveVolumesDirect.Count;
for (int i = 0; i < count; i++)
{
subtractiveVolumesDirect[i].SetLayer(waterTempLayer);
}
TemporaryRenderTexture temporary = RenderTexturesCache.GetTemporary(camera.pixelWidth, camera.pixelHeight, 24, (!SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat)) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGBFloat, true, false, false);
effectsCamera.clearFlags = CameraClearFlags.Color;
effectsCamera.backgroundColor = new Color(0f, 0f, 0.5f, 0f);
effectsCamera.targetTexture = temporary;
effectsCamera.RenderWithShader(this._VolumeFrontShader, "CustomType");
GL.Clear(true, true, new Color(0f, 0f, 0f, 0f), 0f);
Shader.SetGlobalTexture("_VolumesFrontDepth", temporary);
effectsCamera.clearFlags = CameraClearFlags.Nothing;
effectsCamera.targetTexture = this._SubtractiveMaskTexture;
effectsCamera.RenderWithShader(this._VolumeBackShader, "CustomType");
temporary.Dispose();
for (int j = 0; j < count; j++)
{
subtractiveVolumesDirect[j].SetLayer(waterCollidersLayer);
}
propertyBlock.SetTexture(ShaderVariables.SubtractiveMask, this._SubtractiveMaskTexture);
}
if (volumesDirect.Count != 0)
{
this.OnSharedMaskAdditiveRender();
if (this._AdditiveMaskTexture == null)
{
this._AdditiveMaskTexture = RenderTexture.GetTemporary(camera.pixelWidth, camera.pixelHeight, 16, (!SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat)) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear, 1);
}
Graphics.SetRenderTarget(this._AdditiveMaskTexture);
GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
int count2 = volumesDirect.Count;
for (int k = 0; k < count2; k++)
{
volumesDirect[k].SetLayer(waterTempLayer);
volumesDirect[k].EnableRenderers(false);
}
effectsCamera.clearFlags = CameraClearFlags.Nothing;
effectsCamera.targetTexture = this._AdditiveMaskTexture;
effectsCamera.RenderWithShader((!waterCamera.IsInsideAdditiveVolume) ? this._VolumeFrontFastShader : this._VolumeFrontShader, "CustomType");
effectsCamera.clearFlags = CameraClearFlags.Nothing;
effectsCamera.targetTexture = this._AdditiveMaskTexture;
effectsCamera.RenderWithShader(this._VolumeBackShader, "CustomType");
for (int l = 0; l < count2; l++)
{
volumesDirect[l].SetLayer(waterCollidersLayer);
}
propertyBlock.SetTexture(ShaderVariables.AdditiveMask, this._AdditiveMaskTexture);
}
this.OnSharedMaskPostRender();
effectsCamera.targetTexture = null;
}
public override void SetOn(MaterialPropertyBlock block) => block.SetTexture(id, latestValue);
public override void SetValue(InteractableThemeProperty property, int index, float percentage)
{
propertyBlock.SetTexture("_MainTex", property.Values[index].Texture);
renderer.SetPropertyBlock(propertyBlock);
}
private void CreateRenderTextures(Camera sourceCamera)
{
RenderTextureFormat textureFormat = RenderTextureFormat.DefaultHDR;
int size = Math.Max(32, RenderTextureSize);
if (WeatherMakerScript.Instance != null)
{
size = WeatherMakerScript.Instance.PerformanceProfile.ReflectionTextureSize;
}
// cleanup
if (LeftEyeTexture != null && LeftEyeTexture.width != size)
{
LeftEyeTexture.Release();
DestroyImmediate(LeftEyeTexture);
}
if (RightEyeTexture != null && RightEyeTexture.width != size)
{
RightEyeTexture.Release();
DestroyImmediate(RightEyeTexture);
}
if (LeftEyeTexture == null || !LeftEyeTexture.IsCreated())
{
LeftEyeTexture = new RenderTexture(size, size, 16, textureFormat)
{
name = "WeatherMakerPlanaReflectionLeftEyeTexture"
};
LeftEyeTexture.wrapMode = TextureWrapMode.Clamp;
LeftEyeTexture.filterMode = FilterMode.Bilinear;
}
MaterialPropertyBlock reflectBlock = null;
if (ReflectRenderer == null)
{
ReflectMaterial.SetTexture(ReflectionSamplerName, LeftEyeTexture);
}
else
{
reflectBlock = reflectPropertyBlock;
ReflectRenderer.GetPropertyBlock(reflectPropertyBlock);
reflectBlock.SetTexture(ReflectionSamplerName, LeftEyeTexture);
}
if (sourceCamera.stereoEnabled)
{
if (RightEyeTexture == null || !RightEyeTexture.IsCreated())
{
RightEyeTexture = new RenderTexture(size, size, 16, textureFormat)
{
name = "WeatherMakerPlanaReflectionRightEyeTexture"
};
RightEyeTexture.wrapMode = TextureWrapMode.Clamp;
RightEyeTexture.filterMode = FilterMode.Bilinear;
}
if (reflectBlock == null)
{
ReflectMaterial.SetTexture(ReflectionSamplerName2, RightEyeTexture);
}
else
{
reflectBlock.SetTexture(ReflectionSamplerName2, RightEyeTexture);
}
}
if (reflectBlock != null)
{
ReflectRenderer.SetPropertyBlock(reflectBlock);
}
}
public static void RefreshScene(Scene scene, ftLightmapsStorage storage = null, bool updateNonBaked = false)
{
var sceneCount = SceneManager.sceneCount;
if (globalMapsAdditional == null)
{
globalMapsAdditional = new List <LightmapAdditionalData>();
}
var lmaps = new List <LightmapData>();
var lmapsAdditional = new List <LightmapAdditionalData>();
var existingLmaps = LightmapSettings.lightmaps;
var existingLmapsAdditional = globalMapsAdditional;
// Acquire storage
if (storage == null)
{
if (!scene.isLoaded)
{
//Debug.LogError("dbg: Scene not loaded");
return;
}
SceneManager.SetActiveScene(scene);
var go = FindInScene("!ftraceLightmaps", scene);
if (go == null)
{
//Debug.LogError("dbg: no storage");
return;
}
storage = go.GetComponent <ftLightmapsStorage>();
if (storage == null)
{
//Debug.LogError("dbg: no storage 2");
return;
}
}
if (storage.idremap == null || storage.idremap.Length != storage.maps.Count)
{
storage.idremap = new int[storage.maps.Count];
}
// Decide which global engine lightmapping mode to use
// TODO: allow mixing different modes
directionalMode = storage.dirMaps.Count != 0 ? 1 : 0;
bool patchedDirection = false;
SetDirectionalMode();
// Set dummy directional tex for non-directional lightmaps in directional mode
if (directionalMode == 1)
{
for (int i = 0; i < existingLmaps.Length; i++)
{
if (existingLmaps[i].lightmapDir == null)
{
var lm = existingLmaps[i];
lm.lightmapDir = GetEmptyDirectionTex(storage);
existingLmaps[i] = lm;
patchedDirection = true;
}
}
}
// Detect if changes to lightmap array are necessary
bool sameArray = false;
if (existingLmaps.Length == storage.maps.Count)
{
sameArray = true;
for (int i = 0; i < storage.maps.Count; i++)
{
if (existingLmaps[i].lightmapColor != storage.maps[i])
{
sameArray = false;
break;
}
if (storage.rnmMaps0.Count > i && (existingLmapsAdditional.Count <= i || existingLmapsAdditional[i].rnm0 != storage.rnmMaps0[i]))
{
sameArray = false;
break;
}
}
}
if (!sameArray) // create new lightmap array
{
if (sceneCount >= 1)
{
// first add old
for (int i = 0; i < existingLmaps.Length; i++)
{
// skip empty lightmaps (can be created by 5.6 ldata asset or vertex color)
// ... unless there are valid lightmaps around them
bool lightmapIsEmpty = existingLmaps[i] == null || (existingLmaps[i].lightmapColor == null && existingLmaps[i].shadowMask == null);
bool lightmapCanBeSkipped = lightmapIsEmpty && (i == 0 || i == existingLmaps.Length - 1);
if (!lightmapCanBeSkipped)
{
lmaps.Add(existingLmaps[i]);
if (existingLmapsAdditional.Count > i)
{
lmapsAdditional.Add(existingLmapsAdditional[i]);
}
}
}
}
for (int i = 0; i < storage.maps.Count; i++)
{
var texlm = storage.maps[i];
Texture2D texmask = null;
Texture2D texdir = null;
Texture2D texrnm0 = null;
Texture2D texrnm1 = null;
Texture2D texrnm2 = null;
int mapMode = 0;
if (storage.masks.Count > i)
{
texmask = storage.masks[i];
}
if (storage.dirMaps.Count > i)
{
texdir = storage.dirMaps[i];
}
if (storage.rnmMaps0.Count > i)
{
texrnm0 = storage.rnmMaps0[i];
texrnm1 = storage.rnmMaps1[i];
texrnm2 = storage.rnmMaps2[i];
mapMode = storage.mapsMode[i];
}
bool found = false;
int firstEmpty = -1;
for (int j = 0; j < lmaps.Count; j++)
{
if (lmaps[j].lightmapColor == texlm && lmaps[j].shadowMask == texmask)
{
// lightmap already added - reuse
storage.idremap[i] = j;
found = true;
//Debug.LogError("reused "+j);
// additional maps array could be flushed due to script recompilation - recover
if (texrnm0 != null && (lmapsAdditional.Count <= j || lmapsAdditional[j].rnm0 == null))
{
while (lmapsAdditional.Count <= j)
{
lmapsAdditional.Add(new LightmapAdditionalData());
}
var l = new LightmapAdditionalData();
l.rnm0 = texrnm0;
l.rnm1 = texrnm1;
l.rnm2 = texrnm2;
l.mode = mapMode;
lmapsAdditional[j] = l;
}
break;
}
else if (firstEmpty < 0 && lmaps[j].lightmapColor == null && lmaps[j].shadowMask == null)
{
// free (deleted) entry in existing lightmap list - possibly reuse
storage.idremap[i] = j;
firstEmpty = j;
}
}
if (!found)
{
LightmapData lm;
if (firstEmpty >= 0)
{
lm = lmaps[firstEmpty];
}
else
{
lm = new LightmapData();
}
lm.lightmapColor = texlm;
if (storage.masks.Count > i)
{
lm.shadowMask = texmask;
}
if (storage.dirMaps.Count > i && texdir != null)
{
lm.lightmapDir = texdir;
}
else if (directionalMode == 1)
{
lm.lightmapDir = GetEmptyDirectionTex(storage);
}
if (firstEmpty < 0)
{
lmaps.Add(lm);
storage.idremap[i] = lmaps.Count - 1;
}
else
{
lmaps[firstEmpty] = lm;
}
if (storage.rnmMaps0.Count > i)
{
var l = new LightmapAdditionalData();
l.rnm0 = texrnm0;
l.rnm1 = texrnm1;
l.rnm2 = texrnm2;
l.mode = mapMode;
if (firstEmpty < 0)
{
//Debug.LogError("added "+(lmaps.Count-1));
while (lmapsAdditional.Count < lmaps.Count - 1)
{
lmapsAdditional.Add(new LightmapAdditionalData());
}
lmapsAdditional.Add(l);
}
else
{
//Debug.LogError("set " + firstEmpty);
while (lmapsAdditional.Count < firstEmpty + 1)
{
lmapsAdditional.Add(new LightmapAdditionalData());
}
lmapsAdditional[firstEmpty] = l;
}
}
}
}
}
else // reuse existing lightmap array, only remap IDs
{
for (int i = 0; i < storage.maps.Count; i++)
{
storage.idremap[i] = i;
//Debug.LogError("full reuse");
/*if (storage.rnmMaps0.Count > i)
* {
* var l = new LightmapAdditionalData();
* l.rnm0 = storage.rnmMaps0[i];
* l.rnm1 = storage.rnmMaps1[i];
* l.rnm2 = storage.rnmMaps2[i];
* l.mode = storage.mapsMode[i];
* lmapsAdditional.Add(l);
* }*/
}
}
#if UNITY_EDITOR
// Set editor lighting mode
Lightmapping.giWorkflowMode = Lightmapping.GIWorkflowMode.OnDemand;
Lightmapping.realtimeGI = storage.usesRealtimeGI;
//Lightmapping.bakedGI = true; // ? only used for enlighten ? makes editor laggy ?
#endif
// Replace the lightmap array if needed
if (sameArray && patchedDirection)
{
LightmapSettings.lightmaps = existingLmaps;
}
if (!sameArray)
{
LightmapSettings.lightmaps = lmaps.ToArray();
globalMapsAdditional = lmapsAdditional;
}
/*
* // Debug
* var lms = LightmapSettings.lightmaps;
* for(int i=0; i<lms.Length; i++)
* {
* var name1 = ((lms[i]==null || lms[i].lightmapColor==null) ? "-" : lms[i].lightmapColor.name);
* var name2 = (globalMapsAdditional.Count > i ?(globalMapsAdditional[i].rnm0==null?"x":globalMapsAdditional[i].rnm0.name) : "-");
* Debug.LogError(i+" "+name1+" "+name2);
* }
*/
// Attempt to update skybox probe
if (RenderSettings.ambientMode == UnityEngine.Rendering.AmbientMode.Skybox)// && Lightmapping.lightingDataAsset == null)
{
var probe = RenderSettings.ambientProbe;
int isEmpty = -1;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 9; j++)
{
// default bugged probes are [almost] black or 1302?
float a = Mathf.Abs(probe[i, j]);
if (a > 1000.0f || a < 0.000001f)
{
isEmpty = 1;
break;
}
if (probe[i, j] != 0)
{
isEmpty = 0;
break;
}
}
if (isEmpty >= 0)
{
break;
}
}
if (isEmpty != 0)
{
DynamicGI.UpdateEnvironment();
}
}
// Set lightmap data on mesh renderers
var emptyVec4 = new Vector4(1, 1, 0, 0);
for (int i = 0; i < storage.bakedRenderers.Count; i++)
{
var r = storage.bakedRenderers[i];
if (r == null)
{
continue;
}
//if (r.isPartOfStaticBatch) continue;
var id = storage.bakedIDs[i];
Mesh vmesh = null;
if (i < storage.bakedVertexColorMesh.Count)
{
vmesh = storage.bakedVertexColorMesh[i];
}
if (vmesh != null)
{
var r2 = r as MeshRenderer;
if (r2 == null)
{
Debug.LogError("Unity cannot use additionalVertexStreams on non-MeshRenderer");
}
else
{
r2.additionalVertexStreams = vmesh;
r2.lightmapIndex = 0xFFFF;
var prop = new MaterialPropertyBlock();
prop.SetFloat("bakeryLightmapMode", 1);
r2.SetPropertyBlock(prop);
}
continue;
}
int globalID = (id < 0 || id >= storage.idremap.Length) ? id : storage.idremap[id];
r.lightmapIndex = globalID;
if (!r.isPartOfStaticBatch)
{
// scaleOffset is baked on static batches already
var scaleOffset = id < 0 ? emptyVec4 : storage.bakedScaleOffset[i];
r.lightmapScaleOffset = scaleOffset;
}
if (r.lightmapIndex >= 0 && globalID < globalMapsAdditional.Count)
{
var lmap = globalMapsAdditional[globalID];
if (lmap.rnm0 != null)
{
var prop = new MaterialPropertyBlock();
prop.SetTexture("_RNM0", lmap.rnm0);
prop.SetTexture("_RNM1", lmap.rnm1);
prop.SetTexture("_RNM2", lmap.rnm2);
prop.SetFloat("bakeryLightmapMode", lmap.mode);
r.SetPropertyBlock(prop);
}
}
}
// Set lightmap data on definitely-not-baked mesh renderers (can be possibly avoided)
if (updateNonBaked)
{
for (int i = 0; i < storage.nonBakedRenderers.Count; i++)
{
var r = storage.nonBakedRenderers[i];
if (r == null)
{
continue;
}
if (r.isPartOfStaticBatch)
{
continue;
}
r.lightmapIndex = 0xFFFE;
}
}
// Set lightmap data on terrains
for (int i = 0; i < storage.bakedRenderersTerrain.Count; i++)
{
var r = storage.bakedRenderersTerrain[i];
if (r == null)
{
continue;
}
var id = storage.bakedIDsTerrain[i];
r.lightmapIndex = (id < 0 || id >= storage.idremap.Length) ? id : storage.idremap[id];
var scaleOffset = id < 0 ? emptyVec4 : storage.bakedScaleOffsetTerrain[i];
r.lightmapScaleOffset = scaleOffset;
}
// Set shadowmask parameters on lights
for (int i = 0; i < storage.bakedLights.Count; i++)
{
#if UNITY_2017_3_OR_NEWER
if (storage.bakedLights[i] == null)
{
continue;
}
int channel = storage.bakedLightChannels[i];
var output = new LightBakingOutput();
output.isBaked = true;
if (channel < 0)
{
output.lightmapBakeType = LightmapBakeType.Baked;
}
else
{
output.lightmapBakeType = LightmapBakeType.Mixed;
output.mixedLightingMode = channel > 100 ? MixedLightingMode.Subtractive : MixedLightingMode.Shadowmask;
output.occlusionMaskChannel = channel > 100 ? -1 : channel;
output.probeOcclusionLightIndex = storage.bakedLights[i].bakingOutput.probeOcclusionLightIndex;
}
storage.bakedLights[i].bakingOutput = output;
#endif
}
// Increment lightmap refcounts
if (lightmapRefCount == null)
{
lightmapRefCount = new List <int>();
}
for (int i = 0; i < storage.idremap.Length; i++)
{
int currentID = storage.idremap[i];
while (lightmapRefCount.Count <= currentID)
{
lightmapRefCount.Add(0);
}
if (lightmapRefCount[currentID] < 0)
{
lightmapRefCount[currentID] = 0;
}
lightmapRefCount[currentID]++;
}
//if (loadedStorages == null) loadedStorages = new List<ftLightmapsStorage>();
//if (loadedStorages.Contains(storage)) loadedStorages.Add(storage);
//return appendOffset;
}
public void Sync()
{
#if UNITY_EDITOR
// If we have a terrain, we might be moved over another terrain. So lets see if we're in the bounds of our current terrain
// and if not, clear it and try to get a new one..
bool testForNewTerrain = false;
// check bounds of existing terrain
if (msObject != null && testForNewTerrain)
{
var tbounds = TransformBounds(msObject.GetBounds());
Renderer rend = GetComponent <Renderer>();
if (!tbounds.Intersects(rend.bounds))
{
testForNewTerrain = true;
}
}
// see if we have override, if we do, skip terrain testing
if (msOverrideObject != null)
{
if (msOverrideObject is MicroSplatTerrain
#if __MICROSPLAT_MESHTERRAIN__
|| msOverrideObject is MicroSplatMeshTerrain
#endif
)
{
msObject = msOverrideObject;
testForNewTerrain = false;
}
}
if (testForNewTerrain)
{
RaycastHit[] hits = Physics.RaycastAll(this.transform.position + Vector3.up * 100, Vector3.down, 500);
for (int i = 0; i < hits.Length; ++i)
{
var h = hits[i];
var t = h.collider.GetComponent <Terrain>();
if (t != null)
{
var nt = t.GetComponent <MicroSplatTerrain>();
if (nt != null)
{
msObject = nt;
break;
}
}
}
#if __MICROSPLAT_MESHTERRAIN__
if (msObject == null)
{
for (int i = 0; i < hits.Length; ++i)
{
var h = hits [i];
var m = h.collider.GetComponent <MicroSplatMeshTerrain> ();
if (m != null)
{
msObject = m;
break;
}
if (h.collider.transform.parent != null)
{
m = h.collider.transform.parent.GetComponent <MicroSplatMeshTerrain> ();
if (m != null)
{
msObject = m;
break;
}
}
}
}
#endif //__MICROSPLAT_MESHTERRAIN__
}
#endif //UNITY_EDITOR
if (msObject == null)
{
Debug.LogWarning("Terrain Blending: No Terrain Found");
return;
}
Material bmInstance = msObject.GetBlendMatInstance();
if (bmInstance == null)
{
Debug.LogWarning("Terrain Blending: No blend instance found from " + msObject.name);
return;
}
Renderer r = GetComponent <Renderer>();
var materials = r.sharedMaterials;
bool hasBlendMat = false;
for (int i = 0; i < materials.Length; ++i)
{
if (materials[i] == bmInstance && bmInstance != null)
{
hasBlendMat = true;
}
else if (materials[i] == null || materials[i].shader == null || materials[i].shader.name.Contains("_TerrainObjectBlend"))
{
hasBlendMat = true;
materials[i] = bmInstance;
r.sharedMaterials = materials;
}
}
if (!hasBlendMat)
{
System.Array.Resize <Material>(ref materials, materials.Length + 1);
materials[materials.Length - 1] = bmInstance;
r.sharedMaterials = materials;
}
if (props == null)
{
props = new MaterialPropertyBlock();
}
props.Clear();
props.SetVector("_TerrainBlendParams", new Vector4(blendDistance, blendContrast, msObject.transform.position.y, blendCurve));
props.SetVector("_SlopeBlendParams", new Vector4(slopeFilter, slopeContrast, slopeNoise, normalBlendDistance));
props.SetVector("_SnowBlendParams", new Vector4(snowWidth, 0, 0, 0));
props.SetFloat("_TBNoiseScale", noiseScale);
props.SetVector("_FeatureFilters", new Vector4(doTerrainBlend ? 0.0f : 1.0f, doSnow ? 0.0f : 1.0f, 0, 0));
if (normalFromObject != null)
{
props.SetTexture("_NormalOriginal", normalFromObject);
}
r.SetPropertyBlock(props);
}
public static void DrawFullScreen(this CommandBuffer CmdBuffer, RTHandle Source, RenderTargetIdentifier Desc, MaterialPropertyBlock MaterialPropertyBlock = null)
{
CmdBuffer.SetRenderTarget(Desc);
MaterialPropertyBlock.SetTexture(InfinityShaderIDs.RT_MainTexture, Source);
CmdBuffer.DrawMesh(FullScreenMesh, Matrix4x4.identity, BlitMaterial, 0, 1, MaterialPropertyBlock);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (!initialized)
{
Initialize();
}
if (!initialized)
{
return(inputDeps);
}
if (m_CurriculumQuery.CalculateEntityCount() != 1)
{
return(inputDeps);
}
using (s_ResetBackgroundObjects.Auto())
{
objectCache.ResetAllObjects();
}
var entity = m_CurriculumQuery.GetSingletonEntity();
var curriculumState = EntityManager.GetComponentData <CurriculumState>(entity);
var statics = EntityManager.GetComponentObject <PlacementStatics>(entity);
if (curriculumState.ScaleIndex >= statics.ScaleFactors.Length)
{
return(inputDeps);
}
var meshInfos = new NativeArray <MeshInfo>(statics.BackgroundPrefabs.Length, Allocator.TempJob);
for (int i = 0; i < statics.BackgroundPrefabs.Length; i++)
{
// ReSharper disable once UnusedVariable
ObjectPlacementUtilities.GetMeshAndMaterial(statics.BackgroundPrefabs[i], out var material, out var meshToDraw);
meshInfos[i] = new MeshInfo()
{
Bounds = meshToDraw.bounds
};
}
var foregroundObject = statics.ForegroundPrefabs[curriculumState.PrefabIndex];
var foregroundBounds = ObjectPlacementUtilities.ComputeBounds(foregroundObject);
var foregroundRotation =
ObjectPlacementUtilities.ComposeForegroundRotation(curriculumState, statics.OutOfPlaneRotations, statics.InPlaneRotations);
var foregroundScale = ObjectPlacementUtilities.ComputeForegroundScaling(
foregroundBounds, statics.ScaleFactors[curriculumState.ScaleIndex]);
var transformer = new WorldToScreenTransformer(camera);
// NOTE: For perspective projection, size will depend on position within the viewport, but we're approximating
// by computing size for the center
var foregroundSizePixels = ObjectPlacementUtilities.ComputeProjectedArea(
transformer, m_ForegroundCenter, foregroundRotation, foregroundBounds, foregroundScale);
var placementRegion = ObjectPlacementUtilities.ComputePlacementRegion(camera, k_PlacementDistance);
var areaPlacementRegion = placementRegion.width * placementRegion.height;
var cameraSquarePixels = camera.pixelHeight * camera.pixelWidth;
var foregroundSizeUnits = foregroundSizePixels * areaPlacementRegion / cameraSquarePixels;
// Lazy approximation of how many subdivisions we need to achieve the target density
var numCellsSqrt = math.sqrt(m_objectDensity * areaPlacementRegion / foregroundSizeUnits);
var numCellsHorizontal = (int)math.round(numCellsSqrt * m_aspectRatio);
var numCellsVertical = (int)math.round(numCellsSqrt / m_aspectRatio);
var verticalStep = placementRegion.height / numCellsVertical;
var horizontalStep = placementRegion.width / numCellsHorizontal;
var scale0 = m_Rand.NextFloat(0.9f, 1.5f);
var scale1 = m_Rand.NextFloat(0.9f, 1.5f);
var scaleMin = math.min(scale0, scale1);
var scaleMax = math.max(scale0, scale1);
var cameraTf = camera.transform;
var placementOrigin = new Vector3(placementRegion.x, placementRegion.y,
k_PlacementDistance + cameraTf.position.z);
SimulationManager.ReportMetric(m_ScaleRangeMetric, $@"[ {{ ""scaleMin"": {scaleMin}, ""scaleMax"": {scaleMax} }}]");
var meshesToDraw = new NativeArray <MeshDrawInfo>(numCellsHorizontal * numCellsVertical * numFillPasses, Allocator.TempJob);
using (s_PlaceBackgroundObjects.Auto())
{
// XXX: Rather than placing a large collection and then looking for gaps, we simply assume that a sufficiently
// dense background will not have gaps - rendering way more objects than necessary is still substantially
// faster than trying to read the render texture multiple times per frame
new PlaceBackgroundObjectsJob()
{
PlacementOrigin = placementOrigin,
Transformer = new WorldToScreenTransformer(camera),
NumCellsHorizontal = numCellsHorizontal,
NumCellsVertical = numCellsVertical,
HorizontalStep = horizontalStep,
VerticalStep = verticalStep,
ForegroundSize = foregroundSizePixels,
MeshInfos = meshInfos,
MeshDrawInfos = meshesToDraw,
TextureCount = statics.BackgroundImages.Length,
Seed = m_Rand.NextUInt(),
MinScale = scaleMin,
MaxScale = scaleMax
}.Schedule(numFillPasses, 1, inputDeps).Complete();
}
using (s_DrawMeshes.Auto())
{
var properties = new MaterialPropertyBlock();
foreach (var meshDrawInfo in meshesToDraw)
{
var prefab = statics.BackgroundPrefabs[meshDrawInfo.MeshIndex];
var sceneObject = objectCache.GetOrInstantiate(prefab);
ObjectPlacementUtilities.CreateRandomizedHue(properties, backgroundHueMaxOffset, ref m_Rand);
// ReSharper disable once Unity.PreferAddressByIdToGraphicsParams
properties.SetTexture("_BaseMap", statics.BackgroundImages[meshDrawInfo.TextureIndex]);
sceneObject.GetComponentInChildren <MeshRenderer>().SetPropertyBlock(properties);
sceneObject.transform.SetPositionAndRotation(meshDrawInfo.Position, meshDrawInfo.Rotation);
sceneObject.transform.localScale = meshDrawInfo.Scale;
}
}
// We have finished drawing the meshes in the camera view, but the engine itself will call Render()
// at the end of the frame
meshInfos.Dispose();
meshesToDraw.Dispose();
var numObjectsExpected = numCellsHorizontal * numCellsVertical * numFillPasses;
if (numObjectsExpected != objectCache.NumObjectsActive)
{
Debug.LogWarning($"BackgroundGenerator should have placed {numObjectsExpected} but is only using " +
$"{objectCache.NumObjectsActive} from the cache.");
}
return(inputDeps);
}
void Update()
{
if (!PluginEntry.IsAvailable)
{
return;
}
_dataTime = 1.0f / _FPS;
// Plugin lazy initialization
if (_plugin == System.IntPtr.Zero)
{
_plugin = PluginEntry.CreateReceiver(_sourceName);
if (_plugin == System.IntPtr.Zero)
{
return; // No receiver support
}
}
// Texture update event invocation with lazy initialization
if (_callback == System.IntPtr.Zero)
{
_callback = PluginEntry.GetTextureUpdateCallback();
}
if (_sourceTexture == null)
{
_sourceTexture = new Texture2D(8, 8); // Placeholder
_sourceTexture.hideFlags = HideFlags.DontSave;
}
Util.IssueTextureUpdateEvent
(_callback, _sourceTexture, PluginEntry.GetReceiverID(_plugin));
// Texture information retrieval
var width = PluginEntry.GetFrameWidth(_plugin);
var height = PluginEntry.GetFrameHeight(_plugin);
if (width == 0 || height == 0)
{
return; // Not yet ready
}
// Source data dimensions
var alpha = PluginEntry.GetFrameFourCC(_plugin) == FourCC.UYVA;
var sw = width / 2;
var sh = height * (alpha ? 3 : 2) / 2;
// Renew the textures when the dimensions are changed.
if (_sourceTexture.width != sw || _sourceTexture.height != sh)
{
Util.Destroy(_sourceTexture);
Util.Destroy(_receivedTexture);
_sourceTexture = new Texture2D(sw, sh, TextureFormat.RGBA32, false, true);
_sourceTexture.hideFlags = HideFlags.DontSave;
_sourceTexture.filterMode = FilterMode.Point;
}
// Receiver texture lazy initialization
if (_targetTextureOne == null && _receivedTexture == null)
{
_receivedTexture = new RenderTexture(width, height, 0);
_receivedTexture.hideFlags = HideFlags.DontSave;
}
if (_backTexture == null)
{
_backTexture = new RenderTexture(width, height, 0);
_backTexture.hideFlags = HideFlags.DontSave;
}
if (_frontTexture == null)
{
_frontTexture = new RenderTexture(width, height, 0);
_frontTexture.hideFlags = HideFlags.DontSave;
}
if (_blendMaterial == null)
{
_blendMaterial = new Material(Shader.Find("Hidden/Marrow/BlendReceiver"));
_blendMaterial.hideFlags = HideFlags.DontSave;
_blendMaterial.SetTexture("_BackTex", _backTexture);
}
_timer += Time.deltaTime;
if (_timer > _dataTime)
{
_showBack = !_showBack;
_timer = 0.0f;
if (_showBack)
{
Graphics.Blit(_sourceTexture, _frontTexture, _blendMaterial, 0);
}
else
{
Graphics.Blit(_sourceTexture, _backTexture, _blendMaterial, 0);
}
}
if (!_showBack)
{
_blendFactor = _timer / _dataTime;
}
else
{
_blendFactor = 1 - (_timer / _dataTime);
}
_blendMaterial.SetFloat("_BlendFactor", _blendFactor);
Graphics.Blit(_frontTexture, _targetTextureOne, _blendMaterial, 1);
Graphics.Blit(_frontTexture, _targetTextureTwo, _blendMaterial, 2);
// Texture format conversion using the blit shader
_targetTextureOne.IncrementUpdateCount();
// Renderer override
if (_targetRenderer != null)
{
// Material property block lazy initialization
if (_propertyBlock == null)
{
_propertyBlock = new MaterialPropertyBlock();
}
// Read-modify-write
_targetRenderer.GetPropertyBlock(_propertyBlock);
_propertyBlock.SetTexture(_targetMaterialProperty, _targetTextureOne);
_propertyBlock.SetTexture(_targetMaterialProperty, _targetTextureTwo);
_targetRenderer.SetPropertyBlock(_propertyBlock);
}
}
void LateUpdate()
{
last_start = stopwatch.Elapsed.TotalSeconds;
if (drawDebugWindow)
{
DrawDebugWindow();
}
ImGui.EndFrame();
if (queue_font_rebuild)
{
RebuildFonts();
queue_font_rebuild = false;
}
// custom cursors
if (enableCustomCursors)
{
ImGuiMouseCursor cursor = ImGui.GetMouseCursor();
Texture2D cursorTex = null;
Vector2 hotspot = cursorHotspot;
switch (cursor)
{
case ImGuiMouseCursor.Arrow:
cursorTex = customCursorArrow;
break;
case ImGuiMouseCursor.TextInput:
cursorTex = customCursorTextInput;
break;
case ImGuiMouseCursor.ResizeEW:
cursorTex = customCursorResizeEW;
break;
case ImGuiMouseCursor.ResizeNESW:
cursorTex = customCursorResizeNESW;
hotspot.x += 5; hotspot.y += 5;
break;
case ImGuiMouseCursor.ResizeNS:
cursorTex = customCursorResizeNS;
break;
case ImGuiMouseCursor.ResizeNWSE:
cursorTex = customCursorResizeNWSE;
hotspot.x += 5; hotspot.y += 5;
break;
default:
break;
}
// Don't set cursor if it has not actually changed
if (currentCursorTex != cursorTex)
{
if (cursorTex != null)
{
Cursor.SetCursor(cursorTex, hotspot, CursorMode.Auto);
}
else
{
Cursor.SetCursor(null, cursorHotspot, CursorMode.Auto);
}
currentCursorTex = cursorTex;
}
}
ImGui.Render();
// render ImGui
ImDrawDataPtr data = ImGui.GetDrawData();
if (commandBuffer != null)
{
// Clear buffer regardless of whether we have something to render or not
commandBuffer.Clear();
}
// Don't update meshes and Command Buffers if there is nothing to render
if (data.CmdListsCount > 0)
{
// resize meshes array
int numDrawCommands = 0;
for (int i = 0; i < data.CmdListsCount; i++)
{
ImDrawListPtr cmdList = data.getDrawListPtr(i);
var cmdBuffer = cmdList.CmdBuffer;
numDrawCommands += cmdBuffer.Size;
}
if (meshes == null)
{
meshes = new List <ImGuiMesh>();
}
if (meshes.Count != numDrawCommands)
{
// add new meshes to list if needed
for (int i = meshes.Count; i < numDrawCommands; i++)
{
ImGuiMesh mesh = new ImGuiMesh();
meshes.Add(mesh);
}
// delete extra meshes if needed
for (int i = meshes.Count - 1; i >= numDrawCommands; i--)
{
Destroy(meshes[i].mesh);
meshes.RemoveAt(i);
}
}
if (commandBuffer == null)
{
commandBuffer = new CommandBuffer();
commandBuffer.name = "ImGui Renderer";
commandBuffer.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
guiCamera.AddCommandBuffer(CameraEvent.AfterEverything, commandBuffer);
}
commandBuffer.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
// orthogonal projection of GUI mesh to camera space
Matrix4x4 matrix = Matrix4x4.Ortho(0, Screen.width, 0, Screen.height, 0, 0.1f);
// negate world to camera transform and projection which Unity applies itself
matrix = guiCamera.cameraToWorldMatrix * guiCamera.projectionMatrix.inverse * matrix;
// update Command Buffers
int count = 0;
for (int i = 0; i < data.CmdListsCount; i++)
{
ImDrawListPtr cmdList = data.getDrawListPtr(i);
var cmdBuffer = cmdList.CmdBuffer;
uint startElement = 0;
for (int j = 0; j < cmdBuffer.Size; j++)
{
ImDrawCmd cmd = cmdBuffer[j];
Rect rect = new Rect
{
min = new Vector2(cmd.ClipRect.x, Screen.height - cmd.ClipRect.y),
max = new Vector2(cmd.ClipRect.z, Screen.height - cmd.ClipRect.w)
};
commandBuffer.EnableScissorRect(rect);
meshes[count].UpdateMesh(cmd, cmdList.IdxBuffer, cmdList.VtxBuffer, (int)startElement);
if (cmd.TextureId == fontTexturePtr)
{
mpb.SetTexture(main_tex_id, fontTexture);
commandBuffer.DrawMesh(meshes[count].mesh, matrix, material, 0, 0, mpb);
}
else if (textures.ContainsKey(cmd.TextureId))
{
mpb.SetTexture(main_tex_id, textures[cmd.TextureId]);
commandBuffer.DrawMesh(meshes[count].mesh, matrix, material, 0, 0, mpb);
}
else
{
Debug.LogWarning("Image texture missing!");
}
startElement += cmd.ElemCount;
count++;
}
}
}
else if (commandBuffer != null)
{
// Remove Command Buffer if there is nothing to render
guiCamera.RemoveCommandBuffer(CameraEvent.AfterEverything, commandBuffer);
commandBuffer = null;
}
textures.Clear();
last_end = stopwatch.Elapsed.TotalSeconds;
}
// 描画キックを行う
public void UpdateMesh()
{
// ■だけは常に入れておく。他は文字描画要求の都度投げる
font.RequestCharactersInTexture(whiteString);
// 描画キック
mesh.Clear();
if (subMeshCount > 0)
{
subMeshes[subMeshCount - 1].FixIndexCount(indexCount);
// 使用量が半分以下の場合、テンポラリにコピーしてから渡す
if (vertexCount < (capacity / 2)) // 閾値は研究が必要だが、とりあえず。
{
UnityEngine.Profiling.Profiler.BeginSample("DebugPrimitiveRenderer.UpdateMesh.FillTemporary");
temporaryVertices.Clear();
temporaryUv.Clear();
temporaryColors.Clear();
var tmpV = new System.ArraySegment <Vector3>(vertices, 0, vertexCount);
var tmpUv = new System.ArraySegment <Vector2>(uv, 0, vertexCount);
var tmpC = new System.ArraySegment <Color32>(colors, 0, vertexCount);
temporaryVertices.AddRange(tmpV);
temporaryUv.AddRange(tmpUv);
temporaryColors.AddRange(tmpC);
mesh.SetVertices(temporaryVertices);
mesh.SetUVs(0, temporaryUv);
mesh.SetColors(temporaryColors);
UnityEngine.Profiling.Profiler.EndSample();
}
else // 半分以上使っている場合、そのまま渡す。
{
UnityEngine.Profiling.Profiler.BeginSample("DebugPrimitiveRenderer.UpdateMesh.CopyAll");
mesh.vertices = vertices;
mesh.uv = uv;
mesh.colors32 = colors;
UnityEngine.Profiling.Profiler.EndSample();
}
mesh.subMeshCount = subMeshCount;
Material[] materials = new Material[subMeshCount];
for (int i = 0; i < subMeshCount; i++)
{
materials[i] = subMeshes[i].material;
}
meshRenderer.sharedMaterials = materials;
for (int i = 0; i < subMeshCount; i++)
{
UnityEngine.Profiling.Profiler.BeginSample("DebugPrimitiveRenderer.UpdateMesh.FillIndices");
var subMesh = subMeshes[i];
temporaryIndices.Clear();
var tmpI = new System.ArraySegment <int>(indices, subMesh.indexStart, subMesh.indexCount);
temporaryIndices.AddRange(tmpI);
mesh.SetTriangles(temporaryIndices, i, true);
materialPropertyBlock.SetTexture(
textureShaderPropertyId,
subMesh.texture);
meshRenderer.SetPropertyBlock(materialPropertyBlock, i);
UnityEngine.Profiling.Profiler.EndSample();
}
}
meshFilter.sharedMesh = mesh;
vertexCount = 0;
indexCount = 0;
texture = null;
// 毎フレーム白にリセット
Color = new Color32(255, 255, 255, 255);
subMeshCount = 0;
// どうもおかしいので毎フレーム取ってみる。
CharacterInfo ch;
font.GetCharacterInfo(whiteChar, out ch);
whiteUv = ch.uvTopLeft;
whiteUv += ch.uvTopRight;
whiteUv += ch.uvBottomLeft;
whiteUv += ch.uvBottomRight;
whiteUv *= 0.25f;
}
void GenerateGaussianMips(CommandBuffer cmd, HDCamera hdCam)
{
RTHandle source;
Vector2Int size = new Vector2Int(hdCam.actualWidth, hdCam.actualHeight);
if (targetColorBuffer == TargetBuffer.Camera)
{
GetCameraBuffers(out source, out _);
}
else
{
GetCustomBuffers(out source, out _);
}
int dstMipWidth = Mathf.Max(1, size.x >> 1);
int dstMipHeight = Mathf.Max(1, size.y >> 1);
// Scale for downsample
float scaleX = ((float)size.x / source.rt.width);
float scaleY = ((float)size.y / source.rt.height);
if (useMask)
{
// Save the non blurred color into a copy:
cmd.CopyTexture(source, colorCopy);
}
// Downsample.
using (new ProfilingSample(cmd, "Downsample", CustomSampler.Create("Downsample")))
{
var downsampleProperties = new MaterialPropertyBlock();
downsampleProperties.SetTexture(ShaderID._BlitTexture, source);
downsampleProperties.SetVector(ShaderID._BlitScaleBias, new Vector4(scaleX, scaleY, 0f, 0f));
downsampleProperties.SetFloat(ShaderID._BlitMipLevel, 0);
CoreUtils.SetRenderTarget(cmd, downSampleBuffer, ClearFlag.None);
cmd.SetViewport(new Rect(0, 0, dstMipWidth, dstMipHeight));
cmd.DrawProcedural(Matrix4x4.identity, HDUtils.GetBlitMaterial(source.rt.dimension), 1, MeshTopology.Triangles, 3, 1, downsampleProperties);
}
// Horizontal Blur
using (new ProfilingSample(cmd, "H Blur", CustomSampler.Create("H Blur")))
{
var hBlurProperties = new MaterialPropertyBlock();
CoreUtils.SetRenderTarget(cmd, blurBuffer, ClearFlag.None);
hBlurProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
hBlurProperties.SetTexture(ShaderID._Source, downSampleBuffer); // The blur is 4 pixel wide in the shader
hBlurProperties.SetFloat(ShaderID._UVScale, 2);
cmd.SetViewport(new Rect(0, 0, dstMipWidth, dstMipHeight));
CoreUtils.DrawFullScreen(cmd, blurMaterial, shaderPassId: 0, properties: hBlurProperties); // Do not forget the shaderPassId: ! or it won't work
}
// Copy back the result in the color buffer while doing a vertical blur
using (new ProfilingSample(cmd, "V Blur + Copy back", CustomSampler.Create("V Blur + Copy back")))
{
var vBlurProperties = new MaterialPropertyBlock();
// When we use a mask, we do the vertical blur into the downsampling buffer instead of the camera buffer
// We need that because we're going to write to the color buffer and read from this blured buffer which we can't do
// if they are in the same buffer
CoreUtils.SetRenderTarget(cmd, (useMask) ? downSampleBuffer : source, ClearFlag.None);
vBlurProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
vBlurProperties.SetTexture(ShaderID._Source, blurBuffer);
vBlurProperties.SetFloat(ShaderID._UVScale, (useMask) ? 2 : 1);
CoreUtils.DrawFullScreen(cmd, blurMaterial, shaderPassId: 1, properties: vBlurProperties);
}
if (useMask)
{
using (new ProfilingSample(cmd, "Compose Mask Blur", CustomSampler.Create("Compose Mask Blur")))
{
var compositingProperties = new MaterialPropertyBlock();
CoreUtils.SetRenderTarget(cmd, source, ClearFlag.None);
compositingProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
compositingProperties.SetTexture(ShaderID._Source, downSampleBuffer);
compositingProperties.SetTexture(ShaderID._ColorBufferCopy, colorCopy);
compositingProperties.SetTexture(ShaderID._Mask, maskBuffer);
compositingProperties.SetTexture(ShaderID._MaskDepth, maskDepthBuffer);
compositingProperties.SetFloat(ShaderID._InvertMask, invertMask ? 1 : 0);
CoreUtils.DrawFullScreen(cmd, blurMaterial, shaderPassId: 2, properties: compositingProperties);
}
}
}
public void GenerateChannelsMaterialProps(MaterialPropertyBlock props)
{
props.SetTexture("_ChannelsTex", texture);
props.SetVector("_ChannelsTex_UV", uv);
}
void DisplayProbeVolumeAtlas(CommandBuffer cmd, Material debugMaterial, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue, int sliceMode)
{
if (ShaderConfig.s_ProbeVolumesEvaluationMode == ProbeVolumesEvaluationModes.Disabled)
{
return;
}
if (!m_SupportProbeVolume)
{
return;
}
Vector4 validRange = new Vector4(minValue, 1.0f / (maxValue - minValue));
Vector3 textureViewScale = new Vector3(1.0f, 1.0f, 1.0f);
Vector3 textureViewBias = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 textureViewResolution = new Vector3(s_ProbeVolumeAtlasWidth, s_ProbeVolumeAtlasHeight, s_ProbeVolumeAtlasDepth);
Vector4 atlasTextureOctahedralDepthScaleBias = new Vector4(1.0f, 1.0f, 0.0f, 0.0f);
#if UNITY_EDITOR
if (UnityEditor.Selection.activeGameObject != null)
{
var selectedProbeVolume = UnityEditor.Selection.activeGameObject.GetComponent <ProbeVolume>();
if (selectedProbeVolume != null)
{
// User currently has a probe volume selected.
// Compute a scaleBias term so that atlas view automatically zooms into selected probe volume.
int selectedProbeVolumeKey = selectedProbeVolume.GetID();
if (probeVolumeAtlas.TryGetScaleBias(out Vector3 selectedProbeVolumeScale, out Vector3 selectedProbeVolumeBias, selectedProbeVolumeKey))
{
textureViewScale = selectedProbeVolumeScale;
textureViewBias = selectedProbeVolumeBias;
textureViewResolution = new Vector3(
selectedProbeVolume.parameters.resolutionX,
selectedProbeVolume.parameters.resolutionY,
selectedProbeVolume.parameters.resolutionZ
);
}
if (probeVolumeAtlasOctahedralDepth.TryGetScaleBias(out Vector4 selectedProbeVolumeOctahedralDepthScaleBias, selectedProbeVolumeKey))
{
atlasTextureOctahedralDepthScaleBias = selectedProbeVolumeOctahedralDepthScaleBias;
}
}
}
#endif
// Note: The system is not aware of slice packing in Z.
// Need to modify scale and bias terms just before uploading to GPU.
// TODO: Should we make it aware earlier up the chain?
textureViewScale.z = textureViewScale.z / (float)m_ProbeVolumeAtlasSHRTDepthSliceCount;
textureViewBias.z = textureViewBias.z / (float)m_ProbeVolumeAtlasSHRTDepthSliceCount;
MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
propertyBlock.SetTexture(HDShaderIDs._AtlasTextureSH, m_ProbeVolumeAtlasSHRTHandle.rt);
propertyBlock.SetVector(HDShaderIDs._TextureViewScale, textureViewScale);
propertyBlock.SetVector(HDShaderIDs._TextureViewBias, textureViewBias);
propertyBlock.SetVector(HDShaderIDs._TextureViewResolution, textureViewResolution);
cmd.SetGlobalVector(HDShaderIDs._ProbeVolumeAtlasResolutionAndSliceCount, new Vector4(
s_ProbeVolumeAtlasWidth,
s_ProbeVolumeAtlasHeight,
s_ProbeVolumeAtlasDepth,
m_ProbeVolumeAtlasSHRTDepthSliceCount
));
cmd.SetGlobalVector(HDShaderIDs._ProbeVolumeAtlasResolutionAndSliceCountInverse, new Vector4(
1.0f / (float)s_ProbeVolumeAtlasWidth,
1.0f / (float)s_ProbeVolumeAtlasHeight,
1.0f / (float)s_ProbeVolumeAtlasDepth,
1.0f / (float)m_ProbeVolumeAtlasSHRTDepthSliceCount
));
propertyBlock.SetTexture(HDShaderIDs._AtlasTextureOctahedralDepth, m_ProbeVolumeAtlasOctahedralDepthRTHandle.rt);
propertyBlock.SetVector(HDShaderIDs._AtlasTextureOctahedralDepthScaleBias, atlasTextureOctahedralDepthScaleBias);
propertyBlock.SetVector(HDShaderIDs._ValidRange, validRange);
propertyBlock.SetInt(HDShaderIDs._ProbeVolumeAtlasSliceMode, sliceMode);
cmd.SetViewport(new Rect(screenX, screenY, screenSizeX, screenSizeY));
cmd.DrawProcedural(Matrix4x4.identity, debugMaterial, debugMaterial.FindPass("ProbeVolume"), MeshTopology.Triangles, 3, 1, propertyBlock);
}
public void SetUniforms(MaterialPropertyBlock block, Material mat, bool full = true, bool forQuad = false)
{
if (artb == null)
{
Debug.Log("Atmosphere: ARTB is null!"); return;
}
if (mat != null)
{
Helper.SetKeywords(mat, Keywords, false);
}
if (full)
{
if (block == null)
{
return;
}
SetEclipses(block);
SetShine(block);
if (!forQuad)
{
if (planetoid != null)
{
if (planetoid.Ring != null)
{
planetoid.Ring.SetShadows(block, planetoid.Shadows);
}
}
}
block.SetFloat("fade", Fade);
block.SetFloat("density", Density);
block.SetFloat("scale", atmosphereParameters.SCALE);
block.SetFloat("Rg", atmosphereParameters.Rg);
block.SetFloat("Rt", atmosphereParameters.Rt);
block.SetFloat("RL", atmosphereParameters.Rl);
block.SetVector("betaR", atmosphereParameters.BETA_R / 1000);
block.SetVector("betaMSca", atmosphereParameters.BETA_MSca / 1000);
block.SetVector("betaMEx", atmosphereParameters.BETA_MEx / 1000);
block.SetFloat("mieG", Mathf.Clamp(atmosphereParameters.MIE_G, 0.0f, 0.99f));
block.SetFloat("_Aerial_Perspective_Offset", AerialPerspectiveOffset);
block.SetFloat("_ExtinctionGroundFade", ExtinctionGroundFade);
block.SetFloat("_Sun_Glare_Scale", 0.1f);
if (artb.transmittanceT != null)
{
block.SetTexture("_Sky_Transmittance", artb.transmittanceT);
}
if (artb.inscatterT_Read != null)
{
block.SetTexture("_Sky_Inscatter", artb.inscatterT_Read);
}
if (artb.irradianceT_Read != null)
{
block.SetTexture("_Sky_Irradiance", artb.irradianceT_Read);
}
var WCP = forQuad == true ? worldCameraPos - Origin : worldCameraPos;
block.SetMatrix("_Globals_WorldToCamera", worldToCamera);
block.SetMatrix("_Globals_CameraToWorld", cameraToWorld);
block.SetMatrix("_Globals_CameraToScreen", cameraToScreen);
block.SetMatrix("_Globals_ScreenToCamera", screenToCamera);
block.SetVector("_Globals_WorldCameraPos", forQuad == true ? worldCameraPos - Origin : worldCameraPos);
block.SetVector("_Globals_Origin", -Origin);
block.SetVector("WCPG", WCP + (-Origin));
block.SetFloat("_Exposure", HDRExposure);
block.SetFloat("_HDRMode", (int)HDRMode);
SetSunUniforms(block);
}
}
// 'renderSunDisk' parameter is not supported.
// Users should instead create an emissive (or lit) mesh for every relevant light source
// (to support multiple stars in space, moons with moon phases, etc).
public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap, bool renderSunDisk)
{
var pbrSky = builtinParams.skySettings as PhysicallyBasedSky;
// TODO: the following expression is somewhat inefficient, but good enough for now.
Vector3 cameraPos = builtinParams.worldSpaceCameraPos;
Vector3 planetCenter = pbrSky.GetPlanetCenterPosition(cameraPos);
float R = pbrSky.GetPlanetaryRadius();
Vector3 cameraToPlanetCenter = planetCenter - cameraPos;
float r = cameraToPlanetCenter.magnitude;
cameraPos = planetCenter - Mathf.Max(R, r) * cameraToPlanetCenter.normalized;
bool simpleEarthMode = pbrSky.type.value == PhysicallyBasedSkyModel.EarthSimple;
CommandBuffer cmd = builtinParams.commandBuffer;
// Precomputation is done, shading is next.
Quaternion planetRotation = Quaternion.Euler(pbrSky.planetRotation.value.x,
pbrSky.planetRotation.value.y,
pbrSky.planetRotation.value.z);
Quaternion spaceRotation = Quaternion.Euler(pbrSky.spaceRotation.value.x,
pbrSky.spaceRotation.value.y,
pbrSky.spaceRotation.value.z);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);
s_PbrSkyMaterialProperties.SetVector(HDShaderIDs._WorldSpaceCameraPos1, cameraPos);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._ViewMatrix1, builtinParams.viewMatrix);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PlanetRotation, Matrix4x4.Rotate(planetRotation));
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._SpaceRotation, Matrix4x4.Rotate(spaceRotation));
m_PrecomputedData.BindBuffers(cmd, s_PbrSkyMaterialProperties);
int hasGroundAlbedoTexture = 0;
if (pbrSky.groundColorTexture.value != null && !simpleEarthMode)
{
hasGroundAlbedoTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundAlbedoTexture, pbrSky.groundColorTexture.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundAlbedoTexture, hasGroundAlbedoTexture);
int hasGroundEmissionTexture = 0;
if (pbrSky.groundEmissionTexture.value != null && !simpleEarthMode)
{
hasGroundEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundEmissionTexture, pbrSky.groundEmissionTexture.value);
s_PbrSkyMaterialProperties.SetFloat(HDShaderIDs._GroundEmissionMultiplier, pbrSky.groundEmissionMultiplier.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundEmissionTexture, hasGroundEmissionTexture);
int hasSpaceEmissionTexture = 0;
if (pbrSky.spaceEmissionTexture.value != null && !simpleEarthMode)
{
hasSpaceEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._SpaceEmissionTexture, pbrSky.spaceEmissionTexture.value);
s_PbrSkyMaterialProperties.SetFloat(HDShaderIDs._SpaceEmissionMultiplier, pbrSky.spaceEmissionMultiplier.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasSpaceEmissionTexture, hasSpaceEmissionTexture);
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._RenderSunDisk, renderSunDisk ? 1 : 0);
int pass = (renderForCubemap ? 0 : 2);
CoreUtils.DrawFullScreen(builtinParams.commandBuffer, m_PbrSkyMaterial, s_PbrSkyMaterialProperties, pass);
}
void GenerateGaussianMips(CommandBuffer cmd, HDCamera hdCam)
{
RTHandle source;
// Retrieve the target buffer of the blur from the UI:
if (targetColorBuffer == TargetBuffer.Camera)
{
GetCameraBuffers(out source, out _);
}
else
{
GetCustomBuffers(out source, out _);
}
// Save the non blurred color into a copy if the mask is enabled:
if (useMask)
{
cmd.CopyTexture(source, colorCopy);
}
// Downsample
using (new ProfilingSample(cmd, "Downsample", CustomSampler.Create("Downsample")))
{
// This Blit will automatically downsample the color because our target buffer have been allocated in half resolution
HDUtils.BlitCameraTexture(cmd, source, downSampleBuffer, 0);
}
// Horizontal Blur
using (new ProfilingSample(cmd, "H Blur", CustomSampler.Create("H Blur")))
{
var hBlurProperties = new MaterialPropertyBlock();
hBlurProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
hBlurProperties.SetTexture(ShaderID._Source, downSampleBuffer); // The blur is 4 pixel wide in the shader
SetViewPortSize(cmd, hBlurProperties, blurBuffer);
HDUtils.DrawFullScreen(cmd, blurMaterial, blurBuffer, hBlurProperties, shaderPassId: 0); // Do not forget the shaderPassId: ! or it won't work
}
// Copy back the result in the color buffer while doing a vertical blur
using (new ProfilingSample(cmd, "V Blur + Copy back", CustomSampler.Create("V Blur + Copy back")))
{
var vBlurProperties = new MaterialPropertyBlock();
// When we use a mask, we do the vertical blur into the downsampling buffer instead of the camera buffer
// We need that because we're going to write to the color buffer and read from this blured buffer which we can't do
// if they are in the same buffer
vBlurProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
vBlurProperties.SetTexture(ShaderID._Source, blurBuffer);
var targetBuffer = (useMask) ? downSampleBuffer : source;
SetViewPortSize(cmd, vBlurProperties, targetBuffer);
HDUtils.DrawFullScreen(cmd, blurMaterial, targetBuffer, vBlurProperties, shaderPassId: 1); // Do not forget the shaderPassId: ! or it won't work
}
if (useMask)
{
// Merge the non blur copy and the blurred version using the mask buffers
using (new ProfilingSample(cmd, "Compose Mask Blur", CustomSampler.Create("Compose Mask Blur")))
{
var compositingProperties = new MaterialPropertyBlock();
compositingProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
compositingProperties.SetTexture(ShaderID._Source, downSampleBuffer);
compositingProperties.SetTexture(ShaderID._ColorBufferCopy, colorCopy);
compositingProperties.SetTexture(ShaderID._Mask, maskBuffer);
compositingProperties.SetTexture(ShaderID._MaskDepth, maskDepthBuffer);
compositingProperties.SetFloat(ShaderID._InvertMask, invertMask ? 1 : 0);
SetViewPortSize(cmd, compositingProperties, source);
HDUtils.DrawFullScreen(cmd, blurMaterial, source, compositingProperties, shaderPassId: 2); // Do not forget the shaderPassId: ! or it won't work
}
}
}
void Update()
{
// Release the plugin instance when the previously established
// connection is now invalid.
if (_plugin != System.IntPtr.Zero && !PluginEntry.CheckValid(_plugin))
{
Util.IssuePluginEvent(PluginEntry.Event.Dispose, _plugin);
_plugin = System.IntPtr.Zero;
}
// Plugin lazy initialization
if (_plugin == System.IntPtr.Zero)
{
_plugin = PluginEntry.CreateReceiver(_sourceName);
if (_plugin == System.IntPtr.Zero)
{
return; // Spout may not be ready.
}
}
Util.IssuePluginEvent(PluginEntry.Event.Update, _plugin);
// Texture information retrieval
var ptr = PluginEntry.GetTexturePointer(_plugin);
var width = PluginEntry.GetTextureWidth(_plugin);
var height = PluginEntry.GetTextureHeight(_plugin);
// Resource validity check
if (_sharedTexture != null)
{
if (ptr != _sharedTexture.GetNativeTexturePtr() ||
width != _sharedTexture.width ||
height != _sharedTexture.height)
{
// Not match: Destroy to get refreshed.
Util.Destroy(_sharedTexture);
}
}
// Shared texture lazy (re)initialization
if (_sharedTexture == null && ptr != System.IntPtr.Zero)
{
_sharedTexture = Texture2D.CreateExternalTexture(
width, height, TextureFormat.ARGB32, false, false, ptr
);
_sharedTexture.hideFlags = HideFlags.DontSave;
// Destroy the previously allocated receiver texture to
// refresh specifications.
Util.Destroy(_receivedTexture);
}
// Texture format conversion with the blit shader
if (_sharedTexture != null)
{
// Blit shader lazy initialization
if (_blitMaterial == null)
{
_blitMaterial = new Material(Shader.Find("Hidden/Spout/Blit"));
_blitMaterial.hideFlags = HideFlags.DontSave;
}
if (_targetTexture != null)
{
// Blit the shared texture to the target texture.
Graphics.Blit(_sharedTexture, _targetTexture, _blitMaterial, 1);
}
else
{
// Receiver texture lazy initialization
if (_receivedTexture == null)
{
_receivedTexture = new RenderTexture
(_sharedTexture.width, _sharedTexture.height, 0);
_receivedTexture.hideFlags = HideFlags.DontSave;
}
// Blit the shared texture to the receiver texture.
Graphics.Blit(_sharedTexture, _receivedTexture, _blitMaterial, 1);
}
}
// Renderer override
if (_targetRenderer != null && receivedTexture != null)
{
// Material property block lazy initialization
if (_propertyBlock == null)
{
_propertyBlock = new MaterialPropertyBlock();
}
// Read-modify-write
_targetRenderer.GetPropertyBlock(_propertyBlock);
_propertyBlock.SetTexture(_targetMaterialProperty, receivedTexture);
_targetRenderer.SetPropertyBlock(_propertyBlock);
}
}
public static void BindNull(int shapeSlot, MaterialPropertyBlock properties)
{
properties.SetTexture(ParamIdSampler(shapeSlot), Texture2D.blackTexture);
}
}//Use This
public static void BlitSRT(this CommandBuffer buffer, MaterialPropertyBlock block, RenderTexture source, RenderTexture destination, Material mat, int pass)
{
block.SetTexture(ShaderIDs._MainTex, source);
buffer.SetRenderTarget(destination);
buffer.DrawMesh(mesh, Matrix4x4.identity, mat, 0, pass, block);
}//Use This