예제 #1
0
        ///
        ///
        public bool WriteModelFile(string infile, string outfilepath, SlotMaterials slotMat)
        {
            bool onBuffer;

            using (var reader = new BinaryReader(GetStream(infile, out onBuffer), Encoding.UTF8)) {
                // ヘッダ
                string header = reader.ReadString();
                if (onBuffer || reader.BaseStream.Position > 0)
                {
                    if (header == FileConst.HEAD_MODEL)
                    {
                        return(WriteModelFile(reader, header, outfilepath, slotMat));
                    }
                    var msg = LogUtil.Error("正しいモデルファイルではありません。ヘッダが不正です。", header, ", infile=", infile);
                    throw new ACCException(msg.ToString());
                }
            }

            // arc内のファイルがロードできない場合の回避策: Sybaris 0410向け対策. 一括読み込み
            using (var reader = new BinaryReader(new MemoryStream(FileUtilEx.Instance.LoadInternal(infile), false), Encoding.UTF8)) {
                string header = reader.ReadString(); // hader
                if (header == FileConst.HEAD_MODEL)
                {
                    return(WriteModelFile(reader, header, outfilepath, slotMat));
                }
                else
                {
                    var msg = LogUtil.Error("正しいモデルファイルではありません。ヘッダが不正です。", header, ", infile=", infile);
                    throw new ACCException(msg.ToString());
                }
            }
        }
        // Token: 0x06000258 RID: 600 RVA: 0x00014C88 File Offset: 0x00012E88
        public bool WriteModelFile(string infile, string outfilepath, SlotMaterials slotMat)
        {
            bool flag;

            using (BinaryReader binaryReader = new BinaryReader(this.GetStream(infile, out flag), Encoding.UTF8))
            {
                string text = binaryReader.ReadString();
                if (flag || binaryReader.BaseStream.Position > 0L)
                {
                    if (text == FileConst.HEAD_MODEL)
                    {
                        return(this.WriteModelFile(binaryReader, text, outfilepath, slotMat));
                    }
                    StringBuilder stringBuilder = LogUtil.Error(new object[]
                    {
                        "正しいモデルファイルではありません。ヘッダが不正です。",
                        text,
                        ", infile=",
                        infile
                    });
                    throw new ACCException(stringBuilder.ToString());
                }
            }
            bool result;

            using (BinaryReader binaryReader2 = new BinaryReader(new MemoryStream(FileUtilEx.Instance.LoadInternal(infile), false), Encoding.UTF8))
            {
                string text2 = binaryReader2.ReadString();
                if (!(text2 == FileConst.HEAD_MODEL))
                {
                    StringBuilder stringBuilder2 = LogUtil.Error(new object[]
                    {
                        "正しいモデルファイルではありません。ヘッダが不正です。",
                        text2,
                        ", infile=",
                        infile
                    });
                    throw new ACCException(stringBuilder2.ToString());
                }
                result = this.WriteModelFile(binaryReader2, text2, outfilepath, slotMat);
            }
            return(result);
        }
예제 #3
0
        public bool TransferModel(BinaryReader reader, string header, BinaryWriter writer, SlotMaterials slotMat)
        {
            writer.Write(header);
            writer.Write(reader.ReadInt32());  // ver
            writer.Write(reader.ReadString()); // "_SM_" + name
            writer.Write(reader.ReadString()); // base_bone
            int count = reader.ReadInt32();

            writer.Write(count);  // num (bone_count)
            for (int i = 0; i < count; i++)
            {
                writer.Write(reader.ReadString()); // ボーン名
                writer.Write(reader.ReadByte());   // フラグ (_SCL_追加の有無等)
            }

            for (int i = 0; i < count; i++)
            {
                int count2 = reader.ReadInt32();   // parent index
                writer.Write(count2);
            }

            for (int i = 0; i < count; i++)
            {
                // (x, y, z), (x2, y2, z2, w)
                TransferVec(reader, writer, 7);
            }
            int vertexCount    = reader.ReadInt32();
            int facesCount     = reader.ReadInt32();
            int localBoneCount = reader.ReadInt32();

            writer.Write(vertexCount);
            writer.Write(facesCount);
            writer.Write(localBoneCount);

            for (int i = 0; i < localBoneCount; i++)
            {
                writer.Write(reader.ReadString()); // ローカルボーン名
            }
            for (int i = 0; i < localBoneCount; i++)
            {
                TransferVec(reader, writer, 16); // matrix (floatx4, floatx4)
            }
            for (int i = 0; i < vertexCount; i++)
            {
                TransferVec(reader, writer, 8);
            }
            int vertexCount2 = reader.ReadInt32();

            writer.Write(vertexCount2);
            for (int i = 0; i < vertexCount2; i++)
            {
                TransferVec4(reader, writer);
            }
            for (int i = 0; i < vertexCount; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    writer.Write(reader.ReadUInt16());
                }
                TransferVec4(reader, writer);
            }
            for (int i = 0; i < facesCount; i++)
            {
                int cnt = reader.ReadInt32();
                writer.Write(cnt);
                for (int j = 0; j < cnt; j++)
                {
                    writer.Write(reader.ReadInt16());
                }
            }
            // material
            int mateCount = reader.ReadInt32();

            writer.Write(mateCount);
            for (int matNo = 0; matNo < mateCount; matNo++)
            {
                var tm = slotMat.Get(matNo);
                TransferMaterial(reader, writer, tm, tm.onlyModel);
            }

            // morph
            while (reader.PeekChar() != -1)
            {
                string name = reader.ReadString();
                writer.Write(name);
                if (name == "end")
                {
                    break;
                }

                if (name == "morph")
                {
                    string key = reader.ReadString();
                    writer.Write(key);
                    int num = reader.ReadInt32();
                    writer.Write(num);
                    for (int i = 0; i < num; i++)
                    {
                        writer.Write(reader.ReadUInt16());
                        // (x, y, z), (x, y, z)
                        TransferVec(reader, writer, 6);
                    }
                }
            }
            return(true);
        }
예제 #4
0
 private bool WriteModelFile(BinaryReader reader, string header, string outfilepath, SlotMaterials slotMat)
 {
     using (var writer = new BinaryWriter(File.OpenWrite(outfilepath))) {
         return(TransferModel(reader, header, writer, slotMat));
     }
 }
예제 #5
0
        public bool SaveFiles(ACCMenu menu)
        {
            var outDir = fileUtil.GetACCDirectory(trgtMenu.editfile);

            if (!Directory.Exists(outDir))
            {
                Directory.CreateDirectory(outDir);
            }

            LogUtil.Debug("output path:", outDir);
            string filepath = Path.Combine(outDir, menu.EditFileName());

            // menu出力
            ACCMenu.WriteMenuFile(filepath, menu);

            var writeFiles = new HashSet <string>();

            // filterがあれば、適用しアイコンを変更
            string iconfilepath = Path.Combine(outDir, menu.EditIconFileName());

            writeFiles.Add(iconfilepath);
            string icontxt = settings.txtPrefixTex + iconfilepath;

            fileUtil.CopyTex(menu.icon, iconfilepath, icontxt, null);
            LogUtil.Debug("tex file:", iconfilepath);

            // model 出力 (additem)
            foreach (var pair in menu.itemFiles)
            {
                string infile = pair.Key;
                Item   item   = pair.Value;
                if (item.needUpdate)
                {
                    string filename = item.EditFileName();
                    if (HasAlreadyWritten(writeFiles, filename))
                    {
                        continue;
                    }

                    string modelfilepath = Path.Combine(outDir, filename);

                    // modelファイルのスロットのマテリアル/テクスチャ情報を抽出
                    SlotMaterials slotMat = menu.slotMaterials[item.slot];
                    // onlyModelでない場合はshader変更のみとしておく
                    // material slotとmatNoで特定
                    // texture  propName
                    // 必要に応じてtex出力
                    fileUtil.WriteModelFile(infile, modelfilepath, slotMat);
                    LogUtil.Debug("model file:", modelfilepath);
                }
            }

            // mate出力
            foreach (var tm in menu.slotMaterials.Values)
            {
                foreach (var trgtMat in tm.materials)
                {
                    // マテリアル変更が指定された場合 => TODO 切り替え可能とする場合:menuにマテリアル変更を追加する必要あり
                    if (!trgtMat.onlyModel)
                    {
                        var filename = trgtMat.EditFileName();
                        if (HasAlreadyWritten(writeFiles, filename))
                        {
                            continue;
                        }

                        string matefilepath = Path.Combine(outDir, filename);
                        fileUtil.WriteMateFile(trgtMat.filename, matefilepath, trgtMat);
                        LogUtil.Debug("mate file:", matefilepath);

                        if (trgtMat.needPmatChange)
                        {
                            var    name         = Path.GetFileNameWithoutExtension(filename);
                            var    pmatfile     = name + FileConst.EXT_PMAT;
                            string pmatfilepath = Path.Combine(outDir, pmatfile);
                            fileUtil.WritePmat(pmatfilepath, trgtMat.editname,
                                               trgtMat.RenderQueue(), trgtMat.ShaderName());
                            LogUtil.Debug("pmat file:", pmatfilepath);
                        }
                    }

                    // テクスチャ出力
                    foreach (var trgtTex in trgtMat.texDic.Values)
                    {
                        if (!trgtTex.needOutput)
                        {
                            continue;
                        }

                        var tex2d = trgtTex.tex as Texture2D;
                        if (tex2d == null)
                        {
                            LogUtil.Debug("tex is not Texture2D", trgtTex.editname);
                            continue;
                            // TODO RenderTexの場合は無理やりTexture2Dに変換も可能だが…
                        }
                        var texfilename = trgtTex.EditFileName();
                        if (HasAlreadyWritten(writeFiles, texfilename))
                        {
                            continue;
                        }

                        string texfilepath = Path.Combine(outDir, texfilename);
                        fileUtil.WriteTexFile(texfilepath, trgtTex.EditTxtPath(), tex2d.EncodeToPNG());
                        LogUtil.Debug("tex file:", texfilepath);
                    }
                }
            }

            // めくれ、ずらし用menuファイルの出力
            foreach (var res in menu.resFiles.Values)
            {
                // 各モデルファイルで出力が必要となるファイルについて、
                // 元が同名のファイルを参照している場合でも関係なく出力
                // 設定が違う場合もある上、editnameはすべて別名になるはず
                var filename = res.EditFileName();
                if (HasAlreadyWritten(writeFiles, filename))
                {
                    continue;
                }


                string menufilepath  = Path.Combine(outDir, filename);
                var    toCreateFiles = fileUtil.WriteMenuFile(res.filename, menufilepath, res);
                LogUtil.Debug("menu file:", menufilepath);

                foreach (var toCreate in toCreateFiles)
                {
                    // modelを出力
                    if (toCreate.item != null)
                    {
                        var filename0 = toCreate.replaced;
                        if (HasAlreadyWritten(writeFiles, filename0))
                        {
                            continue;
                        }

                        string        modelfilepath = Path.Combine(outDir, filename0);
                        SlotMaterials slotMat       = menu.slotMaterials[toCreate.item.slot];
                        // TODO リプレースが想定される情報であるかチェック
                        fileUtil.WriteModelFile(toCreate.source, modelfilepath, slotMat);

                        // .mate出力
                    }
                    else if (toCreate.material != null)
                    {
                        TargetMaterial trgtMat   = toCreate.material;
                        var            filename0 = toCreate.replaced;
                        if (HasAlreadyWritten(writeFiles, filename0))
                        {
                            continue;
                        }

                        // mate出力==別のtexファイルを出力する可能性有り
                        string matefilepath = Path.Combine(outDir, filename0);
                        fileUtil.WriteMateFile(toCreate.source, matefilepath, trgtMat);
                        // マテリアル名は上位と同じにして、同一pmatを使用する
                        //if (trgtMat.needPmatChange) {
                        //    var name = Path.GetFileNameWithoutExtension(filename);
                        //    var pmatfile = name + FileConst.EXT_PMAT;
                        //    string pmatfilepath = Path.Combine(outDir, pmatfile);
                        //    outUtil.WritePmat(pmatfilepath, trgtMat.editname,
                        //                      trgtMat.RenderQueue(), trgtMat.ShaderName());
                        //    LogUtil.DebugLog("pmatファイルを出力しました。", pmatfilepath);
                        //}

                        foreach (var tex in trgtMat.texDic.Values)
                        {
                            if (!tex.needOutput)
                            {
                                continue;
                            }

                            var tex2d = tex.tex as Texture2D;
                            if (tex2d == null)
                            {
                                LogUtil.Debug("tex is not 2D", tex.editname);
                                continue;
                            }
                            var texfilename = tex.EditFileName();
                            if (HasAlreadyWritten(writeFiles, texfilename))
                            {
                                continue;
                            }

                            // テクスチャをロードし、フィルタを適用
                            Texture2D loadedTex   = null;
                            Texture2D filteredTex = null;
                            if (!tex.fileChanged)   // texファイル変更済の場合はロードされたデータ済みから出力(そのままtex2dを使用)
                            {
                                string texfile = tex.workfilename + FileConst.EXT_TEXTURE;
                                if (!fileUtil.Exists(texfile))
                                {
                                    LogUtil.LogF("リソース参照で使用されているtexファイル({0})が見つかりません。texファイルを出力できません。", texfile);
                                    continue;
                                }
                                loadedTex = TexUtil.Instance.Load(texfile);
                                tex2d     = loadedTex;
                            }

                            if (tex.colorChanged)
                            {
                                filteredTex = ACCTexturesView.Filter(tex2d, tex.filter);
                                tex2d       = filteredTex;
                            }
                            string texfilepath = Path.Combine(outDir, texfilename);
                            fileUtil.WriteTexFile(texfilepath, tex.EditTxtPath(), tex2d.EncodeToPNG());
                            LogUtil.Debug("tex file:", texfilepath);

                            if (loadedTex != null)
                            {
                                UnityEngine.Object.DestroyImmediate(loadedTex);
                            }
                            if (filteredTex != null)
                            {
                                UnityEngine.Object.DestroyImmediate(filteredTex);
                            }
                        }
                    }
                }
            }
            return(true);
        }
        // Token: 0x0600025A RID: 602 RVA: 0x00014E14 File Offset: 0x00013014
        public bool TransferModel(BinaryReader reader, string header, BinaryWriter writer, SlotMaterials slotMat)
        {
            writer.Write(header);
            int num = reader.ReadInt32();

            writer.Write(num);
            writer.Write(reader.ReadString());
            writer.Write(reader.ReadString());
            int num2 = reader.ReadInt32();

            writer.Write(num2);
            for (int i = 0; i < num2; i++)
            {
                writer.Write(reader.ReadString());
                writer.Write(reader.ReadByte());
            }
            for (int j = 0; j < num2; j++)
            {
                int value = reader.ReadInt32();
                writer.Write(value);
            }
            for (int k = 0; k < num2; k++)
            {
                this.TransferVec(reader, writer, 7);
                if (num >= 2001)
                {
                    bool flag = reader.ReadBoolean();
                    writer.Write(flag);
                    if (flag)
                    {
                        this.TransferVec(reader, writer, 3);
                    }
                }
            }
            int num3 = reader.ReadInt32();
            int num4 = reader.ReadInt32();
            int num5 = reader.ReadInt32();

            writer.Write(num3);
            writer.Write(num4);
            writer.Write(num5);
            for (int l = 0; l < num5; l++)
            {
                writer.Write(reader.ReadString());
            }
            for (int m = 0; m < num5; m++)
            {
                this.TransferVec(reader, writer, 16);
            }
            for (int n = 0; n < num3; n++)
            {
                this.TransferVec(reader, writer, 8);
            }
            int num6 = reader.ReadInt32();

            writer.Write(num6);
            for (int num7 = 0; num7 < num6; num7++)
            {
                this.TransferVec4(reader, writer);
            }
            for (int num8 = 0; num8 < num3; num8++)
            {
                for (int num9 = 0; num9 < 4; num9++)
                {
                    writer.Write(reader.ReadUInt16());
                }
                this.TransferVec4(reader, writer);
            }
            for (int num10 = 0; num10 < num4; num10++)
            {
                int num11 = reader.ReadInt32();
                writer.Write(num11);
                for (int num12 = 0; num12 < num11; num12++)
                {
                    writer.Write(reader.ReadInt16());
                }
            }
            int num13 = reader.ReadInt32();

            writer.Write(num13);
            for (int num14 = 0; num14 < num13; num14++)
            {
                TargetMaterial targetMaterial = slotMat.Get(num14);
                this.TransferMaterial(reader, writer, targetMaterial, targetMaterial.onlyModel);
            }
            while (reader.PeekChar() != -1)
            {
                string text = reader.ReadString();
                writer.Write(text);
                if (text == "end")
                {
                    break;
                }
                if (!(text != "morph"))
                {
                    string value2 = reader.ReadString();
                    writer.Write(value2);
                    int num15 = reader.ReadInt32();
                    writer.Write(num15);
                    for (int num16 = 0; num16 < num15; num16++)
                    {
                        writer.Write(reader.ReadUInt16());
                        this.TransferVec(reader, writer, 6);
                    }
                }
            }
            return(true);
        }
        // Token: 0x06000259 RID: 601 RVA: 0x00014DD0 File Offset: 0x00012FD0
        private bool WriteModelFile(BinaryReader reader, string header, string outfilepath, SlotMaterials slotMat)
        {
            bool result;

            using (BinaryWriter binaryWriter = new BinaryWriter(File.OpenWrite(outfilepath)))
            {
                result = this.TransferModel(reader, header, binaryWriter, slotMat);
            }
            return(result);
        }
        public bool TransferModel(BinaryReader reader, string header, BinaryWriter writer, SlotMaterials slotMat)
        {
            writer.Write(header);
            var ver = reader.ReadInt32();

            writer.Write(ver);                 // ver
            writer.Write(reader.ReadString()); // "_SM_" + name
            writer.Write(reader.ReadString()); // base_bone
            var count = reader.ReadInt32();

            writer.Write(count);  // num (bone_count)
            for (var i = 0; i < count; i++)
            {
                writer.Write(reader.ReadString()); // ボーン名
                writer.Write(reader.ReadByte());   // フラグ (_SCL_追加の有無等)
            }

            for (var i = 0; i < count; i++)
            {
                var count2 = reader.ReadInt32();   // parent index
                writer.Write(count2);
            }

            for (var i = 0; i < count; i++)
            {
                // localPosition, localRotation
                // (x, y, z), (x2, y2, z2, w)
                TransferVec(reader, writer, 7);
                // localScale
                if (ver < 2001)
                {
                    continue;
                }

                var readScale = reader.ReadBoolean();
                writer.Write(readScale);
                if (readScale)
                {
                    TransferVec(reader, writer);
                }
            }
            var vertexCount    = reader.ReadInt32();
            var facesCount     = reader.ReadInt32();
            var localBoneCount = reader.ReadInt32();

            writer.Write(vertexCount);
            writer.Write(facesCount);
            writer.Write(localBoneCount);

            for (var i = 0; i < localBoneCount; i++)
            {
                writer.Write(reader.ReadString()); // ローカルボーン名
            }
            for (var i = 0; i < localBoneCount; i++)
            {
                TransferVec(reader, writer, 16); // matrix (floatx4, floatx4)
            }
            for (var i = 0; i < vertexCount; i++)
            {
                TransferVec(reader, writer, 8);
            }
            var vertexCount2 = reader.ReadInt32();

            writer.Write(vertexCount2);
            for (var i = 0; i < vertexCount2; i++)
            {
                TransferVec4(reader, writer);
            }
            for (var i = 0; i < vertexCount; i++)
            {
                for (var j = 0; j < 4; j++)
                {
                    writer.Write(reader.ReadUInt16());
                }
                TransferVec4(reader, writer);
            }
            for (var i = 0; i < facesCount; i++)
            {
                var cnt = reader.ReadInt32();
                writer.Write(cnt);
                for (var j = 0; j < cnt; j++)
                {
                    writer.Write(reader.ReadInt16());
                }
            }
            // material
            var mateCount = reader.ReadInt32();

            writer.Write(mateCount);
            for (var matNo = 0; matNo < mateCount; matNo++)
            {
                var tm = slotMat.Get(matNo);
                TransferMaterial(reader, writer, tm, tm.onlyModel);
            }

            // morph
            while (reader.PeekChar() != -1)
            {
                var name = reader.ReadString();
                writer.Write(name);
                if (name == "end")
                {
                    break;
                }

                if (name != "morph")
                {
                    continue;
                }
                var key = reader.ReadString();
                writer.Write(key);
                var num = reader.ReadInt32();
                writer.Write(num);
                for (var i = 0; i < num; i++)
                {
                    writer.Write(reader.ReadUInt16());
                    // (x, y, z), (x, y, z)
                    TransferVec(reader, writer, 6);
                }
            }
            return(true);
        }