(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2014 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *)

{$INCLUDE "options.inc"}

{$IF GLunit = GL}{$DEFINE GLunit:=GL,GLext}{$ENDIF}

unit uRender;

interface

uses SDLh, uTypes, GLunit, uConsts, uStore{$IFDEF GL2}, uMatrix{$ENDIF};

procedure DrawSprite            (Sprite: TSprite; X, Y, Frame: LongInt);

procedure DrawSprite            (Sprite: TSprite; X, Y, FrameX, FrameY: LongInt);

procedure DrawSpriteFromRect    (Sprite: TSprite; r: TSDL_Rect; X, Y, Height, Position: LongInt); inline;

procedure DrawSpriteClipped     (Sprite: TSprite; X, Y, TopY, RightX, BottomY, LeftX: LongInt);

procedure DrawSpriteRotated     (Sprite: TSprite; X, Y, Dir: LongInt; Angle: real);

procedure DrawSpriteRotatedF    (Sprite: TSprite; X, Y, Frame, Dir: LongInt; Angle: real);

procedure DrawTexture           (X, Y: LongInt; Texture: PTexture); inline;

procedure DrawTexture           (X, Y: LongInt; Texture: PTexture; Scale: GLfloat);

procedure DrawTexture2          (X, Y: LongInt; Texture: PTexture; Scale, Overlap: GLfloat);

procedure DrawTextureFromRect   (X, Y: LongInt; r: PSDL_Rect; SourceTexture: PTexture); inline;

procedure DrawTextureFromRect   (X, Y, W, H: LongInt; r: PSDL_Rect; SourceTexture: PTexture); inline;

procedure DrawTextureFromRectDir(X, Y, W, H: LongInt; r: PSDL_Rect; SourceTexture: PTexture; Dir: LongInt);

procedure DrawTextureCentered   (X, Top: LongInt; Source: PTexture);

procedure DrawTextureF          (Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, w, h: LongInt);

procedure DrawTextureRotated    (Texture: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real);

procedure DrawTextureRotatedF   (Texture: PTexture; Scale, OffsetX, OffsetY: GLfloat; X, Y, Frame, Dir, w, h: LongInt; Angle: real);

procedure DrawCircle            (X, Y, Radius, Width: LongInt);

procedure DrawCircle            (X, Y, Radius, Width: LongInt; r, g, b, a: Byte);

procedure DrawLine              (X0, Y0, X1, Y1, Width: Single; color: LongWord); inline;

procedure DrawLine              (X0, Y0, X1, Y1, Width: Single; r, g, b, a: Byte);

procedure DrawFillRect          (r: TSDL_Rect);

procedure DrawHedgehog          (X, Y: LongInt; Dir: LongInt; Pos, Step: LongWord; Angle: real);

procedure DrawScreenWidget      (widget: POnScreenWidget);

procedure openglTint            (r, g, b, a: Byte); inline;

procedure Tint                  (r, g, b, a: Byte); inline;

procedure Tint                  (c: Longword); inline;

procedure untint(); inline;

procedure setTintAdd            (f: boolean); inline;

implementation

uses uVariables;

{$IFDEF USE_TOUCH_INTERFACE}

const

    FADE_ANIM_TIME = 500;

    MOVE_ANIM_TIME = 500;

{$ENDIF}

var LastTint: LongWord = 0;

procedure DrawSpriteFromRect(Sprite: TSprite; r: TSDL_Rect; X, Y, Height, Position: LongInt); inline;

begin

r.y:= r.y + Height * Position;

r.h:= Height;

DrawTextureFromRect(X, Y, @r, SpritesData[Sprite].Texture)

end;

procedure DrawTextureFromRect(X, Y: LongInt; r: PSDL_Rect; SourceTexture: PTexture); inline;

begin

DrawTextureFromRectDir(X, Y, r^.w, r^.h, r, SourceTexture, 1)

end;

procedure DrawTextureFromRect(X, Y, W, H: LongInt; r: PSDL_Rect; SourceTexture: PTexture); inline;

begin

DrawTextureFromRectDir(X, Y, W, H, r, SourceTexture, 1)

end;

procedure DrawTextureFromRectDir(X, Y, W, H: LongInt; r: PSDL_Rect; SourceTexture: PTexture; Dir: LongInt);

var rr: TSDL_Rect;

    _l, _r, _t, _b: real;

    VertexBuffer, TextureBuffer: array [0..3] of TVertex2f;

begin

if (SourceTexture^.h = 0) or (SourceTexture^.w = 0) then

    exit;

// do not draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs)

if (abs(X) > W) and ((abs(X + W / 2) - W / 2) > cScreenWidth / cScaleFactor) then

    exit;

if (abs(Y) > H) and ((abs(Y + H / 2 - (0.5 * cScreenHeight)) - H / 2) > cScreenHeight / cScaleFactor) then

    exit;

rr.x:= X;

rr.y:= Y;

rr.w:= W;

rr.h:= H;

_l:= r^.x / SourceTexture^.w * SourceTexture^.rx;

_r:= (r^.x + r^.w) / SourceTexture^.w * SourceTexture^.rx;

_t:= r^.y / SourceTexture^.h * SourceTexture^.ry;

_b:= (r^.y + r^.h) / SourceTexture^.h * SourceTexture^.ry;

glBindTexture(GL_TEXTURE_2D, SourceTexture^.id);

if Dir < 0 then

    begin

    VertexBuffer[0].X:= X + rr.w/2;

    VertexBuffer[0].Y:= Y;

    VertexBuffer[1].X:= X - rr.w/2;

    VertexBuffer[1].Y:= Y;

    VertexBuffer[2].X:= X - rr.w/2;

    VertexBuffer[2].Y:= rr.h + Y;

    VertexBuffer[3].X:= X + rr.w/2;

    VertexBuffer[3].Y:= rr.h + Y;

    end

else

    begin

    VertexBuffer[0].X:= X;

    VertexBuffer[0].Y:= Y;

    VertexBuffer[1].X:= rr.w + X;

    VertexBuffer[1].Y:= Y;

    VertexBuffer[2].X:= rr.w + X;

    VertexBuffer[2].Y:= rr.h + Y;

    VertexBuffer[3].X:= X;

    VertexBuffer[3].Y:= rr.h + Y;

    end;

TextureBuffer[0].X:= _l;

TextureBuffer[0].Y:= _t;

TextureBuffer[1].X:= _r;

TextureBuffer[1].Y:= _t;

TextureBuffer[2].X:= _r;

TextureBuffer[2].Y:= _b;

TextureBuffer[3].X:= _l;

TextureBuffer[3].Y:= _b;

glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]);

glTexCoordPointer(2, GL_FLOAT, 0, @TextureBuffer[0]);

glDrawArrays(GL_TRIANGLE_FAN, 0, High(VertexBuffer) - Low(VertexBuffer) + 1);

end;

procedure DrawTexture(X, Y: LongInt; Texture: PTexture); inline;

begin

    DrawTexture(X, Y, Texture, 1.0);

end;

procedure DrawTexture(X, Y: LongInt; Texture: PTexture; Scale: GLfloat);

begin

{$IFDEF GL2}

hglPushMatrix;

hglTranslatef(X, Y, 0);

hglScalef(Scale, Scale, 1);

{$ELSE}

glPushMatrix;

glTranslatef(X, Y, 0);

glScalef(Scale, Scale, 1);

{$ENDIF}

glBindTexture(GL_TEXTURE_2D, Texture^.id);

SetVertexPointer(@Texture^.vb, Length(Texture^.vb));

SetTexCoordPointer(@Texture^.tb, Length(Texture^.vb));

{$IFDEF GL2}

UpdateModelviewProjection;

glDrawArrays(GL_TRIANGLE_FAN, 0, Length(Texture^.vb));

hglPopMatrix;

{$ELSE}

glDrawArrays(GL_TRIANGLE_FAN, 0, Length(Texture^.vb));

glPopMatrix;

{$ENDIF}

end;

{ this contains tweaks in order to avoid land tile borders in blurry land mode }

procedure DrawTexture2(X, Y: LongInt; Texture: PTexture; Scale, Overlap: GLfloat);

var

    TextureBuffer: array [0..3] of TVertex2f;

begin

glPushMatrix();

glTranslatef(X, Y, 0);

glScalef(Scale, Scale, 1);

glBindTexture(GL_TEXTURE_2D, Texture^.id);

TextureBuffer[0].X:= Texture^.tb[0].X + Overlap;

TextureBuffer[0].Y:= Texture^.tb[0].Y + Overlap;

TextureBuffer[1].X:= Texture^.tb[1].X - Overlap;

TextureBuffer[1].Y:= Texture^.tb[1].Y + Overlap;

TextureBuffer[2].X:= Texture^.tb[2].X - Overlap;

TextureBuffer[2].Y:= Texture^.tb[2].Y - Overlap;

TextureBuffer[3].X:= Texture^.tb[3].X + Overlap;

TextureBuffer[3].Y:= Texture^.tb[3].Y - Overlap;

glVertexPointer(2, GL_FLOAT, 0, @Texture^.vb);

glTexCoordPointer(2, GL_FLOAT, 0, @TextureBuffer);

glDrawArrays(GL_TRIANGLE_FAN, 0, Length(Texture^.vb));

glPopMatrix();

end;

procedure DrawTextureF(Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, w, h: LongInt);

begin

    DrawTextureRotatedF(Texture, Scale, 0, 0, X, Y, Frame, Dir, w, h, 0)

end;

procedure DrawTextureRotatedF(Texture: PTexture; Scale, OffsetX, OffsetY: GLfloat; X, Y, Frame, Dir, w, h: LongInt; Angle: real);

var ft, fb, fl, fr: GLfloat;

    hw, nx, ny: LongInt;

    VertexBuffer, TextureBuffer: array [0..3] of TVertex2f;

begin

// do not draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs)

if (abs(X) > W) and ((abs(X + dir * OffsetX) - W / 2) * cScaleFactor > cScreenWidth) then

    exit;

if (abs(Y) > H) and ((abs(Y + OffsetY - (0.5 * cScreenHeight)) - W / 2) * cScaleFactor > cScreenHeight) then

    exit;

{$IFDEF GL2}

hglPushMatrix;

hglTranslatef(X, Y, 0);

{$ELSE}

glPushMatrix;

glTranslatef(X, Y, 0);

{$ENDIF}

if Dir = 0 then Dir:= 1;

{$IFDEF GL2}

hglRotatef(Angle, 0, 0, Dir);

hglTranslatef(Dir*OffsetX, OffsetY, 0);

hglScalef(Scale, Scale, 1);

{$ELSE}

glRotatef(Angle, 0, 0, Dir);

glTranslatef(Dir*OffsetX, OffsetY, 0);

glScalef(Scale, Scale, 1);

{$ENDIF}

// Any reason for this call? And why only in t direction, not s?

//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

hw:= w div (2 div Dir);

nx:= round(Texture^.w / w); // number of horizontal frames

ny:= round(Texture^.h / h); // number of vertical frames

ft:= (Frame mod ny) * Texture^.ry / ny;

fb:= ((Frame mod ny) + 1) * Texture^.ry / ny;

fl:= (Frame div ny) * Texture^.rx / nx;

fr:= ((Frame div ny) + 1) * Texture^.rx / nx;

glBindTexture(GL_TEXTURE_2D, Texture^.id);

VertexBuffer[0].X:= -hw;

VertexBuffer[0].Y:= w / -2;

VertexBuffer[1].X:= hw;

VertexBuffer[1].Y:= w / -2;

VertexBuffer[2].X:= hw;

VertexBuffer[2].Y:= w / 2;

VertexBuffer[3].X:= -hw;

VertexBuffer[3].Y:= w / 2;

TextureBuffer[0].X:= fl;

TextureBuffer[0].Y:= ft;

TextureBuffer[1].X:= fr;

TextureBuffer[1].Y:= ft;

TextureBuffer[2].X:= fr;

TextureBuffer[2].Y:= fb;

TextureBuffer[3].X:= fl;

TextureBuffer[3].Y:= fb;

SetVertexPointer(@VertexBuffer[0], Length(VertexBuffer));

SetTexCoordPointer(@TextureBuffer[0], Length(VertexBuffer));

{$IFDEF GL2}

UpdateModelviewProjection;

{$ENDIF}

glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer));

{$IFDEF GL2}

hglPopMatrix;

{$ELSE}

glPopMatrix;

{$ENDIF}

end;

procedure DrawSpriteRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real);

begin

    DrawTextureRotated(SpritesData[Sprite].Texture,

        SpritesData[Sprite].Width,

        SpritesData[Sprite].Height,

        X, Y, Dir, Angle)

end;

procedure DrawSpriteRotatedF(Sprite: TSprite; X, Y, Frame, Dir: LongInt; Angle: real);

begin

{$IFDEF GL2}

hglPushMatrix;

hglTranslatef(X, Y, 0);

{$ELSE}

glPushMatrix;

glTranslatef(X, Y, 0);

{$ENDIF}

if Dir < 0 then

{$IFDEF GL2}

    hglRotatef(Angle, 0, 0, -1)

{$ELSE}

    glRotatef(Angle, 0, 0, -1)

{$ENDIF}

else

{$IFDEF GL2}

    hglRotatef(Angle, 0, 0,  1);

{$ELSE}

    glRotatef(Angle, 0, 0,  1);

{$ENDIF}

if Dir < 0 then

{$IFDEF GL2}

    hglScalef(-1.0, 1.0, 1.0);

{$ELSE}

    glScalef(-1.0, 1.0, 1.0);

{$ENDIF}

DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame);

{$IFDEF GL2}

hglPopMatrix;

{$ELSE}

glPopMatrix;

{$ENDIF}

end;

procedure DrawTextureRotated(Texture: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real);

var VertexBuffer: array [0..3] of TVertex2f;

begin

// do not draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs)

if (abs(X) > 2 * hw) and ((abs(X) - hw) > cScreenWidth / cScaleFactor) then

    exit;

if (abs(Y) > 2 * hh) and ((abs(Y - 0.5 * cScreenHeight) - hh) > cScreenHeight / cScaleFactor) then

    exit;

{$IFDEF GL2}

hglPushMatrix;

hglTranslatef(X, Y, 0);

{$ELSE}

glPushMatrix;

glTranslatef(X, Y, 0);

{$ENDIF}

if Dir < 0 then

    begin

    hw:= - hw;

{$IFDEF GL2}

    hglRotatef(Angle, 0, 0, -1);

{$ELSE}

    glRotatef(Angle, 0, 0, -1);

{$ENDIF}

    end

else

{$IFDEF GL2}

    hglRotatef(Angle, 0, 0,  1);

{$ELSE}

    glRotatef(Angle, 0, 0, 1);

{$ENDIF}

glBindTexture(GL_TEXTURE_2D, Texture^.id);

VertexBuffer[0].X:= -hw;

VertexBuffer[0].Y:= -hh;

VertexBuffer[1].X:= hw;

VertexBuffer[1].Y:= -hh;

VertexBuffer[2].X:= hw;

VertexBuffer[2].Y:= hh;

VertexBuffer[3].X:= -hw;

VertexBuffer[3].Y:= hh;

SetVertexPointer(@VertexBuffer[0], Length(VertexBuffer));

SetTexCoordPointer(@Texture^.tb, Length(VertexBuffer));

{$IFDEF GL2}

UpdateModelviewProjection;

{$ENDIF}

glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer));

{$IFDEF GL2}

hglPopMatrix;

{$ELSE}

glPopMatrix;

{$ENDIF}

end;

procedure DrawSprite(Sprite: TSprite; X, Y, Frame: LongInt);

var row, col, numFramesFirstCol: LongInt;

begin

    if SpritesData[Sprite].imageHeight = 0 then

        exit;

    numFramesFirstCol:= SpritesData[Sprite].imageHeight div SpritesData[Sprite].Height;

    row:= Frame mod numFramesFirstCol;

    col:= Frame div numFramesFirstCol;

    DrawSprite(Sprite, X, Y, col, row);

end;

procedure DrawSprite(Sprite: TSprite; X, Y, FrameX, FrameY: LongInt);

var r: TSDL_Rect;

begin

    r.x:= FrameX * SpritesData[Sprite].Width;

    r.w:= SpritesData[Sprite].Width;

    r.y:= FrameY * SpritesData[Sprite].Height;

    r.h:= SpritesData[Sprite].Height;

    DrawTextureFromRect(X, Y, @r, SpritesData[Sprite].Texture)

end;

procedure DrawSpriteClipped(Sprite: TSprite; X, Y, TopY, RightX, BottomY, LeftX: LongInt);

var r: TSDL_Rect;

begin

r.x:= 0;

r.y:= 0;

r.w:= SpritesData[Sprite].Width;

r.h:= SpritesData[Sprite].Height;

if (X < LeftX) then

    r.x:= LeftX - X;

if (Y < TopY) then

    r.y:= TopY - Y;

if (Y + SpritesData[Sprite].Height > BottomY) then

    r.h:= BottomY - Y + 1;

if (X + SpritesData[Sprite].Width > RightX) then

    r.w:= RightX - X + 1;

if (r.h < r.y) or (r.w < r.x) then

    exit;

dec(r.h, r.y);

dec(r.w, r.x);

DrawTextureFromRect(X + r.x, Y + r.y, @r, SpritesData[Sprite].Texture)

end;

procedure DrawTextureCentered(X, Top: LongInt; Source: PTexture);

var scale: GLfloat;

begin

    if (Source^.w + 20) > cScreenWidth then

        scale:= cScreenWidth / (Source^.w + 20)

    else

        scale:= 1.0;

    DrawTexture(X - round(Source^.w * scale) div 2, Top, Source, scale)

end;

procedure DrawLine(X0, Y0, X1, Y1, Width: Single; color: LongWord); inline;

begin

DrawLine(X0, Y0, X1, Y1, Width, (color shr 24) and $FF, (color shr 16) and $FF, (color shr 8) and $FF, color and $FF)

end;

procedure DrawLine(X0, Y0, X1, Y1, Width: Single; r, g, b, a: Byte);

var VertexBuffer: array [0..1] of TVertex2f;

begin

    glEnable(GL_LINE_SMOOTH);

{$IFNDEF GL2}

    glDisable(GL_TEXTURE_2D);

    glPushMatrix;

    glTranslatef(WorldDx, WorldDy, 0);

    glLineWidth(Width);

    Tint(r, g, b, a);

    VertexBuffer[0].X:= X0;

    VertexBuffer[0].Y:= Y0;

    VertexBuffer[1].X:= X1;

    VertexBuffer[1].Y:= Y1;

    SetVertexPointer(@VertexBuffer[0], Length(VertexBuffer));

    glDrawArrays(GL_LINES, 0, Length(VertexBuffer));

    untint;

    glPopMatrix;

    glEnable(GL_TEXTURE_2D);

{$ELSE}

    EnableTexture(False);

    hglPushMatrix;