HelloGeometryBatchFactory

package hello;

import jme3tools.optimize.GeometryBatchFactory;

import com.jme3.app.SimpleApplication;
import com.jme3.font.BitmapText;
import com.jme3.input.KeyInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.AnalogListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.light.AmbientLight;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.post.FilterPostProcessor;
import com.jme3.post.filters.FXAAFilter;
import com.jme3.post.ssao.SSAOFilter;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.shape.Box;
import com.jme3.shadow.PssmShadowRenderer;
import com.jme3.system.AppSettings;

public class HelloGeometryBatchFactory extends SimpleApplication {

    public static void main(String[] args) {
        AppSettings settings = new AppSettings(true);
        settings.setResolution(800, 600);
        settings.setTitle(HelloGeometryBatchFactory.class.getSimpleName());
        settings.setSamples(0);
        settings.setFrameRate(60);

        HelloGeometryBatchFactory app = new HelloGeometryBatchFactory();
        app.app = app; // i know, right?
        app.setShowSettings(false);
        app.setSettings(settings);
        app.setPauseOnLostFocus(false);
        app.start();
    }

    private HelloGeometryBatchFactory app;
    private float speedX = 0f, speedY = 0.1f;
    private Vector3f lightDirection = new Vector3f(-.5f, -.5f, -.5f);

    private PssmShadowRenderer pssmRenderer;
    private FilterPostProcessor fpp;
    private FXAAFilter fxaaFilter;
    private SSAOFilter ssaoFilter;
    private boolean useFXAA = false, useSSAO = false;

    private String postInfo = "";
    private BitmapText postText;

    @Override
    public void simpleInitApp() {
        setupCamera();
        setupFont();
        setupKeys();
        setupFloor();
        setupBoxes();
        setupLights();
        setupPost();
    }

    private void setupCamera() {
        flyCam.setEnabled(false);
        inputManager.removeListener(flyCam);

        final RtsCam rtsCam = new RtsCam(cam, rootNode);
        rtsCam.registerWithInput(inputManager);
        rtsCam.setCenter(new Vector3f(0f, 0f, 0f));
    }

    private void setupFont() {
        guiNode.detachAllChildren();
        guiFont = assetManager.loadFont("Interface/Fonts/Console.fnt");
        postText = new BitmapText(guiFont, false);
        postText.setSize(guiFont.getCharSet().getRenderedSize());
        updatePostInfo();
        guiNode.attachChild(postText);
    }

    private void setupKeys() {
        inputManager.addMapping("Left", new KeyTrigger(KeyInput.KEY_LEFT));
        inputManager.addMapping("Right", new KeyTrigger(KeyInput.KEY_RIGHT));
        inputManager.addMapping("Up", new KeyTrigger(KeyInput.KEY_UP));
        inputManager.addMapping("Down", new KeyTrigger(KeyInput.KEY_DOWN));
        inputManager.addMapping("SSAO", new KeyTrigger(KeyInput.KEY_O));
        inputManager.addMapping("PSSM", new KeyTrigger(KeyInput.KEY_P));
        inputManager.addMapping("MSAA", new KeyTrigger(KeyInput.KEY_K));
        inputManager.addMapping("FXAA", new KeyTrigger(KeyInput.KEY_L));

        inputManager.addListener(analogListener, new String[]{"Left", "Right", "Up", "Down"});
        inputManager.addListener(actionListener, new String[]{"SSAO", "PSSM", "MSAA", "FXAA"});
    }

    private AnalogListener analogListener = new AnalogListener() {
        public void onAnalog(String name, float value, float tpf) {
            if (name.equals("Left")) speedY -= 1f * tpf;
            if (name.equals("Right")) speedY += 1f * tpf;
            if (name.equals("Up")) speedX += 1f * tpf;
            if (name.equals("Down")) speedX -= 1f * tpf;
        }
    };

    private ActionListener actionListener = new ActionListener() {
        public void onAction(String name, boolean keyPressed, float tpf) {
            // shadows
            if (name.equals("PSSM") && keyPressed) {
                if (viewPort.getProcessors().contains(pssmRenderer)) viewPort.removeProcessor(pssmRenderer);
                else viewPort.addProcessor(pssmRenderer);
            }
            // hardware MSAA
            if (name.equals("MSAA") && keyPressed) {
                int samples = settings.getSamples();
                if (samples == 0) settings.setSamples(2);
                else if (samples < 16) settings.setSamples(samples * 2);
                else settings.setSamples(0);
                app.setSettings(settings);
                app.restart();
            }
            // ssao filter
            if (name.equals("SSAO") && keyPressed) {
                viewPort.removeProcessor(fpp);
                if (useSSAO) fpp.removeFilter(ssaoFilter);
                else fpp.addFilter(ssaoFilter);
                viewPort.addProcessor(fpp);
                useSSAO = !useSSAO;
            }
            //fxaa
            if (name.equals("FXAA") && keyPressed) {
                viewPort.removeProcessor(fpp);
                if (useFXAA) fpp.removeFilter(fxaaFilter);
                else fpp.addFilter(fxaaFilter);
                viewPort.addProcessor(fpp);
                useFXAA = !useFXAA;
            }

            updatePostInfo();
        }
    };

    private void setupFloor() {
        Material mat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        mat.setBoolean("UseMaterialColors", true);
        mat.setColor("Ambient", ColorRGBA.Gray);
        mat.setColor("Diffuse", ColorRGBA.Gray);
        mat.setColor("Specular", ColorRGBA.Gray);
        mat.setFloat("Shininess", 2);

        Geometry box = new Geometry("Floor", new Box(Vector3f.ZERO, 10f, 0.1f, 10f));
        box.setMaterial(mat);
        box.setShadowMode(ShadowMode.Receive);
        rootNode.attachChild(box);
    }

    private void setupBoxes() {
        float boxSize = 1f;
        int worldSize = 5;

        Material mat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        //mat.getAdditionalRenderState().setWireframe(true);
        mat.setBoolean("UseMaterialColors", true);
        mat.setColor("Ambient", ColorRGBA.White);
        mat.setColor("Diffuse", ColorRGBA.White);
        mat.setColor("Specular", ColorRGBA.White);
        mat.setFloat("Shininess", 12);

        Node boxes = new Node("boxes");
        boxes.move(0, 2f, 0);

        for (int x = 0; x < worldSize; x++) {
            for (int z = 0; z < worldSize; z++) {

                float w1 = (worldSize-1);
                float w2 = w1/2; // 2

                float xx = (x > w2) ? Math.abs(w1 - x) : x;
                float zz = (z > w2) ? Math.abs(w1 - z) : z;

                float y = (xx < zz) ? xx : zz;

                Vector3f pos = new Vector3f(x - w2, y, z - w2);
                Geometry box = new Geometry("Box", new Box(pos, boxSize, boxSize, boxSize));
                box.setMaterial(mat);
                //box.setShadowMode(ShadowMode.CastAndReceive);

                boxes.attachChild(box);
            }
        }

        Spatial optimizedBoxes = GeometryBatchFactory.optimize(boxes);
        optimizedBoxes.setShadowMode(ShadowMode.CastAndReceive);
        rootNode.attachChild(optimizedBoxes);
    }

    private void setupLights() {
        DirectionalLight dl = new DirectionalLight();
        dl.setDirection(lightDirection.normalizeLocal());
        dl.setColor(ColorRGBA.White);
        rootNode.addLight(dl);

        AmbientLight al = new AmbientLight();
        al.setColor(ColorRGBA.White.mult(0.2f));
        rootNode.addLight(al);
    }

    private void setupPost() {
        // set up fpp
        fpp = new FilterPostProcessor(assetManager);
        fpp.setNumSamples(1);

        // post proc filters
        ssaoFilter = new SSAOFilter(12.940201f, 43.928635f, 0.32999992f, 0.6059958f);
        fxaaFilter = new FXAAFilter();

        // shadows
        pssmRenderer = new PssmShadowRenderer(assetManager, 1024, 3);
        pssmRenderer.setDirection(lightDirection.normalizeLocal());
        rootNode.setShadowMode(ShadowMode.Off);
    }

    private void updatePostInfo() {
        boolean hasPSSM = (viewPort.getProcessors().contains(pssmRenderer));
        int samples = settings.getSamples();

        postInfo = "";
        if (hasPSSM) postInfo += "PSSM, ";
        if (useSSAO) postInfo += "SSAO, ";
        if (useFXAA) postInfo += "FXAA, ";
        postInfo += samples + "xAA";

        postText.setText(postInfo);
        postText.setLocalTranslation(settings.getWidth() - postText.getLineWidth() - 10,
                settings.getHeight() - postText.getLineHeight() + 5, 0);
    }

    @Override
    public void simpleUpdate(float tpf) {
        rootNode.getChild("boxes").rotate(speedX*tpf, speedY*tpf, 0f);
    }
}