Esempio n. 1
0
 private static RLEPacketType PacketType(Color32[] _arData, int _iPacketPosition)
 {
     if ((_iPacketPosition != _arData.Length - 1) && EncodeToTGAHelper.Equals(_arData[_iPacketPosition], _arData[_iPacketPosition + 1]))
     {
         return(RLEPacketType.RLE);
     }
     else
     {
         return(RLEPacketType.RAW);
     }
 }
Esempio n. 2
0
    internal void EndDevelop()
    {
#if UNITY_EDITOR
        if (null != depthCamera && null != depthCamera.targetTexture)
        {
            string path = EditorUtility.SaveFilePanel("保存图片", "assets", "", "tga");
            if (path.Length > 0)
            {
                depthCamera.ResetReplacementShader();
                depthCamera.Render();
                var old = RenderTexture.active;
                RenderTexture.active = depthCamera.targetTexture;
                Texture2D png = new Texture2D(depthCamera.targetTexture.width, depthCamera.targetTexture.height, TextureFormat.RGBA32, false);
                png.ReadPixels(new Rect(0, 0, depthCamera.targetTexture.width, depthCamera.targetTexture.height), 0, 0);

                depthCamera.SetReplacementShader(shader, "");
                depthCamera.Render();


                Texture2D png2 = new Texture2D(depthCamera.targetTexture.width, depthCamera.targetTexture.height, TextureFormat.RGBA32, false);
                png2.ReadPixels(new Rect(0, 0, depthCamera.targetTexture.width, depthCamera.targetTexture.height), 0, 0);
                Color [] c1s = png.GetPixels();
                Color[]  c2s = png2.GetPixels();
                for (int i = 0; i < c1s.Length; i++)
                {
                    Color c1 = c1s[i];
                    c1s[i] = new Color(c1.r, c1.g, c1.b, c2s[i].r);
                }
                png.SetPixels(c1s);

//#if UNITY_EDITOR

//#endif
                byte[] dataBytes = EncodeToTGAHelper.EncodeToTGA(png, 4);
                //byte[] dataBytes = png.EncodeToPNG();

                System.IO.File.WriteAllBytes(path, dataBytes);

                int index = path.IndexOf("/Assets/") + 1;
                path = path.Substring(index);

                AssetDatabase.ImportAsset(path);

                ModifyTextureFormat(path, "Standalone", TextureImporterFormat.RGBA32);
                ModifyTextureFormat(path, "iPhone", TextureImporterFormat.ASTC_RGBA_4x4);
                ModifyTextureFormat(path, "Android", TextureImporterFormat.ASTC_RGBA_4x4);

                sceneColorMark = AssetDatabase.LoadAssetAtPath <Texture>(path);


                RenderTexture.active = old;
            }

            if (develop)
            {
                Matrix4x4 biasMatrix = Matrix4x4.identity;
                biasMatrix[0, 0] = 0.5f;
                biasMatrix[1, 1] = 0.5f;
                biasMatrix[2, 2] = 0.5f;
                biasMatrix[0, 3] = 0.5f;
                biasMatrix[1, 3] = 0.5f;
                biasMatrix[2, 3] = 0.5f;
                Matrix4x4 depthProjectionMatrix = depthCamera.projectionMatrix;
                Matrix4x4 depthViewMatrix       = depthCamera.worldToCameraMatrix;
                Matrix4x4 depthVP = depthProjectionMatrix * depthViewMatrix;
                depthVPBias  = biasMatrix * depthVP;
                farClipPlane = depthCamera.farClipPlane;
            }

            farClipPlane              = depthCamera.farClipPlane;
            orthographicSize          = depthCamera.orthographicSize;
            cullingMask               = depthCamera.cullingMask;
            depthCamera.targetTexture = null;
            depthCamera.enabled       = false;
            depthCamera.hideFlags     = HideFlags.HideInInspector | HideFlags.DontSave;
        }



        develop = false;
#endif
    }
Esempio n. 3
0
    public static byte[] EncodeToTGA(this Texture2D _texture2D, int iBytesPerPixel, Compression _compression = Compression.RLE)
    {
        const int iTgaHeaderSize       = 18;
        const int iBytesPerPixelRGB24  = 3; // 1 byte per channel (rgb)
        const int iBytesPerPixelARGB32 = 4; // ~ (rgba)

        //int iBytesPerPixel = format == TextureFormat.ARGB32 || _texture2D.format == TextureFormat.RGBA32
        //    ? iBytesPerPixelARGB32
        //    : iBytesPerPixelRGB24;

        //

        using (MemoryStream memoryStream = new MemoryStream(iTgaHeaderSize + _texture2D.width * _texture2D.height * iBytesPerPixel))
        {
            using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
            {
                // Write TGA Header

                binaryWriter.Write((byte)0);                                           // IDLength (not in use)
                binaryWriter.Write((byte)0);                                           // ColorMapType (not in use)
                binaryWriter.Write((byte)(_compression == Compression.None ? 2 : 10)); // DataTypeCode (10 == Runlength encoded RGB images)
                binaryWriter.Write((short)0);                                          // ColorMapOrigin (not in use)
                binaryWriter.Write((short)0);                                          // ColorMapLength (not in use)
                binaryWriter.Write((byte)0);                                           // ColorMapDepth (not in use)
                binaryWriter.Write((short)0);                                          // Origin X
                binaryWriter.Write((short)0);                                          // Origin Y
                binaryWriter.Write((short)_texture2D.width);                           // Width
                binaryWriter.Write((short)_texture2D.height);                          // Height
                binaryWriter.Write((byte)(iBytesPerPixel * 8));                        // Bits Per Pixel
                binaryWriter.Write((byte)0);                                           // ImageDescriptor (not in use)

                Color32[] arPixels = _texture2D.GetPixels32();

                if (_compression == Compression.None)
                {
                    // Write all Pixels one after the other
                    for (int iPixel = 0; iPixel < arPixels.Length; iPixel++)
                    {
                        Color32 c32Pixel = arPixels[iPixel];
                        binaryWriter.Write(c32Pixel.b);
                        binaryWriter.Write(c32Pixel.g);
                        binaryWriter.Write(c32Pixel.r);

                        if (iBytesPerPixel == iBytesPerPixelARGB32)
                        {
                            binaryWriter.Write(c32Pixel.a);
                        }
                    }
                }
                else
                {
                    // Write RLE Encoded Pixels

                    const int iMaxPacketLength = 128;
                    int       iPacketStart     = 0;
                    int       iPacketEnd       = 0;

                    while (iPacketStart < arPixels.Length)
                    {
                        Color32 c32PreviousPixel = arPixels[iPacketStart];

                        // Get current Packet Type
                        RLEPacketType packetType = EncodeToTGAHelper.PacketType(arPixels, iPacketStart);

                        // Find Packet End
                        int iReadEnd = Mathf.Min(iPacketStart + iMaxPacketLength, arPixels.Length);
                        for (iPacketEnd = iPacketStart + 1; iPacketEnd < iReadEnd; ++iPacketEnd)
                        {
                            bool bPreviousEqualsCurrent = EncodeToTGAHelper.Equals(arPixels[iPacketEnd - 1], arPixels[iPacketEnd]);

                            // Packet End if change in Packet Type or if max Packet-Size reached
                            if (packetType == RLEPacketType.RAW && bPreviousEqualsCurrent ||
                                packetType == RLEPacketType.RLE && !bPreviousEqualsCurrent)
                            {
                                break;
                            }
                        }

                        // Write Packet

                        int iPacketLength = iPacketEnd - iPacketStart;

                        switch (packetType)
                        {
                        case RLEPacketType.RLE:

                            // Add RLE-Bit to PacketLength
                            binaryWriter.Write((byte)((iPacketLength - 1) | (1 << 7)));

                            binaryWriter.Write(c32PreviousPixel.b);
                            binaryWriter.Write(c32PreviousPixel.g);
                            binaryWriter.Write(c32PreviousPixel.r);

                            if (iBytesPerPixel == iBytesPerPixelARGB32)
                            {
                                binaryWriter.Write(c32PreviousPixel.a);
                            }

                            break;

                        case RLEPacketType.RAW:

                            binaryWriter.Write((byte)(iPacketLength - 1));

                            for (int iPacketPosition = iPacketStart; iPacketPosition < iPacketEnd; ++iPacketPosition)
                            {
                                Color32 c32Pixel = arPixels[iPacketPosition];
                                binaryWriter.Write(c32Pixel.b);
                                binaryWriter.Write(c32Pixel.g);
                                binaryWriter.Write(c32Pixel.r);

                                if (iBytesPerPixel == iBytesPerPixelARGB32)
                                {
                                    binaryWriter.Write(c32Pixel.a);
                                }
                            }

                            break;
                        }

                        iPacketStart = iPacketEnd;
                    }
                }

                binaryWriter.Write(0);               // Offset of meta-information (not in use)
                binaryWriter.Write(0);               // Offset of Developer-Area (not in use)
                binaryWriter.Write(c_arV2Signature); // ImageDescriptor (not in use)
            }

            return(memoryStream.ToArray());
        }
    }