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); } } } }