constructor TGraph.Create(WinApi: TWinApi);
begin
  FWinApi := WinApi;

  glEnable(GL_LINE_SMOOTH);
  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
end;

procedure TGraph.Init;
begin
  FWidth := 1;
end;

procedure TGraph.BeginRender;
begin
end;

const
  SHADER_APPLY_MATRIX_V = '' +
    'uniform mat4    uMvp;'#13 +
    'attribute vec3 aPosition;'#13 +
    'varying vec4 vColor;'#13 +
    ''#13 +
    'void main() {'#13 +
    '   vec4 position = vec4(aPosition.xyz, 1.);'#13 +
    '   gl_Position = uMvp * position;'#13 +
    '}';
  SHADER_APPLY_MATRIX_F = '' +
    '#ifdef GL_ES'#13 +
    'precision highp float;'#13 +
    '#endif'#13 +
    ''#13 +
    'void main(void)'#13 +
    '{'#13 +
    '   gl_FragColor = vColor;'#13 +
    '}';


procedure TGraph.Start2D;
var
  Size: TVec2i;
begin
  //{$IFNDEF ANDROID}
  Size := FWinApi.Window.Size;
  glViewPort(0, 0, Size.X, Size.Y);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
	// FIXME for android
  //glOrtho(0, Size.X, Size.Y, 0, -1, 1);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
  //glTranslatef(-0.5, -0.5, 0);
	//{$ENDIF}
end;

procedure TGraph.SetColor(const Color: TVec4f);
begin
  {$IFDEF ANDROID}
	FColor := dcolors.RGBA(Color);
	{$ELSE}
  glColor4fv(@Color);
	{$ENDIF}
end;

procedure TGraph.DrawPixel(const P: TVec2i; const Color: TVec4f);
begin
  {$IFNDEF ANDROID}
  glBegin(GL_POINTS);
    glColor4fv(@Color);
    glVertex2iv(@P);
  glEnd;
	{$ENDIF}
end;

procedure TGraph.DrawLine(const P1, P2: TVec2i; const Color: TVec4f);
begin
  {$IFNDEF ANDROID}
  glBegin(GL_LINES);
    glColor4fv(@Color);
    glVertex2iv(@P1);
    glVertex2iv(@P2);
  glEnd;
	{$ENDIF}
end;

procedure TGraph.DrawRect(const P1, P2: TVec2i; const Color: TVec4f);
begin
  {$IFNDEF ANDROID}
  glBegin(GL_QUADS);
    glColor4fv(@Color);
    glVertex2iv(@P1);
    glVertex2i(P1.X, P2.Y);
    glVertex2iv(@P2);
    glVertex2i(P2.X, P1.Y);
  glEnd;
	{$ENDIF}
end;

procedure TGraph.DrawCircle(const P: TVec2f; R: Single; const Color: TVec4f);
begin
  Self.Color(Color).CircleFilled(P, R);
end;

function TGraph.ResetMatrix: TDraw;
begin
  glLoadIdentity;
end;

function TGraph.PushMatrix: TDraw;
begin
  glPushMatrix;
end;

function TGraph.PopMatrix: TDraw;
begin
  glPopMatrix;
end;

function TGraph.Translate(const V: TVec2f): TDraw;
begin
  glTranslatef(V.X, V.Y, 0);
end;

procedure TGraph.DrawBuffer(X, Y, W, H: Integer; Data: Pointer); 
begin
  Buffer(Data, Vec2i(X, Y), Vec2i(W, H));
end;

procedure TGraph.Pixel(const P: TVec2i; const Color: TVec4f);
begin
  DrawPixel(P, Color);
end;

procedure TGraph.Pixel(X, Y: LongInt; const Color: Cardinal);
begin
  {$IFNDEF ANDROID}
  glBegin(GL_POINTS);
    glColor4ubv(@Color);
    glVertex2i(X, Y);
  glEnd;
	{$ENDIF}
end;

function TGraph.Color(const Value: TVec4f): TDraw;
begin
  {$IFNDEF ANDROID}
  glColor4fv(@Value);
  {$ENDIF}
  Result := Self;
end;

function TGraph.Color(const Value: Cardinal): TDraw; 
begin
  {$IFNDEF ANDROID}
  glColor4ubv(@Value);
  {$ENDIF}
  Result := Self;
end;

function TGraph.RGBA(R, G, B, A: Byte): TDraw;
begin
  glColor4ub(R, G, B, A);
  Result := Self;
end;

function TGraph.Width(W: Float): TDraw;
begin
  FWidth := W;
  glLineWidth(W);
  Result := Self;
end;

function TGraph.From(const Cursor: TVec2i): TDraw;
begin
  FCursor := Cursor;
  Result := Self;
end;

function TGraph.BlendMode(Mode: TBlendMode): TDraw;
begin
  if Mode = BM_NO then
    glDisable(GL_BLEND)
  else begin
    glEnable(GL_BLEND);
    case Mode of
      BM_ALPHA:     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      BM_MUL:       glBlendFunc(GL_ZERO,      GL_SRC_COLOR);
      BM_ADD:       glBlendFunc(GL_ONE,       GL_ONE);
      BM_DIFFUSE:   glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
      BM_ALPHA_ADD: glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    end;
  end;
  Result := Self;
end;

function TGraph.Line(const A, B: TVec2i): TDraw;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_LINES);
    glVertex2iv(@A);
    glVertex2iv(@B);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.Line(const A, B: TVec2f): TDraw;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_LINES);
    glVertex2fv(@A);
    glVertex2fv(@B);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.LineTo(const Cursor: TVec2i): TDraw;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_LINES);
    glVertex2iv(@FCursor);
    glVertex2iv(@Cursor);
  glEnd;
	{$ENDIF}
  FCursor := Cursor;
  Result := Self;
end;

function TGraph.Rect(const R: TRect2i): TDraw;
var
  Filled: TRect2i;
begin
  {$IFNDEF ANDROID}
  if FWidth = 1 then begin
    glBegin(GL_LINE_STRIP);
      glVertex2i(R.P.X - 1,     R.P.Y);
      glVertex2i(R.P.X + R.S.X, R.P.Y);
      glVertex2i(R.P.X + R.S.X, R.P.Y + R.S.Y);
      glVertex2i(R.P.X,         R.P.Y + R.S.Y);
      glVertex2i(R.P.X,         R.P.Y - 1);
    glEnd;
    //glBegin(GL_LINE_LOOP);
    //  glVertex2i(R.P.X,         R.P.Y);
    //  glVertex2i(R.P.X + R.S.X, R.P.Y);
    //  glVertex2i(R.P.X + R.S.X, R.P.Y + R.S.Y);
    //  glVertex2i(R.P.X,         R.P.Y + R.S.Y);
    //glEnd;
	Exit(Self);
  end;
  Filled.P := R.P;
  Filled.S := Vec2i(R.S.X, Round(FWidth));
  RectFilled(Filled);
  Filled.S := Vec2i(Round(FWidth), R.S.Y);
  RectFilled(Filled);
  Filled.P := Add2i(R.P, R.S);
  Filled.S := Vec2i(- R.S.X, - Round(FWidth));
  RectFilled(Filled);
  Filled.S := Vec2i(- Round(FWidth), - R.S.Y);
  RectFilled(Filled);
	{$ENDIF}
  Result := Self;
end;

function TGraph.Circle(const P: TVec2f; R: Single): TDraw;
var
  Count, I: Integer;
  C, S: TFloat;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_LINE_LOOP);
    Count := GetCircleSegments(R);
    for I := 0 to Count - 1 do begin
        C := Cos((I / Count) * 2*pi);
        S := Sin((I / Count) * 2*pi);
        glVertex2f(P.X + R*C, P.Y + R*S);
    end;
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.RectFilled(const R: TRect2i): TDraw;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_QUADS);
    glVertex2iv(@R.P);
    glVertex2i(R.P.X + R.S.X, R.P.Y);
    glVertex2i(R.P.X + R.S.X, R.P.Y + R.S.Y);
    glVertex2i(R.P.X, R.P.Y + R.S.Y);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.CircleFilled(const P: TVec2f; R: Single): TDraw;
var
  Count, I: Integer;
  C, S: TFloat;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_POLYGON);
    Count := GetCircleSegments(R);
    for I := 0 to Count - 1 do begin
        C := Cos((I / Count) * 2*pi);
        S := Sin((I / Count) * 2*pi);
        glVertex2f(P.X + R*C, P.Y + R*S);
    end;
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.Triangle(const X1, Y1, X2, Y2, X3, Y3: Single): TDraw;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_TRIANGLES);
    glVertex2f(X1, Y1);
    glVertex2f(X2, Y2);
    glVertex2f(X3, Y3);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.Triangle(V1, V2, V3: TVec2f): TDraw;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_TRIANGLES);
    glVertex2fv(@V1);
    glVertex2fv(@V2);
    glVertex2fv(@V3);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.Polygon(P: PPolygon2f): TDraw;
var
  I: LongInt;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_LINE_LOOP);
    for I := 0 to High(P^.V) do
      glVertex2fv(@P^.V[I]);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

function TGraph.FilledPolygon(P: PPolygon2f): TDraw;
var
  I: LongInt;
begin
  {$IFNDEF ANDROID}
  glBegin(GL_POLYGON);
    for I := 0 to High(P^.V) do
      glVertex2fv(@P^.V[I]);
  glEnd;
	{$ENDIF}
  Result := Self;
end;

procedure TGraph.Buffer(Data: Pointer; const P, S: TVec2i);
begin
  {$IFNDEF ANDROID}
  glRasterPos2i(P.X, P.Y);
  glPixelZoom(1.0, -1.0);
  glDrawPixels(S.X, S.Y, GL_RGBA, GL_UNSIGNED_BYTE, Data);
	{$ENDIF}
end;

procedure TGraph.EndRender;
begin
  FWinApi.Window.SwapBuffers;
end;

procedure TGraph.ClearScreen(const Color: TVec4f);
begin
  glClearColor(Color.X, Color.Y, Color.Z, Color.W);
  glClear(GL_COLOR_BUFFER_BIT);
end;

procedure TGraph.SetBlendMode(Mode: TBlendMode);
begin
  BlendMode(Mode);
end;
