/**
 * this sketch illustrates a technique we used to create a relfection on
 * small puddles of water.
 */


import gestalt.Gestalt;
import gestalt.candidates.materialplugin.JoglMaterialPluginTextureMatrixTransformer;
import gestalt.candidates.quad.JoglQuad;
import gestalt.p5.GestaltPlugIn;
import gestalt.texture.bitmap.IntegerBitmap;

import mathematik.Vector3f;

import processing.opengl.*;


public class CloudReflection
extends PApplet {

  private GestaltPlugIn gestalt;

  private JoglQuad[] _myQuads;

  private JoglMaterialPluginTextureMatrixTransformer _myTextureMatrixTransform;

  private final float _myWidth = 3000;

  private final float _myHeight = 2000;

  private float _myCloudVelocity;

  private static final int BOTTOM_LEFT = 3;

  private static final int BOTTOM_RIGHT = 2;

  private static final int TOP_LEFT = 0;

  private static final int TOP_RIGHT = 1;

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

    gestalt = new GestaltPlugIn(this);
    gestalt.event().EVENT_CENTER_MOUSE = true;

    /* texture */
    int myTexture = gestalt.texturemanager().create();
    PImage myImage = loadImage("data/sky.png");
    IntegerBitmap myBitmap = new IntegerBitmap(myImage.pixels,
    myImage.width,
    myImage.height,
    Gestalt.TEXTURE_MEDIA_MOVIE);
    gestalt.texturemanager().load(myTexture, myBitmap);
    gestalt.camera().position().x = _myWidth / 2f;
    gestalt.camera().position().y = _myHeight / 2f;

    /* texture matrix */
    _myTextureMatrixTransform = new JoglMaterialPluginTextureMatrixTransformer();

    /* quads */
    float myXSize = 30;
    float myYSize = 30;
    int myHorNumber = 30;
    int myVerNumber = 30;
    _myQuads = new JoglQuad[myHorNumber * myVerNumber];
    for (int i = 0; i < _myQuads.length; i++) {
      float myX = ( (_myWidth / myHorNumber) * (i % myHorNumber));
      float myY = ( (_myHeight / myVerNumber) * (i / myVerNumber));
      Vector3f myPosition = new Vector3f(myX + random( -25, 25),
      myY + random( -25, 25),
      random(20));
      _myQuads[i] = new JoglQuad();
      _myQuads[i].material().transparent = true;
      _myQuads[i].material().setTexture(myTexture);
      _myQuads[i].material().addPlugin(_myTextureMatrixTransform);
      _myQuads[i].getPoints()[BOTTOM_LEFT].set( -myXSize + myPosition.x, -myYSize + myPosition.y, myPosition.z);
      _myQuads[i].getPoints()[BOTTOM_RIGHT].set(myXSize + myPosition.x, -myYSize + myPosition.y, myPosition.z);
      _myQuads[i].getPoints()[TOP_RIGHT].set(myXSize + myPosition.x, myYSize + myPosition.y, myPosition.z);
      _myQuads[i].getPoints()[TOP_LEFT].set( -myXSize + myPosition.x, myYSize + myPosition.y, myPosition.z);

      /* texture coordinates */

      float myXRatio;
      float myYRatio;
      Vector3f myRefPoint = new Vector3f();

      myRefPoint.set(_myQuads[i].getPoints()[BOTTOM_LEFT]);
      myXRatio = (myRefPoint.x + (_myWidth / 2)) / _myWidth;
      myYRatio = (myRefPoint.y + (_myHeight / 2)) / _myHeight;
      _myQuads[i].getTextureCoordinates()[BOTTOM_LEFT].set(myXRatio, myYRatio);

      myRefPoint.set(_myQuads[i].getPoints()[BOTTOM_RIGHT]);
      myXRatio = (myRefPoint.x + (_myWidth / 2)) / _myWidth;
      myYRatio = (myRefPoint.y + (_myHeight / 2)) / _myHeight;
      _myQuads[i].getTextureCoordinates()[BOTTOM_RIGHT].set(myXRatio, myYRatio);

      myRefPoint.set(_myQuads[i].getPoints()[TOP_RIGHT]);
      myXRatio = (myRefPoint.x + (_myWidth / 2)) / _myWidth;
      myYRatio = (myRefPoint.y + (_myHeight / 2)) / _myHeight;
      _myQuads[i].getTextureCoordinates()[TOP_RIGHT].set(myXRatio, myYRatio);

      myRefPoint.set(_myQuads[i].getPoints()[TOP_LEFT]);
      myXRatio = (myRefPoint.x + (_myWidth / 2)) / _myWidth;
      myYRatio = (myRefPoint.y + (_myHeight / 2)) / _myHeight;
      _myQuads[i].getTextureCoordinates()[TOP_LEFT].set(myXRatio, myYRatio);

      gestalt.bin(Gestalt.BIN_3D).add(_myQuads[i]);
    }

    /* properties */
    _myCloudVelocity = 0.0006f;
  }


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

    final float myVelocityRatioX = gestalt.event().mouseX / (float) width;
    final float myVelocityRatioY = gestalt.event().mouseY / (float) height;

    _myTextureMatrixTransform.transform.translation.x -= _myCloudVelocity;
    _myTextureMatrixTransform.transform.translation.y -= _myCloudVelocity;

    gestalt.camera().position().x += 1f * myVelocityRatioX;
    gestalt.camera().position().y += 1f * myVelocityRatioY;

    if (gestalt.event().keyPressed) {
      /* texture */
      if (gestalt.event().key == '+') {
        _myCloudVelocity += 0.00005f;
      }
      if (gestalt.event().key == '-') {
        _myCloudVelocity -= 0.00005f;
      }
    }
  }


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