Суббота, 24.02.2018, 14:46
Поиск
Никнэйм
Сертификат на никнейм Olelucoye, зарегистрирован на Тимофеев Константин Михайлович
Зарегистрируй свой никнейм
Обратная связь
olelucoye.tk@yandex.ru
Реклама AdSense
Реклама
Друзья сайта
  • Лига медицинского права
  • Гостиница "Зай"
  • FAQ по системе
  • Инструкции для uCoz
  • Главная » Статьи » libGDX

    libGDX. Анимация персонажа. Полный код главного класса.

    libGDX. Анимация персонажа. Полный код главного класса.

    import com.badlogic.gdx.ApplicationAdapter;
    import com.badlogic.gdx.Gdx;
    import com.badlogic.gdx.InputMultiplexer;
    import com.badlogic.gdx.InputProcessor;
    import com.badlogic.gdx.Input.Keys;
    import com.badlogic.gdx.assets.AssetManager;
    import com.badlogic.gdx.graphics.GL20;
    import com.badlogic.gdx.graphics.Mesh;
    import com.badlogic.gdx.graphics.PerspectiveCamera;
    import com.badlogic.gdx.graphics.Texture;
    import com.badlogic.gdx.graphics.VertexAttributes.Usage;
    import com.badlogic.gdx.graphics.g2d.Batch;
    import com.badlogic.gdx.graphics.g2d.TextureAtlas;
    import com.badlogic.gdx.graphics.g2d.TextureRegion;
    import com.badlogic.gdx.graphics.g3d.Environment;
    import com.badlogic.gdx.graphics.g3d.Material;
    import com.badlogic.gdx.graphics.g3d.Model;
    import com.badlogic.gdx.graphics.g3d.ModelBatch;
    import com.badlogic.gdx.graphics.g3d.ModelInstance;
    import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
    import com.badlogic.gdx.graphics.g3d.attributes.TextureAttribute;
    import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight;
    import com.badlogic.gdx.graphics.g3d.utils.AnimationController;
    import com.badlogic.gdx.graphics.g3d.utils.AnimationController.AnimationDesc;
    import com.badlogic.gdx.graphics.g3d.utils.AnimationController.AnimationListener;
    import com.badlogic.gdx.graphics.g3d.utils.CameraInputController;
    import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
    import com.badlogic.gdx.math.Matrix4;
    import com.badlogic.gdx.math.Vector3;
    import com.badlogic.gdx.physics.bullet.Bullet;
    import com.badlogic.gdx.physics.bullet.collision.Collision;
    import com.badlogic.gdx.physics.bullet.collision.btBroadphaseInterface;
    import com.badlogic.gdx.physics.bullet.collision.btCollisionConfiguration;
    import com.badlogic.gdx.physics.bullet.collision.btCollisionDispatcher;
    import com.badlogic.gdx.physics.bullet.collision.btCollisionShape;
    import com.badlogic.gdx.physics.bullet.collision.btConvexHullShape;
    import com.badlogic.gdx.physics.bullet.collision.btDbvtBroadphase;
    import com.badlogic.gdx.physics.bullet.collision.btDefaultCollisionConfiguration;
    import com.badlogic.gdx.physics.bullet.collision.btDispatcher;
    import com.badlogic.gdx.physics.bullet.collision.btShapeHull;
    import com.badlogic.gdx.physics.bullet.dynamics.btConstraintSolver;
    import com.badlogic.gdx.physics.bullet.dynamics.btDiscreteDynamicsWorld;
    import com.badlogic.gdx.physics.bullet.dynamics.btDynamicsWorld;
    import com.badlogic.gdx.physics.bullet.dynamics.btRigidBody;
    import com.badlogic.gdx.physics.bullet.dynamics.btSequentialImpulseConstraintSolver;
    import com.badlogic.gdx.physics.bullet.linearmath.btMotionState;
    import com.badlogic.gdx.scenes.scene2d.Actor;
    import com.badlogic.gdx.scenes.scene2d.Stage;
    import com.badlogic.gdx.scenes.scene2d.Touchable;
    import com.badlogic.gdx.utils.Disposable;
    public class interface2d extends ApplicationAdapter implements InputProcessor {
        PerspectiveCamera cam;
        public ModelBatch modelBatch;
        public Environment environment;
        public CameraInputController camController;
        public AssetManager assets;
        boolean loading;
        Model ground, man;
        ModelInstanceAdv groundInst, manInst;
        btDynamicsWorld dynWorld;
        btBroadphaseInterface broadphase;
        btConstraintSolver solver;
        btCollisionConfiguration collisionConf;
        btDispatcher collisionDispatcher;
        InputMultiplexer multiplexer;
        boolean forward = false;
        boolean back = false;
        boolean right = false;
        boolean left = false;
        int rotateAngle = 0;
        float jump = 1;
        float direction = 0, oldDir = 0;
        int scrX, scrY;
        float scaling;
        int oldX =0, oldY = 0, newX = 0, newY = 0;
        public Material land;
        String aName = " ";
        TheStage stage;
        TextureAtlas buttons;
        ButtonActor btnForward, btnBack, btnRight, btnLeft, btnRotateRight, btnRotateLeft, btnJump;
        AnimationController animController;
        AnimationListener jumpListener;
        
        static class ModelInstanceAdv extends ModelInstance implements Disposable{
            public final btRigidBody body;
            public final MotionStateAdv motionState;
            
            public ModelInstanceAdv(Model model, btRigidBody.btRigidBodyConstructionInfo bodyInfo) {
                super(model);
                body = new btRigidBody(bodyInfo);
                motionState = new MotionStateAdv();
                motionState.transform = transform;
                body.setMotionState(motionState);
            }
            @Override
            public void dispose() {
                body.dispose();
                motionState.dispose();
            }
            
            static class Constructor implements Disposable{
                public final Model model;
                public final btCollisionShape collShape;
                public final btRigidBody.btRigidBodyConstructionInfo bodyInfo;
                private static Vector3 inertia = new Vector3();
                public Constructor(Model model, btCollisionShape collShape, float mass){
                    this.model = model;
                    this.collShape = collShape;
                    if(mass > 0f){
                        collShape.calculateLocalInertia(mass, inertia);
                    }else{inertia.set(0f, 0f, 0f);}
                    this.bodyInfo = new btRigidBody.btRigidBodyConstructionInfo(mass, null, collShape, inertia);
                }
                
                public ModelInstanceAdv create(){
                    return new ModelInstanceAdv(model, bodyInfo);
                }
                @Override
                public void dispose() {
                    collShape.dispose();
                    bodyInfo.dispose();
                }
            }
        }
        
        static class MotionStateAdv extends btMotionState{
            Matrix4 transform;
            @Override
            public void getWorldTransform(Matrix4 WorldTrans){
                WorldTrans.set(transform);            
            }
            @Override
            public void setWorldTransform(Matrix4 WorldTrans){
                transform.set(WorldTrans);
            }
        }
        
        public class ButtonActor extends Actor{
            TextureRegion region;
            final float pointX, pointY, scaleXY;
            
            public ButtonActor(TextureRegion tex, float oX, float oY, float sca, String name){
                region = new TextureRegion(tex);
                pointX = oX*sca*64;
                pointY = oY*sca*40;
                scaleXY = sca;
                this.setTouchable(Touchable.enabled);
                setName(name);
            }
            
            @Override
            public void draw(Batch batch, float parentAlpha){
                batch.draw(region, pointX, pointY, getOriginX(), getOriginY(),
                        region.getRegionWidth(), region.getRegionHeight(), scaleXY, scaleXY, getRotation ());
            }
            
            @Override
            public Actor hit (float x, float y, boolean touchable) {
                return x >= pointX && x < pointX +100*scaleXY && y >= pointY && y < pointY + 100*scaleXY ? this : null;
            }
        }
        
        public class TheStage extends Stage{
            
            public boolean touchDown(int screenX, int screenY, int pointer, int button) {
                screenY = scrY - screenY;
                Actor actor = hit(screenX, screenY, true);
                if(actor == null){
                    aName = "null";
                    return false;
                }else{
                    aName = actor.getName();
                    if(aName.equals("forward")){
                        forward = true;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                    }
                    if(aName.equals("back")){
                        back = true;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                    }
                    if(aName.equals("right")){
                        right = true;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                    }
                    if(aName.equals("left")){
                        left = true;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                    }
                    if(aName.equals("rotate_left")){
                        rotateAngle = -1;                    
                    }
                    if(aName.equals("rotate_right")){
                        rotateAngle = 1;                    
                    }
                    if(aName.equals("jump")){
                        animController.animate("robot_rig|Jump", 1, jumpListener, 1);
                        if(jump >= 1)jump = 0;
                    }
                    return true;
                }
            }
            @Override
            public boolean touchUp(int screenX, int screenY, int pointer, int button) {
                screenY = scrY - screenY;
                Actor actor = hit(screenX, screenY, true);
                if(actor == null){
                    aName = "null";
                    return false;
                }else{
                    aName = actor.getName();
                    if(aName.equals(null)){
                        return false;
                    }else if(aName.equals("rotate_right")||aName.equals("rotate_left")){
                        rotateAngle = 0;
                        return true;
                    }else if(aName.equals("forward")){
                        forward = false;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                        return true;
                    }else if(aName.equals("back")){
                        back = false;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                        return true;
                    }else if(aName.equals("right")){
                        right = false;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                        return true;
                    }else if(aName.equals("left")){
                        left = false;
                        animController.animate(CheckAnimationSens(), -1, null, 1);
                        return true;
                    }else{
                        return false;
                    }
                }
            @Override
            public boolean touchDragged(int screenX, int screenY, int pointer) {
                return false;
            }
            
            @Override
            public Actor hit(float x, float y, boolean touchable) {
                Actor  actor  = super.hit(x,y,touchable);
                return actor;
            }
        }
        
        public String CheckAnimationSens(){
            String anim = "robot_rig|Stay";
            if(back)anim = "robot_rig|Back";
            if(forward)anim = "robot_rig|Walk";
            if(right)anim = "robot_rig|Right";
            if(left)anim = "robot_rig|>Left";
            return anim;
        }
            
        @Override
        public void create () {
            Bullet.init();
            assets = new AssetManager();
            assets.load("data/robot3.g3db", Model.class);
            loading = true;
            modelBatch = new ModelBatch();
            environment = new Environment();
            environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1f));
            environment.add(new DirectionalLight().set(0.8f, 0.8f, 0.8f, -1f, -0.8f, -0.2f));
            cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
            cam.position.set(0f, 8f, -8f);
            cam.lookAt(0f,5f, 0f);
            cam.near = 1f;
            cam.far = 300f;
            cam.update();
            collisionConf = new btDefaultCollisionConfiguration();
            collisionDispatcher = new btCollisionDispatcher(collisionConf);
            broadphase = new btDbvtBroadphase();
            solver = new btSequentialImpulseConstraintSolver();
            dynWorld = new btDiscreteDynamicsWorld(collisionDispatcher, broadphase, solver, collisionConf);
            dynWorld.setGravity(new Vector3(0f, -10f, 0f));
            scrX = Gdx.graphics.getWidth();
            scrY = Gdx.graphics.getHeight();
            scaling = scrX/1280f;
            buttons = new TextureAtlas(Gdx.files.internal("img/buttons.atlas"));
            stage = new TheStage();
            btnForward = new ButtonActor(buttons.findRegion("forward"), 16f, 5f, scaling, "forward");
            btnBack = new ButtonActor(buttons.findRegion("back"), 16f, 1f, scaling, "back");
            btnRight = new ButtonActor(buttons.findRegion("right"), 18f, 3f, scaling, "right");
            btnLeft = new ButtonActor(buttons.findRegion("left"), 14f, 3f, scaling, "left");
            btnRotateRight = new ButtonActor(buttons.findRegion("rotate_right"), 1f, 2f, scaling, "rotate_right");
            btnRotateLeft = new ButtonActor(buttons.findRegion("rotate_left"), 3f, 2f, scaling, "rotate_left");
            btnJump = new ButtonActor(buttons.findRegion("jump"), 5f, 2f, scaling, "jump");
            
            stage.addActor(btnForward);
            stage.addActor(btnBack);
            stage.addActor(btnRight);
            stage.addActor(btnLeft);
            stage.addActor(btnRotateRight);
            stage.addActor(btnRotateLeft);
            stage.addActor(btnJump);
                    
            multiplexer = new InputMultiplexer(); 
            camController = new CameraInputController(cam);
            multiplexer.addProcessor(camController);
            multiplexer.addProcessor(this);
            multiplexer.addProcessor(stage);
            Gdx.input.setInputProcessor(multiplexer);
            
            jumpListener = new AnimationListener(){
                @Override
                public void onEnd(AnimationDesc animation) {
                    switch(Gdx.app.getType()) {
                       case Android:
                           animController.queue(CheckAnimationSens(), -1, 1, null, 1);
                           break;
                       case Desktop:
                           animController.queue(CheckAnimation(), -1, 1, null, 1);
                           break;
                    default:
                        break;
                    }
                }
                @Override
                public void onLoop(AnimationDesc animation) {
                    
                }
                
            };
        }
        
        public void doneLoading(){
            TextureAttribute land_attr = TextureAttribute.createDiffuse(new Texture("img/land.jpg"));
            land = new Material(land_attr);
            ModelBuilder modelBuilder = new ModelBuilder();
            ground = modelBuilder.createBox(200f, 0.1f, 200f, land, Usage.Position|Usage.Normal|Usage.TextureCoordinates);
            ModelInstanceAdv.Constructor temp = new ModelInstanceAdv.Constructor(ground, Bullet.obtainStaticNodeShape(ground.nodes), 0f);
            groundInst = temp.create();
            dynWorld.addRigidBody(groundInst.body);
            
            man = assets.get("data/robot3.g3db", Model.class);
            ModelInstanceAdv.Constructor temp2 = new ModelInstanceAdv.Constructor(man,  createConvexHullShape(man, false), 1f);
            manInst = temp2.create();
            manInst.transform.setToTranslation(0f, 0.2f, 0f);
            manInst.body.proceedToTransform(manInst.transform);
            manInst.body.setActivationState(Collision.DISABLE_DEACTIVATION);
            manInst.body.setAngularFactor(new Vector3(0f, 0f, 0f));
            animController = new AnimationController(manInst);
            animController.setAnimation("robot_rig|Stay", -1);
            dynWorld.addRigidBody(manInst.body);
            loading = false;
        }
        
        @Override
        public void render () {
            if(loading&&assets.update()){
                doneLoading();
            }
            
            Gdx.gl.glClearColor(0.3f, 0.5f, 1f, 1f);
            Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT|GL20.GL_DEPTH_BUFFER_BIT);
            final float delta = Math.min(1f/30f, Gdx.graphics.getDeltaTime());
            
            if(!loading){
                oldDir = direction;
                if(rotateAngle != 0){
                    direction = (direction + rotateAngle*360*delta)%360;
                    manInst.transform.rotate(new Vector3(0f, 1f, 0f), rotateAngle*360*delta);
                }
                if(forward){
                    manInst.transform.trn((float)(1.6*delta*Math.sin(Math.toRadians(direction))), 0f, (float)(1.6*delta*Math.cos(Math.toRadians(direction))));
                }
                if(back){
                    manInst.transform.trn(-(float)(delta*Math.sin(Math.toRadians(direction))), 0f, -(float)(delta*Math.cos(Math.toRadians(direction))));
                }
                if(right){
                    manInst.transform.trn((float)(delta*Math.sin(Math.toRadians(direction-90))), 0f, (float)(delta*Math.cos(Math.toRadians(direction-90))));
                }
                if(left){
                    manInst.transform.trn((float)(delta*Math.sin(Math.toRadians(direction+90))), 0f, (float)(delta*Math.cos(Math.toRadians(direction+90))));
                }
                if(jump < 1){
                    jump = jump + 2*delta;
                    manInst.transform.trn(0f, delta*6, 0f);
                }
                
                manInst.body.proceedToTransform(manInst.transform);
                dynWorld.stepSimulation(delta, 5, 1f/60f);
                Vector3 posP = new Vector3();
                manInst.transform.getTranslation(posP);
                cam.position.set((float) (posP.x - 15*Math.sin(Math.toRadians(direction))), 6f, (float) (posP.z - 15*Math.cos(Math.toRadians(direction))));
                cam.rotate(direction - oldDir, 0f, 1f, 0f);
                cam.update();
                camController.update();
                modelBatch.begin(cam);
                modelBatch.render(groundInst, environment);
                modelBatch.render(manInst, environment);
                modelBatch.end();
                animController.update(Gdx.graphics.getDeltaTime());
                stage.draw();
            }
        }
        
        @Override
        public void dispose(){
            dynWorld.dispose();
            solver.dispose();
            broadphase.dispose();
            collisionDispatcher.dispose();
            collisionConf.dispose();
            modelBatch.dispose();
            ground.dispose();
            man.dispose();
        }
        @Override
        public boolean keyDown(int keycode) {
            switch(keycode){
            case Keys.UP:
                animController.animate(CheckAnimation(), -1, null, 1);
                forward = true;
                break;
            case Keys.DOWN:
                animController.animate(CheckAnimation(), -1, null, 1);
                back = true;
                break;
            case Keys.RIGHT:
                animController.animate(CheckAnimation(), -1, null, 1);
                right = true;
                break;
            case Keys.LEFT:
                animController.animate(CheckAnimation(), -1, null, 1);
                left = true;
                break;
            case Keys.SPACE:
                animController.animate("robot_rig|Jump", 1, jumpListener, 1);
                jump = 0;
                break;
            }
            return true;
        }
        @Override
        public boolean keyUp(int keycode) {
            switch(keycode){
            case Keys.UP:
                animController.animate(CheckAnimation(), -1, null, 1);
                forward = false;
                break;
            case Keys.DOWN:
                animController.animate(CheckAnimation(), -1, null, 1);
                back = false;
                break;
            case Keys.RIGHT:
                animController.animate(CheckAnimation(), -1, null, 1);
                right = false;
                break;
            case Keys.LEFT:
                animController.animate(CheckAnimation(), -1, null, 1);
                left = false;
                break;
            }
            return true;
        }
        
        public String CheckAnimation(){
            String anim = "robot_rig|Stay";
            if(Gdx.input.isKeyPressed(Keys.DOWN))anim = "robot_rig|Back";
            if(Gdx.input.isKeyPressed(Keys.UP))anim = "robot_rig|Walk";
            if(Gdx.input.isKeyPressed(Keys.RIGHT))anim = "robot_rig|Right";
            if(Gdx.input.isKeyPressed(Keys.LEFT))anim = "robot_rig|Left";
            return anim;
        }
        @Override
        public boolean keyTyped(char character) {
            return false;
        }
        @Override
        public boolean touchDown(int screenX, int screenY, int pointer, int button) {
            return false;
        }
        @Override
        public boolean touchUp(int screenX, int screenY, int pointer, int button) {
            return false;
        }
        @Override
        public boolean touchDragged(int screenX, int screenY, int pointer) {
           return false;
        }
        @Override
        public boolean mouseMoved(int screenX, int screenY) {
            if(oldX == 0 & oldY == 0 & newX == 0 & newY == 0){
                newX = screenX;
                oldX = screenX;
                newY = screenY;
                oldY = screenY;
            }else{
                oldX = newX;
                oldY = newY;
                newX = screenX;
                newY = screenY;
            }
            if(newX-oldX > 5){
                rotateAngle = -1;
            }else if(newX-oldX < -5){
                rotateAngle = 1;
            }else{rotateAngle = 0;}
            return true;
        }
        @Override
        public boolean scrolled(int amount) {
            return false;
        }
        
        public static btConvexHullShape createConvexHullShape (final Model model, boolean optimize) {
            final Mesh mesh = model.meshes.get(0);
            final btConvexHullShape shape = new btConvexHullShape(mesh.getVerticesBuffer(), mesh.getNumVertices(), mesh.getVertexSize());
            if (!optimize) return shape;
            final btShapeHull hull = new btShapeHull(shape);
            hull.buildHull(shape.getMargin());
            final btConvexHullShape result = new btConvexHullShape(hull);
            shape.dispose();
            hull.dispose();
            return result;
        }
    }

    Категория: libGDX | Добавил: Olelucoye (14.06.2015)
    Просмотров: 1214
    | Рейтинг: 0.0/0
    Всего комментариев: 0
    Добавлять комментарии могут только зарегистрированные пользователи.
    [ Регистрация | Вход ]
    Меню сайта
    Категории раздела
    Андроид разработка [23]
    libGDX [24]
    Мои андроид проекты [6]
    Excel [7]
    Железяки [5]
    Скрипты в блокноте [4]
    Разное [1]
    Форма входа
    Статистика

    Онлайн всего: 1
    Гостей: 1
    Пользователей: 0
    Яндекс Метрика
    Яндекс.Метрика