HaloMap.RawData.BSPModel.InjectModel C# (CSharp) Method

InjectModel() public method

The inject model.
public InjectModel ( string FilePath, Meta meta ) : Meta
FilePath string The file path.
meta HaloMap.Meta.Meta The meta.
return HaloMap.Meta.Meta
        public Meta InjectModel(string FilePath, Meta meta)
        {
            LoadFromOBJ(FilePath);

            char[] crsr = new[] { 'c', 'r', 's', 'r' };
            char[] fklb = new[] { 'f', 'k', 'l', 'b' };

            for (int x = 0; x < this.BSPRawDataMetaChunks.Length; x++)
            {
                

                MemoryStream raw = new MemoryStream();
                BinaryWriter newraw = new BinaryWriter(raw);
                BinaryReader oldraw = new BinaryReader(meta.raw.rawChunks[x].MS);
                int newrawsize = 0;
                int rawchunkid = 0;

                #region Write Header

                oldraw.BaseStream.Position = 0;
                newraw.BaseStream.Position = 0;
                newraw.Write(oldraw.ReadBytes(this.BSPRawDataMetaChunks[x].HeaderSize));
                newrawsize += this.BSPRawDataMetaChunks[x].HeaderSize;

                #endregion

                #region Write Submesh Info

                newraw.BaseStream.Position = newrawsize;
                newraw.Write(crsr);
                newrawsize += 4;
                for (int y = 0; y < this.BSPRawDataMetaChunks[x].SubMeshInfo.Length; y++)
                {
                    oldraw.BaseStream.Position = this.BSPRawDataMetaChunks[x].HeaderSize +
                                                 this.BSPRawDataMetaChunks[x].RawDataChunkInfo[0].Offset + (y * 72);

                    newraw.BaseStream.Position = newrawsize + (y * 72);
                    newraw.Write(oldraw.ReadBytes(72));
                    newraw.BaseStream.Position = newrawsize + 4 + (y * 72);
                    newraw.Write((short)this.BSPRawDataMetaChunks[x].SubMeshInfo[y].ShaderNumber);
                    newraw.Write((short)this.BSPRawDataMetaChunks[x].SubMeshInfo[y].IndiceStart);
                    newraw.Write((short)this.BSPRawDataMetaChunks[x].SubMeshInfo[y].IndiceCount);
                    // newrawsize += 72;
                }

                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[0].ChunkCount =
                    this.BSPRawDataMetaChunks[x].SubMeshInfo.Length;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[0].Size =
                    this.BSPRawDataMetaChunks[x].SubMeshInfo.Length * 72;
                newrawsize += this.BSPRawDataMetaChunks[x].SubMeshInfo.Length * 72;
                // write count
                newraw.BaseStream.Position = 8;
                newraw.Write(this.BSPRawDataMetaChunks[x].SubMeshInfo.Length);

                #endregion

                #region Write Unknown

                rawchunkid = 1;

                while (newrawsize > 0)
                {
                    if (this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize == 2)
                    {
                        break;
                    }

                    oldraw.BaseStream.Position = this.BSPRawDataMetaChunks[x].HeaderSize +
                                                 this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset;
                    newraw.BaseStream.Position = newrawsize;
                    newraw.Write(crsr);
                    newrawsize += 4;
                    newraw.Write(oldraw.ReadBytes(this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size));
                    this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                       this.BSPRawDataMetaChunks[x].
                                                                                           HeaderSize;
                    newrawsize += this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size;
                    rawchunkid++;
                }

                #endregion

                #region Write Indices

                int indicechunkid = rawchunkid;
                newraw.BaseStream.Position = newrawsize;
                newraw.Write(crsr);
                newrawsize += 4;

                for (int y = 0; y < this.BSPRawDataMetaChunks[x].Indices.Length; y++)
                {
                    newraw.Write(this.BSPRawDataMetaChunks[x].Indices[y]);
                }

                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                   this.BSPRawDataMetaChunks[x].
                                                                                       HeaderSize;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkCount =
                    this.BSPRawDataMetaChunks[x].Indices.Length;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size =
                    this.BSPRawDataMetaChunks[x].Indices.Length * 2;
                newrawsize += this.BSPRawDataMetaChunks[x].Indices.Length * 2;
                // indice count
                newraw.BaseStream.Position = 40;
                newraw.Write((short)this.BSPRawDataMetaChunks[x].Indices.Length);
                rawchunkid++;

                #endregion

                #region Write Unknown

                // Pad to 16, after CRSR tag
                if ((newrawsize + 4) % 16 != 0)
                {
                    int pad = 16 - ((newrawsize + 4) % 16);
                    newraw.BaseStream.Position = newrawsize;
                    newraw.Write(new byte[pad]);
                    newrawsize += pad;
                }

                int verticechunkid = 0;
                while (newrawsize > 0)
                {
                    if (this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkCount == 1)
                    {
                        verticechunkid = rawchunkid;
                        break;
                    }

                    oldraw.BaseStream.Position = this.BSPRawDataMetaChunks[x].HeaderSize +
                                                 this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset;
                    newraw.BaseStream.Position = newrawsize;
                    newraw.Write(crsr);
                    newrawsize += 4;
                    newraw.Write(oldraw.ReadBytes(this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size));
                    this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                       this.BSPRawDataMetaChunks[x].
                                                                                           HeaderSize;
                    newrawsize += this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size;

                    rawchunkid++;
                }

                #endregion

                #region Write Vertices

                newraw.BaseStream.Position = newrawsize;
                newraw.Write(crsr);
                newrawsize += 4;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[verticechunkid].ChunkSize = 12;
                newraw.Write(
                    new byte[
                        this.BSPRawDataMetaChunks[x].RawDataChunkInfo[verticechunkid].ChunkSize *
                        this.BSPRawDataMetaChunks[x].VerticeCount]);

                for (int y = 0; y < this.BSPRawDataMetaChunks[x].VerticeCount; y++)
                {
                    newraw.BaseStream.Position = newrawsize +
                                                 (y *
                                                  this.BSPRawDataMetaChunks[x].RawDataChunkInfo[verticechunkid].
                                                      ChunkSize);
                    float vx = this.BSPRawDataMetaChunks[x].Vertices[y].X;
                    float vy = this.BSPRawDataMetaChunks[x].Vertices[y].Y;
                    float vz = this.BSPRawDataMetaChunks[x].Vertices[y].Z;
                    newraw.Write(vx); // xxx.934xxx
                    newraw.Write(vy);
                    newraw.Write(vz);
                }

                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                   this.BSPRawDataMetaChunks[x].
                                                                                       HeaderSize;
                newrawsize += this.BSPRawDataMetaChunks[x].RawDataChunkInfo[verticechunkid].ChunkSize *
                              this.BSPRawDataMetaChunks[x].VerticeCount;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size =
                    this.BSPRawDataMetaChunks[x].RawDataChunkInfo[verticechunkid].ChunkSize *
                    this.BSPRawDataMetaChunks[x].VerticeCount;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize = 0;
                    // this.BSPRawDataMetaChunks[x].RawDataChunkInfo[verticechunkid].ChunkSize * this.BSPRawDataMetaChunks[x].VerticeCount; ;
                // newraw.BaseStream.Position = 100;
                // newraw.Write(this.BSPRawDataMetaChunks[x].VerticeCount);
                rawchunkid++;

                #endregion

                #region Write UVs

                int uvchunkid = verticechunkid + 1;
                newraw.BaseStream.Position = newrawsize;
                newraw.Write(crsr);
                newrawsize += 4;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize = 8;
                for (int y = 0; y < this.BSPRawDataMetaChunks[x].VerticeCount; y++)
                {
                    float u = this.BSPRawDataMetaChunks[x].UVs[y].X;
                    float v = this.BSPRawDataMetaChunks[x].UVs[y].Y;

                    newraw.Write(u);
                    newraw.Write(v);
                }

                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                   this.BSPRawDataMetaChunks[x].
                                                                                       HeaderSize;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize = 1;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size = 8 *
                                                                                 this.BSPRawDataMetaChunks[x].
                                                                                     VerticeCount;
                newrawsize += 8 * this.BSPRawDataMetaChunks[x].VerticeCount;
                rawchunkid++;

                #endregion

                #region Write Normals

                newraw.BaseStream.Position = newrawsize;
                newraw.Write(crsr);
                newrawsize += 4;

                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize = 12;
                for (int y = 0; y < this.BSPRawDataMetaChunks[x].VerticeCount; y++)
                {
                    int cn = ParsedModel.CompressNormal(this.BSPRawDataMetaChunks[x].Normals[y]);

                    // Binormals & Tangents should be recalculated here instead of using old values!!!
                    // int cb = Raw.ParsedModel.CompressNormal(this.BSPRawDataMetaChunks[x].Binormals[y]);
                    // int ct = Raw.ParsedModel.CompressNormal(this.BSPRawDataMetaChunks[x].Tangents[y]);
                    int cb = ParsedModel.CompressNormal(this.BSPRawDataMetaChunks[x].Normals[y]);
                    int ct = ParsedModel.CompressNormal(this.BSPRawDataMetaChunks[x].Normals[y]);
                    // oldraw.BaseStream.Position = newraw.BaseStream.Position;
                    // cn = oldraw.ReadInt32();
                    // cb = oldraw.ReadInt32();
                    // ct = oldraw.ReadInt32();
                    newraw.Write(cn);
                    newraw.Write(cb);
                    newraw.Write(ct);
                }

                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                   this.BSPRawDataMetaChunks[x].
                                                                                       HeaderSize;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize = 2;
                this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size = 12 *
                                                                                 this.BSPRawDataMetaChunks[x].
                                                                                     VerticeCount;
                newrawsize += 12 * this.BSPRawDataMetaChunks[x].VerticeCount;
                rawchunkid++;

                #endregion

                #region Write Other Stuff Not Yet Implemented

                int tempCount = 0;
                while (rawchunkid < this.BSPRawDataMetaChunks[x].RawDataChunkInfo.Length)
                {
                    oldraw.BaseStream.Position = this.BSPRawDataMetaChunks[x].HeaderSize +
                                                 this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset;
                    newraw.BaseStream.Position = newrawsize;
                    newraw.Write(crsr);
                    newrawsize += 4;
                    newraw.Write(oldraw.ReadBytes(this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size));
                    this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Offset = newrawsize -
                                                                                       this.BSPRawDataMetaChunks[x].
                                                                                           HeaderSize;
                    this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].ChunkSize = 3 + tempCount;
                    newrawsize += this.BSPRawDataMetaChunks[x].RawDataChunkInfo[rawchunkid].Size;
                    rawchunkid++;
                    tempCount++;
                }

                #endregion

                // footer
                newraw.BaseStream.Position = newrawsize;
                newraw.Write(fklb);
                newrawsize += 4;
                // raw size
                int rawsize = newrawsize - this.BSPRawDataMetaChunks[x].HeaderSize - 4;
                newraw.BaseStream.Position = 4;
                newraw.Write(rawsize);
                meta.raw.rawChunks[x].size = newrawsize;
                meta.raw.rawChunks[x].MS = raw;

                
            }

            

            #region metachunks

            BinaryWriter BW = new BinaryWriter(meta.MS);

            for (int l = 0; l < this.BSPRawDataMetaChunks.Length; l++)
            {
                BW.BaseStream.Position = this.BSPRawDataMetaChunksOffset + (176 * l);
                short facecount = (short)this.BSPRawDataMetaChunks[l].FaceCount;
                BW.Write((short)this.BSPRawDataMetaChunks[l].VerticeCount);
                BW.Write(facecount);
                BW.BaseStream.Position = this.BSPRawDataMetaChunksOffset + (176 * l) + 52;
                BW.Write(meta.raw.rawChunks[l].size - this.BSPRawDataMetaChunks[l].HeaderSize - 4);

                for (int h = 0; h < this.BSPRawDataMetaChunks[l].RawDataChunkInfo.Length; h++)
                {
                    BW.BaseStream.Position = this.BSPRawDataMetaChunks[l].rawdatainfooffset + (h * 16) + 6;
                    BW.Write((short)this.BSPRawDataMetaChunks[l].RawDataChunkInfo[h].ChunkSize);
                    BW.Write(this.BSPRawDataMetaChunks[l].RawDataChunkInfo[h].Size);
                    BW.Write(this.BSPRawDataMetaChunks[l].RawDataChunkInfo[h].Offset);
                }
            }

            #endregion

            

            return meta;
        }

Usage Example

示例#1
0
        /// <summary>
        /// The inject mesh from obj tool strip menu item_ click.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        /// <remarks></remarks>
        private void injectMeshFromOBJToolStripMenuItem_Click(object sender, EventArgs e)
        {
            folderBrowserDialog.SelectedPath = Prefs.pathExtractsFolder;
            if (folderBrowserDialog.ShowDialog() == DialogResult.Cancel)
            {
                return;
            }

            Prefs.pathExtractsFolder = folderBrowserDialog.SelectedPath;

            Form tempForm = new Form();
            tempForm.ControlBox = false;
            tempForm.FormBorderStyle = FormBorderStyle.FixedDialog;
            tempForm.Size = new Size(250, 100);
            Label tempLabel = new Label();
            tempLabel.AutoSize = true;
            tempLabel.Location = new Point(20, 20);
            tempLabel.Text = "Loading BSP, please wait...";
            ProgressBar tempPB = new ProgressBar();
            tempPB.Location = new Point(20, 60);
            tempPB.Size = new Size(210, 20);
            tempPB.Minimum = 0;
            tempPB.Maximum = 100;
            tempForm.Controls.Add(tempLabel);
            tempForm.Controls.Add(tempPB);
            tempForm.Show();
            Application.DoEvents();

            BSPModel pm = new BSPModel(ref map.SelectedMeta);
            tempLabel.Text = "Loading Model...";
            tempPB.Value = 35;
            Application.DoEvents();
            Meta addme = pm.InjectModel(folderBrowserDialog.SelectedPath, map.SelectedMeta);

            /*
            addme.name += "(new)";
            addme.name = getNameDialog.Show("Choose injection name", "Meta Name:", addme.name, "OK");
            */
            ArrayList oi = new ArrayList();
            oi.Add(addme);

            tempLabel.Text = "Analyzing Layout...";
            tempPB.Value = 60;
            Application.DoEvents();

            MapAnalyzer analyze = new MapAnalyzer();
            MapLayout layout = analyze.ScanMapForLayOut(map, false);
            layout.ReadChunks(map);

            tempLabel.Text = "Rebuilding Map...";
            tempPB.Value = 70;
            Application.DoEvents();

            Builder build = new Builder();
            build.MapBuilder(oi, ref layout, map, false);

            tempLabel.Text = "Refreshing Map...";
            tempPB.Value = 95;
            Application.DoEvents();
            map = Map.Refresh(map);
            formFuncs.AddMetasToTreeView(map, treeView1, metaView, false);
            this.Enabled = true;

            #region Remove form that shows progress

            tempForm.Dispose();

            #endregion

            MessageBox.Show("Done");
        }