Java 类com.badlogic.gdx.math.Matrix4 实例源码

public void tick(float delta, GameScreen screen) {
    if (!started && screen.isPaused()) {
        started = true;
        prevTime = System.currentTimeMillis();
    }
    if (spawns != null && enemyIndex < spawns.size() && System.currentTimeMillis() > prevTime + spawns.get(enemyIndex).getDelay()) {
        prevTime = System.currentTimeMillis();
        String name = spawns.get(enemyIndex).getName();
        ModelInstance instance;
        try {
            Class<?> c = enemyClasses.get(name);
            Constructor constructor = c.getConstructor(Matrix4.class, Map.class, btCollisionWorld.class, IntMap.class, List.class, Map.class);
            enemies.add((Enemy) constructor.newInstance(new Matrix4().setToTranslation(pos), models, world, entity, path, sounds));
        } catch (Exception e) {
            Gdx.app.log("EnemySpawner spawn enemy", e.toString());
        }
        enemyIndex++;
    }
    //for (Enemy enemy : enemies)
    //   enemy.tick(delta, path);
}

public Basic(Matrix4 transform, double speeed, int hp, int health, int range, float coolDown, EnumSet<Types> types, EnumSet<Effects> effects, ModelInstance instance, btCollisionWorld world, IntMap<Entity> entities, List<Vector3> path, Map<String, Sound> sounds) {
    super(transform, speeed, hp, health, range, coolDown, types, effects, instance, new btCompoundShape(), world, entities, ATTACK_ANIMATION, ATTACK_OFFSET, path, sounds);
    ((btCompoundShape)shape).addChildShape(new Matrix4(new Vector3(0, 30, 0), new Quaternion().setEulerAngles(0, 0, 0), new Vector3(1, 1, 1)), new btBoxShape(new Vector3(75, 30, 90)));
    //System.out.println(getModelInstance().getAnimation("Spider_Armature|walk_ani_vor").id);
    listener = new AnimationController.AnimationListener() {
        @Override
        public void onEnd(AnimationController.AnimationDesc animationDesc) {

        }

        @Override
        public void onLoop(AnimationController.AnimationDesc animationDesc) {

        }
    };
    //animation.setAnimation("Spider_Armature|walk_ani_vor");
    //animation.animate("Spider_Armature|walk_ani_vor", -1);
    //animation.action("Spider_Armature|walk_ani_vor", 0, 1000, -1, 1, listener, 0);
    //animation.animate("Spider_Armature|Attack", 0, 1000, 1, 1, listener, 0);
    //animation.queue("Spider_Armature|walk_ani_vor", 0, 1000, -1, 1, listener, 0);
}

public static void GLToClipTransform(Matrix4 transformOut) {
        if(null == transformOut) return;

        Director director = Director.getInstance();

        Matrix4 projection = director.getMatrix(MATRIX_STACK_TYPE.MATRIX_STACK_PROJECTION);
        Matrix4 modelview = director.getMatrix(MATRIX_STACK_TYPE.MATRIX_STACK_MODELVIEW);

//        System.out.println(projection);
//        System.out.println(modelview);

        //?
        transformOut.set(projection);
        transformOut.mul(modelview);
//        *transformOut = projection * modelview;
    }

/**
    * Gets the camera's view matrix.
    *
    * @return The camera view matrix.
    */
     public Matrix4 getViewMatrix() {
//       Mat4 viewInv(getNodeToWorldTransform());
         _viewInv.set(getNodeToWorldTransform());
//      static int count = sizeof(float) * 16;
//      if (memcmp(viewInv.m, _viewInv.m, count) != 0)
//      {
            _viewProjectionDirty = true;
            _frustumDirty = true;
//          _viewInv = viewInv;
//          _view = viewInv.getInversed();
            _view.set(_viewInv).inv();
//      }
        return _view;

//       ViewPort vp;
//       com.badlogic.gdx.graphics.glutils
     }

public void drawBg(Batch batch, float parentAlpha) {
    batch.end();
    Gdx.gl.glLineWidth(1.0f);
    Gdx.gl.glEnable(GL20.GL_BLEND);
    Gdx.gl.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);

    shapeRenderer.setProjectionMatrix(getStage().getCamera().combined);
    Matrix4 matrix = batch.getTransformMatrix();
    shapeRenderer.setTransformMatrix(matrix);

    shapeRenderer.begin(ShapeRenderer.ShapeType.Filled);
    BG.a = parentAlpha;
    shapeRenderer.setColor(BG);
    shapeRenderer.rect(getX(), getY(), getWidth(), getHeight());
    shapeRenderer.end();

    Gdx.gl.glDisable(GL20.GL_BLEND);
    batch.begin();
    batch.setColor(Color.WHITE.r, Color.WHITE.g, Color.WHITE.b, Color.WHITE.a * parentAlpha);
}

public GameScreen(){
    spriteBatch = new SpriteBatch(); // buffer ok
    texture     = new Texture(Gdx.files.internal("bg/gameBG.jpg"));
    viewMatrix  = new Matrix4();  // matriz de visualização
    tranMatrix  = new Matrix4();  // matriz de escala

    // camera
    camera = new PerspectiveCamera(67.0f, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    camera.near = 0.1f;
    camera.far  = 1000f;
    camera.position.set(0, 5, 10);
    camera.lookAt(0, 5, 0);
    camera.update();

    // ambiente
    environment = new Environment();
    environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 1,1,1,1));

    // renderizador
    modelBatch = new ModelBatch();
    p1 = new Player(1);
    p2 = new Player(2);



}

public LevelScreen(String mapName, float rot) {
    this.rot = rot;
    this.mapName = mapName;
    this.inputMapper = new InputMapper(AL.getInputConfig());

    inputMapper.registerInputHanlder(IInputConfig.InputKeys.up, new MoveEventHandler(new Vector2(0, 1)));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.down, new MoveEventHandler(new Vector2(0, -1)));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.right, new MoveEventHandler(new Vector2(1, 0)));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.left, new MoveEventHandler(new Vector2(-1, 0)));

    inputMapper.registerInputHanlder(IInputConfig.InputKeys.ability1, new AbillityEventHandler(Character.ABILITY_1));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.ability2, new AbillityEventHandler(Character.ABILITY_2));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.ability3, new AbillityEventHandler(Character.ABILITY_3));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.ability4, new AbillityEventHandler(Character.ABILITY_4));
    inputMapper.registerInputHanlder(IInputConfig.InputKeys.trait, new AbillityEventHandler(Character.TRAIT));

    rotationMatrix = new Matrix4().rotate(Vector3.X, rot);
    cameraVector = new Vector3(0, 1, 1);
    cameraVector.mul(rotationMatrix);
    invRotationMatrix = rotationMatrix.cpy().inv();
    lastMousePos = new Vector2(Gdx.input.getX(), Gdx.input.getY());
    tempVec = new Vector3();
}

/**
   * Update camera's matrix
   */
  private void UpdateViewMatrix()
   {
       Matrix4 cameraRotation = new Matrix4();
       cameraRotation = Utils.createRotate(updownRot, leftrightRot, 0f, cameraRotation);

       Vector3 cameraOriginalTarget = new Vector3(0, 0, -1);
       Vector3 cameraOriginalUpVector = new Vector3(0, 1, 0);

       // cameraRotation.rotate(1, 0, 0, cameraOriginalTarget.x);
       Vector3 cameraRotatedTarget = Utils.Transform(cameraOriginalTarget, cameraRotation);
       Vector3 cameraFinalTarget =  Utils.addVector(position,cameraRotatedTarget);

       up.set(Utils.Transform(cameraOriginalUpVector, cameraRotation));

       view.setToLookAt(position, cameraFinalTarget, up);
       float aspect = viewportWidth / viewportHeight;
    projection.setToProjection(Math.abs(near), Math.abs(far), fieldOfView, aspect);
    combined.set(projection);
Matrix4.mul(combined.val, view.val);

invProjectionView.set(combined);
Matrix4.inv(invProjectionView.val);
frustum.update(invProjectionView);

   }

public void updateFrustum()
{
    invProjectionView.set(combined);
    Matrix4.inv(invProjectionView.val);
    frustum.update(invProjectionView);
    needUpdateFrustum = false;

}

/**
 * Initialisierung.
 *
 * @param game Zugriff auf die Spielinstanz
 * @param level Zugriff auf die aktive Levelinstanz
 */
public IngameMenu(SchoolGame game, Level level)
{
    this.game = game;
    this.level = level;

    titleFont = game.getTitleFont();
    textFont = game.getDefaultFont();
    smallFont = game.getLongTextFont();

    selectSound = game.getAudioManager().createSound("menu", "select.wav", true);
    changeSound = game.getAudioManager().createSound("menu", "change.wav", true);

    batch = new SpriteBatch();
    shapeRenderer = new ShapeRenderer();

    localeBundle = level.getLocaleBundle();

    fontLayout = new GlyphLayout();

    projection = new Matrix4();
}

@Override
public void draw(Batch batch) {
    age += Gdx.graphics.getDeltaTime();

    final float progress = age * INV_LIFETIME;
    final float currentSize = Interpolation.pow2In.apply(size, 0, progress);
    final float currentRotation = Interpolation.sine.apply(0, TOTAL_ROTATION, progress);

    final Matrix4 original = batch.getTransformMatrix().cpy();
    final Matrix4 rotated = batch.getTransformMatrix();

    final float disp =
            + 0.5f * (size - currentSize) // the smaller, the more we need to "push" to center
            + currentSize * 0.5f; // center the cell for rotation

    rotated.translate(pos.x + disp, pos.y + disp, 0);
    rotated.rotate(0, 0, 1, currentRotation);
    rotated.translate(currentSize * -0.5f, currentSize * -0.5f, 0); // revert centering for rotation

    batch.setTransformMatrix(rotated);
    Cell.draw(color, batch, 0, 0, currentSize);
    batch.setTransformMatrix(original);
}

/**
    * Transform a Vector3 using a Transformation Matrix
    * 
    * @param vector
    *            Vector to transform
    * @param transform
    *            The Transformation matrix
    * @return
    */
   public static Vector3 Transform(Vector3 vector, Matrix4 transform) {
Vector3 result = new Vector3((vector.x * transform.val[Matrix4.M00])
    + (vector.y * transform.val[Matrix4.M10])
    + (vector.z * transform.val[Matrix4.M20])
    + transform.val[Matrix4.M30],
    (vector.x * transform.val[Matrix4.M01])
        + (vector.y * transform.val[Matrix4.M11])
        + (vector.z * transform.val[Matrix4.M21])
        + transform.val[Matrix4.M31],
    (vector.x * transform.val[Matrix4.M02])
        + (vector.y * transform.val[Matrix4.M12])
        + (vector.z * transform.val[Matrix4.M22])
        + transform.val[Matrix4.M32]);

return result;
   }

public void updateAxesAndPosition() {           
    Matrix4 matrix = pose.transform;
    matrix.getTranslation(position);
    xAxis.set(matrix.val[Matrix4.M00], matrix.val[Matrix4.M10], matrix.val[Matrix4.M20]).nor();                                 
    yAxis.set(matrix.val[Matrix4.M01], matrix.val[Matrix4.M11], matrix.val[Matrix4.M21]).nor();                             
    zAxis.set(matrix.val[Matrix4.M02], matrix.val[Matrix4.M12], matrix.val[Matrix4.M22]).nor().scl(-1);

    matTmp.set(trackerSpaceToWorldspaceRotationOffset);
    positionWorld.set(position).mul(matTmp);
    positionWorld.add(trackerSpaceOriginToWorldSpaceTranslationOffset);

    matTmp.set(trackerSpaceToWorldspaceRotationOffset);

    xAxisWorld.set(xAxis).mul(matTmp);
    yAxisWorld.set(yAxis).mul(matTmp);
    zAxisWorld.set(zAxis).mul(matTmp);
}

static void hmdMat4toMatrix4(HmdMatrix44 hdm, Matrix4 mat) {
    float[] val = mat.val;
    FloatBuffer m = hdm.m();

    val[0] = m.get(0);
    val[1] = m.get(4);
    val[2] = m.get(8);
    val[3] = m.get(12);

    val[4] = m.get(1);
    val[5] = m.get(5);
    val[6] = m.get(9);
    val[7] = m.get(13);

    val[8] = m.get(2);
    val[9] = m.get(6);
    val[10] = m.get(10);
    val[11] = m.get(14);

    val[12] = m.get(3);
    val[13] = m.get(7);
    val[14] = m.get(11);
    val[15] = m.get(15);
}

static void hmdMat34ToMatrix4(HmdMatrix34 hmd, Matrix4 mat) {
    float[] val = mat.val;
    FloatBuffer m = hmd.m();

    val[0] = m.get(0);
    val[1] = m.get(4);
    val[2] = m.get(8);
    val[3] = 0;

    val[4] = m.get(1);
    val[5] = m.get(5);
    val[6] = m.get(9);
    val[7] = 0;

    val[8] = m.get(2);
    val[9] = m.get(6);
    val[10] = m.get(10);
    val[11] = 0;

    val[12] = m.get(3);
    val[13] = m.get(7);
    val[14] = m.get(11);
    val[15] = 1;
}

public static Vector2 PointApplyTransform(final Vector2 point, final Matrix4 transform, Vector2 out) {
 stackVec3.set(point, 0);
 stackVec3.mul(transform);
 out.x = stackVec3.x;
 out.y = stackVec3.y;
 return out;
}

public static Vector2 PointApplyTransform(final float pointX, final float pointY, final Matrix4 transform, Vector2 out) {
 stackVec3.set(pointX, pointY,0);
 stackVec3.mul(transform);
 out.x = stackVec3.x;
 out.y = stackVec3.y;
 return out;
}

/**获取当前矩阵 矩阵不可修改，只能读取 */
public final Matrix4 getMatrix(MATRIX_STACK_TYPE type) {
    switch(type) {
    case MATRIX_STACK_MODELVIEW: return _modelViewMatrixStack.peek();
    case MATRIX_STACK_PROJECTION:  return _projectionMatrixStack.peek();
    case MATRIX_STACK_TEXTURE: return _textureMatrixStack.peek();
    }
    return null;
}

/**
     * 相机包含测试
     * @param transform 变换
     * @param size 尺寸
     * @param anchorPointInPoints 锚dian偏移
     * @return
     */
    public final boolean checkVisibility(final Matrix4 transform, final Size size, final Vector2 anchorPointInPoints) {
        final Director director = Director.getInstance();
        //If draw to Rendertexture, return true directly.
        // only cull the default camera. The culling algorithm is valid for default camera.
        if (director.getRunningScene() == null) {// || (scene.getDefaultCamera() != Camera.getVisitingCamera())) {
            return true;
        }

        Vector2 temporigin = director.getVisibleOrigin();
        Size tempsize = director.getVisibleSize();
        Rect visiableRect = stackRect;
        visiableRect.set(temporigin.x, temporigin.y, tempsize.width, tempsize.height);

        // transform center point to screen space
        float hSizeX = size.width/2;
        float hSizeY = size.height/2;
        Vector3 v3p = stackVec3.set(hSizeX - anchorPointInPoints.x, hSizeY - anchorPointInPoints.y, 0);
        v3p.mul(transform);
//      transform.transformPoint(v3p);
        Vector2 v2p = Camera.getVisitingCamera().projectGL(v3p);

        // convert content size to world coordinates
        final float[] val = transform.val;
        float wshw = Math.max(Math.abs(hSizeX * val[Matrix4.M00] + hSizeY * val[Matrix4.M10]), 
                Math.abs(hSizeX * val[Matrix4.M00] - hSizeY * val[Matrix4.M10]));
//              std::max(fabsf(hSizeX * transform.m[0] + hSizeY * transform.m[4]), fabsf(hSizeX * transform.m[0] - hSizeY * transform.m[4]));
        float wshh = Math.max(Math.abs(hSizeX * val[Matrix4.M01] + hSizeY * val[Matrix4.M11]), 
                Math.abs(hSizeX * val[Matrix4.M01] - hSizeY * val[Matrix4.M11])); 
//              std::max(fabsf(hSizeX * transform.m[1] + hSizeY * transform.m[5]), fabsf(hSizeX * transform.m[1] - hSizeY * transform.m[5]));

        // enlarge visible rect half size in screen coord
        visiableRect.x -= wshw;
        visiableRect.y -= wshh;
        visiableRect.width += wshw * 2;
        visiableRect.height += wshh * 2;
        boolean ret = visiableRect.containsPoint(v2p);
//      System.out.println("visiableRect = " + visiableRect + " pos = " + v2p);
        return ret;
    }

/**
* @js NA
*/
public void visit(Renderer renderer,  Matrix4 parentTransform, int parentFlags) {
 if(_visible) {
     adaptRenderers();
     super.visit(renderer, parentTransform, parentFlags);
 }
}

/**
     * Returns the matrix that transform the node's (local) space coordinates into the parent's space coordinates.
     * The matrix is in Pixels.
     * Note: If ancestor is not a valid ancestor of the node, the API would return the same value as @see getNodeToWorldTransform
     *
     * @param ancestor The parent's node pointer.
     * @since v3.7
     * @return The transformation matrix. <b>(pool object)</b>
     */
    public final Matrix4 getNodeToParentTransform(Node ancestor) {
        final Matrix4 t = poolMatrix_1;
//      System.out.println("nodeToParentTransform = " + getNodeToParentTransform() + this);
        t.set(getNodeToParentTransform());
//        Mat4 t(this.getNodeToParentTransform());
        for (Node p = _parent;  p != null && p != ancestor ; p = p._parent) {
//            t = p.getNodeToParentTransform() * t;
            t.mulLeft(p.getNodeToParentTransform());
        }
        return t;
    }

/** 
 * Sets the Transformation matrix manually.
 */
public void setNodeToParentTransform(Matrix4 transform) {
    _transform.set(transform);
    _transformDirty = false;
    _transformUpdated = true;

    if(_additionalTransform != null) {
    if(_additionalTransform[1] == null) {
        _additionalTransform[1] = new Matrix4();
    }
    _additionalTransform[1].set(transform);
    }
}

@Override
    public void draw(Batch batch, float parentAlpha) {
        camera.update();
        Matrix4 projection = batch.getProjectionMatrix();

//      batch.end();

//      Gdx.gl.glViewport((int) frame.x, (int) frame.y, (int) frame.width, (int) frame.height);
//      batch.setProjectionMatrix(camera.combined);
//      batch.begin();

        tint.a = parentAlpha;
        batch.setColor(tint);
        batch.draw(terrain, getX(), getY(), getWidth(), getHeight());

        // draw nation layers
        if (visibilityLookup.get(Nation.FIRE))
            batch.draw(fire, getX(), getY(), getWidth(), getHeight());
        if (visibilityLookup.get(Nation.WATER))
            batch.draw(water, getX(), getY(), getWidth(), getHeight());
        if (visibilityLookup.get(Nation.EARTH))
            batch.draw(earth, getX(), getY(), getWidth(), getHeight());
        if (visibilityLookup.get(Nation.AIR))
            batch.draw(air, getX(), getY(), getWidth(), getHeight());

//      batch.end();
//      batch.setProjectionMatrix(projection);
//      batch.begin();
//      Gdx.gl.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    }

/**
     * Converts a Vector2 to node (local) space coordinates. The result is in Points.
     * <br>返回栈对象
     * <b>pool object</b>
     */
    public Vector2 convertToNodeSpace( Vector2 worldPoint) {
        Matrix4 tmp = getWorldToNodeTransform();
//      System.out.println("temp = " + tmp);
        final Vector3 ret = poolVector3_1.set(worldPoint.x, worldPoint.y, 0);
        ret.mul(tmp);
        return poolVector2_1.set(ret.x, ret.y);
    }

/**
 * Converts a Vector2 to world space coordinates. The result is in Points.
 */
public Vector2 convertToWorldSpace( Vector2 nodePoint) {
    Matrix4 tmp = getNodeToWorldTransform();
    final Vector3 ret = poolVector3_1.set(nodePoint.x, nodePoint.y, 0);
    poolVector3_1.mul(tmp);
    return poolVector2_1.set(ret.x, ret.y);
}

/**
 *  Sets an additional transform matrix to the node.
 *
 *  In order to remove it, call it again with the argument `nullptr`
 *
 *  @note The additional transform will be concatenated at the end of getNodeToParentTransform.
 *        It could be used to simulate `parent-child` relationship between two nodes (e.g. one is in BatchNode, another isn't).
 */
public void setAdditionalTransform(Matrix4 additionalTransform) {
    if(additionalTransform == null) {
        _additionalTransform = null;
    } else {
        if(_additionalTransform == null) {
            _additionalTransform = new Matrix4[2];
            // _additionalTransform[1] is used as a backup for _transform
            _additionalTransform[1] = new Matrix4(_transform);
        }

        _additionalTransform[0] = additionalTransform;
    }
    _transformUpdated = _additionalTransformDirty = _inverseDirty = true;
}

protected int processParentFlags( Matrix4 parentTransform, int parentFlags) {
        if(_usingNormalizedPosition) {
            assert _parent != null: "setNormalizedPosition() doesn't work with orphan nodes";
            if ((parentFlags & FLAGS_CONTENT_SIZE_DIRTY) != 0 || _normalizedPositionDirty) {
                Size s = _parent.getContentSize();
                _position.x = _normalizedPosition.x * s.width;
                _position.y = _normalizedPosition.y * s.height;
                _transformUpdated = _transformDirty = _inverseDirty = true;
                _normalizedPositionDirty = false;
            }
        }
        //remove this two line given that isVisitableByVisitingCamera should not affect the calculation of transform given that we are visiting scene
        //without involving view and projection matrix.
//      if (!isVisitableByVisitingCamera())
//          return parentFlags;
        int flags = parentFlags;
        flags |= (_transformUpdated ? FLAGS_TRANSFORM_DIRTY : 0);
        flags |= (_contentSizeDirty ? FLAGS_CONTENT_SIZE_DIRTY : 0);


        if((flags & FLAGS_DIRTY_MASK) != 0) {   //
//          System.out.println("update >>>>> trans" + getDescription() + _position
//                  + "\n" + parentTransform);
            _modelViewTransform = this.transform(parentTransform);

//          System.out.println("trigger trans  " + _physicsCallFlag + " / " + _onTransformCallback);
            if(_onTransformCallback != null) {//&& !_physicsCallFlag) {
                _onTransformCallback.onTransform(this);
            }
//          Vector3 d = new Vector3();
//          _modelViewTransform.getTranslation(d);
//          System.out.println("transro m = \n" + _modelViewTransform);
        }

        _transformUpdated = false;
        _contentSizeDirty = false;

        return flags;
    }

/**get view projection matrix*/
public Matrix4 getViewProjectionMatrix() {
 getViewMatrix();
if (_viewProjectionDirty) {
    _viewProjectionDirty = false;
    _viewProjection.set(_projection).mul(_view);
}
return _viewProjection;
}

/**
  * Move the camera following the new Postion
 * @param newPosition
 */
private void AddToCameraPosition(Vector3 newPosition)
 {
     float moveSpeed = 0.05f;
     Matrix4 cameraRotation = new Matrix4();
     cameraRotation = Utils.createRotate(updownRot, leftrightRot, 0f, cameraRotation);
     Vector3 rotatedVector = Utils.Transform(newPosition, cameraRotation);
     position.add(rotatedVector.mul(moveSpeed));
     UpdateViewMatrix();
 }

public Matrix4 getCombined()
{
    if(needUpdateProjection)
        updateProjection();
    if(needUpdateView)
        updateViewMatrix();

    combined.set(projection);
    combined.mul(view);
    return combined;
}

/**
    * render the Box2d Debugger
    */
   public void renderBox2dDebugger() {
if (debugRenderEnabled) {
    debugMatrix = new Matrix4(services.getCamera().combined);
    debugMatrix.scale(BOX_TO_WORLD, BOX_TO_WORLD, 1f);
    debugRender.render(world, debugMatrix);
}
   }

/**
 * Draws the given gradient {@link Texture} to the given {@link FrameBuffer}, using the given {@link Color} with the given percent.
 * <p>
 * This is achieved via a gradient shader.
 *
 * @param buffer     the {@link FrameBuffer} to be drawn to
 * @param color      the {@link Color} which should be drawn
 * @param gradient   the gradient texture which should be drawn
 * @param perc       the percent the gradient texture should be drawn
 * @param projection projection matrix for pixel perfect rendering
 */
private void drawToBuffer(FrameBuffer buffer, Color color, TextureRegion gradient, float perc, Matrix4 projection) {
    buffer.begin();
    AL.graphics.getGL20().glClearColor(0, 0, 0, 0);
    AL.graphics.getGL20().glClear(GL20.GL_COLOR_BUFFER_BIT);

    shaderBatch.setProjectionMatrix(projection);
    shaderBatch.begin();
    shaderBatch.setColor(color);
    shader.setUniformf("u_gradient", perc);
    shaderBatch.draw(gradient, -buffer.getWidth() / 2, -buffer.getHeight() / 2);
    shaderBatch.end();
    buffer.end();
}

/**
 * Draws the given gradient {@link Texture} to the given {@link FrameBuffer}, using the given {@link Color} with the given percent.
 * <p>
 * This is achieved via a gradient shader.
 *
 * @param buffer      the {@link FrameBuffer} to be drawn to
 * @param color       the {@link Color} which should be drawn
 * @param gradient    the gradient texture which should be drawn
 * @param perc        the percent the gradient texture should be drawn
 * @param shaderBatch the {@link SpriteBatch} to use
 * @param shader      the {@link ShaderProgram} to use
 * @param projection  projection matrix for pixel perfect rendering
 */
private static void drawToBuffer(FrameBuffer buffer, Color color, Texture gradient, float perc, SpriteBatch shaderBatch, ShaderProgram shader, Matrix4 projection) {
    buffer.begin();
    AL.graphics.getGL20().glClearColor(0, 0, 0, 0);
    AL.graphics.getGL20().glClear(GL20.GL_COLOR_BUFFER_BIT);

    shaderBatch.setProjectionMatrix(projection);
    shaderBatch.begin();
    shaderBatch.setColor(color);
    shader.setUniformf("u_gradient", perc);
    shaderBatch.draw(gradient, -buffer.getWidth() / 2, -buffer.getHeight() / 2);
    shaderBatch.end();
    buffer.end();
}

@Override
public void update (boolean updateFrustum) {
    view.setToLookAt(position, tmp.set(position).add(direction), up);
    combined.set(projection);
    Matrix4.mul(combined.val, view.val);

    if (updateFrustum) {
        invProjectionView.set(combined);
        Matrix4.inv(invProjectionView.val);
        frustum.update(invProjectionView);
    }
}

@Override
public void update(boolean updateFrustum) {
    // get the projection matrix from the HDM
    VRSystem.VRSystem_GetProjectionMatrix(eye.index, near, far, projectionMat);
    VRContext.hmdMat4toMatrix4(projectionMat, projection);

    // get the eye space matrix from the HDM
    VRSystem.VRSystem_GetEyeToHeadTransform(eye.index, eyeMat);
    VRContext.hmdMat34ToMatrix4(eyeMat, eyeSpace);
    invEyeSpace.set(eyeSpace).inv();

    // get the pose matrix from the HDM
    VRDevice hmd = context.getDeviceByType(VRDeviceType.HeadMountedDisplay);
    Vector3 y = hmd.getUp(Space.World);
    Vector3 z = hmd.getDirection(Space.World);
    Vector3 p = hmd.getPosition(Space.World);

    view.idt();
    view.setToLookAt(p, tmp.set(p).add(z), y);

    position.set(p);
    direction.set(z);
    up.set(y);      

    combined.set(projection);
    Matrix4.mul(combined.val, invEyeSpace.val);
    Matrix4.mul(combined.val, view.val);        

    if (updateFrustum) {
        invProjectionView.set(combined);
        Matrix4.inv(invProjectionView.val);
        frustum.update(invProjectionView);
    }
}

public AttackingEntity(Matrix4 transform, int hp, int health, int range, EnumSet<Types> types, EnumSet<Effects> effects, float coolDown, ModelInstance instance, btCollisionShape shape, btCollisionWorld world, IntMap<Entity> entities, String attackAnimation, Vector3 attackOffset, Map<String, Sound> sounds){
    super(transform, hp, health, types, effects, instance, shape, world, entities, sounds);
    this.coolDown = coolDown;
    this.range = range;
    this.attackAnimation = attackAnimation;
    this.attackOffset = attackOffset;
    callback = new ClosestRayResultCallback(new Vector3(), new Vector3());
}

public Entity(Matrix4 transform, int hp, int health, EnumSet<Types> types, EnumSet<Effects> effects, ModelInstance instance, btCollisionShape shape, btCollisionWorld world, IntMap<Entity> entities, Map<String, Sound> sounds){
    this.instance = instance;
    this.transform = transform;
    this.hp = hp;
    this.types = types;
    this.health = health;
    this.effects = effects;
    this.sounds = sounds;
    animation = new AnimationController(instance);
    this.instance.transform.set(transform);
    this.shape = shape;
    body = new btCollisionObject();
    body.setCollisionShape(shape);
    body.setWorldTransform(this.instance.transform);
    this.world = world;
    tempVector = new Vector3();
    tempVector2 = new Vector3();
    this.entities = entities;
    tempQuaternion = new Quaternion();
    quaternion = new Quaternion();
    if(this instanceof Enemy || this instanceof Projectile)
        body.setCollisionFlags(body.getCollisionFlags());
    int index = getNextIndex();
    entities.put(index, this);
    body.setUserValue(index);
    world.addCollisionObject(body);
    boundingBox = instance.calculateBoundingBox(new BoundingBox());
    //for(Node node: instance.nodes)
        //System.out.println();
}

@Override
public btCollisionObject createCollisionObject() {
    btCollisionObject collisionObject = new btCollisionObject();
    collisionObject.setCollisionShape(new btBoxShape(new Vector3(width, height, depth)));
    collisionObject.setWorldTransform(new Matrix4().setTranslation(pos));
    return collisionObject;
}

@Override
public btCollisionObject createCollisionObject() {
    btCollisionObject collisionObject = new btCollisionObject();
    collisionObject.setCollisionShape(new btSphereShape(radius));
    collisionObject.setWorldTransform(new Matrix4().setTranslation(pos));
    return collisionObject;
}

@Override
public void attack(ArrayList<Entity> targets) {
    super.attack(targets);
    try {
        Projectile projectile = projectileEntityTemplate.create(new Matrix4(transform), targets.get(0).getTransform().getTranslation(new Vector3()).sub(transform.getTranslation(tempVector)).setLength(1));
        if(projectile == null)
            Gdx.app.error("ProjectileTower", "Failed to create " + projectileEntityTemplate);
    } catch (Exception e) {
        Gdx.app.error("ProjectileTower", e.getMessage());
    }
}