/**
 * this sketch illustrates a special, stylized, and volumetric kind of fogging we applied to the world;
 */


import gestalt.Gestalt;
import gestalt.context.GLContext;
import gestalt.p5.GestaltPlugIn;
import gestalt.render.bin.RenderBin;
import gestalt.render.bin.ShapeBin;
import gestalt.shape.AbstractShape;
import gestalt.shape.Cube;
import gestalt.shape.Plane;

import mathematik.Vector2f;

import processing.opengl.*;


public class LayerFog
extends PApplet implements Gestalt {

  private GestaltPlugIn gestalt;

  private Vector2f _myFogArea;

  private float _myFogDensity;

  private Plane[] _myFogLayers;

  private MyCube[] _myCubes;

  public void setup() {
    /* setup p5 */
    size(640, 480, OPENGL);
    framerate(50);
    rectMode(CENTER);
    noStroke();

    gestalt = new GestaltPlugIn(this);

    /* create custom bins */
    RenderBin myRenderBin = new RenderBin(2);
    myRenderBin.add(gestalt.texturemanager());
    myRenderBin.add(gestalt.event());
    myRenderBin.add(gestalt.framesetup());
    myRenderBin.add(gestalt.camera());
    ShapeBin myNonTransparentBin = new ShapeBin();
    ShapeBin myTransparentBin = new ShapeBin();
    gestalt.setBinRef(new RenderBin(3));
    gestalt.bin().add(myRenderBin);
    gestalt.bin().add(myNonTransparentBin);
    gestalt.bin().add(myTransparentBin);

    /* create layers */
    _myFogArea = new Vector2f(10, 50);
    _myFogDensity = 0.37f;
    _myFogLayers = new Plane[10];
    for (int i = 0; i < _myFogLayers.length; i++) {
      Plane myPlane = gestalt.drawablefactory().plane();
      myPlane.scale().set(2000, 2000);
      myPlane.material().getColor().set(0.2f, 0.2f, 0.2f, _myFogDensity);
      _myFogLayers[i] = myPlane;
      _myFogLayers[i].setTransformMode(SHAPE_TRANSFORM_MATRIX);
    }
    setPlanePosition();
    myTransparentBin.add(_myFogLayers);

    /* create cubes */
    _myCubes = new MyCube[5];
    for (int i = 0; i < _myCubes.length; i++) {
      MyCube myCube = new MyCube();
      _myCubes[i] = myCube;
    }
    myNonTransparentBin.add(_myCubes);
  }


  private void setPlanePosition() {
    float myFogDistance = _myFogArea.y - _myFogArea.x;
    for (int i = 0; i < _myFogLayers.length; i++) {
      _myFogLayers[i].transform().translation.z = (myFogDistance / _myFogLayers.length) * i + _myFogArea.x;
    }
  }


  public void draw() {
    /* clear screen */
    background(50);

    /* loop cubes */
    for (int i = 0; i < _myCubes.length; i++) {
      _myCubes[i].loop(1 / 50f);
    }
  }


  private class MyCube
    extends AbstractShape {

    private Cube myCube;

    private float myCurrentTime;

    private float _myVelocity;

    public MyCube() {
      myCurrentTime = random(PI);
      _myVelocity = random(0.5f, 1.0f);

      myCube = gestalt.drawablefactory().cube();
      myCube.scale().set(50, 50, 50);
      myCube.position().set(random(0, width), random(0, height), 20);
      myCube.material().getColor().set(1f, 1f, 1f, 1f);
    }


    public void loop(float theDeltaTime) {
      myCurrentTime += theDeltaTime;
      myCube.position().z = 100 * sin(myCurrentTime) * _myVelocity;
      myCube.rotation().set(myCurrentTime / 5f * _myVelocity,
      myCurrentTime / 5f * _myVelocity,
      myCurrentTime / 5f * _myVelocity);
    }


    public void draw(GLContext theRenderContext) {
      myCube.draw(theRenderContext);
    }
  }


  public static void main(String[] args) {
    PApplet.main(new String[] {
      "LayerFog"    }
    );
  }
}