Subversion Repositories AndroidProjects

package com.gebauz.bauzoid2.graphics.model;

import com.gebauz.bauzoid2.game.Engine;
import com.gebauz.bauzoid2.game.Time;
import com.gebauz.bauzoid2.graphics.animation.Animation;
import com.gebauz.bauzoid2.graphics.util.Transform;
import com.gebauz.bauzoid2.math.Matrix4;
import com.gebauz.bauzoid2.math.Quaternion;
import com.gebauz.bauzoid2.math.Vector4;

/**
 * Created by chris on 12.12.2014.
 */
public class Model
{
    // Constants========================================================================================

    // Embedded Types===================================================================================

    // Fields===========================================================================================

    private String mName;
    private Mesh[] mMeshes = null;

    private ModelNode[] mNodes = null;
    private Material[] mMaterials = null;
        private Animation[] mAnimations = null;

    // Methods==========================================================================================

    public Model(String name)
    {
        mName = name;
    }

    public void dispose()
    {
        destroyNodes();
        destroyMeshes();
        destroyMaterials();
    }

    public void destroyMeshes()
    {
        if (mMeshes != null)
        {
            for (int i = 0; i < mMeshes.length; i++)
            {
                mMeshes[i].dispose();
                mMeshes[i] = null;
            }

            mMeshes = null;
        }
    }

    public void destroyMaterials()
    {
        if (mMaterials != null)
        {
            for (int i = 0; i < mMaterials.length; i++)
            {
                mMaterials[i].dispose();
                mMaterials[i] = null;
            }
            mMaterials = null;
        }
    }

    public void destroyNodes()
    {
        if (mNodes != null)
        {
            for (int i = 0; i < mNodes.length; i++)
            {
                mNodes[i] = null;
            }
            mNodes = null;
        }
    }

        public ModelNode findNode(String id)
        {
                for (ModelNode node : mNodes)
                {
                        if (node.getName().equalsIgnoreCase(id))
                                return node;
                }

                return null;
        }

    public void calcGlobalTransforms()
    {
        for (int i = 0; i < mNodes.length; i++)
        {
            ModelNode node = mNodes[i];

            /*com.badlogic.gdx.math.Vector3 translation = new com.badlogic.gdx.math.Vector3(
                node.transform.translation.x, node.transform.translation.y, node.transform.translation.z);
            com.badlogic.gdx.math.Quaternion rotation = new com.badlogic.gdx.math.Quaternion(
                node.transform.rotation.x, node.transform.rotation.y, node.transform.rotation.z, node.transform.rotation.w
            );
            com.badlogic.gdx.math.Vector3 scale = new com.badlogic.gdx.math.Vector3(
                node.transform.scale.x, node.transform.scale.y, node.transform.scale.z
            );

            node.localTransform.set(translation, rotation, scale);

            if (node.getParentIndex() != -1)
            {
                ModelNode parentNode = mNodes[node.getParentIndex()];
                node.globalTransform.set(parentNode.globalTransform).mul(node.localTransform);
            }
            else
            {
                node.globalTransform.set(node.localTransform);
            }*/


                        node.getGlobalTransform().copyFrom(node.transform.calcMatrix());
                        node.getGlobalBindPose().copyFrom(node.bindPose.calcMatrix());
            if (node.getParentIndex() != -1)
            {
                ModelNode parentNode = mNodes[node.getParentIndex()];
                node.getGlobalTransform().postMultiply(parentNode.getGlobalTransform());
                                node.getGlobalBindPose().postMultiply(parentNode.getGlobalBindPose());
            }
        }
    }

    public void render()
    {
                for (Animation anim : mAnimations)
                {
                        anim.setCurrentTime(Time.getRunTime() * 1000);
            anim.setCurrentTime(0);
                        anim.applyAnimation();
                }

        calcGlobalTransforms();

        for (int i = 0; i < mNodes.length; i++)
        {
            ModelNode node = mNodes[i];

            Engine.graphics.renderStates.pushModelMatrix();
            Engine.graphics.renderStates.model.postMultiply(node.getGlobalTransform());

            if (node.parts != null)
            {
                for (ModelPart part : node.parts)
                {
                                        // render bones
                                        part.getMaterial().beginRender();
                    part.getMaterial().setMatrixPalette(part.calcBoneMatrices());
                    //part.render();
                                        part.getMeshGroup().render();
                                        part.getMaterial().endRender();

                                        /*for (int j = 0; j < part.getBoneInfluences().length; j++)
                                        {
                                                ModelNode bone = part.getBoneInfluences()[j];
                                                Transform t = part.getBoneTransforms()[j];

                                                Engine.graphics.renderStates.pushModelMatrix();
                                                Engine.graphics.renderStates.model.copyFrom(bone.getGlobalTransform());
                                                //Engine.graphics.renderStates.model.preMultiply(t.calcMatrix());
                                                //Quaternion q = new Quaternion(0.5f, -0.5f, 0.5f, 0.5f);
                                                //Engine.graphics.renderStates.model.preMultiply(q.toMatrix());
                                                //Engine.graphics.renderStates.model.preMultiply(Matrix4.createScale(3));
                                                Engine.graphics.util.drawMarker(new Vector4(1, 1, 0, 1));
                                                Engine.graphics.renderStates.popModelMatrix();
                                        }*/
                }
            }
                        else
                        {
                                /*Engine.graphics.renderStates.pushModelMatrix();
                                //Quaternion q = new Quaternion(0.5f, -0.5f, 0.5f, 0.5f);
                                //Engine.graphics.renderStates.model.preMultiply(q.toMatrix());
                                //Engine.graphics.renderStates.model.preMultiply(Matrix4.createScale(3));
                                Engine.graphics.util.drawMarker(new Vector4(1, 1, 0, 1));
                                Engine.graphics.renderStates.popModelMatrix();*/
                        }

            Engine.graphics.renderStates.popModelMatrix();
        }
    }

    // Getters/Setters==================================================================================

    public final void setMeshes(Mesh[] meshes) { mMeshes = meshes; }
    public final Mesh[] getMeshes() { return mMeshes; }

    public final void setMaterials(Material[] materials) { mMaterials = materials; }
    public final Material[] getMaterials() { return mMaterials; }

    public final void setNodes(ModelNode[] nodes) { mNodes = nodes; }
    public final ModelNode[] getNodes() { return mNodes; }

        public final void setAnimations(Animation[] anims) { mAnimations = anims; }
        public final Animation[] getAnimations() { return mAnimations; }
}