public static Texture2D CreateClipMask(float[] heightMap, int size, float shoreLevel, TextureFormat format) { Texture2D mask = new Texture2D(size, size, format, false, true); mask.filterMode = FilterMode.Bilinear; int s2 = size * size; Color[] colors = new Color[s2]; for (int i = 0; i < s2; i++) { float h = Mathf.Clamp(heightMap[i] - shoreLevel, 0.0f, 1.0f); if (h > 0.0f) h = 1.0f; colors[i].r = h; colors[i].g = h; colors[i].b = h; colors[i].a = h; } mask.SetPixels(colors); mask.Apply(); return mask; }
public static Texture2D LoadTextureDXT( string path, TextureFormat format, bool mipmap = true ) { var a = Path.Combine( GenFilePaths.CoreModsFolderPath, LoadedModManager.LoadedMods.ToList().Find( s => s.name == "LT_RedistHeat" ).name ); var b = Path.Combine( a, "Textures" ); var filePath = Path.Combine( b, path + ".dds"); var bytes = File.ReadAllBytes( filePath ); if (format != TextureFormat.DXT1 && format != TextureFormat.DXT5) throw new Exception("Invalid TextureFormat. Only DXT1 and DXT5 formats are supported by this method."); var ddsSizeCheck = bytes[4]; if (ddsSizeCheck != 124) throw new Exception("Invalid DDS DXT texture. Unable to read"); //this header byte should be 124 for DDS image files var height = bytes[13] * 256 + bytes[12]; var width = bytes[17] * 256 + bytes[16]; var dxtBytes = new byte[bytes.Length - DDSHeaderSize]; Buffer.BlockCopy(bytes, DDSHeaderSize, dxtBytes, 0, bytes.Length - DDSHeaderSize); var texture = new Texture2D(width, height, format, mipmap); texture.LoadRawTextureData(dxtBytes); texture.Apply(); return (texture); }
public static uint GetPixelSize(TextureFormat textureFormat, int width, int height) { switch (textureFormat) { case TextureFormat.Rgba8: return (uint)(4 * width * height); case TextureFormat.Rgb8: return (uint)(3 * width * height); case TextureFormat.Rgb5551: case TextureFormat.Rgb565: case TextureFormat.Rgba4: case TextureFormat.La8: case TextureFormat.Hilo8: return (uint)(2 * width * height); case TextureFormat.L8: case TextureFormat.A8: case TextureFormat.La4: return (uint)(1 * width * height); case TextureFormat.L4: //TODO: Verify this is correct case TextureFormat.A4: return (uint)((1 * width * height) / 2); case TextureFormat.Etc1: return (uint)Etc.GetEtc1Length(new Size(width, height), false); case TextureFormat.Etc1A4: return (uint)Etc.GetEtc1Length(new Size(width, height), true); default: throw new Exception("Unsupported Texture Format " + (int)textureFormat); } }
public static void GetDXT(Texture2D texture, int i, byte[] bytes, TextureFormat format) { Color32[] colors = texture.GetPixels32(i); uint w = (uint) texture.width>>i; uint h = (uint) texture.height>>i; ColorBlock rgba = new ColorBlock(); BlockDXT1 block1 = new BlockDXT1(); BlockDXT5 block5 = new BlockDXT5(); int blocksize = format == TextureFormat.DXT1 ? 8 : 16; int index = 0; for (uint y = 0; y < h; y += 4) { for (uint x = 0; x < w; x += 4) { rgba.init(w, h, colors, x, y); if (format == TextureFormat.DXT1) { QuickCompress.compressDXT1(rgba, block1); block1.WriteBytes(bytes, index); } else { QuickCompress.compressDXT5(rgba, block5, 0); block5.WriteBytes(bytes, index); } index += blocksize; } } }
/// <summary> /// Creates a bitmap from the currently bound texture /// </summary> public static unsafe Bitmap CreateBitmapFromTexture( int target, int level, TextureFormat format ) { int width = GetTextureLevelParameterInt32( target, level, Gl.GL_TEXTURE_WIDTH ); int height = GetTextureLevelParameterInt32( target, level, Gl.GL_TEXTURE_HEIGHT ); GraphicsLog.Verbose( "Creating bitmap from level {0} in {1}x{2} {3} texture", level, width, height, format ); if ( ( format == TextureFormat.Depth16 ) || ( format == TextureFormat.Depth24 ) || ( format == TextureFormat.Depth32 ) ) { return CreateBitmapFromDepthTexture( target, level, width, height ); } // Handle colour textures // Get texture memory int bytesPerPixel = TextureFormatInfo.GetSizeInBytes( format ); TextureInfo info = CheckTextureFormat( format ); byte[] textureMemory = new byte[ width * height * bytesPerPixel ]; Gl.glGetTexImage( Gl.GL_TEXTURE_2D, level, info.GlFormat, info.GlType, textureMemory ); // TODO: Same problem as above... // Create a Bitmap object from image memory fixed ( byte* textureMemoryPtr = textureMemory ) { // TODO: Add per-case check of Format - in cases with no mapping (see TextureFormatToPixelFormat()), do a manual conversion return new Bitmap( width, height, width * bytesPerPixel, TextureFormatInfo.ToPixelFormat( format ), ( IntPtr )textureMemoryPtr ); } }
public void OpenTexture(Stream data, string fname, TextureFormat format) { Bitmap textureBitmap; Texture.Read(data, out textureBitmap, format); DisplayTexture(textureBitmap, fname, format); }
public static Texture3D LoadVolumeFromFile(string fileName, TextureFormat format, int elementSize ,int width, int height, int depth) { BinaryReader br = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read)); Texture3D noiseTex = new Texture3D(width, height, depth, TextureFormat.RGBA32, false); noiseTex.filterMode = FilterMode.Bilinear; noiseTex.wrapMode = TextureWrapMode.Repeat; int numElements = width * height * depth; List<Color> colors = new List<Color>(numElements); // Get pixels from 2d texture for each slize in z direction for (int z = 0; z < depth; z++) { Texture2D tex2d = LoadTexture2DRaw(br, width, height, format, elementSize); colors.AddRange(tex2d.GetPixels()); } //colors should now be filled with all pixels noiseTex.SetPixels(colors.ToArray()); noiseTex.Apply(false); br.Close(); return noiseTex; }
public Corona.Image ConvertDown(Corona.Image sourceImage, TextureFormat toFormat) { int bits = -1; if (toFormat == TextureFormat.Format2_I2) bits = 2; if (toFormat == TextureFormat.Format3_I4) bits = 4; if (toFormat == TextureFormat.Format4_I8) bits = 8; if (toFormat == TextureFormat.Format7_16bpp) bits = 16; int colors = 1<<bits; Corona.Image ret = null; using (Util.TempFile tmpIn = new Util.TempFile("png"), tmpOut = new Util.TempFile("png")) { sourceImage.Save(tmpIn.Path, Corona.FileFormat.PNG); string output = Run("-treedepth", 4, "-colors", colors, tmpIn, tmpOut); if (toFormat == TextureFormat.Format7_16bpp) ret = Corona.Image.Open(tmpOut.Path, Corona.PixelFormat.R8G8B8A8, Corona.FileFormat.PNG); else ret = Corona.Image.Open(tmpOut.Path, Corona.PixelFormat.I8, Corona.FileFormat.PNG); } return ret; }
/// <summary> /// Creates the texture data /// </summary> public void Create( int width, int height, TextureFormat format ) { m_Width = width; m_Height = height; m_Format = format; m_Data = new byte[ width * height * TextureFormatInfo.GetSizeInBytes( format ) ]; }
/// <summary> /// Generates a texture containing the given graph's noise output. /// If this is being called very often, create a permanent render target and material and /// use the other version of this method instead for much better performance. /// If an error occurred, outputs to the Unity debug console and returns "null". /// </summary> /// <param name="outputComponents"> /// The texture output. /// For example, pass "rgb" or "xyz" to output the noise into the red, green, and blue channels /// but not the alpha channel. /// </param> /// <param name="defaultColor"> /// The color (generally 0-1) of the color components which aren't set by the noise. /// </param> public static Texture2D GenerateToTexture(Graph g, GraphParamCollection c, int width, int height, string outputComponents, float defaultColor, TextureFormat format = TextureFormat.RGBAFloat) { //Generate a shader from the graph and have Unity compile it. string shaderPath = Path.Combine(Application.dataPath, "gpuNoiseShaderTemp.shader"); Shader shader = SaveShader(g, shaderPath, "TempGPUNoiseShader", outputComponents, defaultColor); if (shader == null) { return null; } //Render the shader's output into a render texture and copy the data to a Texture2D. RenderTexture target = new RenderTexture(width, height, 16, RenderTextureFormat.ARGBFloat); target.Create(); Texture2D resultTex = new Texture2D(width, height, format, false, true); //Create the material and set its parameters. Material mat = new Material(shader); c.SetParams(mat); GraphUtils.GenerateToTexture(target, mat, resultTex); //Clean up. target.Release(); if (!AssetDatabase.DeleteAsset(StringUtils.GetRelativePath(shaderPath, "Assets"))) { Debug.LogError("Unable to delete temp file: " + shaderPath); } return resultTex; }
public static byte[] GetScreenBytes(TextureFormat textureFormat) { Texture2D screenTexture = new Texture2D(Screen.width, Screen.height,textureFormat,true); screenTexture.ReadPixels(new Rect(0f, 0f, Screen.width, Screen.height),0,0); screenTexture.Apply(); byte[] byteArray = screenTexture.EncodeToPNG(); return byteArray; }
/// <summary> /// Initializes a new instance of the <see cref="Tango.YUVTexture"/> class. /// NOTE : Texture resolutions will be reset by the API. The sizes passed /// into the constructor are not guaranteed to persist when running on device. /// </summary> /// <param name="width">Width.</param> /// <param name="height">Height.</param> /// <param name="format">Format.</param> /// <param name="mipmap">If set to <c>true</c> mipmap.</param> public YUVTexture(int yPlaneWidth, int yPlaneHeight, int uvPlaneWidth, int uvPlaneHeight, TextureFormat format, bool mipmap) { m_videoOverlayTextureY = new Texture2D(yPlaneWidth, yPlaneHeight, format, mipmap); m_videoOverlayTextureCb = new Texture2D(uvPlaneWidth, uvPlaneHeight, format, mipmap); m_videoOverlayTextureCr = new Texture2D(uvPlaneWidth, uvPlaneHeight, format, mipmap); }
public TileMeshSettings (IVector2 tiles, int tileResolution, float tileSize, MeshMode meshMode, TextureFormat textureFormat) { Tiles = tiles; TileResolution = tileResolution; TileSize = tileSize; MeshMode = meshMode; TextureFormat = textureFormat; }
public Texture2DInfo(int width, int height, TextureFormat format, bool hasMipmaps, byte[] rawData) { this.width = width; this.height = height; this.format = format; this.hasMipmaps = hasMipmaps; this.rawData = rawData; }
public TileMeshSettings(int tilesX, int tilesY, int tileResolution, float tileSize, MeshMode meshMode, TextureFormat textureFormat) { TilesX = tilesX; TilesY = tilesY; TileResolution = tileResolution; TileSize = tileSize; MeshMode = meshMode; TextureFormat = textureFormat; }
public static int GetBitsPerPixel(TextureFormat format) { switch (format) { case TextureFormat.Alpha8: // Alpha-only texture format. return 8; case TextureFormat.ARGB4444: // A 16 bits/pixel texture format. Texture stores color with an alpha channel. return 16; case TextureFormat.RGBA4444: // A 16 bits/pixel texture format. return 16; case TextureFormat.RGB24: // A color texture format. return 24; case TextureFormat.RGBA32: //Color with an alpha channel texture format. return 32; case TextureFormat.ARGB32: //Color with an alpha channel texture format. return 32; case TextureFormat.RGB565: // A 16 bit color texture format. return 16; case TextureFormat.DXT1: // Compressed color texture format. return 4; case TextureFormat.DXT5: // Compressed color with alpha channel texture format. return 8; /* case TextureFormat.WiiI4: // Wii texture format. case TextureFormat.WiiI8: // Wii texture format. Intensity 8 bit. case TextureFormat.WiiIA4: // Wii texture format. Intensity + Alpha 8 bit (4 + 4). case TextureFormat.WiiIA8: // Wii texture format. Intensity + Alpha 16 bit (8 + 8). case TextureFormat.WiiRGB565: // Wii texture format. RGB 16 bit (565). case TextureFormat.WiiRGB5A3: // Wii texture format. RGBA 16 bit (4443). case TextureFormat.WiiRGBA8: // Wii texture format. RGBA 32 bit (8888). case TextureFormat.WiiCMPR: // Compressed Wii texture format. 4 bits/texel, ~RGB8A1 (Outline alpha is not currently supported). return 0; //Not supported yet */ case TextureFormat.PVRTC_RGB2:// PowerVR (iOS) 2 bits/pixel compressed color texture format. return 2; case TextureFormat.PVRTC_RGBA2:// PowerVR (iOS) 2 bits/pixel compressed with alpha channel texture format return 2; case TextureFormat.PVRTC_RGB4:// PowerVR (iOS) 4 bits/pixel compressed color texture format. return 4; case TextureFormat.PVRTC_RGBA4:// PowerVR (iOS) 4 bits/pixel compressed with alpha channel texture format return 4; case TextureFormat.ETC_RGB4:// ETC (GLES2.0) 4 bits/pixel compressed RGB texture format. return 4; case TextureFormat.ATC_RGB4:// ATC (ATITC) 4 bits/pixel compressed RGB texture format. return 4; case TextureFormat.ATC_RGBA8:// ATC (ATITC) 8 bits/pixel compressed RGB texture format. return 8; case TextureFormat.BGRA32:// Format returned by iPhone camera return 32; // case TextureFormat.ATF_RGB_DXT1:// Flash-specific RGB DXT1 compressed color texture format. // case TextureFormat.ATF_RGBA_JPG:// Flash-specific RGBA JPG-compressed color texture format. // case TextureFormat.ATF_RGB_JPG:// Flash-specific RGB JPG-compressed color texture format. // return 0; //Not supported yet } return 0; }
public void OpenTexture(Stream data, string fname, Stream paletteData, TextureFormat format) { Bitmap textureBitmap; TextureBase texture = Texture.GetModule(format); texture.PaletteStream = paletteData; texture.Read(data, out textureBitmap); DisplayTexture(textureBitmap, fname, format); }
/// <summary> /// Returns true if the specified texture format supports an alpha channel /// </summary> public static bool HasAlphaChannel( TextureFormat texFormat ) { switch ( texFormat ) { case TextureFormat.R8G8B8A8: case TextureFormat.B8G8R8A8: case TextureFormat.A8R8G8B8: case TextureFormat.A8B8G8R8: return true; } return false; }
public static bool getTextureFormat(ref TextureFormat result, SerializedObject serialTex) { if(serialTex == null) return false; SerializedProperty prop = serialTex.FindProperty("m_TextureFormat"); if( prop != null ) { result = (TextureFormat)prop.intValue; return true; } Debug.LogError("m_TextureFormat SerializedProperty not found!"); return false; }
// Load a texture with the specified height and calculating width by respecting the aspect ratio public static Texture2D LoadFixedHeightFromFile(string filePath, int fixedHeight, TextureFormat textureFormat = TextureFormat.R16) { Vector2 imageSize = ImageHelper.GetDimensions(filePath); float width = fixedHeight; if (imageSize.y != 0) { width = imageSize.x * fixedHeight / imageSize.y; } return LoadFromFile(filePath, (int)width, fixedHeight, textureFormat); }
public static IEnumerator LoadImage(this Texture2D texture2D, string url, Vector2 size, TextureFormat format = TextureFormat.RGB24, bool mipmap = false) { Texture2D tex = new Texture2D((int)size.x, (int)size.y, format, mipmap); WWW www = new WWW(url); yield return www; if (string.IsNullOrEmpty(www.error)) { www.LoadImageIntoTexture(tex); texture2D = tex; } }
/// <summary> /// Creates a texture instance /// </summary> /// <param name="_Name"></param> /// <param name="_Width"></param> /// <param name="_Height"></param> /// <param name="_Format"></param> /// <param name="_bUseMipMaps">Create mip maps for the texture</param> /// <param name="_FilterMode">Filter mode to use to sample the texture</param> /// <param name="_WrapMode">Wrap mode to use to address the texture</param> /// <returns></returns> public NuajTexture2D( string _Name, int _Width, int _Height, TextureFormat _Format, bool _bUseMipMaps, FilterMode _FilterMode, TextureWrapMode _WrapMode ) { Help.LogDebug( "Nuaj.Help.CreateTexture() \"" + _Name + "\" => " + _Width + "x" + _Height + "x" + _Format ); if ( _Width < 1 || _Height < 1 ) throw new Exception( "NuajTexture2D.ctor() => Invalid resolution !" ); m_Texture = new Texture2D( _Width, _Height, _Format, _bUseMipMaps ); m_Texture.name = _Name; m_Texture.filterMode = _FilterMode; m_Texture.wrapMode = _WrapMode; m_Texture.hideFlags = HideFlags.HideAndDontSave; }
public void create(int width, int height, TextureFormat texFormat = TextureFormat.ARGB32) { this.width = width; this.height = height; texture = new Texture2D(width, height, texFormat, false); if (texture == null) { PGraphics.debuglogWaring("create: new Texture2D <failed>"); return; } clear(new Color(0, 0, 0, 0)); }
public static IEnumerator LoadTexture2D(this Texture2D te, string url, Vector2 size, TextureFormat format = TextureFormat.RGB24, bool mipmap = false) { Texture2D tex = new Texture2D((int)size.x, (int)size.y, format, mipmap); //tex.name = "Demo"; WWW www = new WWW("file:///" + url); yield return www; Debug.Log(url); if (string.IsNullOrEmpty(www.error)) { www.LoadImageIntoTexture(tex); te = tex; } }
public void CompileTextures(string name, TextureFormat format = TextureFormat.RGBA32, Color defaultColor = default(Color), bool linear = false) { if(SystemInfo.supports2DArrayTextures) { UsingArray = true; BuildTextureArray(format, defaultColor, linear); } else { UsingArray = false; BuildAtlas(name, format, defaultColor, linear); } }
public ChannelTexture(int width, int height, TextureFormat format) { tex = new Texture2D(width, height, format, false); tex.wrapMode = TextureWrapMode.Clamp; //important for NPOT #if !((UNITY_ANDROID || UNITY_IPHONE) && !UNITY_EDITOR) pixels = tex.GetPixels32(0); handle = GCHandle.Alloc(pixels, GCHandleType.Pinned); #endif ReAlloc(); }
public bool Build(int width, int height, TextureFormat format = TextureFormat.RGBA32) { _width = width; _height = height; _format = format; if (CreateTexture()) { AVProLiveCameraPlugin.SetTexturePointer(_deviceIndex, _bufferIndex, _texture.GetNativeTexturePtr()); return true; } return false; }
/// <summary> /// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile. /// </summary> /// <param name="textureFormat">The desired type of format for the output texture</param> /// <param name="platform">The graphics platform</param> /// <param name="graphicsProfile">The graphics profile</param> /// <param name="textureSizeInput">The texture size input.</param> /// <param name="textureSizeRequested">The texture size requested.</param> /// <param name="generateMipmaps">Indicate if mipmaps should be generated for the output texture</param> /// <param name="logger">The logger.</param> /// <returns>true if the texture size is supported</returns> /// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception> public static Size2 FindBestTextureSize(TextureFormat textureFormat, GraphicsPlatform platform, GraphicsProfile graphicsProfile, Size2 textureSizeInput, Size2 textureSizeRequested, bool generateMipmaps, ILogger logger) { var textureSize = textureSizeRequested; // compressed DDS files has to have a size multiple of 4. if (platform == GraphicsPlatform.Direct3D11 && textureFormat == TextureFormat.Compressed && ((textureSizeRequested.Width % 4) != 0 || (textureSizeRequested.Height % 4) != 0)) { textureSize.Width = unchecked((int)(((uint)(textureSizeRequested.Width + 3)) & ~(uint)3)); textureSize.Height = unchecked((int)(((uint)(textureSizeRequested.Height + 3)) & ~(uint)3)); } var maxTextureSize = 0; // determine if the desired size if valid depending on the graphics profile switch (graphicsProfile) { case GraphicsProfile.Level_9_1: case GraphicsProfile.Level_9_2: case GraphicsProfile.Level_9_3: if (generateMipmaps && (!IsPowerOfTwo(textureSize.Width) || !IsPowerOfTwo(textureSize.Height))) { // TODO: TEMPORARY SETUP A MAX TEXTURE OF 1024. THIS SHOULD BE SPECIFIED DONE IN THE ASSET INSTEAD textureSize.Width = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Width), 1024); textureSize.Height = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Height), 1024); logger.Warning("Graphic profiles 9.1/9.2/9.3 do not support mipmaps with textures that are not power of 2. Asset is automatically resized to " + textureSize); } maxTextureSize = graphicsProfile >= GraphicsProfile.Level_9_3 ? 4096 : 2048; break; case GraphicsProfile.Level_10_0: case GraphicsProfile.Level_10_1: maxTextureSize = 8192; break; case GraphicsProfile.Level_11_0: case GraphicsProfile.Level_11_1: case GraphicsProfile.Level_11_2: maxTextureSize = 16384; break; default: throw new ArgumentOutOfRangeException("graphicsProfile"); } if (textureSize.Width > maxTextureSize || textureSize.Height > maxTextureSize) { logger.Error("Graphic profile {0} do not support texture with resolution {2} x {3} because it is larger than {1}. " + "Please reduce texture size or upgrade your graphic profile.", graphicsProfile, maxTextureSize, textureSize.Width, textureSize.Height); return new Size2(Math.Min(textureSize.Width, maxTextureSize), Math.Min(textureSize.Height, maxTextureSize)); } return textureSize; }
public static Texture2D LoadFromFile(string filePath, int width, int height, TextureFormat textureFormat = TextureFormat.R16) { // Load texture in memory byte[] fileData = File.ReadAllBytes(filePath); // Create texture for Unity and load it Texture2D texture = new Texture2D(2, 2, textureFormat, false); texture.LoadImage(fileData); // Resize the texture Resize(texture, width, height); return texture; }
/// <summary> /// Generic texture-building method. Creates a texture using a fuction that transforms float coordiantes (in the range [0,1]x[0,1]) into color /// </summary> ///<param name="width">Texture width.</param> ///<param name="height">Texture height</param> /// <param name="colorFunc">Function mapping coordinates to color</param> ///<param name="format">Texture format to use</param> ///<returns></returns> public static Texture Make (int width, int height, Func<float, float, Color> colorFunc, TextureFormat format) { Color[] cols = new Color[width * height]; for (int ii = 0; ii < width; ii++) { for (int jj = 0; jj < height; jj++) { cols [ii + jj * width] = colorFunc ((float)ii / width, (float)jj / height); } } var res = new Texture2D (width, height, format, false); res.SetPixels (cols, 0); res.Apply (); return res; }
public static void Sust(EmitterContext context) { OpCodeImage op = (OpCodeImage)context.CurrOp; SamplerType type = ConvertSamplerType(op.Dimensions); if (type == SamplerType.None) { context.Config.GpuAccessor.Log("Invalid image store sampler type."); return; } int raIndex = op.Ra.Index; int rbIndex = op.Rb.Index; Operand Ra() { if (raIndex > RegisterConsts.RegisterZeroIndex) { return(Const(0)); } return(context.Copy(Register(raIndex++, RegisterType.Gpr))); } Operand Rb() { if (rbIndex > RegisterConsts.RegisterZeroIndex) { return(Const(0)); } return(context.Copy(Register(rbIndex++, RegisterType.Gpr))); } List <Operand> sourcesList = new List <Operand>(); if (op.IsBindless) { sourcesList.Add(context.Copy(Register(op.Rc))); } int coordsCount = type.GetDimensions(); for (int index = 0; index < coordsCount; index++) { sourcesList.Add(Ra()); } if (Sample1DAs2D && (type & SamplerType.Mask) == SamplerType.Texture1D) { sourcesList.Add(Const(0)); type &= ~SamplerType.Mask; type |= SamplerType.Texture2D; } if (type.HasFlag(SamplerType.Array)) { sourcesList.Add(Ra()); type |= SamplerType.Array; } TextureFormat format = TextureFormat.Unknown; if (op.UseComponents) { int componentMask = (int)op.Components; for (int compMask = componentMask, compIndex = 0; compMask != 0; compMask >>= 1, compIndex++) { if ((compMask & 1) != 0) { sourcesList.Add(Rb()); } } if (!op.IsBindless) { format = context.Config.GetTextureFormat(op.HandleOffset); } } else { if (op.ByteAddress) { int xIndex = op.IsBindless ? 1 : 0; sourcesList[xIndex] = context.ShiftRightS32(sourcesList[xIndex], Const(GetComponentSizeInBytesLog2(op.Size))); } int components = GetComponents(op.Size); for (int compIndex = 0; compIndex < components; compIndex++) { sourcesList.Add(Rb()); } format = GetTextureFormat(op.Size); } Operand[] sources = sourcesList.ToArray(); int handle = !op.IsBindless ? op.HandleOffset : 0; TextureFlags flags = op.IsBindless ? TextureFlags.Bindless : TextureFlags.None; TextureOperation operation = context.CreateTextureOperation( Instruction.ImageStore, type, format, flags, handle, 0, null, sources); context.Add(operation); }
public static extern int GetRowBytesFromWidthAndFormat(int width, TextureFormat format);
public static extern void CompressTexture([NotNull] Texture2D texture, TextureFormat format, int quality);
public static extern void CompressCubemapTexture([NotNull] Cubemap texture, TextureFormat format, int quality);
private void OnGUI() { m_Scroll = GUILayout.BeginScrollView(m_Scroll); EditorGUILayout.LabelField("Resolution", EditorStyles.boldLabel); m_ResWidth = EditorGUILayout.IntField("Width", m_ResWidth); m_ResHeight = EditorGUILayout.IntField("Height", m_ResHeight); m_IsTransparent = EditorGUILayout.Toggle("Transparent Background", m_IsTransparent); m_Scale = EditorGUILayout.IntSlider("Scale", m_Scale, 1, 15); // Save Path control. float kButtonWidth = 60; Rect contentRect = EditorGUI.PrefixLabel(EditorGUILayout.GetControlRect(), new GUIContent("Save Path")); Rect textFieldRect = new Rect(contentRect.x, contentRect.y, contentRect.width - kButtonWidth, contentRect.height); Rect buttonRect = new Rect(textFieldRect.x + textFieldRect.width, textFieldRect.y, kButtonWidth, textFieldRect.height); EditorGUI.TextField(textFieldRect, m_Path); if (GUI.Button(buttonRect, "Browse")) { GetPath(); } // Camera m_ScreenshotCamera = EditorGUILayout.ObjectField("Camera", m_ScreenshotCamera, typeof(Camera), true) as Camera; if (m_ScreenshotCamera == null) { m_ScreenshotCamera = FindObjectOfType <Camera>(); } EditorGUILayout.LabelField("Default Options", EditorStyles.boldLabel); GUILayout.BeginHorizontal(); float halfButtonWidth = EditorGUIUtility.currentViewWidth / 2 - 6; // Screen Size button if (GUILayout.Button("Set To Screen Size", GUILayout.Width(halfButtonWidth))) { Vector2 gameView = Handles.GetMainGameViewSize(); m_ResWidth = (int)gameView.x; m_ResHeight = (int)gameView.y; } // Default Size button if (GUILayout.Button("Default Size", GUILayout.Width(halfButtonWidth))) { m_ResWidth = 2560; m_ResHeight = 1440; m_Scale = 1; } GUILayout.EndHorizontal(); // Screenshot resolution info. EditorGUILayout.Space(); EditorGUILayout.LabelField($"Screenshot will be taken at {m_ResWidth*m_Scale} x {m_ResHeight*m_Scale} px", EditorStyles.boldLabel); // Take Screenshot button. if (GUILayout.Button("Take Screenshot", GUILayout.MinHeight(60))) { if (m_Path == "" || !Directory.Exists(m_Path)) { m_Path = EditorUtility.SaveFolderPanel("Path to Save Images", m_Path, Application.dataPath); EditorPrefs.SetString(kPrefKey, m_Path); Debug.Log("Path Set"); } TakeHiResShot(); } EditorGUILayout.Space(); EditorGUILayout.BeginHorizontal(); // Open Last Screenshot button. GUI.enabled = m_LastScreenshot != ""; if (GUILayout.Button("Open Last Screenshot", GUILayout.MinHeight(40), GUILayout.Width(halfButtonWidth))) { Application.OpenURL("file://" + m_LastScreenshot); Debug.Log("Opening File " + m_LastScreenshot); } GUI.enabled = true; // Open Folder button. if (GUILayout.Button("Open Folder", GUILayout.MinHeight(40), GUILayout.Width(halfButtonWidth))) { Application.OpenURL("file://" + m_Path); } EditorGUILayout.EndHorizontal(); if (m_TakeHiResShot) { int resWidthN = m_ResWidth * m_Scale; int resHeightN = m_ResHeight * m_Scale; RenderTexture rt = new RenderTexture(resWidthN, resHeightN, 24); m_ScreenshotCamera.targetTexture = rt; TextureFormat tFormat = m_IsTransparent ? TextureFormat.ARGB32 : TextureFormat.RGB24; Texture2D screenShot = new Texture2D(resWidthN, resHeightN, tFormat, false); m_ScreenshotCamera.Render(); RenderTexture.active = rt; screenShot.ReadPixels(new Rect(0, 0, resWidthN, resHeightN), 0, 0); m_ScreenshotCamera.targetTexture = null; RenderTexture.active = null; byte[] bytes = screenShot.EncodeToPNG(); string filename = ScreenShotName(resWidthN, resHeightN); File.WriteAllBytes(filename, bytes); Debug.Log($"Took screenshot to: {filename}"); Application.OpenURL(filename); m_TakeHiResShot = false; } EditorGUILayout.HelpBox("Requires Unity Pro.", MessageType.Info); GUILayout.EndScrollView(); }
/// <summary> /// Creates and populates a duplicate skin with cloned attachments that are backed by a new packed texture atlas comprised of all the regions from the original skin.</summary> /// <remarks>No Spine.Atlas object is created so there is no way to find AtlasRegions except through the Attachments using them.</remarks> public static Skin GetRepackedSkin(this Skin o, string newName, Shader shader, out Material m, out Texture2D t, int maxAtlasSize = 1024, int padding = 2, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { var skinAttachments = o.Attachments; var newSkin = new Skin(newName); // Use these to detect and use shared regions. var existingRegions = new Dictionary <AtlasRegion, int>(); var regionIndexes = new List <int>(); // Collect all textures from the attachments of the original skin. var repackedAttachments = new List <Attachment>(); var texturesToPack = new List <Texture2D>(); var originalRegions = new List <AtlasRegion>(); int newRegionIndex = 0; foreach (var kvp in skinAttachments) { var newAttachment = kvp.Value.GetClone(true); if (IsRenderable(newAttachment)) { var region = newAttachment.GetAtlasRegion(); int existingIndex; if (existingRegions.TryGetValue(region, out existingIndex)) { regionIndexes.Add(existingIndex); // Store the region index for the eventual new attachment. } else { originalRegions.Add(region); texturesToPack.Add(region.ToTexture()); // Add the texture to the PackTextures argument existingRegions.Add(region, newRegionIndex); // Add the region to the dictionary of known regions regionIndexes.Add(newRegionIndex); // Store the region index for the eventual new attachment. newRegionIndex++; } repackedAttachments.Add(newAttachment); } var key = kvp.Key; newSkin.AddAttachment(key.slotIndex, key.name, newAttachment); } // Fill a new texture with the collected attachment textures. var newTexture = new Texture2D(maxAtlasSize, maxAtlasSize, textureFormat, mipmaps); newTexture.anisoLevel = texturesToPack[0].anisoLevel; newTexture.name = newName; var rects = newTexture.PackTextures(texturesToPack.ToArray(), padding, maxAtlasSize); // Rehydrate the repacked textures as a Material, Spine atlas and Spine.AtlasAttachments var newMaterial = new Material(shader); newMaterial.name = newName; newMaterial.mainTexture = newTexture; var page = newMaterial.ToSpineAtlasPage(); page.name = newName; var repackedRegions = new List <AtlasRegion>(); for (int i = 0, n = originalRegions.Count; i < n; i++) { var oldRegion = originalRegions[i]; var newRegion = UVRectToAtlasRegion(rects[i], oldRegion.name, page, oldRegion.offsetX, oldRegion.offsetY, oldRegion.rotate); repackedRegions.Add(newRegion); } // Map the cloned attachments to the repacked atlas. for (int i = 0, n = repackedAttachments.Count; i < n; i++) { var a = repackedAttachments[i]; a.SetRegion(repackedRegions[regionIndexes[i]]); } // Clean up foreach (var ttp in texturesToPack) { UnityEngine.Object.Destroy(ttp); } t = newTexture; m = newMaterial; return(newSkin); }
public static extern int GetBytesFromTextureFormat(TextureFormat inFormat);
public Texture2D(ObjectReader reader) : base(reader) { m_Width = reader.ReadInt32(); m_Height = reader.ReadInt32(); var m_CompleteImageSize = reader.ReadInt32(); if (version[0] >= 2020) //2020.1 and up { var m_MipsStripped = reader.ReadInt32(); } m_TextureFormat = (TextureFormat)reader.ReadInt32(); if (version[0] < 5 || (version[0] == 5 && version[1] < 2)) //5.2 down { m_MipMap = reader.ReadBoolean(); } else { m_MipCount = reader.ReadInt32(); } if (version[0] > 2 || (version[0] == 2 && version[1] >= 6)) //2.6.0 and up { var m_IsReadable = reader.ReadBoolean(); } if (version[0] >= 2020) //2020.1 and up { var m_IsPreProcessed = reader.ReadBoolean(); } if (version[0] > 2019 || (version[0] == 2019 && version[1] >= 3)) //2019.3 and up { var m_IgnoreMasterTextureLimit = reader.ReadBoolean(); } if (version[0] >= 3) //3.0.0 - 5.4 { if (version[0] < 5 || (version[0] == 5 && version[1] <= 4)) { var m_ReadAllowed = reader.ReadBoolean(); } } if (version[0] > 2018 || (version[0] == 2018 && version[1] >= 2)) //2018.2 and up { var m_StreamingMipmaps = reader.ReadBoolean(); } reader.AlignStream(); if (version[0] > 2018 || (version[0] == 2018 && version[1] >= 2)) //2018.2 and up { var m_StreamingMipmapsPriority = reader.ReadInt32(); } var m_ImageCount = reader.ReadInt32(); var m_TextureDimension = reader.ReadInt32(); m_TextureSettings = new GLTextureSettings(reader); if (version[0] >= 3) //3.0 and up { var m_LightmapFormat = reader.ReadInt32(); } if (version[0] > 3 || (version[0] == 3 && version[1] >= 5)) //3.5.0 and up { var m_ColorSpace = reader.ReadInt32(); } if (version[0] > 2020 || (version[0] == 2020 && version[1] >= 2)) //2020.2 and up { var m_PlatformBlob = reader.ReadUInt8Array(); reader.AlignStream(); } var image_data_size = reader.ReadInt32(); if (image_data_size == 0 && ((version[0] == 5 && version[1] >= 3) || version[0] > 5))//5.3.0 and up { m_StreamData = new StreamingInfo(reader); } ResourceReader resourceReader; if (!string.IsNullOrEmpty(m_StreamData?.path)) { resourceReader = new ResourceReader(m_StreamData.path, assetsFile, m_StreamData.offset, (int)m_StreamData.size); } else { resourceReader = new ResourceReader(reader, reader.BaseStream.Position, image_data_size); } image_data = resourceReader; }
public static RegionAttachment ToRegionAttachmentPMAClone(this Sprite sprite, Shader shader, TextureFormat textureFormat = TextureFormat.RGBA32, bool mipmaps = false, Material materialPropertySource = null) { if (sprite == null) { throw new ArgumentNullException("sprite"); } if (shader == null) { throw new ArgumentNullException("shader"); } AtlasRegion region = sprite.ToAtlasRegionPMAClone(shader, textureFormat, mipmaps, materialPropertySource); float scale = 1f / sprite.pixelsPerUnit; return(region.ToRegionAttachment(sprite.name, scale)); }
public static RegionAttachment ToRegionAttachmentPMAClone(this Sprite sprite, Material materialPropertySource, TextureFormat textureFormat = TextureFormat.RGBA32, bool mipmaps = false) { return(sprite.ToRegionAttachmentPMAClone(materialPropertySource.shader, textureFormat, mipmaps, materialPropertySource)); }
public virtual bool SupportsTextureFormat(TextureFormat format) { return(EditorSystemInfo.SupportsTextureFormat(format)); }
int GetBitsPerPixel(TextureFormat format) { switch (format) { case TextureFormat.Alpha8: // Alpha-only texture format. return(8); case TextureFormat.ARGB4444: // A 16 bits/pixel texture format. Texture stores color with an alpha channel. return(16); case TextureFormat.RGBA4444: // A 16 bits/pixel texture format. return(16); case TextureFormat.RGB24: // A color texture format. return(24); case TextureFormat.RGBA32: //Color with an alpha channel texture format. return(32); case TextureFormat.ARGB32: //Color with an alpha channel texture format. return(32); case TextureFormat.RGB565: // A 16 bit color texture format. return(16); case TextureFormat.DXT1: // Compressed color texture format. return(4); case TextureFormat.DXT5: // Compressed color with alpha channel texture format. return(8); /* * case TextureFormat.WiiI4: // Wii texture format. * case TextureFormat.WiiI8: // Wii texture format. Intensity 8 bit. * case TextureFormat.WiiIA4: // Wii texture format. Intensity + Alpha 8 bit (4 + 4). * case TextureFormat.WiiIA8: // Wii texture format. Intensity + Alpha 16 bit (8 + 8). * case TextureFormat.WiiRGB565: // Wii texture format. RGB 16 bit (565). * case TextureFormat.WiiRGB5A3: // Wii texture format. RGBA 16 bit (4443). * case TextureFormat.WiiRGBA8: // Wii texture format. RGBA 32 bit (8888). * case TextureFormat.WiiCMPR: // Compressed Wii texture format. 4 bits/texel, ~RGB8A1 (Outline alpha is not currently supported). * return 0; //Not supported yet */ case TextureFormat.PVRTC_RGB2: // PowerVR (iOS) 2 bits/pixel compressed color texture format. return(2); case TextureFormat.PVRTC_RGBA2: // PowerVR (iOS) 2 bits/pixel compressed with alpha channel texture format return(2); case TextureFormat.PVRTC_RGB4: // PowerVR (iOS) 4 bits/pixel compressed color texture format. return(4); case TextureFormat.PVRTC_RGBA4: // PowerVR (iOS) 4 bits/pixel compressed with alpha channel texture format return(4); case TextureFormat.ETC_RGB4: // ETC (GLES2.0) 4 bits/pixel compressed RGB texture format. return(4); case TextureFormat.ATC_RGB4: // ATC (ATITC) 4 bits/pixel compressed RGB texture format. return(4); case TextureFormat.ATC_RGBA8: // ATC (ATITC) 8 bits/pixel compressed RGB texture format. return(8); case TextureFormat.BGRA32: // Format returned by iPhone camera return(32); #if !UNITY_5 case TextureFormat.ATF_RGB_DXT1: // Flash-specific RGB DXT1 compressed color texture format. case TextureFormat.ATF_RGBA_JPG: // Flash-specific RGBA JPG-compressed color texture format. case TextureFormat.ATF_RGB_JPG: // Flash-specific RGB JPG-compressed color texture format. return(0); //Not supported yet #endif } return(0); }
private static void Internal_Create([Writable] Texture3D mono, int w, int h, int d, TextureFormat format, bool mipmap) { if (!Texture3D.Internal_CreateImpl(mono, w, h, d, format, mipmap)) { throw new UnityException("Failed to create texture because of invalid parameters."); } }
/// <summary> /// Extracts a DDS file's texture format and pixel data. /// </summary> private static void ExtractDDSTextureFormatAndData(DDSHeader header, UnityBinaryReader reader, out bool hasMipmaps, out uint DDSMipmapLevelCount, out TextureFormat textureFormat, out int bytesPerPixel, out byte[] textureData) { hasMipmaps = Utils.ContainsBitFlags(header.dwCaps, (uint)DDSCaps.Mipmap); hasMipmaps = hasMipmaps || header.dwMipMapCount > 1; // Non-mipmapped textures still have one mipmap level: the texture itself. DDSMipmapLevelCount = hasMipmaps ? header.dwMipMapCount : 1; // If the DDS file contains uncompressed data. if (Utils.ContainsBitFlags(header.pixelFormat.flags, (uint)DDSPixelFormatFlags.RGB)) { // some permutation of RGB if (!Utils.ContainsBitFlags(header.pixelFormat.flags, (uint)DDSPixelFormatFlags.AlphaPixels)) { throw new NotImplementedException("Unsupported DDS file pixel format."); } // some permutation of RGBA else { // There should be 32 bits per pixel. if (header.pixelFormat.RGBBitCount != 32) { throw new FileFormatException("Invalid DDS file pixel format."); } // BGRA32 if ((header.pixelFormat.BBitMask == 0x000000FF) && (header.pixelFormat.GBitMask == 0x0000FF00) && (header.pixelFormat.RBitMask == 0x00FF0000) && (header.pixelFormat.ABitMask == 0xFF000000)) { textureFormat = TextureFormat.BGRA32; bytesPerPixel = 4; } // ARGB32 else if ((header.pixelFormat.ABitMask == 0x000000FF) && (header.pixelFormat.RBitMask == 0x0000FF00) && (header.pixelFormat.GBitMask == 0x00FF0000) && (header.pixelFormat.BBitMask == 0xFF000000)) { textureFormat = TextureFormat.ARGB32; bytesPerPixel = 4; } else { throw new NotImplementedException("Unsupported DDS file pixel format."); } if (!hasMipmaps) { textureData = new byte[header.dwPitchOrLinearSize * header.dwHeight]; } else { // Create a data buffer to hold all mipmap levels down to 1x1. textureData = new byte[TextureUtils.CalculateMipMappedTextureDataSize((int)header.dwWidth, (int)header.dwHeight, bytesPerPixel)]; } reader.ReadRestOfBytes(textureData, 0); } } else if (StringUtils.Equals(header.pixelFormat.fourCC, "DXT1")) { textureFormat = TextureFormat.ARGB32; bytesPerPixel = 4; var compressedTextureData = reader.ReadRestOfBytes(); textureData = DecodeDXT1ToARGB(compressedTextureData, header.dwWidth, header.dwHeight, header.pixelFormat, DDSMipmapLevelCount); } else if (StringUtils.Equals(header.pixelFormat.fourCC, "DXT3")) { textureFormat = TextureFormat.ARGB32; bytesPerPixel = 4; var compressedTextureData = reader.ReadRestOfBytes(); textureData = DecodeDXT3ToARGB(compressedTextureData, header.dwWidth, header.dwHeight, header.pixelFormat, DDSMipmapLevelCount); } else if (StringUtils.Equals(header.pixelFormat.fourCC, "DXT5")) { textureFormat = TextureFormat.ARGB32; bytesPerPixel = 4; var compressedTextureData = reader.ReadRestOfBytes(); textureData = DecodeDXT5ToARGB(compressedTextureData, header.dwWidth, header.dwHeight, header.pixelFormat, DDSMipmapLevelCount); } else { throw new NotImplementedException("Unsupported DDS file pixel format."); } }
/// <summary>Creates a new Texture2D object based on an AtlasRegion. /// If applyImmediately is true, Texture2D.Apply is called immediately after the Texture2D is filled with data.</summary> public static Texture2D ToTexture(this AtlasRegion ar, bool applyImmediately = true, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { Texture2D sourceTexture = ar.GetMainTexture(); Rect r = ar.GetUnityRect(sourceTexture.height); int width = (int)r.width; int height = (int)r.height; Texture2D output = new Texture2D(width, height, textureFormat, mipmaps); output.name = ar.name; Color[] pixelBuffer = sourceTexture.GetPixels((int)r.x, (int)r.y, width, height); output.SetPixels(pixelBuffer); if (applyImmediately) { output.Apply(); } return(output); }
/// <summary> /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data.</summary> public static AtlasRegion ToAtlasRegionPMAClone(this Texture2D t, Shader shader, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { var material = new Material(shader); var newTexture = t.GetClone(false, textureFormat, mipmaps); newTexture.ApplyPMA(true); newTexture.name = t.name + "-pma-"; material.name = t.name + shader.name; material.mainTexture = newTexture; var page = material.ToSpineAtlasPage(); var region = newTexture.ToAtlasRegion(shader); region.page = page; return(region); }
public static extern bool IsValidTextureFormat(TextureFormat format);
public static extern bool ReformatTexture([NotNull("NullExceptionObject")] ref Texture2D texture, int width, int height, TextureFormat textureFormat, bool useMipmap, bool linear);
/// <summary> /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data.</summary> public static AtlasRegion ToAtlasRegionPMAClone(this Sprite s, Shader shader, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { var material = new Material(shader); var tex = s.ToTexture(false, textureFormat, mipmaps); tex.ApplyPMA(true); tex.name = s.name + "-pma-"; material.name = tex.name + shader.name; material.mainTexture = tex; var page = material.ToSpineAtlasPage(); var region = s.ToAtlasRegion(true); region.page = page; return(region); }
public static extern bool IsCompressedTextureFormat(TextureFormat format);
/// <summary> /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate texture of the Sprite's texture data. Returns a RegionAttachment that uses it. Use this if you plan to use a premultiply alpha shader such as "Spine/Skeleton"</summary> public static RegionAttachment ToRegionAttachmentPMAClone(this Sprite sprite, Shader shader, TextureFormat textureFormat = SpriteAtlasRegionExtensions.SpineTextureFormat, bool mipmaps = SpriteAtlasRegionExtensions.UseMipMaps) { if (sprite == null) { throw new System.ArgumentNullException("sprite"); } if (shader == null) { throw new System.ArgumentNullException("shader"); } var region = sprite.ToAtlasRegionPMAClone(shader, textureFormat, mipmaps); var unitsPerPixel = 1f / sprite.pixelsPerUnit; return(region.ToRegionAttachment(sprite.name, unitsPerPixel)); }
public PlanarReflectionProbeCache(HDRenderPipelineAsset hdAsset, IBLFilterGGX iblFilter, int cacheSize, int probeSize, TextureFormat probeFormat, bool isMipmaped) { m_ConvertTextureMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.blitCubeTextureFace); m_ConvertTextureMPB = new MaterialPropertyBlock(); // BC6H requires CPP feature not yet available probeFormat = TextureFormat.RGBAHalf; Debug.Assert(probeFormat == TextureFormat.BC6H || probeFormat == TextureFormat.RGBAHalf, "Reflection Probe Cache format for HDRP can only be BC6H or FP16."); m_ProbeSize = probeSize; m_CacheSize = cacheSize; m_TextureCache = new TextureCache2D("PlanarReflectionProbe"); m_TextureCache.AllocTextureArray(cacheSize, probeSize, probeSize, probeFormat, isMipmaped); m_IBLFilterGGX = iblFilter; m_PerformBC6HCompression = probeFormat == TextureFormat.BC6H; InitializeProbeBakingStates(); }
public Texture3D(int width, int height, int depth, TextureFormat format, bool mipmap) { Texture3D.Internal_Create(this, width, height, depth, format, mipmap); }
public static extern bool ReformatCubemap([NotNull("NullExceptionObject")] Cubemap cubemap, int width, int height, TextureFormat textureFormat, bool useMipmap, bool linear);
/// <summary> /// Determines whether a given /// [`TextureFormat`](https://docs.unity3d.com/ScriptReference/TextureFormat.html) is supported for image /// conversion. /// </summary> /// <param name="image">The <see cref="XRCpuImage"/> to convert.</param> /// <param name="format">The [`TextureFormat`](https://docs.unity3d.com/ScriptReference/TextureFormat.html) /// to test.</param> /// <returns>Returns `true` if <paramref name="image"/> can be converted to <paramref name="format"/>. /// Returns `false` otherwise.</returns> public virtual bool FormatSupported(XRCpuImage image, TextureFormat format) => false;
private static extern bool Internal_CreateImpl([Writable] Texture3D mono, int w, int h, int d, TextureFormat format, bool mipmap);
public static Sprite Load9SliceSprite(string path, RectOffset slices, Vector2 pivot = new Vector2(), TextureFormat format = TextureFormat.BC7, float pixelsPerUnit = 100f, SpriteMeshType spriteType = SpriteMeshType.Tight) { string spriteKey = path + slices; if (spriteCache.TryGetValue(spriteKey, out Sprite foundSprite)) { return(foundSprite); } Texture2D texture2D = SMLHelper.V2.Utility.ImageUtils.LoadTextureFromFile(path, format); if (!texture2D) { return(null); } var border = new Vector4(slices.left, slices.right, slices.top, slices.bottom); Sprite sprite = TextureToSprite(texture2D, pivot, pixelsPerUnit, spriteType, border); spriteCache.Add(spriteKey, sprite); return(sprite); }
/// <summary> /// Method to be implemented by the provider to get the number of bytes required to store an image with the /// given dimensions and <c>TextureFormat</c>. /// </summary> /// <param name="nativeHandle">A unique identifier for the camera image to convert.</param> /// <param name="dimensions">The dimensions of the output image.</param> /// <param name="format">The <c>TextureFormat</c> for the image.</param> /// <param name="size">The number of bytes required to store the converted image.</param> /// <returns><c>true</c> if the output <paramref name="size"/> was set.</returns> /// <exception cref="System.NotSupportedException">Thrown if the implementation does not support camera image conversion.</exception> public virtual bool TryGetConvertedDataSize(int nativeHandle, Vector2Int dimensions, TextureFormat format, out int size) { throw new NotSupportedException("Camera image conversion is not supported by this implementation"); }
private static extern void Internal_Create([Writable] Texture3D mono, int width, int height, int depth, TextureFormat format, bool mipmap);
public override void OnImportAsset(AssetImportContext ctx) { ctx.DependsOnCustomDependency("HLODSystemPlatform"); var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(ctx.selectedBuildTarget); try { UpdateProgress(ctx.assetPath, 0, 1); using (Stream stream = new FileStream(ctx.assetPath, FileMode.Open, FileAccess.Read)) { HLODData data = HLODDataSerializer.Read(stream); RootData rootData = RootData.CreateInstance <RootData>(); TextureFormat compressFormat = GetCompressFormat(data, buildTargetGroup); int currentProgress = 0; int maxProgress = 0; if (data.GetMaterials() != null) { maxProgress += data.GetMaterials().Count; } if (data.GetObjects() != null) { maxProgress += data.GetObjects().Count; } if (data.GetColliders() != null) { maxProgress += data.GetColliders().Count; } rootData.name = "Root"; var serializableMaterials = data.GetMaterials(); var loadedMaterials = new Dictionary <string, Material>(); if (serializableMaterials != null) { for (int mi = 0; mi < serializableMaterials.Count; ++mi) { UpdateProgress(ctx.assetPath, currentProgress++, maxProgress); var sm = serializableMaterials[mi]; if (loadedMaterials.ContainsKey(sm.ID)) { continue; } Material mat = sm.To(); loadedMaterials.Add(sm.ID, mat); if (string.IsNullOrEmpty(AssetDatabase.GetAssetPath(mat)) == false) { continue; } ctx.AddObjectToAsset(mat.name, mat); for (int ti = 0; ti < sm.GetTextureCount(); ++ti) { HLODData.SerializableTexture st = sm.GetTexture(ti); Texture2D texture = st.To(); EditorUtility.CompressTexture(texture, compressFormat, TextureCompressionQuality.Normal); mat.SetTexture(st.Name, texture); ctx.AddObjectToAsset(texture.name, texture); } mat.EnableKeyword("_NORMALMAP"); } } var serializableObjects = data.GetObjects(); var serializableColliders = data.GetColliders(); Dictionary <string, List <GameObject> > createdGameObjects = new Dictionary <string, List <GameObject> >(); Dictionary <string, GameObject> createdColliders = new Dictionary <string, GameObject>(); if (serializableObjects != null) { for (int oi = 0; oi < serializableObjects.Count; ++oi) { UpdateProgress(ctx.assetPath, currentProgress++, maxProgress); var so = serializableObjects[oi]; GameObject go = new GameObject(); go.name = so.Name; MeshFilter mf = go.AddComponent <MeshFilter>(); MeshRenderer mr = go.AddComponent <MeshRenderer>(); List <string> materialIds = so.GetMaterialIds(); List <Material> materials = new List <Material>(); for (int mi = 0; mi < materialIds.Count; ++mi) { string id = materialIds[mi]; if (loadedMaterials.ContainsKey(id)) { materials.Add(loadedMaterials[id]); } else { string path = AssetDatabase.GUIDToAssetPath(id); if (string.IsNullOrEmpty(path) == false) { materials.Add(AssetDatabase.LoadAssetAtPath <Material>(path)); } else { materials.Add(null); } } } Mesh mesh = so.GetMesh().To(); mf.sharedMesh = mesh; mr.sharedMaterials = materials.ToArray(); ctx.AddObjectToAsset(mesh.name, mesh); if (createdGameObjects.ContainsKey(go.name) == false) { createdGameObjects.Add(go.name, new List <GameObject>()); } createdGameObjects[go.name].Add(go); } } if (serializableColliders != null) { for (int ci = 0; ci < serializableColliders.Count; ++ci) { UpdateProgress(ctx.assetPath, currentProgress++, maxProgress); var sc = serializableColliders[ci]; GameObject go; if (createdColliders.ContainsKey(sc.Name) == false) { createdColliders[sc.Name] = new GameObject("Collider"); } go = createdColliders[sc.Name]; var collider = sc.CreateGameObject(); if (collider != null) { collider.name = "Collider" + ci; collider.transform.SetParent(go.transform, true); } } } foreach (var objects in createdGameObjects.Values) { GameObject root; if (objects.Count > 1) { root = new GameObject(); root.name = objects[0].name; for (int i = 0; i < objects.Count; ++i) { objects[i].name = objects[i].name + "_" + i; objects[i].transform.SetParent(root.transform, true); } } else { root = objects[0]; } if (createdColliders.ContainsKey(root.name)) { createdColliders[root.name].transform.SetParent(root.transform, true); } rootData.SetRootObject(root.name, root); ctx.AddObjectToAsset(root.name, root); } ctx.AddObjectToAsset("Root", rootData); ctx.SetMainObject(rootData); } } finally { EditorUtility.ClearProgressBar(); } }