HelloWorldOGL.java

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import com.threed.jpct.*;
import com.threed.jpct.util.*;

/**
 * A simple HelloWorld using the OpenGL-renderer.
 * @author EgonOlsen
 *
 */

public class HelloWorldOGL
{
    private FrameBuffer buffer = null;
    private World world = null;
    private Object3D ground = null;
    private Object3D ball = null;
    private SimpleVector sv = null;
    private Light lamp = null;
    private Projector projector = null;
    private ShadowHelper sh = null;
    private KeyMapper km = new KeyMapper();
    private MouseMapper mm = null;
    private double angle;
    private boolean forward = false;
    private boolean back = false;
    private boolean left = false;
    private boolean right = false;
    private boolean up = false;
    private boolean down = false;
    private TreeEngine trees;

    public static void main(String[] args) throws Exception
    {
        new HelloWorldOGL().loop();
    }

    public HelloWorldOGL() throws Exception
    {
        buffer = new FrameBuffer(800, 600, FrameBuffer.SAMPLINGMODE_NORMAL);
        buffer.disableRenderer(IRenderer.RENDERER_SOFTWARE);
        buffer.enableRenderer(IRenderer.RENDERER_OPENGL);

        mm = new MouseMapper(buffer);

        Config.maxPolysVisible = 50000;
        Config.glAvoidTextureCopies = true;
        Config.glColorDepth = 25;
        Config.glShadowZBias = 0.8f;
        Config.glTrilinear = false;
        Config.farPlane = 40000;
        Config.lightMul = 1;
        Config.mipmap = true;
        Config.collideOffset = 1000;

        world = new World();
        world.setAmbientLight(32, 32, 64);

        char c = File.separatorChar;
        TextureManager.getInstance().addTexture("ground", new Texture("res" + c + "ground.png"));

        ground = Loader.load3DS("res" + c + "ground.3ds", 70f)[0];
        ground.rotateX((float) (-Math.PI / 2));
        ground.translate(-100f, 10f, 2f);
        ground.setSpecularLighting(true);
        ground.setShadingMode(Object3D.SHADING_GOURAUD);
        ground.setTexture("ground");
        ground.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
        ground.setCollisionOptimization(Object3D.COLLISION_DETECTION_OPTIMIZED);
        ground.build();
        world.addObject(ground);

        trees = new TreeEngine(world, ground);

        ball = Primitives.getSphere(40f);
        ball.setAdditionalColor(new Color(255, 255, 128));
        ball.translate(-100f, -400f, 0f);
        ball.setShadingMode(Object3D.SHADING_GOURAUD);
        ball.build();
        world.addObject(ball);

        projector = new Projector();
        projector.setFOV(1.5f);
        projector.setYFOV(1.5f);

        sh = new ShadowHelper(world, buffer, projector, 2048);
        sh.setCullingMode(false);
        sh.setAmbientLight(new Color(16, 16, 64));
        sh.setLightMode(true);
        sh.setBorder(1);

        trees.setShadows(sh);
        sh.addCaster(border);
        sh.addCaster(farm);
        sh.addCaster(helis);
        sh.addReceiver(ground);

        sv = new SimpleVector();
        sv.set(ball.getTransformedCenter());

        lamp = new Light(world);
        lamp.setPosition(sv);
        lamp.setIntensity(255f, 255f, 120f);
        lamp.setAttenuation(800);

        world.getCamera().setPosition(ground.getTransformedCenter().x + 400f, ground.getTransformedCenter().y - 200f, ground.getTransformedCenter().z - 50f);
        world.getCamera().lookAt(ground.getTransformedCenter());
        world.getCamera().setFOV(1.5f);
    }

    private void loop() throws Exception
    {
        while (!org.lwjgl.opengl.Display.isCloseRequested())
        {
            angle += 0.05f;
            ball.translate((float) Math.cos(angle), (float) Math.sin(angle), 0f);

            sv = ball.getTransformedCenter();

            lamp.setPosition(sv);

            projector.lookAt(ground.getTransformedCenter());
            projector.setPosition(sv);

            move();

            buffer.clear(new Color(0, 112, 148));

            sh.updateShadowMap();
            world.renderScene(buffer);

            world.draw(buffer);
            sh.drawScene();

            buffer.update();
            buffer.displayGLOnly();

            Thread.sleep(10);
        }
        buffer.disableRenderer(IRenderer.RENDERER_OPENGL);
        buffer.dispose();
        System.exit(0);
    }

    private void move()
    {
        KeyState ks = null;
        while ((ks = km.poll()) != KeyState.NONE)
        {
            if (ks.getKeyCode() == KeyEvent.VK_Z)
            {
                forward = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_S)
            {
                back = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_Q)
            {
                left = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_D)
            {
                right = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_PAGE_UP)
            {
                up = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_PAGE_DOWN)
            {
                down = ks.getState();
            }
        }

        if (forward)
        {
            world.getCamera().moveCamera(Camera.CAMERA_MOVEIN, 2f);
        }
        if (back)
        {
            world.getCamera().moveCamera(Camera.CAMERA_MOVEOUT, 2f);
        }
        if (left)
        {
            if (mm.isGrabbed(1))
            {
                world.getCamera().moveCamera(Camera.CAMERA_MOVELEFT, 2f);
            }
            else
            {
                world.getCamera().rotateAxis(world.getCamera().getYAxis(), -0.1f);
            }
        }
        if (right)
        {
            if (mm.isGrabbed(1))
            {
                world.getCamera().moveCamera(Camera.CAMERA_MOVERIGHT, 2f);
            }
            else
            {
            world.getCamera().rotateAxis(world.getCamera().getYAxis(), 0.1f);
            }
        }
        if (up)
        {
            world.getCamera().rotateAxis(world.getCamera().getZAxis(), 0.1f);
        }
        if (down)
        {
            world.getCamera().rotateAxis(world.getCamera().getZAxis(), -0.1f);
        }

        if (mm.isGrabbed(0) || mm.isGrabbed(1))
        {
            world.getCamera().rotateAxis(new SimpleVector(mm.getDeltaY(), mm.getDeltaX(), 0f), 0.05f);
        }
    }
}