Search in sources :

Example 51 with Vector3

use of com.badlogic.gdx.math.Vector3 in project RubeLoader by tescott.

the class RubeLoaderTest method create.

@Override
public void create() {
    float w = Gdx.graphics.getWidth();
    float h = Gdx.graphics.getHeight();
    Gdx.input.setInputProcessor(this);
    mB2Controllers = new Array<B2Controller>();
    mCamPos = new Vector3();
    mCurrentPos = new Vector3();
    camera = new OrthographicCamera(100, 100 * h / w);
    camera.position.set(50, 50, 0);
    camera.zoom = 1.8f;
    camera.update();
    loader = new RubeSceneLoader();
    scene = loader.loadScene(Gdx.files.internal("data/palmcontrollers.json"));
    debugRender = new Box2DDebugRenderer();
    batch = new SpriteBatch();
    polygonBatch = new PolygonSpriteBatch();
    textureMap = new HashMap<String, Texture>();
    textureRegionMap = new HashMap<Texture, TextureRegion>();
    createSpatialsFromRubeImages(scene);
    createPolySpatialsFromRubeFixtures(scene);
    mWorld = scene.getWorld();
    // configure simulation settings
    mVelocityIter = scene.velocityIterations;
    mPositionIter = scene.positionIterations;
    if (scene.stepsPerSecond != 0) {
        mSecondsPerStep = 1f / scene.stepsPerSecond;
    }
    mWorld.setContactListener(this);
    //
    // example of custom property handling
    //
    Array<Body> bodies = scene.getBodies();
    if ((bodies != null) && (bodies.size > 0)) {
        for (int i = 0; i < bodies.size; i++) {
            Body body = bodies.get(i);
            String gameInfo = (String) scene.getCustom(body, "GameInfo", null);
            if (gameInfo != null) {
                System.out.println("GameInfo custom property: " + gameInfo);
            }
        }
    }
    // Instantiate any controllers that are in the scene
    Array<Fixture> fixtures = scene.getFixtures();
    if ((fixtures != null) && (fixtures.size > 0)) {
        for (int i = 0; i < fixtures.size; i++) {
            Fixture fixture = fixtures.get(i);
            int controllerType = (Integer) scene.getCustom(fixture, "ControllerType", 0);
            switch(controllerType) {
                case B2Controller.BUOYANCY_CONTROLLER:
                    // only allow polygon buoyancy controllers for now..
                    if (fixture.getShape().getType() == Shape.Type.Polygon) {
                        float bodyHeight = fixture.getBody().getPosition().y;
                        // B2BuoyancyController b2c = new B2BuoyancyController();
                        // need to calculate the fluid surface height for the buoyancy controller
                        PolygonShape shape = (PolygonShape) fixture.getShape();
                        shape.getVertex(0, mTmp);
                        // initialize the height, transforming to 'world'
                        float maxHeight = mTmp.y + bodyHeight;
                        // find the maxHeight
                        for (int j = 1; j < shape.getVertexCount(); j++) {
                            shape.getVertex(j, mTmp);
                            // transform to world coordinates
                            maxHeight = Math.max(maxHeight, mTmp.y + bodyHeight);
                        }
                        B2BuoyancyController b2c = new B2BuoyancyController(// assume up
                        B2BuoyancyController.DEFAULT_SURFACE_NORMAL, (Vector2) scene.getCustom(fixture, "ControllerVelocity", B2BuoyancyController.DEFAULT_FLUID_VELOCITY), mWorld.getGravity(), maxHeight, fixture.getDensity(), (Float) scene.getCustom(fixture, "LinearDrag", B2BuoyancyController.DEFAULT_LINEAR_DRAG), (Float) scene.getCustom(fixture, "AngularDrag", B2BuoyancyController.DEFAULT_ANGULAR_DRAG));
                        // reference back to the controller from the fixture (see
                        fixture.setUserData(b2c);
                        // beginContact/endContact)
                        // add it to the list so it can be stepped later
                        mB2Controllers.add(b2c);
                    }
                    break;
                case B2Controller.GRAVITY_CONTROLLER:
                    {
                        B2GravityController b2c = new B2GravityController();
                        b2c = new B2GravityController((Vector2) scene.getCustom(fixture, "ControllerVelocity", B2GravityController.DEFAULT_GRAVITY));
                        fixture.setUserData(b2c);
                        mB2Controllers.add(b2c);
                    }
                    break;
            }
        }
    }
    scene.printStats();
    // no longer need any scene references
    scene.clear();
}
Also used : PolygonShape(com.badlogic.gdx.physics.box2d.PolygonShape) OrthographicCamera(com.badlogic.gdx.graphics.OrthographicCamera) B2BuoyancyController(com.gushikustudios.box2d.controllers.B2BuoyancyController) Vector3(com.badlogic.gdx.math.Vector3) B2Controller(com.gushikustudios.box2d.controllers.B2Controller) PolygonSpriteBatch(com.badlogic.gdx.graphics.g2d.PolygonSpriteBatch) SpriteBatch(com.badlogic.gdx.graphics.g2d.SpriteBatch) PolygonSpriteBatch(com.badlogic.gdx.graphics.g2d.PolygonSpriteBatch) Texture(com.badlogic.gdx.graphics.Texture) TextureRegion(com.badlogic.gdx.graphics.g2d.TextureRegion) Box2DDebugRenderer(com.badlogic.gdx.physics.box2d.Box2DDebugRenderer) RubeSceneLoader(com.gushikustudios.rube.loader.RubeSceneLoader) B2GravityController(com.gushikustudios.box2d.controllers.B2GravityController) Fixture(com.badlogic.gdx.physics.box2d.Fixture) Body(com.badlogic.gdx.physics.box2d.Body)

Example 52 with Vector3

use of com.badlogic.gdx.math.Vector3 in project bdx by GoranM.

the class Camera method screenPosition.

public Vector2f screenPosition(Vector3f p) {
    Viewport vp = scene.viewport;
    Vector3 out = data.project(new Vector3(p.x, p.y, p.z), vp.x, vp.y, vp.w, vp.h);
    return new Vector2f(Math.round(out.x), Math.round(out.y));
}
Also used : Vector2f(javax.vecmath.Vector2f) Viewport(com.nilunder.bdx.gl.Viewport) Vector3(com.badlogic.gdx.math.Vector3)

Example 53 with Vector3

use of com.badlogic.gdx.math.Vector3 in project bdx by GoranM.

the class GameObject method join.

public void join(HashMap<Mesh, ArrayList<Matrix4f>> map) {
    // Collect transformed vertex arrays for each material & calculate number of indices
    int VERT_STRIDE = Bdx.VERT_STRIDE;
    HashMap<Material, ArrayList<float[]>> tvaMap = new HashMap<Material, ArrayList<float[]>>();
    HashMap<Material, Integer> lenMap = new HashMap<Material, Integer>();
    Mesh m;
    Node node;
    Material mat;
    MeshPart meshPart;
    float[] va, tva;
    int numIndices, numVertices, offset, j, len;
    Vector3f p = new Vector3f();
    Vector3f s = new Vector3f();
    Matrix3f o = new Matrix3f();
    Vector3f vP = new Vector3f();
    Vector3f nP = new Vector3f();
    Vector3f vPT = new Vector3f();
    Vector3f nPT = new Vector3f();
    Vector3f pos = position();
    Vector3f sca = scale();
    Matrix3f oriInv = orientation().inverted();
    for (Map.Entry<Mesh, ArrayList<Matrix4f>> e : map.entrySet()) {
        m = e.getKey();
        node = m.model.nodes.get(0);
        for (Matrix4f t : e.getValue()) {
            t.get(p);
            p.sub(pos);
            p = oriInv.mult(p.div(sca));
            t.getRotationScale(o);
            o = oriInv.mult(o);
            s.set(t.m30, t.m31, t.m32);
            if (s.length() == 0) {
                s.set(1, 1, 1);
            }
            s = s.div(sca);
            for (NodePart nodePart : node.parts) {
                meshPart = nodePart.meshPart;
                numIndices = meshPart.size;
                numVertices = numIndices * VERT_STRIDE;
                offset = meshPart.offset * VERT_STRIDE;
                va = meshPart.mesh.getVertices(offset, numVertices, new float[numVertices]);
                tva = new float[numVertices];
                j = 0;
                for (int i = 0; i < numIndices; i++) {
                    vP.set(va[j], va[j + 1], va[j + 2]);
                    nP.set(va[j + 3], va[j + 4], va[j + 5]);
                    vPT.set(o.mult(vP.mul(s)));
                    vPT.add(p);
                    nPT.set(o.mult(vP.plus(nP)));
                    nPT.sub(o.mult(vP));
                    tva[j] = vPT.x;
                    tva[j + 1] = vPT.y;
                    tva[j + 2] = vPT.z;
                    tva[j + 3] = nPT.x;
                    tva[j + 4] = nPT.y;
                    tva[j + 5] = nPT.z;
                    tva[j + 6] = va[j + 6];
                    tva[j + 7] = va[j + 7];
                    j += VERT_STRIDE;
                }
                mat = m.materials.get(nodePart.material.id);
                ArrayList<float[]> l;
                if (tvaMap.containsKey(mat)) {
                    l = tvaMap.get(mat);
                    len = lenMap.get(mat);
                } else {
                    l = new ArrayList<float[]>();
                    tvaMap.put(mat, l);
                    len = 0;
                }
                l.add(tva);
                lenMap.put(mat, len + tva.length);
            }
        }
    }
    // Build a unique model out of meshparts for each material
    ModelBuilder builder = new ModelBuilder();
    builder.begin();
    short idx = 0;
    MeshPartBuilder mpb;
    for (Map.Entry<Material, ArrayList<float[]>> e : tvaMap.entrySet()) {
        mat = e.getKey();
        len = lenMap.get(mat);
        tva = new float[len];
        j = 0;
        for (float[] verts : e.getValue()) {
            numVertices = verts.length;
            for (int i = 0; i < numVertices; i++) {
                tva[i + j] = verts[i];
            }
            j += numVertices;
        }
        mpb = builder.part(mat.name(), GL20.GL_TRIANGLES, Usage.Position | Usage.Normal | Usage.TextureCoordinates, mat);
        mpb.vertex(tva);
        try {
            for (short i = 0; i < len / VERT_STRIDE; i++) {
                mpb.index(idx);
                idx += 1;
            }
        } catch (Error error) {
            throw new RuntimeException("MODEL ERROR: Models with more than 32767 vertices are not supported. Decrease the number of objects to join.");
        }
    }
    Model finishedModel = builder.end();
    // Update mesh
    mesh(new Mesh(finishedModel, scene));
    // Update dimensionsNoScale and origin
    com.badlogic.gdx.graphics.Mesh mesh = finishedModel.meshes.first();
    BoundingBox bbox = mesh.calculateBoundingBox();
    Vector3 dimensions = bbox.getDimensions(new Vector3());
    Vector3 center = bbox.getCenter(new Vector3());
    dimensionsNoScale = new Vector3f(dimensions.x, dimensions.y, dimensions.z);
    origin = new Vector3f(center.x, center.y, center.z);
    // Update body
    updateBody();
    if (json.get("mesh_name").asString() == null) {
        visible = json.get("visible").asBoolean();
    }
}
Also used : HashMap(java.util.HashMap) Node(com.badlogic.gdx.graphics.g3d.model.Node) ArrayList(java.util.ArrayList) MeshPartBuilder(com.badlogic.gdx.graphics.g3d.utils.MeshPartBuilder) MeshPart(com.badlogic.gdx.graphics.g3d.model.MeshPart) ModelBuilder(com.badlogic.gdx.graphics.g3d.utils.ModelBuilder) Matrix3f(javax.vecmath.Matrix3f) BoundingBox(com.badlogic.gdx.math.collision.BoundingBox) Mesh(com.nilunder.bdx.gl.Mesh) Material(com.nilunder.bdx.gl.Material) Vector3(com.badlogic.gdx.math.Vector3) ManifoldPoint(com.bulletphysics.collision.narrowphase.ManifoldPoint) Matrix4f(javax.vecmath.Matrix4f) Vector3f(javax.vecmath.Vector3f) Model(com.badlogic.gdx.graphics.g3d.Model) NodePart(com.badlogic.gdx.graphics.g3d.model.NodePart) HashMap(java.util.HashMap) Map(java.util.Map)

Example 54 with Vector3

use of com.badlogic.gdx.math.Vector3 in project bdx by GoranM.

the class Scene method init.

public void init() {
    requestedRestart = false;
    requestedEnd = false;
    paused = false;
    visible = true;
    if (shapeRenderer == null)
        shapeRenderer = new ShapeRenderer();
    drawCommands = new ArrayList<ArrayList<Object>>();
    lastFrameBuffer = new RenderBuffer(null);
    environment = new Environment();
    environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0, 0, 0, 1));
    environment.set(new PointLightsAttribute());
    environment.set(new SpotLightsAttribute());
    environment.set(new DirectionalLightsAttribute());
    screenShaders = new ArrayList<ScreenShader>();
    defaultMaterial = new Material("__BDX_DEFAULT");
    defaultMaterial.set(new ColorAttribute(ColorAttribute.AmbientLight, 1, 1, 1, 1));
    defaultMaterial.set(new ColorAttribute(ColorAttribute.Diffuse, 1, 1, 1, 1));
    defaultMaterial.set(new BlendingAttribute());
    defaultMaterial.set(new BDXColorAttribute(BDXColorAttribute.Tint, 0, 0, 0));
    defaultMesh = new Mesh(new ModelBuilder().createBox(1.0f, 1.0f, 1.0f, defaultMaterial, Usage.Position | Usage.Normal | Usage.TextureCoordinates), this);
    meshes = new HashMap<String, Mesh>();
    textures = new HashMap<String, Texture>();
    materials = new HashMap<String, Material>();
    modelToFrame = new HashMap<>();
    materials.put(defaultMaterial.id, defaultMaterial);
    BroadphaseInterface broadphase = new DbvtBroadphase();
    DefaultCollisionConfiguration collisionConfiguration = new DefaultCollisionConfiguration();
    SequentialImpulseConstraintSolver solver = new SequentialImpulseConstraintSolver();
    CollisionDispatcher dispatcher = new CollisionDispatcher(collisionConfiguration);
    toBeAdded = new ArrayList<GameObject>();
    toBeRemoved = new ArrayList<GameObject>();
    objects = new LinkedListNamed<GameObject>();
    lights = new LinkedListNamed<Light>();
    templates = new HashMap<String, GameObject>();
    json = new JsonReader().parse(scene);
    name = json.get("name").asString();
    world = new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
    world.setDebugDrawer(new Bullet.DebugDrawer(json.get("physviz").asBoolean()));
    gravity(new Vector3f(0, 0, -json.get("gravity").asFloat()));
    float[] ac = json.get("ambientColor").asFloatArray();
    ambientLight(new Color(ac[0], ac[1], ac[2], 1));
    if (!clearColorDefaultSet) {
        float[] cc = json.get("clearColor").asFloatArray();
        Bdx.display.clearColor.set(cc[0], cc[1], cc[2], 0);
        clearColorDefaultSet = true;
    }
    if (json.get("framerateProfile").asBoolean()) {
        Bdx.profiler.init();
    }
    float[] fc = json.get("clearColor").asFloatArray();
    fogColor = new Color(fc[0], fc[1], fc[2], 1);
    fog(json.get("mistOn").asBoolean());
    fogRange(json.get("mistStart").asFloat(), json.get("mistDepth").asFloat());
    for (JsonValue mat : json.get("materials")) {
        String texName = mat.get("texture").asString();
        boolean hasAlpha = mat.get("alpha_blend").asString().equals("ALPHA");
        float opacity = hasAlpha ? mat.get("opacity").asFloat() : 1;
        Material material = new Material(mat.name);
        float[] c = mat.get("color").asFloatArray();
        material.set(ColorAttribute.createDiffuse(c[0], c[1], c[2], opacity));
        float[] s = mat.get("spec_color").asFloatArray();
        material.set(ColorAttribute.createSpecular(s[0], s[1], s[2], 1));
        material.set(FloatAttribute.createShininess(mat.get("shininess").asFloat()));
        material.set(new BDXColorAttribute(BDXColorAttribute.Tint, 0, 0, 0));
        IntAttribute shadeless = (IntAttribute) new BDXIntAttribute();
        if (mat.get("shadeless").asBoolean())
            shadeless.value = 1;
        material.set(shadeless);
        float emitStrength = mat.get("emit").asFloat();
        material.set(new BDXColorAttribute(BDXColorAttribute.Emit, emitStrength, emitStrength, emitStrength));
        if (mat.get("backface_culling").asBoolean())
            material.set(new IntAttribute(IntAttribute.CullFace, GL20.GL_BACK));
        else
            material.set(new IntAttribute(IntAttribute.CullFace, GL20.GL_NONE));
        if (texName != null) {
            Texture texture = textures.get(texName);
            if (texture == null) {
                texture = new Texture(Gdx.files.internal("bdx/textures/" + texName));
                textures.put(texName, texture);
            }
            texture.setWrap(TextureWrap.Repeat, TextureWrap.Repeat);
            material.texture(texture);
        }
        material.set(new DepthTestAttribute());
        if (hasAlpha) {
            BlendingAttribute ba = new BlendingAttribute(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
            ba.opacity = opacity;
            material.set(ba);
            // Discard pixels that fail this alpha test (sub-1% alpha)
            material.set(FloatAttribute.createAlphaTest(0.01f));
            // Turn on back-to-front sorting for alpha-enabled objects by default
            material.backToFrontSorting(true);
        } else {
            BlendingAttribute ba = new BlendingAttribute();
            ba.blended = false;
            material.set(ba);
        }
        materials.put(mat.name, material);
    }
    for (JsonValue model : json.get("models")) {
        meshes.put(model.name, new Mesh(createModel(model), this, model.name));
    }
    HashMap<String, JsonValue> fonts = new HashMap<>();
    for (JsonValue fontj : json.get("fonts")) {
        String font = fontj.asString();
        fonts.put(font, new JsonReader().parse(Gdx.files.internal("bdx/fonts/" + font + ".fntx")));
    }
    FAnim.loadActions(json.get("actions"));
    for (JsonValue gobj : json.get("objects")) {
        GameObject g = instantiator.newObject(gobj);
        g.json = gobj;
        g.name = gobj.name;
        g.scene = this;
        g.props = new HashMap<String, JsonValue>();
        for (JsonValue prop : gobj.get("properties")) {
            g.props.put(prop.name, prop);
        }
        String meshName = gobj.get("mesh_name").asString();
        if (meshName != null) {
            g.visibleNoChildren(gobj.get("visible").asBoolean());
            g.mesh(meshName);
        } else {
            g.visibleNoChildren(false);
            g.mesh(defaultMesh);
        }
        com.badlogic.gdx.graphics.Mesh mesh = g.modelInstance.model.meshes.first();
        float[] trans = gobj.get("transform").asFloatArray();
        JsonValue origin = json.get("origins").get(meshName);
        JsonValue dimensions = json.get("dimensions").get(meshName);
        g.origin = origin == null ? new Vector3f() : new Vector3f(origin.asFloatArray());
        g.dimensionsNoScale = dimensions == null ? new Vector3f(1, 1, 1) : new Vector3f(dimensions.asFloatArray());
        JsonValue physics = gobj.get("physics");
        g.currBodyType = GameObject.BodyType.valueOf(physics.get("body_type").asString());
        g.currBoundsType = GameObject.BoundsType.valueOf(physics.get("bounds_type").asString());
        g.body = Bullet.makeBody(mesh, trans, g.origin, g.currBodyType, g.currBoundsType, physics);
        g.body.setUserPointer(g);
        g.scale(getGLMatrixScale(trans));
        String type = gobj.get("type").asString();
        if (type.equals("FONT")) {
            Text t = (Text) g;
            t.font = fonts.get(gobj.get("font").asString());
            t.text(gobj.get("text").asString());
            t.capacity = t.text().length();
            String align = gobj.get("alignment").asString();
            if (align.equals("RIGHT"))
                t.alignment(Text.Alignment.RIGHT);
            else if (align.equals("CENTER"))
                t.alignment(Text.Alignment.CENTER);
            else
                t.alignment(Text.Alignment.LEFT);
        } else if (type.equals("LAMP")) {
            JsonValue settings = gobj.get("lamp");
            Light l = (Light) g;
            if (settings.getString("type").equals("SUN"))
                l.type = Light.Type.SUN;
            else if (settings.getString("type").equals("SPOT"))
                l.type = Light.Type.SPOT;
            else
                // POINT lamps; HEMI and AREA aren't supported, so they're turned into POINTs
                l.type = Light.Type.POINT;
            l.energy(settings.getFloat("energy"));
            float[] c = settings.get("color").asFloatArray();
            l.color(new Color(c[0], c[1], c[2], c[3]));
            if (l.type.equals(Light.Type.SPOT)) {
                l.spotSize(settings.getFloat("spot_size"));
            }
        } else if (type.equals("CAMERA")) {
            Camera c = (Camera) g;
            float[] projection = gobj.get("camera").get("projection").asFloatArray();
            Vector2f resolution = new Vector2f(json.get("resolution").asFloatArray());
            if (gobj.get("camera").get("type").asString().equals("PERSP")) {
                c.initData(Camera.Type.PERSPECTIVE);
                c.size(resolution);
                c.resolution(resolution);
                c.projection(new Matrix4f(projection));
                c.fov(c.fov());
            } else {
                c.initData(Camera.Type.ORTHOGRAPHIC);
                c.size(resolution);
                c.resolution(resolution);
                c.zoom(2 / projection[0]);
            }
            Matrix4 pm = new Matrix4(projection);
            pm.inv();
            Vector3 vec = new Vector3(0, 0, -1);
            vec.prj(pm);
            c.near(-vec.z);
            vec.set(0, 0, 1);
            vec.prj(pm);
            c.far(-vec.z);
        }
        templates.put(g.name, g);
    }
    hookParentChild();
    cameras = new ArrayListNamed<Camera>();
    addInstances();
    camera = (Camera) objects.get(json.get("cameras").asStringArray()[0]);
    String frameType = json.get("frame_type").asString();
    Viewport.Type viewportType;
    if (frameType.equals("LETTERBOX")) {
        viewportType = Viewport.Type.LETTERBOX;
    } else if (frameType.equals("EXTEND")) {
        viewportType = Viewport.Type.EXTEND;
    } else {
        // "SCALE"
        viewportType = Viewport.Type.SCALE;
    }
    viewport = new Viewport(this, viewportType);
    for (GameObject g : sortByPriority(new ArrayList<GameObject>(objects))) {
        initGameObject(g);
    }
    valid = true;
}
Also used : HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) com.badlogic.gdx.graphics(com.badlogic.gdx.graphics) ModelBuilder(com.badlogic.gdx.graphics.g3d.utils.ModelBuilder) ArrayListGameObject(com.nilunder.bdx.GameObject.ArrayListGameObject) CollisionDispatcher(com.bulletphysics.collision.dispatch.CollisionDispatcher) Color(com.nilunder.bdx.utils.Color) JsonValue(com.badlogic.gdx.utils.JsonValue) Mesh(com.nilunder.bdx.gl.Mesh) ShapeRenderer(com.badlogic.gdx.graphics.glutils.ShapeRenderer) Matrix4(com.badlogic.gdx.math.Matrix4) SequentialImpulseConstraintSolver(com.bulletphysics.dynamics.constraintsolver.SequentialImpulseConstraintSolver) Environment(com.badlogic.gdx.graphics.g3d.Environment) BroadphaseInterface(com.bulletphysics.collision.broadphase.BroadphaseInterface) JsonReader(com.badlogic.gdx.utils.JsonReader) DefaultCollisionConfiguration(com.bulletphysics.collision.dispatch.DefaultCollisionConfiguration) DbvtBroadphase(com.bulletphysics.collision.broadphase.DbvtBroadphase) Vector3(com.badlogic.gdx.math.Vector3) DiscreteDynamicsWorld(com.bulletphysics.dynamics.DiscreteDynamicsWorld)

Example 55 with Vector3

use of com.badlogic.gdx.math.Vector3 in project Entitas-Java by Rubentxu.

the class ActuatorEntity method addCameraActuator.

public ActuatorEntity addCameraActuator(Camera camera, short height, float damping, float minDistanceX, float minDistanceY, String followTagEntity) {
    CameraActuator component = (CameraActuator) recoverComponent(ActuatorComponentsLookup.CameraActuator);
    if (component == null) {
        component = new CameraActuator(camera, height, damping, minDistanceX, minDistanceY, followTagEntity);
    } else {
        component.actuator = (indexOwner) -> {
            Set<GameEntity> followEntities = Indexed.getTagEntities(followTagEntity);
            for (GameEntity followEntity : followEntities) {
                RigidBody rc = followEntity.getRigidBody();
                Transform transform = rc.body.getTransform();
                Vector3 position = camera.position;
                position.x += (transform.getPosition().x + minDistanceX - position.x) * damping;
                position.y += (transform.getPosition().y + minDistanceY - position.y) * height;
            }
        };
    }
    addComponent(ActuatorComponentsLookup.CameraActuator, component);
    return this;
}
Also used : GameEntity(ilargia.egdx.logicbricks.gen.game.GameEntity) CameraActuator(ilargia.egdx.logicbricks.component.actuator.CameraActuator) Vector3(com.badlogic.gdx.math.Vector3) RigidBody(ilargia.egdx.logicbricks.component.game.RigidBody) Transform(com.badlogic.gdx.physics.box2d.Transform)

Aggregations

Vector3 (com.badlogic.gdx.math.Vector3)64 Matrix4 (com.badlogic.gdx.math.Matrix4)10 Quaternion (com.badlogic.gdx.math.Quaternion)9 Vector2 (com.badlogic.gdx.math.Vector2)6 Node (com.badlogic.gdx.graphics.g3d.model.Node)5 Texture (com.badlogic.gdx.graphics.Texture)4 Model (com.badlogic.gdx.graphics.g3d.Model)4 NodeKeyframe (com.badlogic.gdx.graphics.g3d.model.NodeKeyframe)4 BoundingBox (com.badlogic.gdx.math.collision.BoundingBox)4 VertexAttribute (com.badlogic.gdx.graphics.VertexAttribute)3 SpriteBatch (com.badlogic.gdx.graphics.g2d.SpriteBatch)3 Material (com.badlogic.gdx.graphics.g3d.Material)3 ModelNode (com.badlogic.gdx.graphics.g3d.model.data.ModelNode)3 ModelBuilder (com.badlogic.gdx.graphics.g3d.utils.ModelBuilder)3 Mesh (com.badlogic.gdx.graphics.Mesh)2 OrthographicCamera (com.badlogic.gdx.graphics.OrthographicCamera)2 ModelInstance (com.badlogic.gdx.graphics.g3d.ModelInstance)2 Animation (com.badlogic.gdx.graphics.g3d.model.Animation)2 MeshPart (com.badlogic.gdx.graphics.g3d.model.MeshPart)2 NodeAnimation (com.badlogic.gdx.graphics.g3d.model.NodeAnimation)2