Slick Forums

// push the current transformation matrix to the stack
GL11.glPushMatrix();

// rotate over the Z-axis
GL11.glRotatef(rotation, 0, 0, 1);

// scale on the X an Y axis by scale
GL11.glScalef(scale,scale , 1);

// perform translation (x,y)
GL11.glTranslatef(x, y,0);

// this is YOUR IMAGE
image.draw(0,0);

// Pop the matrix so that these transformations are not applied to
// all the other images.
GL11.glPopMatrix();

@Override
public void render(Graphics g) {
   SGL renderer = Renderer.get();
   // how do if fill the buffer that it works?
   FloatBuffer buffer = FloatBuffer.wrap(absoluteTransform.getMatrixPosition());

   renderer.glPushMatrix();
   renderer.glLoadMatrix(buffer);
   image.draw();
   renderer.glPopMatrix();
}

graphics.pushTransform();
graphics.translate( tx, ty );
graphics.scale( sx, sy );
graphics.rotate( 0, 0, angle ); // first two arguments are for centre of rotation
image.draw();
graphics.popTransform();

public void render(Image image,Transform transform, Graphics g){
      float[] tm=transform.getMatrixPosition(); //get the transform matrix
      
       //pad the transform to get a 4x4 3d affine transform
      float[] toBuffer={
            tm[0],tm[3],0,tm[6],
            tm[1],tm[4],0,tm[7],
            0    ,0    ,1    ,0,
            tm[2],tm[5],0    ,1 //<-note that I have not used tm[8] here as one might expect
      };
      
      //GL11 wants a "direct" FloatBuffer, but you can only get that by creating a direct ByteBuffer
      //and then creating a FloatBuffer as a view of that ByteBuffer.
      //the ByteBuffer is allocated 16*4 bytes, because there are 16 floats and each float needs 4 bytes
      ByteBuffer bb=ByteBuffer.allocateDirect(16*4);

      //this has something to do with the default byte order setting in Java being inappropriate
      bb.order(ByteOrder.nativeOrder());

      for(float f:toBuffer){
         bb.putFloat(f);
      }
      bb.rewind();
      FloatBuffer transformBuffer=bb.asFloatBuffer();

      GL11.glPushMatrix();      
      GL11.glLoadMatrix(transformBuffer);
      image.draw();
      GL11.glPopMatrix();
      
   }

   private final float[] rect = new float[8];
   
   //same functionality as Image.draw, for convenience
   public void drawImage(Image image, Transform t, Color c) {
      image.startUse();
      (c!=null ? c : Color.white).bind();
      drawImageEmbedded(image, t);
      image.endUse();
   }
   
   //same functionality as drawEmbedded -- i.e. requires startUse/endUse
   public void drawImageEmbedded(Image image, Transform t) {
      //reset our array of points to the image's bounds
      rect[0] = 0;                 //top left
      rect[1] = 0;
      rect[2] = image.getWidth();  //top right
      rect[3] = 0;
      rect[4] = image.getWidth();  //bottom right
      rect[5] = image.getHeight();
      rect[6] = 0;                 //bottom left
      rect[7] = image.getHeight();
         
      //transform the points
      t.transform(rect, 0, rect, 0, 4);
      SGL gl = Renderer.get();
      
      //get the texture coordinates for our image or sub-image
      float u = image.getTextureOffsetX();
      float v = image.getTextureOffsetY();
      float uw = image.getTextureWidth();
      float vh = image.getTextureHeight();
   
      //place each point with the texture coordinate
      gl.glTexCoord2f(u, v);
      gl.glVertex2f(rect[0], rect[1]);
      gl.glTexCoord2f(u+uw, v);
      gl.glVertex2f(rect[2], rect[3]);
      gl.glTexCoord2f(u+uw, v+vh);
      gl.glVertex2f(rect[4], rect[5]);
      gl.glTexCoord2f(u, v+vh);
      gl.glVertex2f(rect[6], rect[7]);
   }