java类com.badlogic.gdx.graphics.PerspectiveCamera的实例源码

public void setupScene () {
    plane = new Mesh(true, 4, 6, new VertexAttribute(Usage.Position, 3, ShaderProgram.POSITION_ATTRIBUTE), new VertexAttribute(
        Usage.Normal, 3, ShaderProgram.NORMAL_ATTRIBUTE));
    plane.setVertices(new float[] {-10, -1, 10, 0, 1, 0, 10, -1, 10, 0, 1, 0, 10, -1, -10, 0, 1, 0, -10, -1, -10, 0, 1, 0});
    plane.setIndices(new short[] {3, 2, 1, 1, 0, 3});

    texture = new Texture(Gdx.files.internal("data/badlogic.jpg"), Format.RGB565, true);
    texture.setFilter(TextureFilter.MipMap, TextureFilter.Nearest);

    cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    cam.position.set(0, 5, 10);
    cam.lookAt(0, 0, 0);
    cam.update();
    controller = new PerspectiveCamController(cam);

    projector = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    projector.position.set(2, 3, 2);
    projector.lookAt(0, 0, 0);
    projector.normalizeUp();
    projector.update();
}

@Override
public void create () {
    texture = new Texture(Gdx.files.internal("data/badlogic.jpg"), true);
    texture.setFilter(TextureFilter.MipMap, TextureFilter.Linear);
    ObjLoader objLoader = new ObjLoader();
    mesh = objLoader.loadObj(Gdx.files.internal("data/cube.obj"));
    mesh.materials.get(0).set(new TextureAttribute(TextureAttribute.Diffuse, texture));
    modelInstance = new ModelInstance(mesh);
    modelBatch = new ModelBatch();

    cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    cam.position.set(3, 3, 3);
    cam.direction.set(-1, -1, -1);
    batch = new SpriteBatch();
    font = new BitmapFont();
}

@Override
public void create() {
    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(10f, 10f, 10f);
    cam.lookAt(0, 0, 0);
    cam.near = 1f;
    cam.far = 300f;
    cam.update();

    camController = new CameraInputController(cam);
    Gdx.input.setInputProcessor(camController);

    ModelBuilder modelBuilder = new ModelBuilder();
       model = modelBuilder.createBox(5f, 5f, 5f, 
           new Material(ColorAttribute.createDiffuse(Color.GREEN)),
           Usage.Position | Usage.Normal);
       instance = new ModelInstance(model);
}

public static EyeParams transform(Viewport viewport) {
    int eye = viewport == VirtualReality.head.getLeftEye() ? 0 : 1;
    EyeParams eyeParams = new EyeParams(eye);

    eyeParams.getViewport().setViewport(viewport.getScreenX(), viewport.getScreenY(), MathUtils.nextPowerOfTwo(viewport.getScreenWidth()),
            MathUtils.nextPowerOfTwo(viewport.getScreenHeight()));

    float fov = ((PerspectiveCamera) viewport.getCamera()).fieldOfView;
    eyeParams.getFov().setLeft(fov);
    eyeParams.getFov().setRight(fov);
    eyeParams.getFov().setTop(fov);
    eyeParams.getFov().setBottom(fov);

    for (int i = 0; i < 16; i++) {
        eyeParams.getTransform().getEyeView()[i] = viewport.getCamera().view.val[i];
    }

    for (int i = 0; i < 16; i++) {
        eyeParams.getTransform().getPerspective()[i] = viewport.getCamera().projection.val[i];
    }

    return eyeParams;
}

private void moveCamera(ICamera camera, Vector3d sideRemainder, Vector3d side, Vector3d sideCapped, double angle, boolean switchSides) {
    PerspectiveCamera cam = camera.getCamera();
    Vector3 sidef = sideCapped.put(aux1);

    if (switchSides) {
        cam.position.add(sidef);
        cam.direction.rotate(cam.up, (float) -angle);

        // Uncomment to enable 3D in points
        camera.getPos().add(sideRemainder);
        camera.setShift(sideRemainder);

    } else {
        cam.position.sub(sidef);
        cam.direction.rotate(cam.up, (float) angle);

        // Uncomment to enable 3D in points
        camera.getPos().sub(sideRemainder);
        camera.setShift(sideRemainder);
        camera.getShift().scl(-1d);
    }
    cam.update();
}

public AbstractCamera(CameraManager parent) {
    this.parent = parent;
    pos = new Vector3d();
    posinv = new Vector3d();
    shift = new Vector3d();
    tmp = new Vector3d();

    frustum = new Frustumd();

    camLeft = new PerspectiveCamera(GlobalConf.scene.CAMERA_FOV, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight());
    camLeft.near = (float) CAM_NEAR;
    camLeft.far = (float) CAM_FAR;

    camRight = new PerspectiveCamera(GlobalConf.scene.CAMERA_FOV, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight());
    camRight.near = (float) CAM_NEAR;
    camRight.far = (float) CAM_FAR;

    projection = new Matrix4d();
    view = new Matrix4d();
    combined = new Matrix4d();
}

@Override
public void create () {
    if (assets == null) assets = new AssetManager();

    modelBatch = new ModelBatch();

    cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    cam.position.set(10f, 10f, 10f);
    cam.lookAt(0, 0, 0);
    cam.near = 0.1f;
    cam.far = 1000f;
    cam.update();

    createAxes();

    Gdx.input.setInputProcessor(inputController = new CameraInputController(cam));
}

@Override
public void create () {
    modelBatch = new ModelBatch(new BaseShaderProvider() {
        @Override
        protected Shader createShader (Renderable renderable) {
            return new TestShader();
        }
    });

    cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    cam.position.set(10f, 10f, 10f);
    cam.lookAt(0, 0, 0);
    cam.near = 0.1f;
    cam.far = 300f;
    cam.update();

    camController = new CameraInputController(cam);
    Gdx.input.setInputProcessor(camController);

    Material material = new Material(new TestAttribute(1f));
    ModelBuilder builder = new ModelBuilder();
    model = builder.createCone(5, 5, 5, 20, material, Usage.Position);
    instance = new ModelInstance(model);
    testAttribute = (TestAttribute)instance.materials.get(0).get(TestAttribute.ID);
}

public void drawShadows(PerspectiveCamera camera) {
    drawCounter -= Time.getDelta();
    if (drawCounter < 0) {
        drawCounter = Config.SHADOW_FRAMES;
    } else {
        return;
    }

    ShadowManager.get().begin(camera.position, lod);

    ShaderProgram shadowShader = ShadowManager.get().shader;

    for (int i = 0; i < bundleArray.size; i++) {
        Bundle bundle = bundleArray.items[i];
        if (!bundle.visible || !bundle.inLargeRange || !bundle.inRange)
            continue;
        bundle.drawShadows(camera, shadowShader, lod, 3);
    }

    ShadowManager.get().end();
}

@Override
public void create () {
    modelBatch = new ModelBatch();
    environment = new Environment();
    environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1.f));
    environment.set(new ColorAttribute(ColorAttribute.Fog, 0.13f, 0.13f, 0.13f, 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(30f, 10f, 30f);
    cam.lookAt(0, 0, 0);
    cam.near = 0.1f;
    cam.far = 45f;
    cam.update();

    ModelBuilder modelBuilder = new ModelBuilder();
    model = modelBuilder.createBox(5f, 5f, 5f, new Material(ColorAttribute.createDiffuse(Color.GREEN)), Usage.Position
        | Usage.Normal);
    instance = new ModelInstance(model);

    Gdx.input.setInputProcessor(new InputMultiplexer(this, inputController = new CameraInputController(cam)));
}