Пример #1
0
        public static Image GetXThumbnail(SimPe.PackedFiles.Wrapper.Cpf cpf)
        {
            if (xthumbs == null)
            {
                xthumbs = SimPe.Packages.File.LoadFromFile(System.IO.Path.Combine(PathProvider.SimSavegameFolder, "Thumbnails\\BuildModeThumbnails.package"));
            }

            SimPe.Packages.File      tmbs = xthumbs;
            Data.XObjFunctionSubSort fss  = GetFunctionSort(cpf);

            uint inst = cpf.GetSaveItem("guid").UIntegerValue;
            uint grp  = cpf.FileDescriptor.Group;

            if (cpf.GetItem("thumbnailinstanceid") != null)
            {
                inst = cpf.GetSaveItem("thumbnailinstanceid").UIntegerValue;
                grp  = cpf.GetSaveItem("thumbnailgroupid").UIntegerValue;
            }


            //get Thumbnail Type
            uint[] types = new uint[] { 0x8C311262, 0x8C31125E }; //floors, walls
            if (fss == Data.XObjFunctionSubSort.Roof)
            {
                types = new uint[] { 0xCC489E46 }
            }
            ;
            else if (fss == Data.XObjFunctionSubSort.Fence_Rail || fss == Data.XObjFunctionSubSort.Fence_Halfwall)
            {
                types = new uint[] { 0xCC30CDF8 }
            }
            ;
            else if (fss == Data.XObjFunctionSubSort.Roof)
            {
                types = new uint[] { 0xCC489E46 }
            }
            ;
            else if (fss == Data.XObjFunctionSubSort.Terrain)
            {
                types = new uint[] { 0xEC3126C4 };
                if (cpf.GetItem("texturetname") != null)
                {
                    inst = Hashes.GetCrc32(Hashes.StripHashFromName(cpf.GetItem("texturetname").StringValue.Trim().ToLower()));
                }
            }
            else if (cpf.FileDescriptor.Type == Data.MetaData.XNGB)
            {
                types = new uint[] { 0x4D533EDD };
                if (nthumbs == null)
                {
                    nthumbs = SimPe.Packages.File.LoadFromFile(System.IO.Path.Combine(PathProvider.SimSavegameFolder, "Thumbnails\\CANHObjectsThumbnails.package"));
                }
                tmbs = nthumbs;
            }


            return(GetThumbnail(cpf.GetSaveItem("name").StringValue, types, grp, inst, tmbs));
            //tmbs = null;
        }
Пример #2
0
        public ColorOptionsItem(SimPe.PackedFiles.Wrapper.Cpf mmat)
        {
            this.MMAT = mmat;

            Subset  = mmat.GetSaveItem("subsetName").StringValue.Trim().ToLower();
            Family  = mmat.GetSaveItem("family").StringValue.Trim().ToLower();
            Guid    = mmat.GetSaveItem("objectGUID").UIntegerValue;
            Default = mmat.GetSaveItem("defaultMaterial").BooleanValue;
            matd    = null;
        }
Пример #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="cs"></param>
        /// <param name="cpf"></param>
        /// <returns>ResourceDescriptor for the references String</returns>
        protected static SimPe.Interfaces.Files.IPackedFileDescriptor UpdateDescription(OWCloneSettings cs, SimPe.Packages.GeneratableFile package, SimPe.PackedFiles.Wrapper.Cpf cpf)
        {
            cpf.GetSaveItem("cost").UIntegerValue      = (uint)cs.Price;
            cpf.GetSaveItem("name").StringValue        = cs.Title.Replace("\n", " ").Replace("\t", "    ").Replace("\r", " ");
            cpf.GetSaveItem("description").StringValue = cs.Description.Replace("\n", " ").Replace("\t", "    ").Replace("\r", " ");
            cpf.SynchronizeUserData();

            SimPe.Interfaces.Files.IPackedFileDescriptor pfd = package.FindFile(cpf.GetSaveItem("stringsetrestypeid").UIntegerValue, 0, cpf.GetSaveItem("stringsetgroupid").UIntegerValue, cpf.GetSaveItem("stringsetid").UIntegerValue);

            return(pfd);
        }
Пример #4
0
        /// <summary>
        /// Add Resources referenced from XML Files
        /// </summary>
        /// <param name="names"></param>
        public void AddFromXml(SimPe.Interfaces.Files.IPackageFile pkg)
        {
            SimPe.Interfaces.Files.IPackedFileDescriptor[] index = (SimPe.Interfaces.Files.IPackedFileDescriptor[])pkg.Index.Clone();
            foreach (SimPe.Interfaces.Files.IPackedFileDescriptor pfd in index)
            {
                SimPe.PackedFiles.Wrapper.Cpf cpf = new SimPe.PackedFiles.Wrapper.Cpf();
                if (!cpf.CanHandleType(pfd.Type))
                {
                    continue;
                }

                cpf.ProcessData(pfd, pkg);

                //xobj
                AddFromXml(cpf.GetItem("material"), "_txmt", Data.MetaData.TXMT);

                //hood object
                if (pfd.Type == Data.MetaData.XNGB)
                {
                    AddFromXml(cpf.GetItem("modelname"), "_cres", Data.MetaData.CRES);
                }

                //fences
                AddFromXml(cpf.GetItem("diagrail"), "_cres", Data.MetaData.CRES);
                AddFromXml(cpf.GetItem("post"), "_cres", Data.MetaData.CRES);
                AddFromXml(cpf.GetItem("rail"), "_cres", Data.MetaData.CRES);
                AddFromXml(cpf.GetItem("diagrail"), "_txmt", Data.MetaData.TXMT);
                AddFromXml(cpf.GetItem("post"), "_txmt", Data.MetaData.TXMT);
                AddFromXml(cpf.GetItem("rail"), "_txmt", Data.MetaData.TXMT);

                //terrain
                AddFromXml(cpf.GetItem("texturetname"), "_txtr", Data.MetaData.TXTR);
                AddFromXml(cpf.GetItem("texturetname"), "_detail_txtr", Data.MetaData.TXTR);
                AddFromXml(cpf.GetItem("texturetname"), "-bump_txtr", Data.MetaData.TXTR);

                //roof
                AddFromXml(cpf.GetItem("textureedges"), "_txtr", Data.MetaData.TXTR);
                AddFromXml(cpf.GetItem("texturetop"), "_txtr", Data.MetaData.TXTR);
                AddFromXml(cpf.GetItem("texturetopbump"), "_txtr", Data.MetaData.TXTR);
                AddFromXml(cpf.GetItem("texturetrim"), "_txtr", Data.MetaData.TXTR);
                AddFromXml(cpf.GetItem("textureunder"), "_txtr", Data.MetaData.TXTR);

                SimPe.Interfaces.Scenegraph.IScenegraphFileIndexItem[] items =
                    FileTable.FileIndex.FindFile(
                        cpf.GetSaveItem("stringsetrestypeid").UIntegerValue,
                        cpf.GetSaveItem("stringsetgroupid").UIntegerValue,
                        cpf.GetSaveItem("stringsetid").UIntegerValue,
                        null
                        );
                AddFromXml(items);
            }
        }
Пример #5
0
        /// <summary>
        /// Add the MATD referenced by the passed MMAT
        /// </summary>
        /// <param name="mmat">A valid MMAT file</param>
        protected void AddMATD(SimPe.PackedFiles.Wrapper.Cpf mmat)
        {
            SimPe.Packages.File pkg  = SimPe.Packages.File.LoadFromFile(System.IO.Path.Combine(PathProvider.Global.GetExpansion(Expansions.BaseGame).InstallFolder, "TSData\\Res\\Sims3D\\Objects02.package"));
            ArrayList           list = new ArrayList();
            string flname            = Hashes.StripHashFromName(mmat.GetSaveItem("name").StringValue) + "_txmt";

            Interfaces.Files.IPackedFileDescriptor[] pfds = pkg.FindFile(flname, 0x49596978);

            foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
            {
                SimPe.Plugin.Rcol matd = new GenericRcol(null, false);
                matd.ProcessData(pfd, pkg);

                if (matd.FileName.Trim().ToLower() == flname.Trim().ToLower())
                {
                    matd.SynchronizeUserData();
                    if (package.FindFile(matd.FileDescriptor) == null)
                    {
                        package.Add(matd.FileDescriptor);
                    }
                }
            }

            //pkg.Reader.Close();
        }
Пример #6
0
        private bool FindInField(SimPe.PackedFiles.Wrapper.Cpf cpf, bool found, string fldname)
        {
            string n = cpf.GetSaveItem(fldname).StringValue.ToLower();

            if (compareType == CompareType.Equal)
            {
                found = n == name;
            }
            else if (compareType == CompareType.Start)
            {
                found = n.StartsWith(name);
            }
            else if (compareType == CompareType.End)
            {
                found = n.EndsWith(name);
            }
            else if (compareType == CompareType.Contain)
            {
                found = n.IndexOf(name) > -1;
            }
            else if (compareType == CompareType.RegExp && reg != null)
            {
                found = reg.IsMatch(n);
            }
            return(found);
        }
Пример #7
0
        public void ExecuteEventHandler(object sender, SimPe.Events.ResourceEventArgs e)
        {
            if (!RealChangeEnabledStateEventHandler(null, e))
            {
                System.Windows.Forms.MessageBox.Show(Localization.GetString("This is not an appropriate context in which to use this tool"),
                                                     Localization.GetString(this.ToString()));
                return;
            }

            if (Message.Show(SimPe.Localization.GetString("Fix_Fence_Warning"), SimPe.Localization.GetString("Warning"), System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
            {
                return;
            }



            try
            {
                SimPe.Interfaces.Files.IPackedFileDescriptor[] pfds = e.LoadedPackage.Package.FindFiles(Data.MetaData.XFNC);
                foreach (SimPe.Interfaces.Files.IPackedFileDescriptor pfd in pfds)
                {
                    SimPe.PackedFiles.Wrapper.Cpf cpf = new SimPe.PackedFiles.Wrapper.Cpf();
                    cpf.ProcessData(pfd, e.LoadedPackage.Package);

                    uint guid = cpf.GetSaveItem("guid").UIntegerValue;
                    //load the Descriptor for the String Resource
                    SimPe.Interfaces.Files.IPackedFileDescriptor p = e.LoadedPackage.Package.FindFile(
                        cpf.GetSaveItem("stringsetrestypeid").UIntegerValue,
                        0,
                        cpf.GetSaveItem("stringsetgroupid").UIntegerValue,
                        cpf.GetSaveItem("stringsetid").UIntegerValue
                        );

                    //change the Properties
                    cpf.GetSaveItem("resourcegroupid").UIntegerValue  = 0x4c8cc5c0;
                    cpf.GetSaveItem("resourceid").UIntegerValue       = guid;
                    cpf.GetSaveItem("stringsetgroupid").UIntegerValue = guid;

                    cpf.SynchronizeUserData(true, true);

                    //change the Descriptor for the XML
                    cpf.FileDescriptor.Instance = guid;
                    cpf.FileDescriptor.Group    = 0x4c8cc5c0;

                    //change the descriptor for the CTSS
                    if (p != null)
                    {
                        p.Group = guid;
                    }
                }
            }
            catch (Exception ex)
            {
                Helper.ExceptionMessage(ex);
            }
        }
Пример #8
0
        /// <summary>
        /// Remove some unreferenced and useless Files
        /// </summary>
        public void CleanUp()
        {
            if (WaitingScreen.Running)
            {
                WaitingScreen.UpdateMessage("Cleaning up");
            }
            Interfaces.Files.IPackedFileDescriptor[] mpfds = package.FindFiles(Data.MetaData.MMAT);             //MMAT
            ArrayList mmats = new ArrayList();

            foreach (Interfaces.Files.IPackedFileDescriptor pfd in mpfds)
            {
                SimPe.PackedFiles.Wrapper.Cpf mmat = new SimPe.PackedFiles.Wrapper.Cpf();
                mmat.ProcessData(pfd, package);

                string content = Scenegraph.MmatContent(mmat);

                if (!mmats.Contains(content))
                {
                    string txmtname = (string)Hashes.StripHashFromName(mmat.GetSaveItem("name").StringValue.Trim().ToLower()) + "_txmt";
                    string cresname = (string)Hashes.StripHashFromName(mmat.GetSaveItem("modelName").StringValue.Trim().ToLower());

                    if (package.FindFile(Hashes.StripHashFromName(txmtname), 0x49596978).Length < 0)
                    {
                        pfd.MarkForDelete = true;
                    }
                    if (package.FindFile(Hashes.StripHashFromName(cresname), 0xE519C933).Length < 0)
                    {
                        pfd.MarkForDelete = true;
                    }

                    if (!pfd.MarkForDelete)
                    {
                        mmats.Add(content);
                    }
                }
                else
                {
                    pfd.MarkForDelete = true;
                }
            }
        }
Пример #9
0
        /// <summary>
        /// Return all Modelnames that can be found in this package
        /// </summary>
        /// <param name="pkg">The Package you want to scan</param>
        /// <returns>a list of Modelnames</returns>
        public static string[] FindModelNames(SimPe.Interfaces.Files.IPackageFile pkg)
        {
            ArrayList names = new ArrayList();

            Interfaces.Files.IPackedFileDescriptor[] pfds = pkg.FindFile(Data.MetaData.STRING_FILE, 0, 0x85);
            if (pfds.Length > 0)
            {
                foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
                {
                    SimPe.PackedFiles.Wrapper.Str str = new SimPe.PackedFiles.Wrapper.Str();
                    str.ProcessData(pfd, pkg);

                    foreach (SimPe.PackedFiles.Wrapper.StrToken item in str.Items)
                    {
                        string mname = Hashes.StripHashFromName(item.Title.Trim().ToLower());
                        if (!mname.EndsWith("_cres"))
                        {
                            mname += "_cres";
                        }
                        if ((mname != "") && (!names.Contains(mname)))
                        {
                            names.Add(mname);
                        }
                    }
                }
            }

            pfds = pkg.FindFiles(Data.MetaData.MMAT);
            if (pfds.Length > 0)
            {
                foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
                {
                    SimPe.PackedFiles.Wrapper.Cpf cpf = new SimPe.PackedFiles.Wrapper.Cpf();
                    cpf.ProcessData(pfd, pkg);

                    string mname = Hashes.StripHashFromName(cpf.GetSaveItem("modelName").StringValue.Trim().ToLower());
                    if (!mname.EndsWith("_cres"))
                    {
                        mname += "_cres";
                    }
                    if ((mname != "") && (!names.Contains(mname)))
                    {
                        names.Add(mname);
                    }
                }
            }

            string[] ret = new string[names.Count];
            names.CopyTo(ret);

            return(ret);
        }
Пример #10
0
        /// <summary>
        /// Changes all guids (ignore the current GUID)
        /// </summary>
        /// <param name="newguid">The new GUID</param>
        public void FixGuids(uint newguid)
        {
            Interfaces.Files.IPackedFileDescriptor[] mpfds = package.FindFiles(Data.MetaData.MMAT);

            foreach (Interfaces.Files.IPackedFileDescriptor pfd in mpfds)
            {
                SimPe.PackedFiles.Wrapper.Cpf mmat = new SimPe.PackedFiles.Wrapper.Cpf();
                mmat.ProcessData(pfd, package);

                mmat.GetSaveItem("objectGUID").UIntegerValue = newguid;
                mmat.SynchronizeUserData();
            }
        }
Пример #11
0
        /// <summary>
        /// Changes all guids (Depends on the passed Replacement Map)
        /// </summary>
        /// <param name="guids">List of GuidSet Objects</param>
        public void FixGuids(ArrayList guids)
        {
            Interfaces.Files.IPackedFileDescriptor[] mpfds = package.FindFiles(Data.MetaData.MMAT);

            foreach (Interfaces.Files.IPackedFileDescriptor pfd in mpfds)
            {
                SimPe.PackedFiles.Wrapper.Cpf mmat = new SimPe.PackedFiles.Wrapper.Cpf();
                mmat.ProcessData(pfd, package);


                if (guids != null)
                {
                    foreach (GuidSet sget in guids)
                    {
                        if (mmat.GetSaveItem("objectGUID").UIntegerValue == sget.oldguid)
                        {
                            mmat.GetSaveItem("objectGUID").UIntegerValue = sget.guid;
                            mmat.SynchronizeUserData();
                        }
                    }
                }
            }
        }
Пример #12
0
        /// <summary>
        /// Find the Modelname of the Original Object
        /// </summary>
        /// <param name="package">The Package containing the Data</param>
        /// <returns>The Modelname</returns>
        public static string FindMainOldName(SimPe.Interfaces.Files.IPackageFile package)
        {
            Interfaces.Files.IPackedFileDescriptor[] pfds = package.FindFiles(Data.MetaData.STRING_FILE);
            foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
            {
                if (pfd.Instance == 0x85)
                {
                    SimPe.PackedFiles.Wrapper.Str str = new SimPe.PackedFiles.Wrapper.Str();
                    str.ProcessData(pfd, package);

                    SimPe.PackedFiles.Wrapper.StrItemList sil = str.LanguageItems(1);
                    if (sil.Length > 1)
                    {
                        return(sil[1].Title);
                    }
                    else if (str.Items.Length > 1)
                    {
                        return(str.Items[1].Title);
                    }
                }
            }

            pfds = package.FindFiles(0x4C697E5A);
            foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
            {
                SimPe.PackedFiles.Wrapper.Cpf cpf = new SimPe.PackedFiles.Wrapper.Cpf();
                cpf.ProcessData(pfd, package);

                if (cpf.GetSaveItem("modelName").StringValue.Trim() != "")
                {
                    return(cpf.GetSaveItem("modelName").StringValue.Trim());
                }
            }

            return("SimPE");
        }
Пример #13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ocpf">The MMAT or Property Set describing the Model</param>
        /// <returns>The Texture or null</returns>
        public object FindTxtrName(object ocpf)
        {
            SimPe.PackedFiles.Wrapper.Cpf     cpf  = (SimPe.PackedFiles.Wrapper.Cpf)ocpf;
            SimPe.PackedFiles.Wrapper.CpfItem item = cpf.GetSaveItem("name");

            if (cpf.Package != BasePackage)
            {
                string name = FindTxtrName(cpf.FileDescriptor);
                return(FindUserTxtr(name));
            }
            else
            {
                string name = FindTxtrName(item.StringValue + "_txmt");
                return(FindTxtr(name));
            }
        }
Пример #14
0
        protected void UpdateXObjScreen(SimPe.Interfaces.Files.IPackageFile pkg, bool clear)
        {
            if (clear)
            {
                ClearScreen();
            }
            if (cpf == null)
            {
                return;
            }

            nfo.FirstExpansion = PackageInfo.FileFrom(cpf.FileDescriptor);
            SetupCategories(SimPe.Cache.ObjectCacheItem.GetCategory(SimPe.Cache.ObjectCacheItemVersions.DockableOW, (SimPe.Data.ObjFunctionSubSort)GetFunctionSort(cpf), Data.ObjectTypes.Normal, SimPe.Cache.ObjectClass.XObject));

            nfo.Image = GetXThumbnail(cpf);
            if (pkg != null)
            {
                RenderGmdcPreview(pkg);
            }

            SimPe.PackedFiles.Wrapper.StrItemList strs = GetCtssItems();
            if (strs != null)
            {
                if (strs.Count > 0)
                {
                    nfo.Name = strs[0].Title;
                }
                if (strs.Count > 1)
                {
                    nfo.Description = strs[1].Title;
                }
            }
            else
            {
                nfo.Name        = cpf.GetSaveItem("name").StringValue;
                nfo.Description = cpf.GetSaveItem("description").StringValue;
            }


            nfo.Price = (int)cpf.GetSaveItem("cost").UIntegerValue;
            UpdateScreen();
        }
Пример #15
0
        protected void UpdateXObjScreen()
        {
            ClearScreen();
            if (cpf == null)
            {
                return;
            }
            this.lbEPs.Visible = this.lbEPList.Visible = false;

            SetupCategories(SimPe.Cache.ObjectCacheItem.GetCategory(SimPe.Cache.ObjectCacheItemVersions.DockableOW, (SimPe.Data.ObjFunctionSubSort)GetFunctionSort(cpf), Data.ObjectTypes.Normal, SimPe.Cache.ObjectClass.XObject));

            pb.Image = null;
            pb.Image = GenerateImage(pb.Size, GetXThumbnail(cpf), true);

            SimPe.PackedFiles.Wrapper.StrItemList strs = GetCtssItems();
            if (strs != null)
            {
                if (strs.Count > 0)
                {
                    this.lbName.Text = strs[0].Title;
                }
                if (strs.Count > 1)
                {
                    this.lbAbout.Text = strs[1].Title;
                }
            }
            else
            {
                this.lbName.Text  = cpf.GetSaveItem("name").StringValue;
                this.lbAbout.Text = cpf.GetSaveItem("description").StringValue;
            }


            this.lbPrice.Text = cpf.GetSaveItem("cost").UIntegerValue.ToString() + " $";

            if (pb.Image == null)
            {
                pb.Image = defimg;
            }
        }
Пример #16
0
        void FillCategoryNodes(Hashtable mmap)
        {
            WaitingScreen.Wait();
            try
            {
                FileTable.FileIndex.Load();
                Interfaces.Scenegraph.IScenegraphFileIndexItem[] items = FileTable.FileIndex.FindFile(Data.MetaData.GZPS, true);
                foreach (Interfaces.Scenegraph.IScenegraphFileIndexItem item in items)
                {
                    SimPe.PackedFiles.Wrapper.Cpf skin = new SimPe.PackedFiles.Wrapper.Cpf();
                    skin.ProcessData(item);

                    if (skin.GetSaveItem("type").StringValue == "skin")
                    {
                        bool added   = false;
                        uint skinage = skin.GetSaveItem("age").UIntegerValue;
                        uint skincat = skin.GetSaveItem("category").UIntegerValue;
                        if ((skincat & (uint)Data.SkinCategories.Skin) == (uint)Data.SkinCategories.Skin)
                        {
                            skincat = (uint)Data.SkinCategories.Skin;
                        }
                        if (skin.GetSaveItem("override0subset").StringValue.Trim().ToLower().StartsWith("hair"))
                        {
                            skincat = (uint)Data.SkinCategories.Skin;
                        }
                        if (skin.GetSaveItem("override0subset").StringValue.Trim().ToLower().StartsWith("bang"))
                        {
                            skincat = (uint)Data.SkinCategories.Skin;
                        }
                        uint   skinsex = skin.GetSaveItem("gender").UIntegerValue;
                        string name    = skin.GetSaveItem("name").StringValue;
                        foreach (uint age in mmap.Keys)
                        {
                            if ((age & skinage) == age)
                            {
                                Hashtable cats = (Hashtable)mmap[age];
                                foreach (uint cat in cats.Keys)
                                {
                                    if ((cat & skincat) == cat)
                                    {
                                        Hashtable sex = (Hashtable)cats[cat];
                                        foreach (uint g in sex.Keys)
                                        {
                                            if ((g & skinsex) == g)
                                            {
                                                TreeNode parent = (TreeNode)sex[g];
                                                TreeNode node   = new TreeNode(name);
                                                node.Tag = skin;
                                                parent.Nodes.Add(node);

                                                added = true;
                                            }
                                        }
                                    }
                                }
                            }
                        }                         //foreach age

                        if (!added)
                        {
                            TreeNode tn = new TreeNode(name);
                            tn.Tag = skin;
                            tvmale.Nodes.Add(tn);
                            tvfemale.Nodes.Add((TreeNode)tn.Clone());
                        }
                    }
                }
            }
            finally
            {
                WaitingScreen.Stop();
            }
        }
Пример #17
0
        /// <summary>
        /// Fix all links
        /// </summary>
        public string Fix(string family, uint group, ref int ct, Hashtable matdrep, Hashtable txtrrep, ArrayList guids)
        {
            //make sure the references are loaded
            txtr = TXTR;

            string groups = "#0x" + Helper.HexString(group) + "!";

            groups = "##0x1c050000!";
            MMAT.GetSaveItem("family").StringValue = family;
            string matdname = Hashes.StripHashFromName(MMAT.GetSaveItem("name").StringValue) + "_" + family;

            if (matdrep[MMAT.GetSaveItem("name").StringValue] == null)
            {
                matdrep.Add(MMAT.GetSaveItem("name").StringValue, groups + matdname);
                MMAT.GetSaveItem("name").StringValue = groups + matdname;
            }
            else
            {
                MMAT.GetSaveItem("name").StringValue = (string)matdrep[MMAT.GetSaveItem("name").StringValue];
            }

            //make sure we use a supported GUID
            if (guids.Count > 0)
            {
                if (!guids.Contains(MMAT.GetSaveItem("objectGUID").UIntegerValue))
                {
                    MMAT.GetSaveItem("objectGUID").UIntegerValue = (uint)guids[0];
                }
            }

            MMAT.GetSaveItem("defaultMaterial").BooleanValue = false;
            MMAT.FileDescriptor.Instance = (uint)(0x4000 + ct++);
            MMAT.FileDescriptor.Group    = 0xffffffff;

            string txtrname = groups + "_" + family;
            string org      = "";

            if (MATD != null)
            {
                MaterialDefinition md = (MaterialDefinition)MATD.Blocks[0];
                md.FileDescription = matdname;
                MATD.FileName      = groups + matdname + "_txmt";
                SimPe.Packages.PackedFileDescriptor matdpfd = new PackedFileDescriptor();

                matdpfd.Type              = MATD.FileDescriptor.Type;
                MATD.FileDescriptor       = matdpfd;
                MATD.FileDescriptor.Group = 0x1c050000;                 //group; //0x1C0532FA;

                MATD.FileDescriptor.Instance = Hashes.InstanceHash(Hashes.StripHashFromName(MATD.FileName));
                MATD.FileDescriptor.SubType  = Hashes.SubTypeHash(Hashes.StripHashFromName(MATD.FileName));

                org = TxtrRef;
                string realtxtrname = "";                 //Hashes.StripHashFromName(md.GetProperty("stdMatBaseTextureName").Value);
                if (TXTR != null)
                {
                    realtxtrname = Hashes.StripHashFromName(TXTR.FileName);
                    if (realtxtrname.Length > 5)
                    {
                        realtxtrname = realtxtrname.Substring(0, realtxtrname.Length - 5);
                    }
                }

                //we foudn a texture
                if (realtxtrname.Trim() != "")
                {
                    txtrname = realtxtrname + "_" + family;
                    if (txtrrep[realtxtrname] == null)
                    {
                        txtrrep.Add(realtxtrname, txtrname);
                        txtrrep.Add(txtrname, txtrname);
                    }
                    else
                    {
                        txtrname = (string)txtrrep[realtxtrname];
                    }

                    md.GetProperty("stdMatBaseTextureName").Value = /*groups +*/ Hashes.StripHashFromName(txtrname);

                    string[] files = new string[1];
                    files[0]   = /*groups +*/ Hashes.StripHashFromName(txtrname);
                    md.Listing = files;
                }
            }


            if (TXTR != null)
            {
                TXTR.FileName = groups + txtrname + "_txtr";
                SimPe.Packages.PackedFileDescriptor txtrpfd = new PackedFileDescriptor();

                txtrpfd.Type              = TXTR.FileDescriptor.Type;
                TXTR.FileDescriptor       = txtrpfd;
                TXTR.FileDescriptor.Group = 0x1c050000;                 //group; //0x1C0532FA;

                TXTR.FileDescriptor.Instance = Hashes.InstanceHash(Hashes.StripHashFromName(TXTR.FileName));
                TXTR.FileDescriptor.SubType  = Hashes.SubTypeHash(Hashes.StripHashFromName(TXTR.FileName));
            }

            return(org);
        }
Пример #18
0
        /// <summary>
        /// Create a new Instance and load the main Template Files
        /// </summary>
        /// <param name="package"></param>
        public PhotoStudioTemplate(Interfaces.Files.IPackageFile package)
        {
            this.package = package;

            Interfaces.Files.IPackedFileDescriptor pfd = package.FindFile(0xEBCF3E27, 0xffffffff, 0xffffffff, 0xffffffff);
            pset = new SimPe.PackedFiles.Wrapper.Cpf();
            ctss = null;
            if (pfd != null)
            {
                pset.ProcessData(pfd, package);

                pfd = package.FindFile(Data.MetaData.CTSS_FILE, 0xffffffff, 0xffffffff, pset.GetSaveItem("description").UIntegerValue);
                if (pfd != null)
                {
                    ctss = new SimPe.PackedFiles.Wrapper.Str();
                    ctss.ProcessData(pfd, package);
                }
            }
        }
Пример #19
0
 /// <summary>
 /// returns a unique identifier for the MMAT Files
 /// </summary>
 /// <param name="mmat"></param>
 /// <returns></returns>
 public static string MmatContent(SimPe.PackedFiles.Wrapper.Cpf mmat)
 {
     return(mmat.GetSaveItem("modelName").StringValue /*+mmat.GetSaveItem("family").StringValue*/ + mmat.GetSaveItem("subsetName").StringValue + mmat.GetSaveItem("name").StringValue + Helper.HexString(mmat.GetSaveItem("objectStateIndex").UIntegerValue) + Helper.HexString(mmat.GetSaveItem("materialStateFlags").UIntegerValue) + Helper.HexString(mmat.GetSaveItem("objectGUID").UIntegerValue));
 }
Пример #20
0
        public static Data.XObjFunctionSubSort GetFunctionSort(SimPe.PackedFiles.Wrapper.Cpf cpf)
        {
            string type = cpf.GetSaveItem("type").StringValue.Trim().ToLower();

            switch (type)
            {
            case "":
            case "canh":
            {
                string stype = cpf.GetSaveItem("sort").StringValue.Trim().ToLower();
                if (stype == "landmark")
                {
                    return(Data.XObjFunctionSubSort.Hood_Landmark);
                }
                else if (stype == "flora")
                {
                    return(Data.XObjFunctionSubSort.Hood_Flora);
                }
                else if (stype == "effects")
                {
                    return(Data.XObjFunctionSubSort.Hood_Effects);
                }
                else if (stype == "misc")
                {
                    return(Data.XObjFunctionSubSort.Hood_Misc);
                }
                else if (stype == "stone")
                {
                    return(Data.XObjFunctionSubSort.Hood_Stone);
                }
                else
                {
                    return(Data.XObjFunctionSubSort.Hood_Other);
                }
            }

            case "wall":
            {
                string stype = cpf.GetSaveItem("subsort").StringValue.Trim().ToLower();
                if (stype == "brick")
                {
                    return(Data.XObjFunctionSubSort.Wall_Brick);
                }
                else if (stype == "masonry")
                {
                    return(Data.XObjFunctionSubSort.Wall_Masonry);
                }
                else if (stype == "paint")
                {
                    return(Data.XObjFunctionSubSort.Wall_Paint);
                }
                else if (stype == "paneling")
                {
                    return(Data.XObjFunctionSubSort.Wall_Paneling);
                }
                else if (stype == "poured")
                {
                    return(Data.XObjFunctionSubSort.Wall_Poured);
                }
                else if (stype == "siding")
                {
                    return(Data.XObjFunctionSubSort.Wall_Siding);
                }
                else if (stype == "tile")
                {
                    return(Data.XObjFunctionSubSort.Wall_Tile);
                }
                else if (stype == "wallpaper")
                {
                    return(Data.XObjFunctionSubSort.Wall_Wallpaper);
                }
                else
                {
                    return(Data.XObjFunctionSubSort.Wall_Other);
                }
            }

            case "terrainpaint":
            {
                return(Data.XObjFunctionSubSort.Terrain);
            }

            case "floor":
            {
                string stype = cpf.GetSaveItem("subsort").StringValue.Trim().ToLower();
                if (stype == "brick")
                {
                    return(Data.XObjFunctionSubSort.Floor_Brick);
                }
                else if (stype == "carpet")
                {
                    return(Data.XObjFunctionSubSort.Floor_Carpet);
                }
                else if (stype == "lino")
                {
                    return(Data.XObjFunctionSubSort.Floor_Lino);
                }
                else if (stype == "poured")
                {
                    return(Data.XObjFunctionSubSort.Floor_Poured);
                }
                else if (stype == "stone")
                {
                    return(Data.XObjFunctionSubSort.Floor_Stone);
                }
                else if (stype == "tile")
                {
                    return(Data.XObjFunctionSubSort.Floor_Tile);
                }
                else if (stype == "wood")
                {
                    return(Data.XObjFunctionSubSort.Floor_Wood);
                }
                else
                {
                    return(Data.XObjFunctionSubSort.Floor_Other);
                }
            }

            case "roof":
            {
                return(Data.XObjFunctionSubSort.Roof);
            }

            case "fence":
            {
                if (cpf.GetSaveItem("ishalfwall").UIntegerValue == 1)
                {
                    return(Data.XObjFunctionSubSort.Fence_Halfwall);
                }
                return(Data.XObjFunctionSubSort.Fence_Rail);
            }

            default:
            {
                return((Data.XObjFunctionSubSort) 0);
            }
            }
        }
Пример #21
0
        static void ConsumeFromXobj(SimPe.Cache.ObjectCacheItem oci, Interfaces.Scenegraph.IScenegraphFileIndexItem nrefitem, SimPe.Data.MetaData.Languages deflang)
        {
            SimPe.PackedFiles.Wrapper.Cpf cpf = new SimPe.PackedFiles.Wrapper.Cpf();
            nrefitem.FileDescriptor.UserData = nrefitem.Package.Read(nrefitem.FileDescriptor).UncompressedData;
            cpf.ProcessData(nrefitem);

            oci.FileDescriptor = nrefitem.FileDescriptor;
            oci.LocalGroup     = nrefitem.LocalGroup;
            oci.ObjectType     = SimPe.Data.ObjectTypes.Normal;

            SetFunctionSortForXObj(cpf, oci);

            oci.ObjectFileName = cpf.GetSaveItem("filename").StringValue;
            if (oci.ObjectFileName == "")
            {
                oci.ObjectFileName = cpf.GetSaveItem("name").StringValue;
            }

            oci.Useable = true;
            oci.Class   = SimPe.Cache.ObjectClass.XObject;



            Interfaces.Scenegraph.IScenegraphFileIndexItem[] ctssitems = FileTable.FileIndex.FindFile(cpf.GetSaveItem("stringsetrestypeid").UIntegerValue, cpf.GetSaveItem("stringsetgroupid").UIntegerValue, cpf.GetSaveItem("stringsetid").UIntegerValue, null);             //Data.MetaData.STRING_FILE
            if (ctssitems.Length > 0)
            {
                SimPe.PackedFiles.Wrapper.Str str = new SimPe.PackedFiles.Wrapper.Str();
                str.ProcessData(ctssitems[0]);
                SimPe.PackedFiles.Wrapper.StrItemList items = str.LanguageItems(deflang);
                if (items.Length > 0)
                {
                    oci.Name = items[0].Title;
                }
                else
                {
                    items = str.LanguageItems(1);
                    if (items.Length > 0)
                    {
                        oci.Name = items[0].Title;
                    }
                    else
                    {
                        oci.Name = "";
                    }
                }
            }
            else
            {
                oci.Name = "";
            }

            if (oci.Name == "")
            {
                oci.Name = oci.ObjectFileName;
            }

            //now the ModeName File
            if (cpf.GetItem("texturetname") != null)
            {
                oci.ModelName = cpf.GetItem("texturetname").StringValue;
            }
            else if (cpf.GetItem("filename") != null)
            {
                oci.ModelName = cpf.GetItem("filename").StringValue;
            }
            else
            {
                oci.ModelName = cpf.GetSaveItem("material").StringValue;
            }

            //oci.Name = cpf.GetSaveItem("type").StringValue + " - "+ cpf.GetSaveItem("subsort").StringValue;


            if (oci.Thumbnail == null)
            {
                oci.Thumbnail = ObjectPreview.GetXThumbnail(cpf);
            }
            ObjectReader.changedcache = true;
        }
Пример #22
0
        /// <summary>
        /// Chnages materialStateFlags and objectStateIndex according to the MaTD Reference Name
        /// </summary>
        /// <param name="mmat">The MMAT File to change the values in</param>
        public static void FixMMAT(SimPe.PackedFiles.Wrapper.Cpf mmat)
        {
            string name = mmat.GetSaveItem("name").StringValue;

            if (name.EndsWith("_clean"))
            {
                mmat.GetSaveItem("materialStateFlags").UIntegerValue = 0;
                mmat.GetSaveItem("objectStateIndex").IntegerValue    = 0;
            }
            else if (name.EndsWith("_dirty"))
            {
                mmat.GetSaveItem("materialStateFlags").UIntegerValue = 2;
                mmat.GetSaveItem("objectStateIndex").IntegerValue    = 1;
            }
            else if (name.EndsWith("_lit"))
            {
                mmat.GetSaveItem("materialStateFlags").UIntegerValue = 1;
                mmat.GetSaveItem("objectStateIndex").IntegerValue    = 3;
            }
            else if (name.EndsWith("_unlit"))
            {
                mmat.GetSaveItem("materialStateFlags").UIntegerValue = 0;
                mmat.GetSaveItem("objectStateIndex").IntegerValue    = 4;
            }
            else if (name.EndsWith("_on"))
            {
                mmat.GetSaveItem("materialStateFlags").UIntegerValue = 2;
                mmat.GetSaveItem("objectStateIndex").IntegerValue    = 6;
            }
            else if (name.EndsWith("_off"))
            {
                mmat.GetSaveItem("materialStateFlags").UIntegerValue = 0;
                mmat.GetSaveItem("objectStateIndex").IntegerValue    = 5;
            }
        }
Пример #23
0
        public SimPe.Cache.PackageType GetType(SimPe.Interfaces.Files.IPackageFile pkg)
        {
            SimPe.Interfaces.Files.IPackedFileDescriptor[] pfds = pkg.FindFiles(Data.MetaData.GZPS);
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(Data.MetaData.XOBJ);                             //Object XML
            }
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(0x2C1FD8A1);                             //TextureOverlay XML
            }
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(0x8C1580B5);                             //Hairtone XML
            }
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(0x0C1FE246);                             //Mesh Overlay XML
            }
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(Data.MetaData.XROF);                             //Object XML
            }
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(Data.MetaData.XFLR);                             //Object XML
            }
            if (pfds.Length == 0)
            {
                pfds = pkg.FindFiles(Data.MetaData.XFNC);                             //Object XML
            }
            if (pfds.Length > 0)
            {
                SimPe.PackedFiles.Wrapper.Cpf cpf = new SimPe.PackedFiles.Wrapper.Cpf();
                cpf.ProcessData(pfds[0], pkg, false);

                string type = cpf.GetSaveItem("type").StringValue.Trim().ToLower();

                switch (type)
                {
                case "wall":
                {
                    return(SimPe.Cache.PackageType.Wallpaper);
                }

                case "terrainpaint":
                {
                    return(SimPe.Cache.PackageType.Terrain);
                }

                case "floor":
                {
                    return(SimPe.Cache.PackageType.Floor);
                }

                case "roof":
                {
                    return(SimPe.Cache.PackageType.Roof);
                }

                case "fence":
                {
                    return(SimPe.Cache.PackageType.Fence);
                }

                case "skin":
                {
                    uint cat = cpf.GetSaveItem("category").UIntegerValue;

                    if ((cat & (uint)Data.SkinCategories.Skin) != 0)
                    {
                        return(SimPe.Cache.PackageType.Skin);
                    }
                    else
                    {
                        return(SimPe.Cache.PackageType.Cloth);
                    }
                }

                case "meshoverlay":
                case "textureoverlay":
                {
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.Blush)
                    {
                        return(SimPe.Cache.PackageType.Blush);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.Eye)
                    {
                        return(SimPe.Cache.PackageType.Eye);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.EyeBrow)
                    {
                        return(SimPe.Cache.PackageType.EyeBrow);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.EyeShadow)
                    {
                        return(SimPe.Cache.PackageType.EyeShadow);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.Glasses)
                    {
                        return(SimPe.Cache.PackageType.Glasses);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.Lipstick)
                    {
                        return(SimPe.Cache.PackageType.Lipstick);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.Mask)
                    {
                        return(SimPe.Cache.PackageType.Mask);
                    }
                    if (cpf.GetSaveItem("subtype").UIntegerValue == (uint)Data.TextureOverlayTypes.Beard)
                    {
                        return(SimPe.Cache.PackageType.Beard);
                    }

                    if (type == "meshoverlay")
                    {
                        return(SimPe.Cache.PackageType.Accessory);
                    }
                    return(SimPe.Cache.PackageType.Makeup);
                }

                case "hairtone":
                {
                    return(SimPe.Cache.PackageType.Hair);
                }
                }
            }

            return(SimPe.Cache.PackageType.Unknown);
        }
Пример #24
0
        /// <summary>
        /// Add a MMAT to the package
        /// </summary>
        protected SimPe.PackedFiles.Wrapper.Cpf AddMMAT(SimPe.Plugin.Rcol matd, string subset, string cresname, uint instance, bool substate)
        {
            //now add the default MMAT
            System.IO.BinaryReader br = new System.IO.BinaryReader(this.GetType().Assembly.GetManifestResourceStream("SimPe.Plugin.mmat.simpe"));
            SimPe.Packages.PackedFileDescriptor pfd1 = new SimPe.Packages.PackedFileDescriptor();
            pfd1.Group    = 0xffffffff; pfd1.SubType = 0x00000000; pfd1.Instance = instance; pfd1.Type = 0x4C697E5A;          //MMAT
            pfd1.UserData = br.ReadBytes((int)br.BaseStream.Length);

            package.Add(pfd1);
            SimPe.PackedFiles.Wrapper.Cpf mmat = new SimPe.PackedFiles.Wrapper.Cpf();
            mmat.ProcessData(pfd1, package);

            if (!substate)
            {
                mmat.GetSaveItem("family").StringValue = System.Guid.NewGuid().ToString();
            }
            mmat.GetSaveItem("name").StringValue       = matd.FileName.Substring(0, matd.FileName.Length - 5);
            mmat.GetSaveItem("subsetName").StringValue = subset;
            mmat.GetSaveItem("modelName").StringValue  = cresname;

            //Get the GUID
            Interfaces.Files.IPackedFileDescriptor[] pfds = package.FindFiles(Data.MetaData.OBJD_FILE);
            mmat.GetSaveItem("objectGUID").UIntegerValue = 0x00000000;
            foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
            {
                SimPe.PackedFiles.Wrapper.Objd objd = new SimPe.PackedFiles.Wrapper.Objd(null);
                objd.ProcessData(pfds[0], package);
                mmat.GetSaveItem("objectGUID").UIntegerValue = objd.SimId;

                if (pfd.Instance == 0x000041A7)
                {
                    break;
                }
            }

            ObjectRecolor.FixMMAT(mmat);
            mmat.SynchronizeUserData();

            gm_pkg.Add(mmat.FileDescriptor);

            //alternate states
            if (!substate)
            {
                string name = mmat.GetSaveItem("name").StringValue;
                pfds = ObjectCloner.FindStateMatchingMatd(name, package);


                if (pfds != null)
                {
                    if (pfds.Length > 0)
                    {
                        SimPe.Plugin.Rcol submatd = new GenericRcol(null, false);
                        submatd.ProcessData(pfds[0], package);

                        SimPe.PackedFiles.Wrapper.Cpf mmat2 = AddMMAT(submatd, subset, cresname, instance, true);
                        mmat2.GetSaveItem("family").StringValue = mmat.GetSaveItem("family").StringValue;
                    }
                }
            }

            return(mmat);
        }