forked from BilalY/Rasagar
540 lines
23 KiB
C#
540 lines
23 KiB
C#
using System;
|
|
using System.IO;
|
|
using UnityEngine;
|
|
using UnityEngine.Experimental.Rendering;
|
|
using UnityEngine.TerrainTools;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace UnityEditor.TerrainTools
|
|
{
|
|
internal class ToolboxHelper
|
|
{
|
|
// Toolbox setting serialization
|
|
public static string LibraryPath = "/../Library/TerrainTools/";
|
|
public static string ToolboxPrefsWindow = "ToolboxWindowPrefs";
|
|
public static string ToolboxPrefsCreate = "ToolboxCreatePrefs";
|
|
public static string ToolboxPrefsSettings = "ToolboxSettingsPrefs";
|
|
public static string ToolboxPrefsUtility = "ToolboxUtilityPrefs";
|
|
public static string ToolboxPrefsVisualization = "ToolboxVisualizationPrefs";
|
|
|
|
public enum ByteOrder { Mac = 1, Windows = 2 };
|
|
public enum RenderPipeline
|
|
{
|
|
Default,
|
|
HD,
|
|
LW,
|
|
Universal,
|
|
None
|
|
}
|
|
|
|
public static int[] GUITextureResolutions = new int[] { 32, 64, 128, 256, 512, 1024, 2048, 4096 };
|
|
public static string[] GUITextureResolutionNames = new string[] { "32", "64", "128", "256", "512", "1024", "2048", "4096" };
|
|
public static int[] GUIHeightmapResolutions = new int[] { 33, 65, 129, 257, 513, 1025, 2049, 4097 };
|
|
public static GUIContent[] GUIHeightmapResolutionNames = new GUIContent[]
|
|
{
|
|
EditorGUIUtility.TrTextContent("33"),
|
|
EditorGUIUtility.TrTextContent("65"),
|
|
EditorGUIUtility.TrTextContent("129"),
|
|
EditorGUIUtility.TrTextContent("257"),
|
|
EditorGUIUtility.TrTextContent("513"),
|
|
EditorGUIUtility.TrTextContent("1025"),
|
|
EditorGUIUtility.TrTextContent("2049"),
|
|
EditorGUIUtility.TrTextContent("4097")
|
|
};
|
|
|
|
public static bool IsPowerOfTwo(int x)
|
|
{
|
|
return (x != 0) && ((x & (x - 1)) == 0);
|
|
}
|
|
|
|
public static bool IsInteger(double x)
|
|
{
|
|
return (x % 1) == 0;
|
|
}
|
|
|
|
public static string GetPrefFilePath(string prefType)
|
|
{
|
|
string filePath = string.Empty;
|
|
string dirPath = Application.dataPath + LibraryPath;
|
|
if (!Directory.Exists(dirPath))
|
|
{
|
|
Directory.CreateDirectory(dirPath);
|
|
}
|
|
|
|
filePath = dirPath + prefType + ".json";
|
|
|
|
return filePath;
|
|
}
|
|
|
|
public static string GetBitDepth(Heightmap.Depth depth)
|
|
{
|
|
switch (depth)
|
|
{
|
|
case Heightmap.Depth.Bit16:
|
|
return "16 bit";
|
|
case Heightmap.Depth.Bit8:
|
|
return "8 bit";
|
|
default:
|
|
return "8 bit";
|
|
}
|
|
}
|
|
|
|
public static Terrain[] GetSelectedTerrainsInScene(SelectionMode selectionMode = SelectionMode.Unfiltered)
|
|
{
|
|
var objs = Selection.GetFiltered(typeof(Terrain), selectionMode);
|
|
var terrains = new Terrain[objs.Length];
|
|
for (var i = 0; i < objs.Length; i++)
|
|
{
|
|
terrains[i] = objs[i] as Terrain;
|
|
}
|
|
|
|
return terrains;
|
|
}
|
|
|
|
public static Terrain[] GetAllTerrainsInScene()
|
|
{
|
|
return GameObject.FindObjectsOfType<Terrain>();
|
|
}
|
|
|
|
public static void CalculateAdjacencies(Terrain[] terrains, int tilesX, int tilesZ)
|
|
{
|
|
if (terrains == null || terrains.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// set neighbor terrains to update normal maps
|
|
for (int y = 0; y < tilesZ; y++)
|
|
{
|
|
for (int x = 0; x < tilesX; x++)
|
|
{
|
|
int index = (y * tilesX) + x;
|
|
Terrain terrain = terrains[index];
|
|
Terrain leftTerrain = (x > 0) ? terrains[index - 1] : null;
|
|
Terrain rightTerrain = (x < tilesX - 1) ? terrains[index + 1] : null;
|
|
Terrain topTerrain = (y > 0) ? terrains[index - tilesX] : null;
|
|
Terrain bottomTerrain = (y < tilesZ - 1) ? terrains[index + tilesX] : null;
|
|
|
|
// NOTE: "top" and "bottom" are reversed because of the way the terrain is handled...
|
|
terrain.SetNeighbors(leftTerrain, bottomTerrain, rightTerrain, topTerrain);
|
|
}
|
|
}
|
|
}
|
|
public static Texture2D GetTextureCopy(Texture2D texture)
|
|
{
|
|
var creationFlags = texture.mipmapCount > 0
|
|
? TextureCreationFlags.MipChain
|
|
: TextureCreationFlags.None;
|
|
var textureCopy = new Texture2D(texture.width, texture.height, texture.graphicsFormat, texture.mipmapCount,
|
|
creationFlags);
|
|
Graphics.CopyTexture(texture, textureCopy);
|
|
return textureCopy;
|
|
}
|
|
|
|
public static Texture2D GetPartialTexture(Texture2D sourceTexture, Vector2Int resolution, Vector2Int offset)
|
|
{
|
|
if (offset.x > resolution.x || offset.y > resolution.y)
|
|
return null;
|
|
|
|
var destColor = sourceTexture.GetPixels(offset.x, offset.y, resolution.x, resolution.y);
|
|
Texture2D newTexture = new Texture2D(resolution.x, resolution.y);
|
|
newTexture.SetPixels(destColor);
|
|
|
|
return newTexture;
|
|
}
|
|
|
|
// referencing from TerrainInspector.ResizeControltexture()
|
|
public static void ResizeControlTexture(TerrainData terrainData, int resolution)
|
|
{
|
|
RenderTexture oldRT = RenderTexture.active;
|
|
RenderTexture[] oldAlphaMaps = new RenderTexture[terrainData.alphamapTextureCount];
|
|
for (int i = 0; i < oldAlphaMaps.Length; i++)
|
|
{
|
|
terrainData.alphamapTextures[i].filterMode = FilterMode.Bilinear;
|
|
oldAlphaMaps[i] = RenderTexture.GetTemporary(resolution, resolution, 0, SystemInfo.GetGraphicsFormat(DefaultFormat.HDR));
|
|
Graphics.Blit(terrainData.alphamapTextures[i], oldAlphaMaps[i]);
|
|
}
|
|
|
|
Undo.RegisterCompleteObjectUndo(terrainData, "Resize alphamap");
|
|
|
|
terrainData.alphamapResolution = resolution;
|
|
for (int i = 0; i < oldAlphaMaps.Length; i++)
|
|
{
|
|
RenderTexture.active = oldAlphaMaps[i];
|
|
|
|
CopyActiveRenderTextureToTexture(terrainData.GetAlphamapTexture(i), new RectInt(0, 0, resolution, resolution), Vector2Int.zero, false);
|
|
}
|
|
terrainData.SetBaseMapDirty();
|
|
RenderTexture.active = oldRT;
|
|
for (int i = 0; i < oldAlphaMaps.Length; i++)
|
|
{
|
|
RenderTexture.ReleaseTemporary(oldAlphaMaps[i]);
|
|
}
|
|
|
|
terrainData.SetBaseMapDirty();
|
|
}
|
|
|
|
// referencing from TerrainData.GPUCopy.CopyActiveRenderTextureToTexture()
|
|
public static void CopyActiveRenderTextureToTexture(Texture2D dstTexture, RectInt sourceRect, Vector2Int dest, bool allowDelayedCPUSync)
|
|
{
|
|
var source = RenderTexture.active;
|
|
if (source == null)
|
|
throw new InvalidDataException("Active RenderTexture is null.");
|
|
|
|
int dstWidth = dstTexture.width;
|
|
int dstHeight = dstTexture.height;
|
|
|
|
allowDelayedCPUSync = allowDelayedCPUSync && SupportsCopyTextureBetweenRTAndTexture;
|
|
if (allowDelayedCPUSync)
|
|
{
|
|
if (dstTexture.mipmapCount > 1)
|
|
{
|
|
var tmp = RenderTexture.GetTemporary(new RenderTextureDescriptor(dstWidth, dstHeight, source.format));
|
|
if (!tmp.IsCreated())
|
|
{
|
|
tmp.Create();
|
|
}
|
|
Graphics.CopyTexture(dstTexture, 0, 0, tmp, 0, 0);
|
|
Graphics.CopyTexture(source, 0, 0, sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height, tmp, 0, 0, dest.x, dest.y);
|
|
|
|
tmp.GenerateMips();
|
|
Graphics.CopyTexture(tmp, dstTexture);
|
|
RenderTexture.ReleaseTemporary(tmp);
|
|
}
|
|
else
|
|
{
|
|
Graphics.CopyTexture(source, 0, 0, sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height, dstTexture, 0, 0, dest.x, dest.y);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal || !SystemInfo.graphicsUVStartsAtTop)
|
|
dstTexture.ReadPixels(new Rect(sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height), dest.x, dest.y);
|
|
else
|
|
dstTexture.ReadPixels(new Rect(sourceRect.x, source.height - sourceRect.yMax, sourceRect.width, sourceRect.height), dest.x, dest.y);
|
|
dstTexture.Apply(true);
|
|
}
|
|
}
|
|
|
|
private static bool SupportsCopyTextureBetweenRTAndTexture {
|
|
get
|
|
{
|
|
const CopyTextureSupport kRT2TexAndTex2RT = CopyTextureSupport.RTToTexture | CopyTextureSupport.TextureToRT;
|
|
return (SystemInfo.copyTextureSupport & kRT2TexAndTex2RT) == kRT2TexAndTex2RT;
|
|
}
|
|
}
|
|
|
|
public static float kNormalizedHeightScale => 32766.0f / 65535.0f;
|
|
public static void CopyTextureToTerrainHeight(TerrainData terrainData, Texture2D heightmap, Vector2Int indexOffset, int resolution, int numTiles, float baseLevel, float remap)
|
|
{
|
|
terrainData.heightmapResolution = resolution + 1;
|
|
|
|
float hWidth = heightmap.height;
|
|
float div = hWidth / numTiles;
|
|
|
|
float scale = ((resolution / (resolution + 1.0f)) * (div + 1)) / hWidth;
|
|
float offset = ((resolution / (resolution + 1.0f)) * div) / hWidth;
|
|
|
|
Vector2 scaleV = new Vector2(scale, scale);
|
|
Vector2 offsetV = new Vector2(offset * indexOffset.x, offset * indexOffset.y);
|
|
|
|
Material blitMaterial = GetHeightBlitMaterial();
|
|
blitMaterial.SetFloat("_Height_Offset", baseLevel * kNormalizedHeightScale);
|
|
blitMaterial.SetFloat("_Height_Scale", remap * kNormalizedHeightScale);
|
|
RenderTexture heightmapRT = RenderTexture.GetTemporary(terrainData.heightmapTexture.descriptor);
|
|
Graphics.Blit(heightmap, heightmapRT, blitMaterial);
|
|
|
|
Graphics.Blit(heightmapRT, terrainData.heightmapTexture, scaleV, offsetV);
|
|
|
|
terrainData.DirtyHeightmapRegion(new RectInt(0, 0, terrainData.heightmapTexture.width, terrainData.heightmapTexture.height), TerrainHeightmapSyncControl.HeightAndLod);
|
|
RenderTexture.ReleaseTemporary(heightmapRT);
|
|
}
|
|
|
|
public static void ResizeHeightmap(TerrainData terrainData, int resolution)
|
|
{
|
|
RenderTexture oldRT = RenderTexture.active;
|
|
|
|
RenderTexture oldHeightmap = RenderTexture.GetTemporary(terrainData.heightmapTexture.descriptor);
|
|
Graphics.Blit(terrainData.heightmapTexture, oldHeightmap);
|
|
|
|
#if UNITY_2019_3_OR_NEWER
|
|
// terrain holes
|
|
RenderTexture oldHoles = RenderTexture.GetTemporary(terrainData.holesTexture.width, terrainData.holesTexture.height);
|
|
Graphics.Blit(terrainData.holesTexture, oldHoles);
|
|
#endif
|
|
|
|
Undo.RegisterCompleteObjectUndo(terrainData, "Resize heightmap");
|
|
|
|
float sUV = 1.0f;
|
|
int dWidth = terrainData.heightmapResolution;
|
|
int sWidth = resolution;
|
|
|
|
Vector3 oldSize = terrainData.size;
|
|
terrainData.heightmapResolution = resolution;
|
|
terrainData.size = oldSize;
|
|
|
|
oldHeightmap.filterMode = FilterMode.Bilinear;
|
|
|
|
// Make sure textures are offset correctly when resampling
|
|
// tsuv = (suv * swidth - 0.5) / (swidth - 1)
|
|
// duv = (tsuv(dwidth - 1) + 0.5) / dwidth
|
|
// duv = (((suv * swidth - 0.5) / (swidth - 1)) * (dwidth - 1) + 0.5) / dwidth
|
|
// k = (dwidth - 1) / (swidth - 1) / dwidth
|
|
// duv = suv * (swidth * k) + 0.5 / dwidth - 0.5 * k
|
|
|
|
float k = (dWidth - 1.0f) / (sWidth - 1.0f) / dWidth;
|
|
float scaleX = sUV * (sWidth * k);
|
|
float offsetX = (float)(0.5 / dWidth - 0.5 * k);
|
|
Vector2 scale = new Vector2(scaleX, scaleX);
|
|
Vector2 offset = new Vector2(offsetX, offsetX);
|
|
|
|
Graphics.Blit(oldHeightmap, terrainData.heightmapTexture, scale, offset);
|
|
RenderTexture.ReleaseTemporary(oldHeightmap);
|
|
|
|
#if UNITY_2019_3_OR_NEWER
|
|
oldHoles.filterMode = FilterMode.Point;
|
|
Graphics.Blit(oldHoles, (RenderTexture)terrainData.holesTexture);
|
|
RenderTexture.ReleaseTemporary(oldHoles);
|
|
#endif
|
|
|
|
RenderTexture.active = oldRT;
|
|
|
|
terrainData.DirtyHeightmapRegion(new RectInt(0, 0, terrainData.heightmapTexture.width, terrainData.heightmapTexture.height), TerrainHeightmapSyncControl.HeightAndLod);
|
|
#if UNITY_2019_3_OR_NEWER
|
|
terrainData.DirtyTextureRegion(TerrainData.HolesTextureName, new RectInt(0, 0, terrainData.holesTexture.width, terrainData.holesTexture.height), false);
|
|
#endif
|
|
}
|
|
|
|
// Unity PNG encoder does not support 16bit export, change will come later 2019
|
|
public static void ExportTerrainHeightsToTexture(TerrainData terrainData, Heightmap.Format format, string path, bool flipVertical, Vector2 inputLevelsRange)
|
|
{
|
|
RenderTexture oldRT = RenderTexture.active;
|
|
int width = terrainData.heightmapTexture.width - 1;
|
|
int height = terrainData.heightmapTexture.height - 1;
|
|
var texture = new Texture2D(width, height, terrainData.heightmapTexture.graphicsFormat, TextureCreationFlags.None);
|
|
RenderTexture.active = terrainData.heightmapTexture;
|
|
texture.ReadPixels(new Rect(0, 0, width, height), 0, 0);
|
|
|
|
//Remap Texture
|
|
Color[] pixels = texture.GetPixels();
|
|
for (int i = 0; i < pixels.Length; i += 4)
|
|
{
|
|
pixels[i].r = (pixels[i].r * 2) * (inputLevelsRange.y - inputLevelsRange.x) + inputLevelsRange.x;
|
|
pixels[i + 1].r = (pixels[i + 1].r * 2) * (inputLevelsRange.y - inputLevelsRange.x) + inputLevelsRange.x;
|
|
pixels[i + 2].r = (pixels[i + 2].r * 2) * (inputLevelsRange.y - inputLevelsRange.x) + inputLevelsRange.x;
|
|
pixels[i + 3].r = (pixels[i + 3].r * 2) * (inputLevelsRange.y - inputLevelsRange.x) + inputLevelsRange.x;
|
|
}
|
|
texture.SetPixels(pixels);
|
|
texture.Apply();
|
|
|
|
//Flip Texture
|
|
if (flipVertical)
|
|
ToolboxHelper.FlipTexture(texture, true);
|
|
|
|
byte[] bytes;
|
|
switch (format)
|
|
{
|
|
case Heightmap.Format.TGA:
|
|
bytes = texture.EncodeToTGA();
|
|
path = path + ".tga";
|
|
break;
|
|
default:
|
|
bytes = texture.EncodeToPNG();
|
|
path = path + ".png";
|
|
break;
|
|
}
|
|
|
|
File.WriteAllBytes(path, bytes);
|
|
RenderTexture.active = oldRT;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a path relative to the project directory for saving assets.
|
|
/// If the path is outside the assets directory it will return the Assets folder.
|
|
/// </summary>
|
|
/// <param name="requestedDirectory">The directory we want to save to, absolute or relative</param>
|
|
/// <param name="forceToAssets">If we want the directory to be forced into the assets directory</param>
|
|
/// <returns>A relative path, inside the project directory</returns>
|
|
internal static string GetProjectRelativeSaveDirectory(string requestedDirectory, bool forceToAssets = true)
|
|
{
|
|
var referenceUri = new Uri(Application.dataPath + "/..");
|
|
if (Path.IsPathRooted(requestedDirectory))
|
|
{
|
|
try
|
|
{
|
|
var fileUri = new Uri(requestedDirectory);
|
|
requestedDirectory = Uri.UnescapeDataString(referenceUri.MakeRelativeUri(fileUri).ToString());
|
|
}
|
|
catch
|
|
{
|
|
if (forceToAssets)
|
|
requestedDirectory = "Assets";
|
|
return requestedDirectory;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var fileUri = new Uri(Application.dataPath + "/../" + requestedDirectory);
|
|
requestedDirectory = Uri.UnescapeDataString(referenceUri.MakeRelativeUri(fileUri).ToString());
|
|
}
|
|
// if the directory doesn't start with "Assets+Path.DirectorySeparatorChar"
|
|
// then the terraindata will not end up in the assetdatabase, and not correctly be loaded
|
|
// so force it to the correct location
|
|
if (forceToAssets && (!requestedDirectory.StartsWith("Assets") || !requestedDirectory.StartsWith("Assets/")))
|
|
requestedDirectory = "Assets";
|
|
return requestedDirectory;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reports if a directory is within the Project/Assets folder.
|
|
/// Directory does not need to exist.
|
|
/// </summary>
|
|
/// <param name="requestedDirectory"></param>
|
|
/// <returns></returns>
|
|
internal static bool IsDirectoryWithinAssets(string requestedDirectory)
|
|
{
|
|
return GetProjectRelativeSaveDirectory(requestedDirectory, false) ==
|
|
GetProjectRelativeSaveDirectory(requestedDirectory);
|
|
}
|
|
|
|
public static void ExportTerrainHeightsToRawFile(TerrainData terrainData, string path, Heightmap.Depth depth, bool flipVertical, ByteOrder byteOrder, Vector2 inputLevelsRange)
|
|
{
|
|
// trim off the extra 1 pixel, so we get a power of two sized texture
|
|
#if UNITY_2019_3_OR_NEWER
|
|
int heightmapWidth = terrainData.heightmapResolution - 1;
|
|
int heightmapHeight = terrainData.heightmapResolution - 1;
|
|
#else
|
|
int heightmapWidth = terrainData.heightmapWidth - 1;
|
|
int heightmapHeight = terrainData.heightmapHeight - 1;
|
|
#endif
|
|
float[,] heights = terrainData.GetHeights(0, 0, heightmapWidth, heightmapHeight);
|
|
byte[] data = new byte[heightmapWidth * heightmapHeight * (int)depth];
|
|
|
|
if (depth == Heightmap.Depth.Bit16)
|
|
{
|
|
float normalize = (1 << 16);
|
|
for (int y = 0; y < heightmapHeight; ++y)
|
|
{
|
|
for (int x = 0; x < heightmapWidth; ++x)
|
|
{
|
|
int index = x + y * heightmapWidth;
|
|
int srcY = flipVertical ? heightmapHeight - 1 - y : y;
|
|
|
|
float remappedHeight = heights[srcY, x] * (inputLevelsRange.y - inputLevelsRange.x) + inputLevelsRange.x;
|
|
|
|
int height = Mathf.RoundToInt(remappedHeight * normalize);
|
|
ushort compressedHeight = (ushort)Mathf.Clamp(height, 0, ushort.MaxValue);
|
|
|
|
byte[] byteData = System.BitConverter.GetBytes(compressedHeight);
|
|
if ((byteOrder == ByteOrder.Mac) == System.BitConverter.IsLittleEndian)
|
|
{
|
|
data[index * 2 + 0] = byteData[1];
|
|
data[index * 2 + 1] = byteData[0];
|
|
}
|
|
else
|
|
{
|
|
data[index * 2 + 0] = byteData[0];
|
|
data[index * 2 + 1] = byteData[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float normalize = (1 << 8);
|
|
for (int y = 0; y < heightmapHeight; ++y)
|
|
{
|
|
for (int x = 0; x < heightmapWidth; ++x)
|
|
{
|
|
int index = x + y * heightmapWidth;
|
|
int srcY = flipVertical ? heightmapHeight - 1 - y : y;
|
|
|
|
float remappedHeight = heights[y, x] * (inputLevelsRange.y - inputLevelsRange.x) + inputLevelsRange.x;
|
|
|
|
int height = Mathf.RoundToInt(remappedHeight * normalize);
|
|
byte compressedHeight = (byte)Mathf.Clamp(height, 0, byte.MaxValue);
|
|
data[index] = compressedHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
FileStream fs = new FileStream((path + ".raw"), FileMode.Create);
|
|
fs.Write(data, 0, data.Length);
|
|
fs.Close();
|
|
}
|
|
|
|
public static Material GetHeightBlitMaterial()
|
|
{
|
|
return new Material(Shader.Find("Hidden/TerrainTools/HeightBlit"));
|
|
}
|
|
|
|
public static void FlipTexture(Texture2D texture, bool isHorizontal)
|
|
{
|
|
if (texture == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// check if texture is read-only before proceeding, because it could pass in a Texture2D from an object selector UI
|
|
if (!texture.isReadable)
|
|
{
|
|
string assetPath = AssetDatabase.GetAssetPath(texture);
|
|
var textureImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
|
|
if (textureImporter != null)
|
|
{
|
|
textureImporter.isReadable = true;
|
|
AssetDatabase.ImportAsset(assetPath);
|
|
AssetDatabase.Refresh();
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
Color[] originalPixels = texture.GetPixels();
|
|
Color[] flippedPixels = new Color[originalPixels.Length];
|
|
int width = texture.width;
|
|
int height = texture.height;
|
|
for (int y = 0; y < height; y++)
|
|
{
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
int flippedIndex = isHorizontal ? y * width + width - 1 - x : (height - 1) * width - y * width + x;
|
|
int originalIndex = y * width + x;
|
|
if (flippedIndex < 0)
|
|
continue;
|
|
flippedPixels[flippedIndex] = originalPixels[originalIndex];
|
|
}
|
|
}
|
|
texture.SetPixels(flippedPixels);
|
|
texture.Apply();
|
|
}
|
|
|
|
public static RenderPipeline GetRenderPipeline()
|
|
{
|
|
if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset == null)
|
|
{
|
|
return RenderPipeline.Default;
|
|
}
|
|
else if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset.GetType().FullName
|
|
== "UnityEngine.Rendering.HighDefinition.HDRenderPipelineAsset")
|
|
{
|
|
return RenderPipeline.HD;
|
|
}
|
|
else if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset.GetType().FullName
|
|
== "UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset")
|
|
{
|
|
return RenderPipeline.Universal;
|
|
}
|
|
else if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset.GetType().FullName
|
|
== "UnityEngine.Rendering.LWRP.LightweightRenderPipelineAsset")
|
|
{
|
|
return RenderPipeline.LW;
|
|
}
|
|
|
|
return RenderPipeline.Default;
|
|
}
|
|
}
|
|
}
|