/**
* Copyright (c) 2003 Sun Microsystems, Inc. All  Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, 
* this list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may 
* be used to endorse or promote products derived from this software without 
* specific prior written permission.
* 
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS
* LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
* IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT
* OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
* PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use in the
* design, construction, operation or maintenance of any nuclear facility.
*
* Created on Jun 24, 2003
*/

import java.nio.ByteBuffer;

import net.java.games.joal.AL;
import net.java.games.joal.ALC;
import net.java.games.joal.ALFactory;
import net.java.games.joal.util.ALut;

/**
 * @author Athomas Goldberg
 *
 */
public class LoopingAndFadeaway {

    static int[] buffer = new int[1];
    static int[] source = new int[1];
    static float[] sourcePos = { 0.0f, 0.0f, 0.0f };
    static float[] sourceVel = { 0.0f, 0.0f, 0.1f };
    static float[] listenerPos = { 0.0f, 0.0f, 0.0f };
    static float[] listenerVel = { 0.0f, 0.0f, -0.1f };
    static float[] listenerOri = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f };
    static AL al;
    static ALC alc;

    static int loadALData() {
        if (al.alGetError() != AL.AL_NO_ERROR) {
            return AL.AL_FALSE;
        }

        int[] format = new int[1];
        int[] size = new int[1];
        ByteBuffer[] data = new ByteBuffer[1];
        int[] freq = new int[1];
        int[] loop = new int[1];

        // Load wav data into a buffer.
        al.alGenBuffers(1, buffer, 0);
        if (al.alGetError() != AL.AL_NO_ERROR)
            return AL.AL_FALSE;

        ALut.alutLoadWAVFile(
            "wavdata/Footsteps.wav",
            format, data, size, freq, loop);
        al.alBufferData(buffer[0], format[0], data[0], size[0], freq[0]);
        System.out.println("bufferID " + buffer[0]);

        al.alGenSources(1, source, 0);
        System.out.println("sourceID " + source[0]);
        al.alSourcei(source[0], AL.AL_BUFFER, buffer[0]);
        al.alSourcef(source[0], AL.AL_PITCH, 1.0f);
        al.alSourcef(source[0], AL.AL_GAIN, 1.0f);
        al.alSourcefv(source[0], AL.AL_POSITION, sourcePos, 0);
        al.alSourcefv(source[0], AL.AL_POSITION, sourceVel, 0);
        al.alSourcei(source[0], AL.AL_LOOPING, AL.AL_TRUE);

        if (al.alGetError() != AL.AL_NO_ERROR) {
            return AL.AL_FALSE;
        }

        return AL.AL_TRUE;
    }

    static void setListenerValues() {
        al.alListenerfv(AL.AL_POSITION, listenerPos, 0);
        al.alListenerfv(AL.AL_VELOCITY, listenerVel, 0);
        al.alListenerfv(AL.AL_ORIENTATION, listenerOri, 0);
    }

    static void killAllData() {
        al.alDeleteBuffers(1, buffer, 0);
        al.alDeleteSources(1, source, 0);
    }

    public static void main(String[] args) {
        try {
            ALut.alutInit();
            al = ALFactory.getAL();
        } catch(Exception e) {
            e.printStackTrace();
            return;
        }

        if(loadALData() == AL.AL_FALSE) {
            System.exit(1);
        }; 
        al.alSourcePlay(source[0]);
        long startTime = System.currentTimeMillis();
        long elapsed = 0;
        long ticker = 0;
        long lastTime = 0;
        while (elapsed < 10000) {
            elapsed = System.currentTimeMillis() - startTime;            
            if (ticker > 100)
            {
              ticker = 0;
//              sourcePos[0] += sourceVel[0];
//              sourcePos[1] += sourceVel[1];
//              sourcePos[2] += sourceVel[2];
//              al.alSourcefv(source[0], AL.AL_POSITION, sourcePos, 0);
              listenerPos[0] += listenerVel[0];
              listenerPos[1] += listenerVel[1];
              listenerPos[2] += listenerVel[2];
              al.alListenerfv(AL.AL_POSITION, listenerPos, 0);
            }
            ticker += System.currentTimeMillis() - lastTime;
            lastTime = System.currentTimeMillis(); 
        }
        ALut.alutExit();
    }
}

    id = createOpenGLID();

    // Bind this texture to its id
    gl.glBindTexture(texType, id);

    gl.glTexParameteri(texType, GL.GL_TEXTURE_MIN_FILTER, minFilter);
    gl.glTexParameteri(texType, GL.GL_TEXTURE_MAG_FILTER, magFilter);
    gl.glTexParameteri(texType, GL.GL_TEXTURE_WRAP_S, wrapMode_s);
    gl.glTexParameteri(texType, GL.GL_TEXTURE_WRAP_T, wrapMode_t);
    gl.glTexParameteri(texType, GL.GL_TEXTURE_WRAP_R, wrapMode_r);
    if(anisotropicFiltering != 0)
      gl.glTexParameterf(texType, GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropicFiltering);

    gl.glTexImage2D(GL.GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, internalFormat, width, height, 0, internalFormat, pixelFormat, posxData.getBuffer());
    gl.glTexImage2D(GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, internalFormat, width, height, 0, internalFormat, pixelFormat, posyData.getBuffer());
    gl.glTexImage2D(GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, internalFormat, width, height, 0, internalFormat, pixelFormat, poszData.getBuffer());
    gl.glTexImage2D(GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, internalFormat, width, height, 0, internalFormat, pixelFormat, negxData.getBuffer());
    gl.glTexImage2D(GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, internalFormat, width, height, 0, internalFormat, pixelFormat, negyData.getBuffer());
    gl.glTexImage2D(GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, internalFormat, width, height, 0, internalFormat, pixelFormat, negzData.getBuffer());

    gl.glEnable(texType);
    gl.glBindTexture(texType, id);

    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_COMBINE);
    gl.glTexEnvfv(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_COLOR, refl.getValues(), 0);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_COMBINE_RGB, GL.GL_INTERPOLATE);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_SRC0_RGB, GL.GL_TEXTURE);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_OPERAND0_RGB, GL.GL_SRC_COLOR);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_SRC1_RGB, GL.GL_PREVIOUS);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_OPERAND1_RGB, GL.GL_SRC_COLOR);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_SRC2_RGB, GL.GL_CONSTANT);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_OPERAND2_RGB, GL.GL_SRC_ALPHA);

    gl.glGetDoublev(GL.GL_MODELVIEW_MATRIX, mvmatrix);

    double[] tex = texmatrix.array();
    double[] mv = mvmatrix.array();

    tex[0] = mv[0];
    tex[1] = mv[4];
    tex[2] = mv[8];
    tex[3] = mv[12];

    tex[4] = mv[1];
    tex[5] = mv[5];
    tex[6] = mv[9];
    tex[7] = mv[13];

    tex[8] = mv[2];
    tex[9] = mv[6];
    tex[10] = mv[10];
    tex[11] = mv[14];

    tex[12] = -mv[0]*mv[3] -mv[4]*mv[7] -mv[8]*mv[11];
    tex[13] = -mv[1]*mv[3] -mv[5]*mv[7] -mv[9]*mv[11];
    tex[14] = -mv[2]*mv[3] -mv[6]*mv[7] -mv[10]*mv[11];
    tex[15] = mv[15];

    gl.glMatrixMode(GL.GL_TEXTURE);
    gl.glLoadMatrixd(texmatrix);
    gl.glMatrixMode(GL.GL_MODELVIEW);

package test;

import java.awt.Container;

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.swing.JApplet;

import com.sun.opengl.util.FPSAnimator;

public class Engine extends JApplet
  implements GLEventListener
{
  private static final long serialVersionUID = 4056777684480799564L;
  
  protected Container frame = null;
  protected GLAutoDrawable canvas = null;
  protected FPSAnimator fpsAnim = null;
  
  protected long currentTimestamp = System.currentTimeMillis();
  
  protected GL gl = null; 

   @Override
  public void init()
  {
     frame = this;
     frame.setName("Test");
     this.setSize(10, 10);
     
     GLCapabilities glCaps = new GLCapabilities();
     glCaps.setHardwareAccelerated(true);
     glCaps.setNumSamples(4);
     glCaps.setSampleBuffers(true);
     
     canvas = new GLCanvas(glCaps);
     canvas.addGLEventListener(this);
     
     frame.add((GLCanvas)canvas);

     fpsAnim = new FPSAnimator(canvas, 60, true);
  }
  

  @Override
  public void start(){
    fpsAnim.start();
  }

  @Override
  public void stop(){
    fpsAnim.stop();
  }

  @Override
  public void destroy(){
  }


  @Override
  public void display(GLAutoDrawable arg0){
    long newTime = System.currentTimeMillis();
    long deltaTime = newTime - currentTimestamp;
    currentTimestamp = newTime;
    
    System.out.println(deltaTime);
  }


  @Override
  public void displayChanged(GLAutoDrawable arg0, boolean arg1, boolean arg2){
  }


  @Override
  public void init(GLAutoDrawable drawable){
    gl = drawable.getGL();
  }


  @Override
  public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4){ 
  }

}

    float t = 0.0f;
    const float dt = 0.01f;

    float currentTime = time();
    float accumulator = 0.0f;

    State previous;
    State current;

    while (!quit)
    {
         float newTime = time();
         float deltaTime = newTime - currentTime;
         currentTime = newTime;

         accumulator += deltaTime;

         while (accumulator>=dt)
         {
              previousState = currentState;
              integrate(currentState, t, dt);
              t += dt;
              accumulator -= dt;
         }

         const float alpha = accumulator / dt;

         State state = currentState*alpha + previousState*(1.0f-alpha);

         render(state);
    }