コード例 #1
0
        // Demolish object to reference
        public static bool DemolishReference(RayfireRigid scr)
        {
            if (scr.demolitionType == DemolitionType.ReferenceDemolition)
            {
                // Get instance
                GameObject referenceGo = scr.referenceDemolition.GetReference();

                // Has reference
                if (referenceGo != null)
                {
                    // Instantiate turned off reference
                    bool refState = referenceGo.activeSelf;
                    referenceGo.SetActive(false);
                    GameObject fragRoot = scr.InstantiateGo(referenceGo);
                    referenceGo.SetActive(refState);
                    fragRoot.name = referenceGo.name;

                    // Set tm
                    scr.rootChild                  = fragRoot.transform;
                    scr.rootChild.position         = scr.transForm.position;
                    scr.rootChild.rotation         = scr.transForm.rotation;
                    scr.rootChild.transform.parent = RayfireMan.inst.transForm;

                    // Clear list for fragments
                    scr.fragments = new List <RayfireRigid>();

                    // Check root for rigid props
                    RayfireRigid rootScr = fragRoot.gameObject.GetComponent <RayfireRigid>();

                    // Reference Root has not rigid. Add to
                    if (rootScr == null && scr.referenceDemolition.addRigid == true)
                    {
                        // Add rigid and copy
                        rootScr = fragRoot.gameObject.AddComponent <RayfireRigid>();
                        rootScr.initialization = RayfireRigid.InitType.AtStart;

                        scr.CopyPropertiesTo(rootScr);

                        // Copy particles
                        RFParticles.CopyParticles(scr, rootScr);

                        // Single mesh TODO improve
                        if (fragRoot.transform.childCount == 0)
                        {
                            rootScr.objectType = ObjectType.Mesh;
                        }

                        // Multiple meshes
                        if (fragRoot.transform.childCount > 0)
                        {
                            rootScr.objectType = ObjectType.MeshRoot;
                        }
                    }

                    // Activate and init rigid
                    scr.rootChild.gameObject.SetActive(true);

                    // Reference has rigid
                    if (rootScr != null)
                    {
                        // Create rigid for root children
                        if (rootScr.objectType == ObjectType.MeshRoot)
                        {
                            for (int i = 0; i < rootScr.fragments.Count; i++)
                            {
                                rootScr.fragments[i].limitations.currentDepth++;
                            }
                            scr.fragments.AddRange(rootScr.fragments);
                            scr.DestroyRigid(rootScr);
                        }

                        // Get ref rigid
                        else if (rootScr.objectType == ObjectType.Mesh ||
                                 rootScr.objectType == ObjectType.SkinnedMesh)
                        {
                            rootScr.meshDemolition.runtimeCaching.type = CachingType.Disable;
                            RFDemolitionMesh.DemolishMesh(rootScr);

                            // TODO COPY MESH DATA FROM ROOTSCR TO THIS TO REUSE

                            scr.fragments.AddRange(rootScr.fragments);
                            RayfireMan.DestroyFragment(rootScr, rootScr.rootParent, 1f);
                        }

                        // Get ref rigid
                        else if (rootScr.objectType == ObjectType.NestedCluster ||
                                 rootScr.objectType == ObjectType.ConnectedCluster)
                        {
                            rootScr.Default();
                            rootScr.limitations.contactPoint = scr.limitations.contactPoint;
                            RFDemolitionCluster.DemolishCluster(rootScr);
                            rootScr.physics.exclude = true;
                            scr.fragments.AddRange(rootScr.fragments);
                            RayfireMan.DestroyFragment(rootScr, rootScr.rootParent, 1f);
                        }

                        // Has rigid by has No fragments. Stop demolition
                        if (scr.HasFragments == false)
                        {
                            scr.demolitionType = DemolitionType.None;
                            return(false);
                        }
                    }
                }

                // Has no rigid, has No fragments, but demolished
                scr.limitations.demolished = true;
            }

            return(true);
        }
コード例 #2
0
        // Demolish object to reference
        public static bool DemolishReference(RayfireRigid scr)
        {
            if (scr.demolitionType == DemolitionType.ReferenceDemolition)
            {
                // Demolished
                scr.limitations.demolished = true;

                // Turn off original
                scr.gameObject.SetActive(false);

                // Get instance
                GameObject refGo = scr.referenceDemolition.GetReference();

                // Has no reference
                if (refGo == null)
                {
                    return(true);
                }

                // Instantiate turned off reference with null parent
                GameObject instGo = Object.Instantiate(refGo, scr.transForm.position, scr.transForm.rotation);
                instGo.name = refGo.name;

                // Set root to manager or to the same parent
                if (RayfireMan.inst != null && RayfireMan.inst.advancedDemolitionProperties.parent == RFManDemolition.FragmentParentType.Manager)
                {
                    instGo.transform.parent = RayfireMan.inst.transform;
                }
                else
                {
                    instGo.transform.parent = scr.transForm.parent;
                }

                // Set tm
                scr.rootChild = instGo.transform;

                // Copy scale
                if (scr.referenceDemolition.inheritScale == true)
                {
                    scr.rootChild.localScale = scr.transForm.localScale;
                }

                // Clear list for fragments
                scr.fragments = new List <RayfireRigid>();

                // Check root for rigid props
                RayfireRigid refScr = instGo.gameObject.GetComponent <RayfireRigid>();

                // Reference Root has not rigid. Add to
                if (refScr == null && scr.referenceDemolition.addRigid == true)
                {
                    // Add rigid and copy
                    refScr = instGo.gameObject.AddComponent <RayfireRigid>();

                    // Copy rigid
                    scr.CopyPropertiesTo(refScr);

                    // Copy particles
                    RFParticles.CopyParticles(scr, refScr);

                    // Single mesh TODO improve
                    if (instGo.transform.childCount == 0)
                    {
                        refScr.objectType = ObjectType.Mesh;
                    }

                    // Multiple meshes
                    if (instGo.transform.childCount > 0)
                    {
                        refScr.objectType = ObjectType.MeshRoot;
                    }
                }

                // Activate and init rigid
                instGo.transform.gameObject.SetActive(true);

                // Reference has rigid
                if (refScr != null)
                {
                    // Init if not initialized yet
                    refScr.Initialize();

                    // Create rigid for root children
                    if (refScr.objectType == ObjectType.MeshRoot)
                    {
                        for (int i = 0; i < refScr.fragments.Count; i++)
                        {
                            refScr.fragments[i].limitations.currentDepth++;
                        }
                        scr.fragments.AddRange(refScr.fragments);
                        scr.DestroyRigid(refScr);
                    }

                    // Get ref rigid
                    else if (refScr.objectType == ObjectType.Mesh ||
                             refScr.objectType == ObjectType.SkinnedMesh)
                    {
                        refScr.meshDemolition.runtimeCaching.type = CachingType.Disable;
                        RFDemolitionMesh.DemolishMesh(refScr);

                        // TODO COPY MESH DATA FROM ROOTSCR TO THIS TO REUSE

                        scr.fragments.AddRange(refScr.fragments);


                        RayfireMan.DestroyFragment(refScr, refScr.rootParent, 1f);
                    }

                    // Get ref rigid
                    else if (refScr.objectType == ObjectType.NestedCluster ||
                             refScr.objectType == ObjectType.ConnectedCluster)
                    {
                        refScr.Default();

                        // Copy contact data
                        refScr.limitations.contactPoint   = scr.limitations.contactPoint;
                        refScr.limitations.contactVector3 = scr.limitations.contactVector3;
                        refScr.limitations.contactNormal  = scr.limitations.contactNormal;

                        // Demolish
                        RFDemolitionCluster.DemolishCluster(refScr);

                        // Collect new fragments
                        scr.fragments.AddRange(refScr.fragments);


                        //refScr.physics.exclude = true;
                        //RayfireMan.DestroyFragment (refScr, refScr.rootParent, 1f);
                    }
                }
            }

            return(true);
        }