예제 #1
0
        void RawTexture()
        {
            int     xyMax = 512;
            SSTimer ss    = new SSTimer("合图raw方式");

            Rect[] rec = new Rect[4];
            rec[0].xMin = 0; rec[0].xMax = 0.5f; rec[0].yMin = 0; rec[0].yMax = 0.5f;
            rec[1].xMin = 0.5f; rec[1].xMax = 1f; rec[1].yMin = 0f; rec[1].yMax = 0.5f;
            rec[2].xMin = 0f; rec[2].xMax = 0.5f; rec[2].yMin = 0.5f; rec[2].yMax = 1f;
            rec[3].xMin = 0.5f; rec[3].xMax = 1; rec[3].yMin = 0.5f; rec[3].yMax = 1f;
            //mergeTxMgr.Instance.getBlcokBytes(texture2s[0], 512);
            //mergeTxMgr.Instance.getBlcokBytes(texture2s[1], 512);
            //mergeTxMgr.Instance.getBlcokBytes(texture2s[2], 512);
            int blockByte = mergeTxMgr.Instance.getBlcokBytes(texture2s[3], 512);

            mergeTxMgr.Instance.getByteInTx(rec[0].xMin, rec[0].yMin, mergeTxMgr.Instance.data, blockByte, xyMax, texture2s[0]);
            mergeTxMgr.Instance.getByteInTx(rec[1].xMin, rec[1].yMin, mergeTxMgr.Instance.data, blockByte, xyMax, texture2s[1]);
            mergeTxMgr.Instance.getByteInTx(rec[2].xMin, rec[2].yMin, mergeTxMgr.Instance.data, blockByte, xyMax, texture2s[2]);
            mergeTxMgr.Instance.getByteInTx(rec[3].xMin, rec[3].yMin, mergeTxMgr.Instance.data, blockByte, xyMax, texture2s[3]);
            ss.Dispose();
            outTexture      = new Texture2D(xyMax, xyMax, texture2s[0].format, false);
            outTexture.name = "raw__texture__512X512";
            outTexture.LoadRawTextureData(mergeTxMgr.Instance.data);
            outTexture.Apply(false, true);
        }
예제 #2
0
        void Blit()
        {
            SSTimer ss = new SSTimer("合图Blit方式");

            outTexture           = new RenderTexture(512, 512, 0, RenderTextureFormat.ARGB32);
            outTexture.name      = "blit___texture_512X512";
            outTexture.useMipMap = true;

            var lastTarget = RenderTexture.active;

            RenderTexture.active = outTexture;

            GL.Clear(true, true, Color.clear);
            Vector4 textST = new Vector4();

            for (int i = 0; i < rects.Length; i++)
            {
                Rect  r  = rects[i];
                float tw = texture2s[i].width * totalScale;
                float th = texture2s[i].height * totalScale;
                textST.x = MaxAtlasSize / tw;
                textST.y = MaxAtlasSize / th;
                textST.z = -r.x / MaxAtlasSize * textST.x;
                textST.w = -r.y / MaxAtlasSize * textST.y;
                rendererMaterial.SetVector("_Tex_ST", textST);
                textST.x = textST.y = r.width / tw / 2;
                textST.z = textST.w = r.height / th / 2;
                rendererMaterial.SetVector("_Rect", textST);
                r.Set(r.x / MaxAtlasSize, r.y / MaxAtlasSize, tw / MaxAtlasSize, th / MaxAtlasSize);
                //rects[i] = r;
                rendererMaterial.mainTexture = texture2s[i];
                Graphics.Blit(texture2s[i], rendererMaterial);
            }
            RenderTexture.active = lastTarget;
            ss.Dispose();
        }
예제 #3
0
        /** 合并蒙皮,合并纹理
         *  纹理需要打开读写
         */
        void CombineObject(GameObject skeleton, int combine_size)
        {
            if (combineHolderList == null || combineHolderList.Count == 0)
            {
                return;
            }

            List <Transform> transforms = new List <Transform>();

            CollectionTransforms(skeleton.transform, ref transforms);

            List <Transform> bones = new List <Transform>();

            string   flag        = "hair-?_clothes-?_pants-?_shoes-?";
            Material newMaterial = null;

            Mesh shaderMesh = null;
            List <CombineInstance>    combineInstances = new List <CombineInstance>();
            List <Vector2[]>          oldUV            = new List <Vector2[]>();
            List <Material>           materials        = new List <Material>();
            SkinnedMeshCombinerHolder holder           = null;

            for (int i = 0; i < combineHolderList.Count; i++)
            {
                holder = combineHolderList[i];
                CombineInstance ci = new CombineInstance();
                ci.mesh         = holder.mesh;
                ci.subMeshIndex = 0;
                combineInstances.Add(ci);
                materials.Add(holder.material);

                for (int j = 0; j < holder.stringHolder.content.Length; j++)
                {
                    int tBase = 0;
                    for (tBase = 0; tBase < transforms.Count; tBase++)
                    {
                        if (holder.stringHolder.content[j].Equals(transforms[tBase].name))
                        {
                            bones.Add(transforms[tBase]);
                            break;
                        }
                    }
                }
            }

            List <Texture2D> Textures = new List <Texture2D>();
            TextureFormat    format   = TextureFormat.RGBA32;

            for (int i = 0; i < materials.Count; i++)
            {
                Textures.Add(materials[i].GetTexture(COMBINE_DIFFUSE_TEXTURE) as Texture2D);
            }
            format      = Textures[0].format;
            newMaterial = UnityEngine.Object.Instantiate(materials[0]);

            newMaterial.name = flag;
            Texture2D newDiffuseTex = null;

            SSTimer ss = new SSTimer("合图Pack方式");

            newDiffuseTex           = new Texture2D(combine_size, combine_size, format, true);
            newDiffuseTex.name      = "packtexture__texture_512X512";
            newMaterial.mainTexture = newDiffuseTex;
            Rect[] uvs = newDiffuseTex.PackTextures(Textures.ToArray(), 0, maxnumsize, true);
            ss.Dispose();
            Vector2[] uva, uvb;
            for (int j = 0; j < combineInstances.Count; j++)
            {
                uva = (Vector2[])(combineInstances[j].mesh.uv);
                uvb = new Vector2[uva.Length];
                for (int k = 0; k < uva.Length; k++)
                {
                    uvb[k] = new Vector2((uva[k].x * uvs[j].width) + uvs[j].x, (uva[k].y * uvs[j].height) + uvs[j].y);
                }
                oldUV.Add(combineInstances[j].mesh.uv);
                combineInstances[j].mesh.uv = uvb;
            }
            shaderMesh = new Mesh();
            shaderMesh.CombineMeshes(combineInstances.ToArray(), true, false);
            shaderMesh.name = flag;
            for (int i = 0; i < combineInstances.Count; i++)
            {
                combineInstances[i].mesh.uv = oldUV[i];
            }

            GameObject body = new GameObject("body");

            body.layer                   = skeleton.layer;
            body.transform.parent        = skeleton.transform;
            body.transform.localPosition = Vector3.zero;
            body.transform.eulerAngles   = Vector3.zero;

            SkinnedMeshRenderer skr = body.AddComponent <SkinnedMeshRenderer>();

            skr.sharedMesh     = shaderMesh;
            skr.bones          = bones.ToArray();
            skr.sharedMaterial = newMaterial;
        }