/// <summary>
/// Compute the max size of a power of two atlas for a given size in byte (weight).
/// </summary>
/// <param name="weight">Atlas size in bytes.</param>
/// <param name="hasMipmap">Atlas uses mip maps.</param>
/// <param name="format">Atlas format.</param>
/// <returns></returns>
public static int GetMaxCacheSizeForWeightInByte(int weight, bool hasMipmap, GraphicsFormat format)
{
float bytePerPixel = (float)GraphicsFormatUtility.GetBlockSize(format) * (hasMipmap ? k_MipmapFactorApprox : 1.0f);
var maxAtlasSquareSize = Mathf.Sqrt((float)weight / bytePerPixel);
return(CoreUtils.PreviousPowerOfTwo((int)maxAtlasSquareSize));
}
public CustomRenderTexture(int width, int height, GraphicsFormat format)
{
Internal_CreateCustomRenderTexture(this, GraphicsFormatUtility.IsSRGBFormat(format) ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear);
this.width = width;
this.height = height;
this.format = GraphicsFormatUtility.GetRenderTextureFormat(format);
}
private void SetupReflectionTexture(Camera camera)
{
if (!camera)
{
return;
}
float scaleRatio = UnityEngine.Rendering.Universal.UniversalRenderPipeline.asset.renderScale * GetScaleValue();
int width = (int)(camera.pixelWidth * scaleRatio);
int height = (int)(camera.pixelHeight * scaleRatio);
if (m_reflectionRT)
{
if ((m_reflectionRT.width == width) && (m_reflectionRT.height == height))
{
return;
}
else
{
RenderTexture.ReleaseTemporary(m_reflectionRT);
m_reflectionRT = null;
}
}
const bool useHdr10 = true;
const RenderTextureFormat hdrFormat = useHdr10 ? RenderTextureFormat.RGB111110Float : RenderTextureFormat.DefaultHDR;
//m_reflectionRT = RenderTexture.GetTemporary(width, height, 16, RenderTextureFormat.ARGB32);
m_reflectionRT = RenderTexture.GetTemporary(width, height, 16, GraphicsFormatUtility.GetGraphicsFormat(hdrFormat, true));
}
internal bool ValidateFormat(TextureFormat format)
{
bool flag = SystemInfo.SupportsTextureFormat(format);
bool result;
if (flag)
{
result = true;
}
else
{
bool flag2 = GraphicsFormatUtility.IsCompressedTextureFormat(format);
if (flag2)
{
Debug.LogWarning(string.Format("'{0}' is not supported on this platform. Decompressing texture. Use 'SystemInfo.SupportsTextureFormat' C# API to check format support.", format.ToString()), this);
result = true;
}
else
{
Debug.LogError(string.Format("Texture creation failed. '{0}' is not supported on this platform. Use 'SystemInfo.SupportsTextureFormat' C# API to check format support.", format.ToString()), this);
result = false;
}
}
return(result);
}
/// <summary>
/// Perform async read back from the provided source texture.
/// </summary>
/// <param name="src">Texture source to be used for the read back.</param>
/// <param name="mipIndex">Index of the mipmap to be fetched.</param>
/// <param name="dstFormat">Target TextureFormat of the data. If the target format is different from the format stored on the GPU, the conversion is automatic.</param>
/// <param name="functor">Functor that will be invoked after the async read back request is complete.</param>
/// <typeparam name="T">Type for the destination data buffer.</typeparam>
/// <returns>Returns an AsynRequest</returns>
public static AsyncRequest <object> Capture <T>(Texture src, int mipIndex, GraphicsFormat dstFormat, Func <AsyncRequest <object>, AsyncRequest <object> .Result> functor = null) where T : struct
{
var req = Manager.Instance.CreateRequest <AsyncRequest <object> >();
if (GraphicsUtilities.SupportsAsyncReadback())
{
AsyncGPUReadback.Request(src, mipIndex, GraphicsFormatUtility.GetTextureFormat(dstFormat), (AsyncGPUReadbackRequest request) =>
{
req.error = request.hasError;
if (!request.hasError)
{
req.data = request.GetData <T>().ToArray();
req.Enqueue(functor);
req.Execute();
}
});
}
else
{
req.data = GraphicsUtilities.GetPixelsSlow(src as RenderTexture);
req.Enqueue(functor);
req.Execute();
}
return(req);
}
public SparseTexture(int width, int height, GraphicsFormat format, int mipCount)
{
if (ValidateFormat(format, FormatUsage.Sample))
{
Internal_Create(this, width, height, GraphicsFormatUtility.GetTextureFormat(format), GraphicsFormatUtility.IsSRGBFormat(format), mipCount);
}
}
public override void OnPreviewSettings()
{
// Do not allow changing of pages when multiple atlases is selected.
if (targets.Length == 1 && m_OptionDisplays != null && m_OptionValues != null && m_TotalPages > 1)
{
m_PreviewPage = EditorGUILayout.IntPopup(m_PreviewPage, m_OptionDisplays, m_OptionValues, styles.preDropDown, GUILayout.MaxWidth(50));
}
else
{
m_PreviewPage = 0;
}
if (m_PreviewTextures != null)
{
m_PreviewPage = Mathf.Min(m_PreviewPage, m_PreviewTextures.Length - 1);
Texture2D t = m_PreviewTextures[m_PreviewPage];
if (GraphicsFormatUtility.HasAlphaChannel(t.format) || (m_PreviewAlphaTextures != null && m_PreviewAlphaTextures.Length > 0))
{
m_ShowAlpha = GUILayout.Toggle(m_ShowAlpha, m_ShowAlpha ? styles.alphaIcon : styles.RGBIcon, styles.previewButton);
}
int mipCount = Mathf.Max(1, TextureUtil.GetMipmapCount(t));
if (mipCount > 1)
{
GUILayout.Box(styles.smallZoom, styles.previewLabel);
m_MipLevel = Mathf.Round(GUILayout.HorizontalSlider(m_MipLevel, mipCount - 1, 0, styles.previewSlider, styles.previewSliderThumb, GUILayout.MaxWidth(64)));
GUILayout.Box(styles.largeZoom, styles.previewLabel);
}
}
}
override public string GetInfoString()
{
RenderTexture t = target as RenderTexture;
string info = t.width + "x" + t.height;
if (t.dimension == UnityEngine.Rendering.TextureDimension.Tex3D)
{
info += "x" + t.volumeDepth;
}
if (!t.isPowerOfTwo)
{
info += "(NPOT)";
}
if (QualitySettings.desiredColorSpace == ColorSpace.Linear)
{
bool formatIsHDR = GraphicsFormatUtility.IsIEEE754Format(t.graphicsFormat);
bool sRGB = t.sRGB && !formatIsHDR;
info += " " + (sRGB ? "sRGB" : "Linear");
}
info += " " + t.graphicsFormat;
info += " " + EditorUtility.FormatBytes(TextureUtil.GetRuntimeMemorySizeLong(t));
return(info);
}
internal void SaveCurrentViewToImage()
{
// Temp texture for the readback (before compression)
Texture2D tmp = new Texture2D(savedTexture.width, savedTexture.height, GraphicsFormat.R32G32B32A32_SFloat, TextureCreationFlags.None);
// Radback color & depth:
RenderTexture.active = tmpRenderTexture;
tmp.filterMode = settings.GetResolvedFilterMode(graph);
tmp.wrapMode = settings.GetResolvedWrapMode(graph);
tmp.ReadPixels(new Rect(0, 0, savedTexture.width, savedTexture.height), 0, 0);
RenderTexture.active = null;
tmp.Apply();
#if UNITY_EDITOR
if (GraphicsFormatUtility.IsCompressedFormat(savedTexture.graphicsFormat))
{
EditorUtility.CompressTexture(tmp, compressionFormat, TextureCompressionQuality.Best);
EditorUtility.CopySerialized(tmp, savedTexture);
Object.DestroyImmediate(tmp);
}
else
{
savedTexture.SetPixels(tmp.GetPixels());
savedTexture.Apply();
}
#endif
graph.NotifyNodeChanged(this);
if (!graph.IsObjectInGraph(savedTexture))
{
graph.AddObjectToGraph(savedTexture);
}
}
/// <summary>
/// Validates the lookup texture assigned to the volume component.
/// </summary>
/// <returns>True if the texture is valid, false otherwise.</returns>
public bool ValidateLUT()
{
var asset = UniversalRenderPipeline.asset;
if (asset == null || texture.value == null)
{
return(false);
}
int lutSize = asset.colorGradingLutSize;
if (texture.value.height != lutSize)
{
return(false);
}
bool valid = false;
switch (texture.value)
{
case Texture2D t:
valid |= t.width == lutSize * lutSize &&
!GraphicsFormatUtility.IsSRGBFormat(t.graphicsFormat);
break;
case RenderTexture rt:
valid |= rt.dimension == TextureDimension.Tex2D &&
rt.width == lutSize * lutSize &&
!rt.sRGB;
break;
}
return(valid);
}
public void CopyPixelDataToLayer <T>(NativeArray <T> colorData, int layerIdx, GraphicsFormat format) where T : struct
{
var layer = GetLayer(layerIdx);
NativeArray <T> dstDataAsColor;
AtomicSafetyHandle safety = AtomicSafetyHandle.Create();
unsafe
{
dstDataAsColor = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <T>(layer.data, layer.dataSize, Allocator.None);
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref dstDataAsColor, safety);
}
var dstWidth = layer.scanlineSize / UnsafeUtility.SizeOf <T>();
int scanLines = height / (int)GraphicsFormatUtility.GetBlockHeight(format);
int pitch = (width * (int)GraphicsFormatUtility.GetBlockSize(format)) / ((int)GraphicsFormatUtility.GetBlockWidth(format) * UnsafeUtility.SizeOf <T>());
if (scanLines * pitch > colorData.Length)
{
throw new ArgumentException($"Could not copy from ColorData in layer {layer}, {format}. The Provided source array is smaller than the tile content.");
}
if ((scanLines - 1) * dstWidth + pitch > dstDataAsColor.Length)
{
throw new ArgumentException($"Trying to write outside of the layer {layer} data buffer bounds. Is the provided format {format} correct?");
}
for (int i = 0; i < scanLines; ++i)
{
NativeArray <T> .Copy(colorData, i *pitch, dstDataAsColor, i *dstWidth, pitch);
}
dstDataAsColor.Dispose();
AtomicSafetyHandle.Release(safety);
}
void OnCompleteReadback(AsyncGPUReadbackRequest request)
{
if (request.hasError)
{
Debug.LogError("GPU readback error detected");
return;
}
// This happens when the delayed async readback happens as we're exiting play mode
if (instance == null || visibilityMaskTexture == null)
{
return;
}
// Read the color of the visibility mask texture to determine which visibility masks are active on cursor
Texture2D visibilityMaskTex = new Texture2D(
1,
1,
GraphicsFormatUtility.GetTextureFormat(visibilityMaskTexture.graphicsFormat),
false
);
visibilityMaskTex.LoadRawTextureData(request.GetData <Color32>());
visibilityMaskTex.Apply();
// Only one pixel so we can sample at 0, 0
Color sample = visibilityMaskTex.GetPixel(0, 0);
visibilityMaskValue = DimensionShaderUtils.MaskValueFromSample(sample.linear);
}
internal static int PrepareVolumePreview(Material material, Texture texture, Vector3 scale, float opacity,
FilterMode filterMode, bool colorRamp, Gradient customColorRamp, Camera camera, Matrix4x4 trs, float qualityModifier = 2)
{
float inverseResolution;
Vector3 inverseScale;
PrepareGeneralPreview(material, texture, out inverseScale, out inverseResolution, customColorRamp);
uint colorChannelCount = GraphicsFormatUtility.GetColorComponentCount(texture.graphicsFormat);
material.SetVector(MaterialProps.globalScale, scale);
material.SetFloat(MaterialProps.ramp, Convert.ToSingle(colorRamp));
material.SetFloat(MaterialProps.invResolution, inverseResolution);
material.SetVector(MaterialProps.invChannels, new Vector3(1.0f / colorChannelCount, 1.0f / colorChannelCount, 1.0f / colorChannelCount));
material.SetFloat(MaterialProps.alpha, Mathf.Pow(Mathf.Clamp01(opacity), 3));
material.SetFloat(MaterialProps.filterMode, Convert.ToSingle(filterMode));
float quality = inverseResolution / qualityModifier / 2;
material.SetFloat(MaterialProps.quality, quality);
material.SetMatrix("_CamToW", camera.cameraToWorldMatrix);
material.SetMatrix("_WToCam", camera.worldToCameraMatrix);
material.SetMatrix("_ObjToW", trs);
material.SetMatrix("_WToObj", trs.inverse);
return(Convert.ToInt32(1 / inverseResolution * qualityModifier * 2));
}
public static bool CompareFormat(this RenderTexture rt, GraphicsFormat format)
{
#if UNITY_2019_3_OR_NEWER
return(rt.graphicsFormat == format);
#else
return(rt.format == GraphicsFormatUtility.GetRenderTextureFormat(format));
#endif
}
static public bool TextureHasAlpha(Texture2D inTex)
{
if (inTex != null)
{
return(GraphicsFormatUtility.HasAlphaChannel(GraphicsFormatUtility.GetGraphicsFormat(inTex.format, true)));
}
return(false);
}
private bool RenderTextureHasDepth()
{
if (GraphicsFormatUtility.IsDepthFormat((GraphicsFormat)m_ColorFormat.enumValueIndex))
{
return(true);
}
return(m_DepthFormat.enumValueIndex != 0);
}
internal bool ValidateSize(int width, int height, GraphicsFormat format)
{
if (GraphicsFormatUtility.GetBlockSize(format) * (width / GraphicsFormatUtility.GetBlockWidth(format)) * (height / GraphicsFormatUtility.GetBlockHeight(format)) < 65536)
{
Debug.LogError(String.Format("SparseTexture creation failed. The minimum size in bytes of a SparseTexture is 64KB."), this);
return(false);
}
return(true);
}
private static void ValidateIsNotCrunched(TextureFormat textureFormat)
{
bool flag = GraphicsFormatUtility.IsCrunchFormat(textureFormat);
if (flag)
{
throw new ArgumentException("Crunched SparseTexture is not supported.");
}
}
static void SetupAlternateGetBlockSize()
{
_blockSizeMap = new Dictionary <GraphicsFormat, int>();
foreach (GraphicsFormat format in Enum.GetValues(typeof(GraphicsFormat)))
{
_blockSizeMap[format] = (int)GraphicsFormatUtility.GetBlockSize(format);
_componentCountMap[format] = (int)GraphicsFormatUtility.GetComponentCount(format);
}
}
public override string GetInfoString()
{
Texture t = target as Texture;
string info = t.width + "x" + t.height;
GraphicsFormat format = GraphicsFormatUtility.GetFormat(t);
info += " " + GraphicsFormatUtility.GetFormatString(format);
return(info);
}
static bool IsRenderTextureFormatSupportedForLinearFiltering(RenderTextureFormat format)
{
#if UNITY_2019_1_OR_NEWER
GraphicsFormat graphicFormat = GraphicsFormatUtility.GetGraphicsFormat(format, RenderTextureReadWrite.Linear);
return(SystemInfo.IsFormatSupported(graphicFormat, FormatUsage.Linear));
#else
return(format.IsSupported());
#endif
}
internal static void ValidateFormat(Texture src, GraphicsFormat dstformat)
{
GraphicsFormat srcformat = GraphicsFormatUtility.GetFormat(src);
if (!SystemInfo.IsFormatSupported(srcformat, FormatUsage.ReadPixels))
{
Debug.LogError(String.Format("'{0}' doesn't support ReadPixels usage on this platform. Async GPU readback failed.", srcformat));
}
}
/// <summary>
/// Specifies whether the Texture has an alpha channel or not. Returns true if it does and false otherwise.
/// </summary>
/// <param name="tex">The Texture for this function to check.</param>
/// <returns></returns>
public static bool TextureHasAlpha(Texture2D tex)
{
if (tex == null)
{
return(false);
}
return(GraphicsFormatUtility.HasAlphaChannel(tex.graphicsFormat));
}
static bool IsRenderTextureFormatSupportedForLinearFiltering(RenderTextureFormat format)
{
#if UNITY_2019_1_OR_NEWER
var gFormat = GraphicsFormatUtility.GetGraphicsFormat(format, RenderTextureReadWrite.Linear);
return(SystemInfo.IsFormatSupported(gFormat, FormatUsage.Linear));
#else
// No good/fast way to test it on pre-2019.1
return(format.IsSupported());
#endif
}
private static string[] BuildTextureStrings(int[] texFormatValues)
{
string[] retval = new string[texFormatValues.Length];
for (int i = 0; i < texFormatValues.Length; i++)
{
int val = texFormatValues[i];
retval[i] = (val < 0 ? "Automatic" : GraphicsFormatUtility.GetFormatString((TextureFormat)val));
}
return(retval);
}
private bool RenderTextureHasDepth()
{
if (((GraphicsFormat)m_ColorFormat.enumValueIndex == GraphicsFormat.None) ||
GraphicsFormatUtility.IsDepthFormat((GraphicsFormat)m_ColorFormat.enumValueIndex)) /* This should be removed if ShadowAuto and DepthAuto formats are finally removed (they are currently deprecated already)*/
{
return(true);
}
return(m_DepthStencilFormat.enumValueIndex != 0);
}
public static Rect[] PackTexture(out Texture2D atlas_, Texture2D[] texture_, int size_, int padding_)
{
//TODO test on device
var format = texture_[0].graphicsFormat;
if (!SystemInfo.IsFormatSupported(format, FormatUsage.Sample))
{
Log.Warning($"unsupported format {format}");
atlas_ = new Texture2D(1, 1);
return(atlas_.PackTextures(texture_, padding_, size_));
}
var rect = new System.Collections.Generic.List <Rect>(texture_.Length);
var texArray = texture_.Select(t => new Vector2(t.width, t.height)).ToArray();
if (!Texture2D.GenerateAtlas(texArray, padding_, size_, rect))
{
Log.Error("failed to pack textures");
atlas_ = null;
return(null);
}
atlas_ = new Texture2D(size_, size_, format, TextureCreationFlags.None);
//etc2+eac 8bpp 4x4 = 128bits
//dxt5/bc3 8bpp 4x4 = 128bits
//pvrtc 4bpp: 4x4 = 64bits 2bpp: 8x4=64bits
//astc fixed 128bits
var blockSize = GraphicsFormatUtility.GetBlockSize(format);
var blockWidth = (int)GraphicsFormatUtility.GetBlockWidth(format);
var blockHeight = (int)GraphicsFormatUtility.GetBlockHeight(format);
if (blockSize == 16)
{
CopyTextureRawData <Block128Bit>(atlas_, texture_, rect, blockWidth, blockHeight);
}
else if (blockSize == 8)
{
CopyTextureRawData <UInt64>(atlas_, texture_, rect, blockWidth, blockHeight);
}
else if (blockSize == 4)
{
CopyTextureRawData <UInt32>(atlas_, texture_, rect, blockWidth, blockHeight);
}
else
{
Log.Warning($"unsupported block size {blockSize} byte");
}
atlas_.Apply(false, true);
float sizeInv = 1f / size_;
for (int k = 0; k < rect.Count; ++k)
{
var r = rect[k];
rect[k] = new Rect(r.x * sizeInv, r.y * sizeInv, r.width * sizeInv, r.height * sizeInv);
}
return(rect.ToArray());
}
public override string GetInfoString()
{
if (m_PreviewTextures != null && m_PreviewPage < m_PreviewTextures.Length)
{
Texture2D t = m_PreviewTextures[m_PreviewPage];
GraphicsFormat format = GraphicsFormatUtility.GetFormat(t);
return(string.Format("{0}x{1} {2}\n{3}", t.width, t.height, GraphicsFormatUtility.GetFormatString(format), EditorUtility.FormatBytes(TextureUtil.GetStorageMemorySizeLong(t))));
}
return("");
}
public RenderTexture(int width, int height, int depth, GraphicsFormat format)
{
if (!ValidateFormat(format, FormatUsage.Render))
{
return;
}
Internal_Create(this);
this.width = width; this.height = height; this.depth = depth; this.graphicsFormat = format;
SetSRGBReadWrite(GraphicsFormatUtility.IsSRGBFormat(format));
}
private void PlanarReflectionTexture(Camera cam)
{
if (_reflectionTexture == null)
{
var res = ReflectionResolution(cam, UniversalRenderPipeline.asset.renderScale);
const bool useHdr10 = true;
const RenderTextureFormat hdrFormat = useHdr10 ? RenderTextureFormat.RGB111110Float : RenderTextureFormat.DefaultHDR;
_reflectionTexture = RenderTexture.GetTemporary(res.x, res.y, 16,
GraphicsFormatUtility.GetGraphicsFormat(hdrFormat, true));
}
_reflectionCamera.targetTexture = _reflectionTexture;
}
