コード例 #1
0
        /// <summary>
        /// Reads the data-block from a stream.
        /// </summary>
        public override void Read(ResourceDataReader reader, params object[] parameters)
        {
            base.Read(reader, parameters);

            // read structure data
            this.Poses                 = reader.ReadBlock <ResourceSimpleList64 <DataVec3V> >();
            this.ControllerPointer     = reader.ReadUInt64();
            this.BoundCompositePointer = reader.ReadUInt64();
            this.Unknown_30h           = reader.ReadBlock <SimpleList64 <uint> >();
            this.Unknown_40h           = reader.ReadUInt64();
            this.Unknown_48h           = reader.ReadUInt64();
            this.Unknown_50h           = reader.ReadMatrix4x4();
            this.BoneIndex             = reader.ReadBlock <SimpleList64 <uint> >();
            this.Unknown_A0h           = reader.ReadUInt64();
            this.Unknown_A8h           = reader.ReadUInt64();
            this.Unknown_B0h           = reader.ReadUInt64();
            this.Unknown_B8h           = reader.ReadUInt64();
            this.Unknown_C0h           = reader.ReadUInt32();
            this.Unknown_C4h           = reader.ReadUInt32();
            this.Unknown_C8h           = reader.ReadUInt64();

            // read reference data
            this.Controller = reader.ReadBlockAt <CharacterClothController>(
                this.ControllerPointer // offset
                );
            this.BoundComposite = reader.ReadBlockAt <BoundComposite>(
                this.BoundCompositePointer // offset
                );
        }
コード例 #2
0
ファイル: GenCol.cs プロジェクト: nathan130200/gtautil
        static BoundComposite GenCol_CreateBoundComposite(ModelData data)
        {
            var bComposite = new BoundComposite()
            {
                BoundingBoxCenter    = (RAGE_Vector3)data.BsCenter,
                BoundingSphereRadius = data.BsRadius,
                BoundingBoxMin       = (RAGE_Vector3)data.BbMin,
                BoundingBoxMax       = (RAGE_Vector3)data.BbMax,
                CenterGravity        = new RAGE_Vector3(0.0f, 0.0f, 0.0f),
                Margin      = 0.04f,
                Type        = 10,
                Children    = new ResourcePointerArray64 <Bound>(),
                ChildFlags1 = new ResourceSimpleArray <ulong_r>()
                {
                    new ulong_r {
                        Value = 0
                    }
                },
                ChildFlags2 = new ResourceSimpleArray <ulong_r>()
                {
                    new ulong_r {
                        Value = 0
                    }
                }
            };

            var mat    = Matrix5x4.Identity;
            var matrix = new RAGE_Matrix4();

            matrix.m11 = mat.M11;
            matrix.m12 = mat.M12;
            matrix.m13 = mat.M13;
            matrix.m14 = mat.M14;
            matrix.m21 = mat.M21;
            matrix.m21 = mat.M21;
            matrix.m22 = mat.M22;
            matrix.m23 = mat.M23;
            matrix.m24 = mat.M24;
            matrix.m31 = mat.M31;
            matrix.m32 = mat.M32;
            matrix.m33 = mat.M33;
            matrix.m34 = mat.M34;
            matrix.m41 = mat.M41;
            matrix.m42 = mat.M42;
            matrix.m43 = mat.M43;
            matrix.m44 = mat.M44;

            bComposite.ChildTransformations1 = new ResourceSimpleArray <RAGE_Matrix4> {
                matrix
            };
            bComposite.ChildTransformations2 = new ResourceSimpleArray <RAGE_Matrix4> {
                matrix
            };

            return(bComposite);
        }
コード例 #3
0
ファイル: RenderableCache.cs プロジェクト: thuskey/CodeWalker
 public RenderableBoundComposite GetRenderableBoundComp(BoundComposite boundcomp)
 {
     return(boundcomps.Get(boundcomp));
 }
コード例 #4
0
ファイル: MainForm.cs プロジェクト: smallo92/Ymap-YbnMover
        private void startButton_Click(object sender, EventArgs e)
        {
            timerTime            = DateTime.Now;
            watch                = new System.Threading.Timer(Tick, null, 0, 10);
            cancelButton.Enabled = true;
            var errorFiles = new List <string>()
            {
            };

            new Thread(() =>
            {
                Thread.CurrentThread.IsBackground = true;
                //while (cancelLoop)
                //{
                for (var j = 0; j < CurrentList.Items.Count; j++)
                {
                    string filename      = CurrentList.Items[j].ToString();
                    FilesAddedLabel.Text = "Processing " + Path.GetFileName(filename) + " (" + (j + 1) + " of " + CurrentList.Items.Count + ")";

                    Vector3 moveVec = new Vector3(float.Parse(xMove.Text), float.Parse(yMove.Text), float.Parse(zMove.Text));
                    //Quaternion rotVec = Quaternion.RotationYawPitchRoll(float.Parse(xRotate.Text), float.Parse(yRotate.Text), float.Parse(zRotate.Text));

                    if (backupFilesToolStripMenuItem.Checked)
                    {
                        if (!filename.Contains(".rpf"))
                        {
                            File.Copy(filename, $"{filename}.old", true);
                        }
                        else
                        {
                            string fileDirectory = StringFunctions.TopMostRPF(filename);
                            File.Copy(fileDirectory, Path.Combine(fileDirectory, ".old"));
                        }
                    }

                    if (filename.EndsWith(".ybn"))
                    {
                        YbnFile ybn = new YbnFile();
                        RpfDirectoryEntry RPFFilesDirectory;
                        byte[] oldData;
                        if (filename.Contains(".rpf"))
                        {
                            string fileDirectory = StringFunctions.TopMostRPF(filename);
                            if (File.Exists(filename))
                            {
                                RPFFilesDirectory = null;
                                oldData           = File.ReadAllBytes(filename);
                            }
                            else
                            {
                                RpfFile TopRPF = new RpfFile(fileDirectory, fileDirectory);
                                TopRPF.ScanStructure(null, null);
                                (RPFFilesDirectory, oldData) = RPFFunctions.GetFileData(TopRPF, Path.GetFileName(filename));
                            }
                        }
                        else
                        {
                            RPFFilesDirectory = null;
                            oldData           = File.ReadAllBytes(filename);
                        }

                        try
                        {
                            ybn.Load(oldData);

                            if (ybn.Bounds != null)
                            {
                                ybn.Bounds.BoxCenter    += moveVec;
                                ybn.Bounds.BoxMax       += moveVec;
                                ybn.Bounds.BoxMin       += moveVec;
                                ybn.Bounds.SphereCenter += moveVec;

                                BoundComposite boundcomp = ybn.Bounds as BoundComposite;
                                var compchilds           = boundcomp?.Children?.data_items;
                                if (boundcomp.BVH != null)
                                {
                                    Vector3 boundcompBBC            = MathFunctions.ConvertToVec3(boundcomp.BVH.BoundingBoxCenter);
                                    Vector3 boundcompBBMax          = MathFunctions.ConvertToVec3(boundcomp.BVH.BoundingBoxMax);
                                    Vector3 boundcompBBMin          = MathFunctions.ConvertToVec3(boundcomp.BVH.BoundingBoxMin);
                                    boundcomp.BVH.BoundingBoxCenter = new Vector4(boundcompBBC + moveVec, boundcomp.BVH.BoundingBoxCenter.W);
                                    boundcomp.BVH.BoundingBoxMax    = new Vector4(boundcompBBMax + moveVec, boundcomp.BVH.BoundingBoxMax.W);
                                    boundcomp.BVH.BoundingBoxMin    = new Vector4(boundcompBBMin + moveVec, boundcomp.BVH.BoundingBoxMin.W);
                                }
                                if (compchilds != null)
                                {
                                    for (int i = 0; i < compchilds.Length; i++)
                                    {
                                        compchilds[i].BoxCenter    += moveVec;
                                        compchilds[i].BoxMax       += moveVec;
                                        compchilds[i].BoxMin       += moveVec;
                                        compchilds[i].SphereCenter += moveVec;
                                        BoundBVH bgeom              = compchilds[i] as BoundBVH;
                                        if (bgeom != null)
                                        {
                                            if (bgeom.BVH != null)
                                            {
                                                Vector3 bgeomBBC            = MathFunctions.ConvertToVec3(bgeom.BVH.BoundingBoxCenter);
                                                Vector3 bgeomBBMax          = MathFunctions.ConvertToVec3(bgeom.BVH.BoundingBoxMax);
                                                Vector3 bgeomBBMin          = MathFunctions.ConvertToVec3(bgeom.BVH.BoundingBoxMin);
                                                bgeom.BVH.BoundingBoxCenter = new Vector4(bgeomBBC + moveVec, bgeom.BVH.BoundingBoxCenter.W);
                                                bgeom.BVH.BoundingBoxMax    = new Vector4(bgeomBBMax + moveVec, bgeom.BVH.BoundingBoxMax.W);
                                                bgeom.BVH.BoundingBoxMin    = new Vector4(bgeomBBMin + moveVec, bgeom.BVH.BoundingBoxMin.W);
                                            }
                                            bgeom.CenterGeom = bgeom.CenterGeom + moveVec;
                                        }
                                    }
                                }
                            }
                            byte[] newData = ybn.Save();
                            if (filename.Contains(".rpf"))
                            {
                                if (File.Exists(filename))
                                {
                                    RPFFilesDirectory = null;
                                    oldData           = File.ReadAllBytes(filename);
                                }
                                else
                                {
                                    RPFFunctions.AddFileBackToRPF(RPFFilesDirectory, filename, newData);
                                }
                            }
                            else
                            {
                                File.WriteAllBytes(filename, newData);
                            }
                        }
                        catch (Exception)
                        {
                            errorFiles.Add(filename);
                        }
                    }
                    else if (filename.EndsWith(".ymap"))
                    {
                        YmapFile ymap = new YmapFile();
                        RpfDirectoryEntry RPFFilesDirectory;
                        byte[] oldData;
                        if (filename.Contains(".rpf"))
                        {
                            string fileDirectory = StringFunctions.TopMostRPF(filename);
                            if (File.Exists(filename))
                            {
                                RPFFilesDirectory = null;
                                oldData           = File.ReadAllBytes(filename);
                            }
                            else
                            {
                                RpfFile TopRPF = new RpfFile(fileDirectory, fileDirectory);
                                TopRPF.ScanStructure(null, null);
                                (RPFFilesDirectory, oldData) = RPFFunctions.GetFileData(TopRPF, Path.GetFileName(filename));
                            }
                        }
                        else
                        {
                            RPFFilesDirectory = null;
                            oldData           = File.ReadAllBytes(filename);
                        }

                        try
                        {
                            ymap.Load(oldData);
                            if (ymap.CarGenerators != null)
                            {
                                foreach (YmapCarGen yEnts in ymap.CarGenerators)
                                {
                                    yEnts.SetPosition(yEnts.Position + moveVec);
                                    //yEnts.Orientation = Quaternion.Add(yEnts.Orientation, rotVec);
                                }
                            }
                            if (ymap.AllEntities != null)
                            {
                                foreach (YmapEntityDef yEnts in ymap.AllEntities)
                                {
                                    yEnts.SetPosition(yEnts.Position + moveVec);
                                    //yEnts.Orientation = Quaternion.Add(yEnts.Orientation, rotVec);
                                }
                            }
                            if (ymap.DistantLODLights != null)
                            {
                                int lightCount = ymap._CMapData.DistantLODLightsSOA.position.Count1;
                                for (int i = 0; i < lightCount; i++)
                                {
                                    Vector3 vector3     = ymap.DistantLODLights.positions[i].ToVector3() + moveVec;
                                    MetaVECTOR3 metaVec = new MetaVECTOR3 {
                                        x = vector3.X, y = vector3.Y, z = vector3.Z
                                    };
                                    ymap.DistantLODLights.positions[i] = metaVec;
                                }
                            }
                            if (ymap.GrassInstanceBatches != null)
                            {
                                foreach (YmapGrassInstanceBatch yEnts in ymap.GrassInstanceBatches)
                                {
                                    yEnts.Position += moveVec;
                                    yEnts.AABBMin  += moveVec;
                                    yEnts.AABBMax  += moveVec;
                                }
                            }

                            ymap._CMapData.streamingExtentsMax = ymap.CMapData.streamingExtentsMax + moveVec;
                            ymap._CMapData.streamingExtentsMin = ymap.CMapData.streamingExtentsMin + moveVec;
                            ymap._CMapData.entitiesExtentsMax  = ymap.CMapData.entitiesExtentsMax + moveVec;
                            ymap._CMapData.entitiesExtentsMin  = ymap.CMapData.entitiesExtentsMin + moveVec;

                            byte[] newData = ymap.Save();
                            if (filename.Contains(".rpf"))
                            {
                                if (File.Exists(filename))
                                {
                                    RPFFilesDirectory = null;
                                    oldData           = File.ReadAllBytes(filename);
                                }
                                else
                                {
                                    RPFFunctions.AddFileBackToRPF(RPFFilesDirectory, filename, newData);
                                }
                            }
                            else
                            {
                                File.WriteAllBytes(filename, newData);
                            }
                        }
                        catch (Exception)
                        {
                            errorFiles.Add(filename);
                        }
                    }
                }
                if (errorFiles.Count != 0)
                {
                    string message = "The following file(s) were corrupted and were not edited.\n\n";
                    foreach (string item in errorFiles)
                    {
                        message = message + item + "\n";
                    }

                    MessageBox.Show(message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                FilesAddedLabel.Text = "Complete";
                cancelButton.Enabled = false;
                watch.Dispose();
                //}
            }).Start();
        }