static void ExportToEXR(string path, Texture2D tex, Texture2D.EXRFlags flags)
{
#if UNITY_2018_1_OR_NEWER
System.IO.File.WriteAllBytes(path, ImageConversion.EncodeToEXR(tex, flags));
#else
System.IO.File.WriteAllBytes(path, tex.EncodeToEXR(flags));
#endif
}
public UnityTexture2DCodec(MediaType.Image format)
{
if (format != MediaType.Image.EXR &&
format != MediaType.Image.Jpeg &&
format != MediaType.Image.Png &&
format != MediaType.Image.X_Tga &&
format != MediaType.Image.Raw)
{
throw new NotSupportedException($"Unity doesn't know how to encode {format.Value} image data.");
}
ContentType = format;
exrFlags = Texture2D.EXRFlags.None;
jpegEncodingQuality = 80;
}
public void OnInspectorGUI(Action onValueChanged)
{
var newOutputType = (TextureOutputType)EditorGUILayout.EnumPopup("Output Format", m_outputType);
if (newOutputType != m_outputType)
{
m_outputType = newOutputType;
onValueChanged();
}
if (m_outputType == TextureOutputType.JPG)
{
var newQuality = EditorGUILayout.IntSlider("JPG Quality", m_jpgQuality, 1, 100);
if (newQuality != m_jpgQuality)
{
m_jpgQuality = newQuality;
onValueChanged();
}
}
#if UNITY_5_6_OR_NEWER
if (m_outputType == TextureOutputType.EXR)
{
var exrOpt = (Texture2D.EXRFlags)EditorGUILayout.EnumPopup("EXR Option", m_exrFlags);
if (exrOpt != m_exrFlags)
{
m_exrFlags = exrOpt;
onValueChanged();
}
}
#endif
var newScaleType = (TextureFilterType)EditorGUILayout.EnumPopup("Filter Mode", m_filterType);
if (newScaleType != m_filterType)
{
m_filterType = newScaleType;
onValueChanged();
}
var newScale = EditorGUILayout.Slider("Scale(%)", m_scale * 100f, 1.0f, 100.0f);
newScale = newScale / 100f;
if (m_scale != newScale)
{
m_scale = newScale;
onValueChanged();
}
}
static internal Texture2D.EXRFlags ToNativeType(EXRCompressionType type)
{
Texture2D.EXRFlags nativeType = Texture2D.EXRFlags.None;
switch (type)
{
case ImageRecorderSettings.EXRCompressionType.RLE:
nativeType = Texture2D.EXRFlags.CompressRLE;
break;
case ImageRecorderSettings.EXRCompressionType.Zip:
nativeType = Texture2D.EXRFlags.CompressZIP;
break;
case ImageRecorderSettings.EXRCompressionType.None:
nativeType = Texture2D.EXRFlags.None;
break;
default:
throw new InvalidEnumArgumentException($"Unexpected compression type '{type}'.");
}
return(nativeType);
}
public static Il2CppStructArray <byte> EncodeToEXR(Texture2D tex, Texture2D.EXRFlags flags)
{
if (tex == null)
{
throw new ArgumentException("The texture cannot be null.");
}
if (EncodeToEXRDelegateField == null)
{
throw new NullReferenceException("The EncodeToEXRDelegateField cannot be null.");
}
Il2CppStructArray <byte> il2CppStructArray;
IntPtr encodeToEXRDelegateField = EncodeToEXRDelegateField(IL2CPP.Il2CppObjectBaseToPtr(tex), flags);
if (encodeToEXRDelegateField != IntPtr.Zero)
{
il2CppStructArray = new Il2CppStructArray <byte>(encodeToEXRDelegateField);
}
else
{
il2CppStructArray = null;
}
return(il2CppStructArray);
}
public static byte[] EncodeToEXR(this Texture2D tex)
{
Texture2D.EXRFlags flags = Texture2D.EXRFlags.None;
return(tex.EncodeToEXR(flags));
}
public static extern byte[] EncodeToEXR(this Texture2D tex, [DefaultValue("Texture2D.EXRFlags.None")] Texture2D.EXRFlags flags);
public static NativeArray <byte> EncodeNativeArrayToEXR <T>(NativeArray <T> input, GraphicsFormat format, uint width, uint height, uint rowBytes = 0, Texture2D.EXRFlags flags = Texture2D.EXRFlags.None) where T : struct
{
unsafe
{
var size = input.Length * UnsafeUtility.SizeOf <T>();
var result = UnsafeEncodeNativeArrayToEXR(NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks <T>(input), ref size, format, width, height, rowBytes, flags);
var output = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <byte>(result, size, Allocator.Persistent);
var safety = AtomicSafetyHandle.Create();
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref output, safety);
AtomicSafetyHandle.SetAllowReadOrWriteAccess(safety, true);
return(output);
}
}
public static extern byte[] EncodeToEXR(this Texture2D tex, Texture2D.EXRFlags flags);
public byte[] EncodeToEXR()
{
Texture2D.EXRFlags flags = Texture2D.EXRFlags.None;
return(this.EncodeToEXR(flags));
}
public extern byte[] EncodeToEXR([DefaultValue("EXRFlags.None")] Texture2D.EXRFlags flags);
void OnGUI()
{
EditorGUI.BeginChangeCheck();
// var newConvertType = (ConvertType)EditorGUILayout.EnumPopup( "Convert Type", convertType);
var newConvertType = (ConvertType)EditorGUILayout.EnumPopup(convertType);
if (EditorGUI.EndChangeCheck() != false)
{
Record("Change Convert Type");
convertType = newConvertType;
}
importParam?.OnGUI(convertType);
exportParam?.OnGUI(convertType);
EditorGUILayout.BeginHorizontal();
{
GUILayout.FlexibleSpace();
EditorGUI.BeginDisabledGroup(!exportParam.VerifyExport(convertType));
bool export = GUILayout.Button(" Export ");
EditorGUI.EndDisabledGroup();
if (export != false)
{
System.Func <int, bool, Color[][]> importMethod = null;
switch (convertType)
{
case ConvertType.kFrom6SidedToCubemap:
{
importMethod = importParam.GetTexturesFrom6Sided;
break;
}
case ConvertType.kFromPanoramaToCubemap:
case ConvertType.kFromPanoramaTo6Sided:
{
importMethod = importParam.GetTexturesFromPanorama;
break;
}
}
if (importMethod != null)
{
string extension;
TextureFormat textureFormat;
bool bExportEXR = true;
Texture2D.EXRFlags exrFlags = Texture2D.EXRFlags.None;
System.Func <Texture2D, Texture2D.EXRFlags, byte[]> encodeMethod;
switch (exportParam.fileFormat)
{
case ExportFileFormat.kExr16:
{
extension = "exr";
textureFormat = TextureFormat.RGBAHalf;
encodeMethod = EncodeToEXR;
break;
}
case ExportFileFormat.kExr16Zip:
{
extension = "exr";
textureFormat = TextureFormat.RGBAHalf;
exrFlags |= Texture2D.EXRFlags.CompressZIP;
encodeMethod = EncodeToEXR;
break;
}
case ExportFileFormat.kExr16Rle:
{
extension = "exr";
textureFormat = TextureFormat.RGBAHalf;
exrFlags |= Texture2D.EXRFlags.CompressRLE;
encodeMethod = EncodeToEXR;
break;
}
case ExportFileFormat.kExr32:
{
extension = "exr";
textureFormat = TextureFormat.RGBAFloat;
exrFlags |= Texture2D.EXRFlags.OutputAsFloat;
encodeMethod = EncodeToEXR;
break;
}
case ExportFileFormat.kExr32Zip:
{
extension = "exr";
textureFormat = TextureFormat.RGBAFloat;
exrFlags |= Texture2D.EXRFlags.OutputAsFloat;
exrFlags |= Texture2D.EXRFlags.CompressZIP;
encodeMethod = EncodeToEXR;
break;
}
case ExportFileFormat.kExr32Rle:
{
extension = "exr";
textureFormat = TextureFormat.RGBAFloat;
exrFlags |= Texture2D.EXRFlags.OutputAsFloat;
exrFlags |= Texture2D.EXRFlags.CompressRLE;
encodeMethod = EncodeToEXR;
break;
}
default: /* case ExportFileFormat.kPng: */
{
extension = "png";
bExportEXR = false;
textureFormat = TextureFormat.RGBA32;
encodeMethod = EncodeToPNG;
break;
}
}
string savePath = EditorUtility.SaveFilePanelInProject(
"Cubemap Converter", string.Empty, extension, string.Empty);
if (string.IsNullOrEmpty(savePath) == false)
{
Color[][] colors = importMethod(exportParam.resolution, bExportEXR);
if (colors != null)
{
switch (convertType)
{
case ConvertType.kFrom6SidedToCubemap:
case ConvertType.kFromPanoramaToCubemap:
{
Texture2D cubemap = CreateCubeTexture2D(colors, exportParam.resolution, textureFormat);
if (cubemap != null)
{
byte[] bytes = encodeMethod(cubemap, exrFlags);
DestroyImmediate(cubemap);
File.WriteAllBytes(savePath, bytes);
AssetDatabase.Refresh();
var importer = TextureImporter.GetAtPath(savePath) as TextureImporter;
if (importer != null)
{
importer.textureShape = TextureImporterShape.TextureCube;
importer.wrapMode = TextureWrapMode.Clamp;
AssetDatabase.ImportAsset(savePath);
}
}
break;
}
case ConvertType.kFromPanoramaTo6Sided:
{
string directory = Path.GetDirectoryName(savePath);
string fileName = Path.GetFileNameWithoutExtension(savePath);
for (int i0 = 0; i0 < colors.Length; ++i0)
{
Texture2D texture = CreateTexture2D(colors[i0], exportParam.resolution, textureFormat);
if (texture != null)
{
savePath = Path.ChangeExtension(
string.Format("{0}/{1}-{2}",
directory, fileName, exportParam.faceSuffixes[i0]), extension);
byte[] bytes = encodeMethod(texture, exrFlags);
DestroyImmediate(texture);
File.WriteAllBytes(savePath, bytes);
}
}
break;
}
}
}
}
}
AssetDatabase.Refresh();
}
GUILayout.FlexibleSpace();
}
EditorGUILayout.EndHorizontal();
}
static byte[] EncodeToEXR(Texture2D texture, Texture2D.EXRFlags exrFlags)
{
return(ImageConversion.EncodeToEXR(texture, exrFlags));
}
static byte[] EncodeToPNG(Texture2D texture, Texture2D.EXRFlags exrFlags)
{
return(texture.EncodeToPNG());
}
public unsafe static NativeArray <byte> EncodeNativeArrayToEXR <T>(NativeArray <T> input, GraphicsFormat format, uint width, uint height, uint rowBytes = 0u, Texture2D.EXRFlags flags = Texture2D.EXRFlags.None) where T : struct
{
int length = input.Length * UnsafeUtility.SizeOf <T>();
void *dataPointer = ImageConversion.UnsafeEncodeNativeArrayToEXR(NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks <T>(input), ref length, format, width, height, rowBytes, flags);
NativeArray <byte> result = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <byte>(dataPointer, length, Allocator.Persistent);
AtomicSafetyHandle atomicSafetyHandle = AtomicSafetyHandle.Create();
NativeArrayUnsafeUtility.SetAtomicSafetyHandle <byte>(ref result, atomicSafetyHandle);
AtomicSafetyHandle.SetAllowReadOrWriteAccess(atomicSafetyHandle, true);
return(result);
}
private unsafe static extern void *UnsafeEncodeNativeArrayToEXR(void *array, ref int sizeInBytes, GraphicsFormat format, uint width, uint height, uint rowBytes = 0u, Texture2D.EXRFlags flags = Texture2D.EXRFlags.None);
public UnityTexture2DCodec(Texture2D.EXRFlags exrFlags)
: this(MediaType.Image.EXR)
{
this.exrFlags = exrFlags;
}
public static extern byte[] EncodeArrayToEXR(Array array, GraphicsFormat format, uint width, uint height, uint rowBytes = 0u, Texture2D.EXRFlags flags = Texture2D.EXRFlags.None);
void Export(ExportFormat exportFormat, System.Func <string, string> callback)
{
string extension = string.Empty;
switch (exportFormat)
{
case ExportFormat.kExr16:
case ExportFormat.kExr16ZIP:
case ExportFormat.kExr16RLE:
case ExportFormat.kExr32:
case ExportFormat.kExr32ZIP:
case ExportFormat.kExr32RLE:
{
extension = "exr";
break;
}
default: /* case ExportFormat.kPng: */
{
extension = "png";
break;
}
}
string path = callback?.Invoke(extension) ?? string.Empty;
if (string.IsNullOrEmpty(path) == false)
{
Texture2D texture = null;
switch (exportFormat)
{
case ExportFormat.kExr16:
case ExportFormat.kExr16ZIP:
case ExportFormat.kExr16RLE:
{
texture = new Texture2D(previewTexture.width, previewTexture.height, TextureFormat.RGBAHalf, false, false);
break;
}
case ExportFormat.kExr32:
case ExportFormat.kExr32ZIP:
case ExportFormat.kExr32RLE:
{
texture = new Texture2D(previewTexture.width, previewTexture.height, TextureFormat.RGBAFloat, false, false);
break;
}
default: /* case ExportFormat.kPng: */
{
texture = new Texture2D(previewTexture.width, previewTexture.height, TextureFormat.RGBA32, false, false);
break;
}
}
if (texture != null)
{
var current = RenderTexture.active;
RenderTexture.active = previewTexture;
texture.ReadPixels(new Rect(0, 0, previewTexture.width, previewTexture.height), 0, 0);
texture.Apply();
RenderTexture.active = current;
byte[] bytes = null;
if (exportFormat == ExportFormat.kPng)
{
bytes = texture.EncodeToPNG();
}
else
{
Texture2D.EXRFlags exrFlags = Texture2D.EXRFlags.None;
switch (exportFormat)
{
case ExportFormat.kExr16ZIP:
{
exrFlags |= Texture2D.EXRFlags.CompressZIP;
break;
}
case ExportFormat.kExr16RLE:
{
exrFlags |= Texture2D.EXRFlags.CompressRLE;
break;
}
case ExportFormat.kExr32:
{
exrFlags |= Texture2D.EXRFlags.OutputAsFloat;
break;
}
case ExportFormat.kExr32ZIP:
{
exrFlags |= Texture2D.EXRFlags.OutputAsFloat;
exrFlags |= Texture2D.EXRFlags.CompressZIP;
break;
}
case ExportFormat.kExr32RLE:
{
exrFlags |= Texture2D.EXRFlags.OutputAsFloat;
exrFlags |= Texture2D.EXRFlags.CompressRLE;
break;
}
}
bytes = ImageConversion.EncodeToEXR(texture, exrFlags);
}
Texture.DestroyImmediate(texture);
if (bytes != null)
{
System.IO.File.WriteAllBytes(path, bytes);
}
}
}
}
