コード例 #1
0
    public void ApplyBlendOffsets()
    {
        BlendShapeLoader           loader      = BlendShapeLoader.GetComponent <BlendShapeLoader>();
        Dictionary <string, float> blendValues = loader.GetBlendShapeValues();

        foreach (GameObject gameObject in m_particleEntities.Values)
        {
            DynamicParticleComponent particle = gameObject.GetComponent <DynamicParticleComponent>();

            BodyShapeOffSetTable offsetsTable = particle.ParticleInfo.VertInfo.BodyShapeOffsetTable;

            Vector3 offset   = Vector3.zero;
            Vector3 original = m_particleSnapShot[particle.ParticleInfo.VertInfo.VertID];

            offset = original;
            foreach (KeyValuePair <string, Vector3> kvp in offsetsTable.Definitions)
            {
                if (blendValues.TryGetValue(kvp.Key, out float blendValue))
                {
                    offset += Vector3.Lerp(original, kvp.Value, blendValue) - original;
                }
            }
            gameObject.transform.position = offset;
        }

        foreach (GameObject gameObject in m_collisionEntities.Values)
        {
            DynamicCollisionComponent collision    = gameObject.GetComponent <DynamicCollisionComponent>();
            CollisionInfoShapeOffsets offsetsTable = collision.CollisionInfo.CollisionInfoDefinition.BodyShapeOffSets;
        }
    }
コード例 #2
0
    public void GenerateParticleOffset(string blendShapeName)
    {
        SkinnedMeshRenderer        skinnedMeshRender = Model.GetComponentInChildren <SkinnedMeshRenderer>();
        BlendShapeLoader           loader            = BlendShapeLoader.GetComponent <BlendShapeLoader>();
        MeshCollider               meshCollider      = loader.CurrentModel.AddComponent <MeshCollider>();
        Dictionary <string, float> blendValues       = loader.GetBlendShapeValues();

        loader.SetBlendShapeValue(blendShapeName, 1.0f);
        Mesh bakedMesh = new Mesh();

        skinnedMeshRender.BakeMesh(bakedMesh);

        meshCollider.sharedMesh = bakedMesh;

        foreach (GameObject gameObject in m_particleEntities.Values)
        {
            DynamicParticleComponent particle = gameObject.GetComponent <DynamicParticleComponent>();
            BodyShapeOffSetTable     offsets  = particle.ParticleInfo.VertInfo.BodyShapeOffsetTable;
            float   colliderRadius            = particle.ParticleInfo.ConfigValues.m_colliderRadius;
            float   colliderRadiusScale       = particle.ParticleInfo.VertInfo.ColliderRadiusScale;
            Vector3 pointOnMesh = meshCollider.ClosestPoint(gameObject.transform.position);
            Vector3 dir         = (pointOnMesh - gameObject.transform.position).normalized;

            Vector3 finalPosition = pointOnMesh + dir * (colliderRadius * colliderRadiusScale);

            offsets.Definitions[blendShapeName] = finalPosition;
        }

        DestroyImmediate(meshCollider);
    }
コード例 #3
0
    public void LoadModel()
    {
        if (Model != null)
        {
            DestroyImmediate(Model);
            Model = null;
        }

        GameObject asset = AssetDatabase.LoadAssetAtPath <GameObject>(ModelPath);

        Model  = Instantiate(asset);
        Gender = ModelPath.Contains("female") ? GenderEnum.Female : GenderEnum.Male;

        string           gender = Gender == GenderEnum.Female ? "f_" : "m_";
        BlendShapeLoader loader = BlendShapeLoader.GetComponent <BlendShapeLoader>();

        loader.SetBlendShapesModel(gender + "blendsShapes");

        if (Model != null)
        {
            SkinnedMeshRenderer renderer = Model.GetComponentInChildren <SkinnedMeshRenderer>();

            if (renderer != null)
            {
                renderer.material = m_defaultMaterial;
            }

            Model.transform.position = Vector3.zero;
            Model.transform.SetParent(transform);
            //added for visualisation.
            ViewSkeleton skelVisual = Model.AddComponent <ViewSkeleton>();

            skelVisual.rootNode = Model.transform;
        }
    }
コード例 #4
0
    private void BlendShapePanel(ClothSimEntity clothSimEntity)
    {
        m_foldoutStateBlend = EditorGUILayout.BeginFoldoutHeaderGroup(m_foldoutStateBlend, "BlendShapes");
        BlendShapeLoader loader = null;

        if (clothSimEntity.BlendShapeLoader != null)
        {
            loader = clothSimEntity.BlendShapeLoader.GetComponent <BlendShapeLoader>();

            if (GUILayout.Button("Update BlendShapes"))
            {
                if (!clothSimEntity.AllowBlendShapeUpdate)
                {
                    clothSimEntity.Model.SetActive(false);
                    loader.SetBlendShapeActive(true);
                    clothSimEntity.SaveSnapShot();
                    clothSimEntity.AllowBlendShapeUpdate = true;
                }
                else
                {
                    clothSimEntity.Model.SetActive(true);
                    loader.SetBlendShapeActive(false);
                    loader.ClearBlendShapes();
                    clothSimEntity.RestoreSnapShot();
                    clothSimEntity.AllowBlendShapeUpdate = false;
                }
            }

            if (clothSimEntity.AllowBlendShapeUpdate)
            {
                Dictionary <string, float> blendShapeValues = loader.GetBlendShapeValues();
                Dictionary <string, float> newValues        = new Dictionary <string, float>(blendShapeValues);

                foreach (KeyValuePair <string, float> kvp in blendShapeValues)
                {
                    EditorGUILayout.LabelField(kvp.Key);
                    newValues[kvp.Key] = EditorGUILayout.Slider(kvp.Value, 0.0f, 1.0f);
                }

                loader.SetBlendShapeValues(newValues);
            }

            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
        }
        EditorGUILayout.EndFoldoutHeaderGroup();
    }
コード例 #5
0
    private void GenerateBlendShapeOffsetsPanel(ClothSimEntity clothSimEntity)
    {
        m_foldoutStateBlendShapeOffsets = EditorGUILayout.BeginFoldoutHeaderGroup(m_foldoutStateBlendShapeOffsets, "BlendShapes Offsets");
        BlendShapeLoader loader = null;

        if (clothSimEntity.BlendShapeLoader != null)
        {
            loader = clothSimEntity.BlendShapeLoader.GetComponent <BlendShapeLoader>();

            string[] opts = loader.GetBlendShapeValues().Keys.ToArray();

            m_blendShapeIndex = EditorGUILayout.Popup(m_blendShapeIndex, opts);

            if (GUILayout.Button("Generate BlendShape Offsets"))
            {
                clothSimEntity.GenerateParticleOffset(opts[m_blendShapeIndex]);
            }
        }

        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
        EditorGUILayout.EndFoldoutHeaderGroup();
    }
コード例 #6
0
    private void BlendShapeEditor(ClothSimEntity clothSimEntity, DynamicCollisionComponent dynamicCollision, CollisionInfoShapeOffsets offsetsTable)
    {
        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
        ShapeRenderer    shapeRenderer    = clothSimEntity.ShapeRenderer.GetComponent <ShapeRenderer>();
        BlendShapeLoader blendShapeLoader = clothSimEntity.BlendShapeLoader.GetComponent <BlendShapeLoader>();

        string[] opts = offsetsTable.BodyShapeOffsets.Keys.ToArray();

        m_currentOffsetsIndex = EditorGUILayout.Popup(m_currentOffsetsIndex, opts);
        Material modelMaterial = clothSimEntity.Model.GetComponentInChildren <SkinnedMeshRenderer>().material;
        bool     isCapsule     = dynamicCollision.CollisionInfo.CollisionInfoDefinition.CollisionType == "capsule";

        if (opts.Count() > 0)
        {
            EditorGUILayout.BeginHorizontal();
            //this is Blah
            if (GUILayout.Button("Edit"))
            {
                if (!m_isEditMode)
                {
                    if (offsetsTable.BodyShapeOffsets.TryGetValue(opts[m_currentOffsetsIndex], out CollisionInfoDefinition outDef))
                    {
                        float radius = dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius;
                        float length = isCapsule ? dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length : 0.0f;

                        shapeRenderer.Initialise(isCapsule ? Shape.ShapeType.Capsule : Shape.ShapeType.Sphere, dynamicCollision.transform.rotation, dynamicCollision.transform.position, radius, length);
                        blendShapeLoader.ClearBlendShapes();
                        blendShapeLoader.SetBlendShapeActive(true);
                        blendShapeLoader.SetBlendShapeValue(opts[m_currentOffsetsIndex], 1.0f);
                        dynamicCollision.DummyObject.transform.localPosition = outDef.PositionOffset;
                        //dynamicCollision.transform.position = dynamicCollision.DummyObject.transform.position;
                        dynamicCollision.DummyObject.transform.localEulerAngles = outDef.RotationOffset;
                        dynamicCollision.transform.rotation = dynamicCollision.DummyObject.transform.rotation;
                        dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius = outDef.Radius;

                        if (isCapsule)
                        {
                            dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length = outDef.Length;
                        }

                        modelMaterial.color = ClothSimEntity.Translucient;
                        m_isEditMode        = true;
                    }
                }
                else
                {
                    dynamicCollision.transform.position = shapeRenderer.transform.position;
                    dynamicCollision.transform.rotation = shapeRenderer.transform.rotation;
                    dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length = shapeRenderer.ShapeDefinition.Length;
                    dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius = shapeRenderer.ShapeDefinition.Radius;

                    shapeRenderer.Clear();
                    m_isEditMode = false;
                    blendShapeLoader.ClearBlendShapes();
                    modelMaterial.color = ClothSimEntity.Opaque;
                }
            }
            EditorGUILayout.EndHorizontal();

            if (m_isEditMode)
            {
                dynamicCollision.DummyObject.transform.localPosition = EditorGUILayout.Vector3Field("Position Offset", dynamicCollision.DummyObject.transform.localPosition);


                Vector3 eulerAngles = dynamicCollision.GetEulerAnglesDegrees(dynamicCollision.DummyObject.transform.localRotation);

                dynamicCollision.DummyObject.transform.localEulerAngles = EditorGUILayout.Vector3Field("Rotation Offset", eulerAngles);

                if (isCapsule)
                {
                    dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length = EditorGUILayout.FloatField("Length", dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length);
                }

                dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius = EditorGUILayout.FloatField("Radius", dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius);

                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("Save"))
                {
                    CollisionInfoDefinition collisionInfoDefinition = offsetsTable.BodyShapeOffsets[opts[m_currentOffsetsIndex]];

                    collisionInfoDefinition.PositionOffset = dynamicCollision.DummyObject.transform.localPosition;

                    Vector3 saveEulerAngles = dynamicCollision.GetEulerAnglesDegrees(dynamicCollision.DummyObject.transform.localRotation);
                    collisionInfoDefinition.RotationOffset = saveEulerAngles;
                    collisionInfoDefinition.Radius         = dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius;

                    if (isCapsule)
                    {
                        collisionInfoDefinition.Length = dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length;
                    }

                    //restore the original values.

                    dynamicCollision.CollisionInfo.CollisionInfoDefinition.Radius = shapeRenderer.ShapeDefinition.Radius;
                    dynamicCollision.CollisionInfo.CollisionInfoDefinition.Length = shapeRenderer.ShapeDefinition.Length;

                    dynamicCollision.transform.position = shapeRenderer.transform.position;
                    dynamicCollision.transform.rotation = shapeRenderer.transform.rotation;

                    shapeRenderer.Clear();
                    blendShapeLoader.ClearBlendShapes();
                    modelMaterial.color = ClothSimEntity.Opaque;
                    m_isEditMode        = false;
                }

                EditorGUILayout.EndHorizontal();
            }
        }

        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("Add Offset"))
        {
        }

        if (GUILayout.Button("Remove Offset"))
        {
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
    }
コード例 #7
0
    private void BlendShapeEditor(ClothSimEntity clothSimEntity, DynamicParticleComponent dynamicParticle, BodyShapeOffSetTable offsetsTable)
    {
        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
        ShapeRenderer    shapeRenderer    = clothSimEntity.ShapeRenderer.GetComponent <ShapeRenderer>();
        BlendShapeLoader blendShapeLoader = clothSimEntity.BlendShapeLoader.GetComponent <BlendShapeLoader>();

        string[] opts = offsetsTable.Definitions.Keys.ToArray();

        m_currentOffsetsIndex = EditorGUILayout.Popup(m_currentOffsetsIndex, opts);
        Material modelMaterial = clothSimEntity.Model.GetComponentInChildren <SkinnedMeshRenderer>().material;

        //this is Blah
        if (opts.Count() > 0)
        {
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Edit"))
            {
                if (!m_isEditMode)
                {
                    if (offsetsTable.Definitions.TryGetValue(opts[m_currentOffsetsIndex], out Vector3 outVector))
                    {
                        float radius      = dynamicParticle.ParticleInfo.ConfigValues.m_colliderRadius;
                        float radiusScale = dynamicParticle.ParticleInfo.VertInfo.ColliderRadiusScale;
                        shapeRenderer.Initialise(Shape.ShapeType.Sphere, dynamicParticle.transform.rotation, dynamicParticle.transform.position, radius * radiusScale);
                        blendShapeLoader.ClearBlendShapes();
                        blendShapeLoader.SetBlendShapeActive(true);
                        blendShapeLoader.SetBlendShapeValue(opts[m_currentOffsetsIndex], 1.0f);
                        dynamicParticle.transform.position = outVector;
                        modelMaterial.color = ClothSimEntity.Translucient;

                        m_isEditMode = true;
                    }
                }
                else
                {
                    dynamicParticle.transform.position = shapeRenderer.transform.position;
                    shapeRenderer.Clear();
                    m_isEditMode = false;
                    blendShapeLoader.ClearBlendShapes();
                    modelMaterial.color = ClothSimEntity.Opaque;
                }
            }
            EditorGUILayout.EndHorizontal();

            if (m_isEditMode)
            {
                EditorGUILayout.BeginHorizontal();
                dynamicParticle.transform.position = EditorGUILayout.Vector3Field("Position", dynamicParticle.transform.position);

                if (GUILayout.Button("Save"))
                {
                    offsetsTable.Definitions[opts[m_currentOffsetsIndex]] = dynamicParticle.transform.position;
                    dynamicParticle.transform.position = shapeRenderer.transform.position;

                    shapeRenderer.Clear();
                    blendShapeLoader.ClearBlendShapes();
                    modelMaterial.color = ClothSimEntity.Opaque;
                    m_isEditMode        = false;
                }

                EditorGUILayout.EndHorizontal();
            }
        }


        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("Add Offset"))
        {
        }

        if (GUILayout.Button("Remove Offset"))
        {
        }
        EditorGUILayout.EndHorizontal();
        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
    }