package Media;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import main.Engine;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.ARBVertexBufferObject;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL13.*;
import static org.lwjgl.opengl.GL15.*;
import static org.lwjgl.util.glu.GLU.*;
import org.lwjgl.util.vector.Vector2f;
import org.lwjgl.util.vector.Vector4f;
import org.newdawn.slick.opengl.ImageDataFactory;
import org.newdawn.slick.opengl.InternalTextureLoader;
import org.newdawn.slick.opengl.LoadableImageData;
import org.newdawn.slick.opengl.TextureImpl;
import org.newdawn.slick.util.ResourceLoader;

public class Sprite
{
  public static final int
    NORMAL = 0,
    FLIP_VERTICAL = 1,
    FLIP_HORIZONTAL = 2;

  private int texID = 0;
  private int texWidth = 0;
  private int texHeight = 0;
  private int imageWidth = 0;
  private int imageHeight = 0;
  private FloatBuffer quadVertices = null;
  private FloatBuffer quadTexVertices = null;
  private int vboQuadHandle = 0;
  private int vboQuadTexHandle = 0;

  public Sprite( String fileName )
  {
    try
    {
      InputStream in = ResourceLoader.getResourceAsStream( fileName );
      texID = InternalTextureLoader.createTextureID();
      TextureImpl texture = new TextureImpl( fileName, GL_TEXTURE_2D, texID );
      glBindTexture( GL_TEXTURE_2D, texID );

      LoadableImageData imageData = ImageDataFactory.getImageDataFor( fileName );
      ByteBuffer textureBuffer = imageData.loadImage( new BufferedInputStream( in ), false, null );

      int width = imageData.getWidth();
      int height = imageData.getHeight();
      boolean hasAlpha = imageData.getDepth() == 32;

      texture.setTextureWidth( imageData.getTexWidth() );
      texture.setTextureHeight( imageData.getTexHeight() );

      texWidth = texture.getTextureWidth();
      texHeight = texture.getTextureHeight();

      IntBuffer temp = BufferUtils.createIntBuffer( 16 );
      glGetInteger( GL_MAX_TEXTURE_SIZE, temp );
      int max = temp.get(0);

      if ((texWidth > max) || (texHeight > max))
      {
        System.err.println("Attempt to allocate a texture to big for the current hardware");
        Engine.Ptr().Window.close();
      }

      int srcPixelFormat = hasAlpha ? GL_RGBA : GL_RGB;
      int componentCount = hasAlpha ? 4 : 3;

      texture.setWidth( width );
      texture.setHeight( height );
      texture.setAlpha( hasAlpha );

      imageWidth = texture.getImageWidth();
      imageHeight = texture.getImageHeight();

      glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
      gluBuild2DMipmaps( GL_TEXTURE_2D, componentCount,
        InternalTextureLoader.get2Fold( width ),
        InternalTextureLoader.get2Fold( height ),
        srcPixelFormat, GL_UNSIGNED_BYTE, textureBuffer );
      glBindTexture( GL_TEXTURE_2D, 0 );

      float[] vert = {
        0.0f, 0.0f,
        (float)texWidth, 0.0f,
        (float)texWidth, (float)texHeight,
        0.0f, (float)texHeight
      };

      float[] texVertices = {
        0.0f, 0.0f,
        1.0f, 0.0f,
        1.0f, 1.0f,
        0.0f, 1.0f
      };

      vboQuadHandle = glGenBuffers();
      vboQuadTexHandle = glGenBuffers();

      quadVertices = BufferUtils.createFloatBuffer( 4 * 2 );
      quadVertices.put( vert );
      quadVertices.flip();

      quadTexVertices = BufferUtils.createFloatBuffer( 4 * 2 );
      quadTexVertices.put( texVertices );
      quadTexVertices.flip();

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
      ARBVertexBufferObject.glBufferDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, quadVertices,
                    ARBVertexBufferObject.GL_STREAM_DRAW_ARB );

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
      ARBVertexBufferObject.glBufferDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, quadTexVertices,
                    ARBVertexBufferObject.GL_STREAM_DRAW_ARB );

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );
    }
    catch (IOException e)
    {
      System.out.println( "Can't load texture from file " + fileName + ": " + e.getLocalizedMessage() );
      Engine.Ptr().Window.close();
    }
  }

  public void use()
  {
    glBindTexture( GL_TEXTURE_2D, texID );
  }

  public Vector2f size()
  {
    return new Vector2f( texWidth, texHeight );
  }

  public int width()
  {
    return texWidth;
  }

  public int height()
  {
    return texHeight;
  }

  public Vector2f imageSize()
  {
    return new Vector2f( imageWidth, imageHeight );
  }

  public int imageWidth()
  {
    return imageWidth;
  }

  public int imageHeight()
  {
    return imageHeight;
  }

  public int ID()
  {
    return texID;
  }

  public void destroy()
  {
    glDeleteTextures( texID );
    ARBVertexBufferObject.glDeleteBuffersARB( vboQuadHandle );
    ARBVertexBufferObject.glDeleteBuffersARB( vboQuadTexHandle );
  }

  public void setTexEnvi( int param1, int param2 )
  {
    glTexEnvi( GL_TEXTURE_ENV, param1, param2 );
  }

  public static void activeTexture( int num )
  {
    glActiveTexture( GL_TEXTURE0 + num );
    glEnable( GL_TEXTURE_2D );
  }

  public static void deactiveTextures( int count )
  {
    for (int i = count - 1; i > -1; --i)
    {
      glActiveTexture( GL_TEXTURE0 + i );
      glBindTexture( GL_TEXTURE_2D, 0 );  
      glDisable( GL_TEXTURE_2D );
    }
  }

  public void draw( Vector4f geom, float angle, float alpha, boolean centered, int mode )
  {
    float[] vert = {
      0.0f, 0.0f,
      geom.getZ(), 0.0f,
      geom.getZ(), geom.getW(),
      0.0f, geom.getW()
    };

    if (centered)
    {
      vert = new float[] {
        -geom.getZ() / 2.0f, -geom.getW() / 2.0f,
        geom.getZ() / 2.0f, -geom.getW() / 2.0f,
        geom.getZ() / 2.0f, geom.getW() / 2.0f,
        -geom.getZ() / 2.0f, geom.getW() / 2.0f
      };
    }

    quadVertices.clear();
    quadVertices.put( vert );
    quadVertices.flip();

    // Normal render
    float[] texVertices = {
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f
    };

    // Flip vertical
    if (mode == FLIP_VERTICAL)
    {
      texVertices = new float[] {
        0.0f, 1.0f,
        1.0f, 1.0f,
        1.0f, 0.0f,
        0.0f, 0.0f
      };
    }

    // Flip horizontal
    else if (mode == FLIP_HORIZONTAL)
    {
      texVertices = new float[] {
        1.0f, 0.0f,
        0.0f, 0.0f,
        0.0f, 1.0f,
        1.0f, 1.0f
      };
    }

    quadTexVertices.clear();
    quadTexVertices.put( texVertices );
    quadTexVertices.flip();

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadVertices );
    glVertexPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadTexVertices );
    glTexCoordPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );

    glLoadIdentity();

    if (centered)
    {
      glTranslatef( geom.getX(), geom.getY(), 0.0f );
      glRotatef( angle, 0.0f, 0.0f, 1.0f );
    }
    else
    {
      glTranslatef( geom.getX() + geom.getZ() / 2.0f, geom.getY() + geom.getW() / 2.0f, 0.0f );
      glRotatef( angle, 0.0f, 0.0f, 1.0f );
      glTranslatef( -geom.getZ() / 2.0f, -geom.getW() / 2.0f, 0.0f );
    }

    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    glEnable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, texID );

    glColor4f( 1.0f, 1.0f, 1.0f, alpha );

    glEnableClientState( GL_VERTEX_ARRAY );
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );

    glDrawArrays( GL_QUADS, 0, 4 );

    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
    glDisableClientState( GL_VERTEX_ARRAY );

    glDisable( GL_TEXTURE_2D );
    glDisable( GL_BLEND );
  }

  public void drawPart( Vector4f geom, Vector4f partGeom, float angle, float alpha,
    boolean centered, int mode )
  {
    float[] vert = {
      0.0f, 0.0f,
      geom.getZ(), 0.0f,
      geom.getZ(), geom.getW(),
      0.0f, geom.getW()
    };

    if (centered)
    {
      vert = new float[] {
        -geom.getZ() / 2.0f, -geom.getW() / 2.0f,
        geom.getZ() / 2.0f, -geom.getW() / 2.0f,
        geom.getZ() / 2.0f, geom.getW() / 2.0f,
        -geom.getZ() / 2.0f, geom.getW() / 2.0f
      };
    }

    quadVertices.clear();
    quadVertices.put( vert );
    quadVertices.flip();

    float tx = partGeom.getX() / (float)texWidth;
    float ty = partGeom.getY() / (float)texHeight;
    float tw = partGeom.getZ() / (float)texWidth;
    float th = partGeom.getW() / (float)texHeight;

    // Normal render
    float[] texVertices = {
      tx, ty,
      tx + tw, ty,
      tx + tw, ty + th,
      tx, ty + th
    };

    // Flip vertical
    if (mode == FLIP_VERTICAL)
    {
      texVertices = new float[] {
        tx, ty + th,
        tx + tw, ty + th,
        tx + tw, ty,
        tx, ty
      };
    }

    // Flip horizontal
    else if (mode == FLIP_HORIZONTAL)
    {
      texVertices = new float[] {
        tx + tw, ty,
        tx, ty,
        tx, ty + th,
        tx + tw, ty + th
      };
    }

    quadTexVertices.clear();
    quadTexVertices.put( texVertices );
    quadTexVertices.flip();

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadVertices );
    glVertexPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadTexVertices );
    glTexCoordPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );

    glLoadIdentity();

    if (centered)
    {
      glTranslatef( geom.getX(), geom.getY(), 0.0f );
      glRotatef( angle, 0.0f, 0.0f, 1.0f );
    }
    else
    {
      glTranslatef( geom.getX() + geom.getZ() / 2.0f, geom.getY() + geom.getW() / 2.0f, 0.0f );
      glRotatef( angle, 0.0f, 0.0f, 1.0f );
      glTranslatef( -geom.getZ() / 2.0f, -geom.getW() / 2.0f, 0.0f );
    }

    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    glEnable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, texID );

    glColor4f( 1.0f, 1.0f, 1.0f, alpha );

    glEnableClientState( GL_VERTEX_ARRAY );
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );

    glDrawArrays( GL_QUADS, 0, 4 );

    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
    glDisableClientState( GL_VERTEX_ARRAY );

    glDisable( GL_TEXTURE_2D );
    glDisable( GL_BLEND );
  }
}

package pointer.media;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.ARBVertexBufferObject;
import org.lwjgl.util.vector.Vector2f;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;

import static org.lwjgl.BufferUtils.createByteBuffer;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.GL_CLAMP_TO_EDGE;
import static org.lwjgl.opengl.GL15.glGenBuffers;

public class Sprite
{
  public static final int
    NORMAL = 0,
    FLIP_VERTICAL = 1,
    FLIP_HORIZONTAL = 2;

  private int texID = 0;
  private FloatBuffer quadVertices = null;
  private FloatBuffer quadTexVertices = null;
  private int vboQuadHandle = 0;
  private int vboQuadTexHandle = 0;
  private Vector2f size;
  private Vector2f position = new Vector2f( 0, 0 );
  private float angle = 0;

  public Sprite( InputStream is )
  {
    try
    {
      BufferedImage bufImg = ImageIO.read( is );
      size = new Vector2f( bufImg.getWidth(), bufImg.getHeight() );
      int[] pixels = new int[ bufImg.getWidth() * bufImg.getHeight() ];
      bufImg.getRGB( 0, 0, bufImg.getWidth(), bufImg.getHeight(), pixels, 0, bufImg.getWidth() );
      ByteBuffer buffer = createByteBuffer( bufImg.getWidth() * bufImg.getHeight() * 4 );

      for (int y = 0; y < bufImg.getHeight(); ++y)
      {
        for (int x = 0; x < bufImg.getWidth(); ++x)
        {
          int pixel = pixels[ y * bufImg.getWidth() + x ];
          buffer.put( (byte)((pixel >> 16) & 0xFF) );
          buffer.put( (byte)((pixel >> 8) & 0xFF) );
          buffer.put( (byte)(pixel & 0xFF) );
          buffer.put( (byte)((pixel >> 24) & 0xFF) );
        }
      }

      buffer.flip();

      texID = glGenTextures();
      glBindTexture( GL_TEXTURE_2D, texID );
      glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
      glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, bufImg.getWidth(), bufImg.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer );

      float[] vert = {
        -bufImg.getWidth() / 2.0f, -bufImg.getHeight() / 2.0f,
        bufImg.getWidth() / 2.0f, -bufImg.getHeight() / 2.0f,
        bufImg.getWidth() / 2.0f, bufImg.getHeight() / 2.0f,
        -bufImg.getWidth() / 2.0f, bufImg.getHeight() / 2.0f
      };

      float[] texVertices = {
        0.0f, 0.0f,
        1.0f, 0.0f,
        1.0f, 1.0f,
        0.0f, 1.0f
      };

      vboQuadHandle = glGenBuffers();
      vboQuadTexHandle = glGenBuffers();

      quadVertices = BufferUtils.createFloatBuffer( 4 * 2 );
      quadVertices.put( vert );
      quadVertices.flip();

      quadTexVertices = BufferUtils.createFloatBuffer( 4 * 2 );
      quadTexVertices.put( texVertices );
      quadTexVertices.flip();

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
      ARBVertexBufferObject.glBufferDataARB(
        ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
        quadVertices,
        ARBVertexBufferObject.GL_STREAM_DRAW_ARB
      );

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
      ARBVertexBufferObject.glBufferDataARB(
        ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
        quadTexVertices,
        ARBVertexBufferObject.GL_STREAM_DRAW_ARB
      );

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );
    }
    catch (Exception e)
    {
      System.err.println( "Sprite: " + e.getLocalizedMessage() );
    }
  }

  public int getID()
  {
    return texID;
  }

  public void setPosition( Vector2f pos )
  {
    position = pos;
  }

  /**
   * Set pivot to sprite in pixels
   * @param p: new pivot
   */
  public void setPivot( Vector2f p )
  {
    float tlX = p.getX() == 0 ? 0 : p.getX() - size.getX();
    float tlY = p.getY() == 0 ? 0 : p.getY() - size.getY();
    float trX = p.getX() == 0 ? size.getX() : size.getX() - p.getX();
    float trY = p.getY() == 0 ? 0 : p.getY() - size.getY();
    float brX = p.getX() == 0 ? size.getX() : size.getX() - p.getX();
    float brY = p.getY() == 0 ? size.getY() : size.getY() - p.getY();
    float blX = p.getX() == 0 ? 0 : p.getX() - size.getX();
    float blY = p.getY() == 0 ? size.getY() : size.getY() - p.getY();

    float[] vert = {
      tlX, tlY,
      trX, trY,
      brX, brY,
      blX, blY
    };

    quadVertices.clear();
    quadVertices.put( vert );
    quadVertices.flip();
  }

  public void setAngle( float a )
  {
    angle = a;
  }

  public void setDrawMode( int dm )
  {
    // Normal render
    float[] texVertices = new float[] {
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f
    };

    // Flip vertical
    if (dm == FLIP_VERTICAL)
    {
      texVertices = new float[] {
        0.0f, 1.0f,
        1.0f, 1.0f,
        1.0f, 0.0f,
        0.0f, 0.0f
      };
    }
    // Flip horizontal
    else if (dm == FLIP_HORIZONTAL)
    {
      texVertices = new float[] {
        1.0f, 0.0f,
        0.0f, 0.0f,
        0.0f, 1.0f,
        1.0f, 1.0f
      };
    }

    quadTexVertices.clear();
    quadTexVertices.put( texVertices );
    quadTexVertices.flip();
  }

  public void draw()
  {
    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadVertices );
    glVertexPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadTexVertices );
    glTexCoordPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );

    glLoadIdentity();

    glTranslatef( position.getX(), position.getY(), 0.0f );
    glRotatef( angle, 0.0f, 0.0f, 1.0f );

    glEnable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, texID );

    glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );

    glEnableClientState( GL_VERTEX_ARRAY );
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );

    glDrawArrays( GL_QUADS, 0, 4 );

    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
    glDisableClientState( GL_VERTEX_ARRAY );

    glBindTexture( GL_TEXTURE_2D, 0 );
    glDisable( GL_TEXTURE_2D );
  }

  public void destroy()
  {
    glDeleteTextures( texID );
    ARBVertexBufferObject.glDeleteBuffersARB( vboQuadHandle );
    ARBVertexBufferObject.glDeleteBuffersARB( vboQuadTexHandle );
  }
}