Mercurial Mercurial > hedgewars / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hedgewars/uRender.pas
branchqmlfrontend
changeset 12881 07a267d72fce
parent 12878 b3426030a426
child 13772 5c0ea888c926
equal deleted inserted replaced
12880:590c7f324292 12881:07a267d72fce 
   121 {$ENDIF}
 
   121 {$ENDIF}
 
   122 
   122 
   123 var VertexBuffer : array [0 ..59] of TVertex2f;
 
   123 var VertexBuffer : array [0 ..59] of TVertex2f;
 
   124     TextureBuffer: array [0 .. 7] of TVertex2f;
 
   124     TextureBuffer: array [0 .. 7] of TVertex2f;
 
   125     LastTint: LongWord = 0;
 
   125     LastTint: LongWord = 0;
 
       
   126 {$IFNDEF GL2}
 
   126     LastColorPointer , LastTexCoordPointer , LastVertexPointer : Pointer;
 
   127     LastColorPointer , LastTexCoordPointer , LastVertexPointer : Pointer;
 
   127 {$IFDEF GL2}
 
       
   128     LastColorPointerN, LastTexCoordPointerN, LastVertexPointerN: Integer;
 
       
   129 {$ENDIF}
 
   128 {$ENDIF}
 
   130 
   129 
   131 {$IFDEF USE_S3D_RENDERING}
 
   130 {$IFDEF USE_S3D_RENDERING}
 
   132     // texture/vertex buffers for left/right/default eye modes
 
   131     // texture/vertex buffers for left/right/default eye modes
 
   133     texLRDtb, texLvb, texRvb: array [0..3] of TVertex2f;
 
   132     texLRDtb, texLvb, texRvb: array [0..3] of TVertex2f;
 
   282 begin
 
   281 begin
 
   283     f:= pfsOpenRead(cPathz[ptShaders] + '/' + shaderFile);
 
   282     f:= pfsOpenRead(cPathz[ptShaders] + '/' + shaderFile);
 
   284     checkFails(f <> nil, 'Unable to load ' + shaderFile, true);
 
   283     checkFails(f <> nil, 'Unable to load ' + shaderFile, true);
 
   285 
   284 
   286     source:='';
 
   285     source:='';
 
       
   286     line:='';
 
   287     while not pfsEof(f) do
 
   287     while not pfsEof(f) do
 
   288     begin
 
   288     begin
 
   289         pfsReadLnA(f, line);
 
   289         pfsReadLnA(f, line);
 
   290         source:= source + line + #10;
 
   290         source:= source + line + #10;
 
   291     end;
 
   291     end;
 
   294 
   294 
   295     WriteLnToConsole('Compiling shader: ' + cPathz[ptShaders] + '/' + shaderFile);
 
   295     WriteLnToConsole('Compiling shader: ' + cPathz[ptShaders] + '/' + shaderFile);
 
   296 
   296 
   297     sourceA:=PChar(source);
 
   297     sourceA:=PChar(source);
 
   298     lengthA:=Length(source);
 
   298     lengthA:=Length(source);
 
       
   299     WriteLnToConsole('Length: ' + inttostr(Length(source)));
 
   299 
   300 
   300     shader:=glCreateShader(shaderType);
 
   301     shader:=glCreateShader(shaderType);
 
   301     glShaderSource(shader, 1, @sourceA, @lengthA);
 
   302     glShaderSource(shader, 1, @sourceA, @lengthA);
 
   302     glCompileShader(shader);
 
   303     glCompileShader(shader);
 
   303     glGetShaderiv(shader, GL_COMPILE_STATUS, @compileResult);
 
   304     glGetShaderiv(shader, GL_COMPILE_STATUS, @compileResult);
 
   738         glDisableVertexAttribArray(aTexCoord);
 
   739         glDisableVertexAttribArray(aTexCoord);
 
   739         glEnableVertexAttribArray(aColor);
 
   740         glEnableVertexAttribArray(aColor);
 
   740         {$ELSE}
 
   741         {$ELSE}
 
   741         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 
   742         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 
   742         glEnableClientState(GL_COLOR_ARRAY);
 
   743         glEnableClientState(GL_COLOR_ARRAY);
 
       
   744         LastTexCoordPointer:= nil;
 
   743         {$ENDIF}
 
   745         {$ENDIF}
 
   744         LastTexCoordPointer:= nil;
 
       
   745         end
 
   746         end
 
   746     else
 
   747     else
 
   747         begin
 
   748         begin
 
   748         {$IFDEF GL2}
 
   749         {$IFDEF GL2}
 
   749         glDisableVertexAttribArray(aColor);
 
   750         glDisableVertexAttribArray(aColor);
 
   750         glEnableVertexAttribArray(aTexCoord);
 
   751         glEnableVertexAttribArray(aTexCoord);
 
   751         {$ELSE}
 
   752         {$ELSE}
 
   752         glDisableClientState(GL_COLOR_ARRAY);
 
   753         glDisableClientState(GL_COLOR_ARRAY);
 
   753         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
   754         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
       
   755         LastColorPointer:= nil;
 
   754         {$ENDIF}
 
   756         {$ENDIF}
 
   755         LastColorPointer:= nil;
 
       
   756         end;
 
   757         end;
 
   757     EnableTexture(not b);
 
   758     EnableTexture(not b);
 
   758 end;
 
   759 end;
 
   759 
   760 
   760 procedure UpdateModelviewProjection(); inline;
 
   761 procedure UpdateModelviewProjection(); inline;
 
   773 end;
 
   774 end;
 
   774 
   775 
   775 procedure SetTexCoordPointer(p: Pointer; n: Integer); inline;
 
   776 procedure SetTexCoordPointer(p: Pointer; n: Integer); inline;
 
   776 begin
 
   777 begin
 
   777 {$IFDEF GL2}
 
   778 {$IFDEF GL2}
 
   778     if (p = LastTexCoordPointer) and (n = LastTexCoordPointerN) then
 
       
   779         exit;
 
       
   780     glBindBuffer(GL_ARRAY_BUFFER, tBuffer);
 
   779     glBindBuffer(GL_ARRAY_BUFFER, tBuffer);
 
   781     glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * n * 2, p, GL_STATIC_DRAW);
 
   780     glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * n * 2, p, GL_STATIC_DRAW);
 
   782     glEnableVertexAttribArray(aTexCoord);
 
   781     glEnableVertexAttribArray(aTexCoord);
 
   783     glVertexAttribPointer(aTexCoord, 2, GL_FLOAT, GL_FALSE, 0, pointer(0));
 
   782     glVertexAttribPointer(aTexCoord, 2, GL_FLOAT, GL_FALSE, 0, pointer(0));
 
   784     LastTexCoordPointerN:= n;
 
       
   785 {$ELSE}
 
   783 {$ELSE}
 
   786     if p = LastTexCoordPointer then
 
   784     if p = LastTexCoordPointer then
 
   787         exit;
 
   785         exit;
 
   788     n:= n;
 
   786     n:= n;
 
   789     glTexCoordPointer(2, GL_FLOAT, 0, p);
 
   787     glTexCoordPointer(2, GL_FLOAT, 0, p);
 
   790 {$ENDIF}
 
       
   791     LastTexCoordPointer:= p;
 
   788     LastTexCoordPointer:= p;
 
       
   789 {$ENDIF}
 
   792 end;
 
   790 end;
 
   793 
   791 
   794 procedure SetVertexPointer(p: Pointer; n: Integer); inline;
 
   792 procedure SetVertexPointer(p: Pointer; n: Integer); inline;
 
   795 begin
 
   793 begin
 
   796 {$IFDEF GL2}
 
   794 {$IFDEF GL2}
 
   797     if (p = LastVertexPointer) and (n = LastVertexPointerN) then
 
       
   798         exit;
 
       
   799     glBindBuffer(GL_ARRAY_BUFFER, vBuffer);
 
   795     glBindBuffer(GL_ARRAY_BUFFER, vBuffer);
 
   800     glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * n * 2, p, GL_STATIC_DRAW);
 
   796     glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * n * 2, p, GL_STATIC_DRAW);
 
   801     glEnableVertexAttribArray(aVertex);
 
   797     glEnableVertexAttribArray(aVertex);
 
   802     glVertexAttribPointer(aVertex, 2, GL_FLOAT, GL_FALSE, 0, pointer(0));
 
   798     glVertexAttribPointer(aVertex, 2, GL_FLOAT, GL_FALSE, 0, pointer(0));
 
   803     LastVertexPointerN:= n;
 
       
   804 {$ELSE}
 
   799 {$ELSE}
 
   805     if p = LastVertexPointer then
 
   800     if p = LastVertexPointer then
 
   806         exit;
 
   801         exit;
 
   807     n:= n;
 
   802     n:= n;
 
   808     glVertexPointer(2, GL_FLOAT, 0, p);
 
   803     glVertexPointer(2, GL_FLOAT, 0, p);
 
   809 {$ENDIF}
 
       
   810     LastVertexPointer:= p;
 
   804     LastVertexPointer:= p;
 
       
   805 {$ENDIF}
 
   811 end;
 
   806 end;
 
   812 
   807 
   813 procedure SetColorPointer(p: Pointer; n: Integer); inline;
 
   808 procedure SetColorPointer(p: Pointer; n: Integer); inline;
 
   814 begin
 
   809 begin
 
   815 {$IFDEF GL2}
 
   810 {$IFDEF GL2}
 
   816     if (p = LastColorPointer) and (n = LastColorPointerN) then
 
       
   817         exit;
 
       
   818     glBindBuffer(GL_ARRAY_BUFFER, cBuffer);
 
   811     glBindBuffer(GL_ARRAY_BUFFER, cBuffer);
 
   819     glBufferData(GL_ARRAY_BUFFER, n * 4, p, GL_STATIC_DRAW);
 
   812     glBufferData(GL_ARRAY_BUFFER, n * 4, p, GL_STATIC_DRAW);
 
   820     glEnableVertexAttribArray(aColor);
 
   813     glEnableVertexAttribArray(aColor);
 
   821     glVertexAttribPointer(aColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, pointer(0));
 
   814     glVertexAttribPointer(aColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, pointer(0));
 
   822     LastColorPointerN:= n;
 
       
   823 {$ELSE}
 
   815 {$ELSE}
 
   824     if p = LastColorPointer then
 
   816     if p = LastColorPointer then
 
   825         exit;
 
   817         exit;
 
   826     n:= n;
 
   818     n:= n;
 
   827     glColorPointer(4, GL_UNSIGNED_BYTE, 0, p);
 
   819     glColorPointer(4, GL_UNSIGNED_BYTE, 0, p);
 
   828 {$ENDIF}
 
       
   829     LastColorPointer:= p;
 
   820     LastColorPointer:= p;
 
       
   821 {$ENDIF}
 
   830 end;
 
   822 end;
 
   831 
   823 
   832 procedure EnableTexture(enable:Boolean);
 
   824 procedure EnableTexture(enable:Boolean);
 
   833 begin
 
   825 begin
 
   834     {$IFDEF GL2}
 
   826     {$IFDEF GL2}
 
   881         begin
 
   873         begin
 
   882         openglPopMatrix;
 
   874         openglPopMatrix;
 
   883         end
 
   875         end
 
   884     else
 
   876     else
 
   885         begin
 
   877         begin
 
   886         openglPushMatrix; // save default scaling in matrix
 
   878         if cScaleFactor = cDefaultZoomLevel then
 
       
   879             begin
 
       
   880             openglPushMatrix; // save default scaling in matrix;
 
       
   881             end;
 
   887         openglLoadIdentity();
 
   882         openglLoadIdentity();
 
   888         openglScalef(f / cScreenWidth, -f / cScreenHeight, 1.0);
 
   883         openglScalef(f / cScreenWidth, -f / cScreenHeight, 1.0);
 
   889         openglTranslatef(0, -cScreenHeight div 2, 0);
 
   884         openglTranslatef(0, -cScreenHeight div 2, 0);
 
   890         end;
 
   885         end;
 
   891 
   886 
   977     DrawTexture(X, Y, Texture, 1.0);
 
   972     DrawTexture(X, Y, Texture, 1.0);
 
   978 end;
 
   973 end;
 
   979 
   974 
   980 procedure DrawTexture(X, Y: LongInt; Texture: PTexture; Scale: GLfloat);
 
   975 procedure DrawTexture(X, Y: LongInt; Texture: PTexture; Scale: GLfloat);
 
   981 begin
 
   976 begin
 
   982 
       
   983 openglPushMatrix;
 
   977 openglPushMatrix;
 
   984 openglTranslatef(X, Y, 0);
 
   978 openglTranslatef(X, Y, 0);
 
   985 
   979 
   986 if Scale <> 1.0 then
 
   980 if Scale <> 1.0 then
 
   987     openglScalef(Scale, Scale, 1);
 
   981     openglScalef(Scale, Scale, 1);
 
   994 UpdateModelviewProjection;
 
   988 UpdateModelviewProjection;
 
   995 
   989 
   996 glDrawArrays(GL_TRIANGLE_FAN, 0, Length(Texture^.vb));
 
   990 glDrawArrays(GL_TRIANGLE_FAN, 0, Length(Texture^.vb));
 
   997 openglPopMatrix;
 
   991 openglPopMatrix;
 
   998 
   992 
       
   993 UpdateModelviewProjection;
 
   999 end;
 
   994 end;
 
  1000 
   995 
  1001 { this contains tweaks in order to avoid land tile borders in blurry land mode }
 
   996 { this contains tweaks in order to avoid land tile borders in blurry land mode }
 
  1002 procedure DrawTexture2(X, Y: LongInt; Texture: PTexture; Scale, Overlap: GLfloat);
 
   997 procedure DrawTexture2(X, Y: LongInt; Texture: PTexture; Scale, Overlap: GLfloat);
 
  1003 var
 
   998 var
 
  1023 
  1018 
  1024 UpdateModelviewProjection;
 
  1019 UpdateModelviewProjection;
 
  1025 
  1020 
  1026 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1021 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1027 openglPopMatrix;
 
  1022 openglPopMatrix;
 
       
  1023 
       
  1024 UpdateModelviewProjection;
 
  1028 end;
 
  1025 end;
 
  1029 
  1026 
  1030 procedure DrawTextureF(Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, w, h: LongInt);
 
  1027 procedure DrawTextureF(Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, w, h: LongInt);
 
  1031 begin
 
  1028 begin
 
  1032     DrawTextureRotatedF(Texture, Scale, 0, 0, X, Y, Frame, Dir, w, h, 0)
 
  1029     DrawTextureRotatedF(Texture, Scale, 0, 0, X, Y, Frame, Dir, w, h, 0)
 
  1130 
  1127 
  1131 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1128 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1132 
  1129 
  1133 openglPopMatrix;
 
  1130 openglPopMatrix;
 
  1134 
  1131 
       
  1132 UpdateModelviewProjection;
 
       
  1133 
  1135 end;
 
  1134 end;
 
  1136 
  1135 
  1137 procedure DrawSpriteRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real);
 
  1136 procedure DrawSpriteRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real);
 
  1138 begin
 
  1137 begin
 
  1139     DrawTextureRotated(SpritesData[Sprite].Texture,
 
  1138     DrawTextureRotated(SpritesData[Sprite].Texture,
 
  1169 
  1168 
  1170 // apply angle after (conditional) mirroring
 
  1169 // apply angle after (conditional) mirroring
 
  1171 if Angle <> 0  then
 
  1170 if Angle <> 0  then
 
  1172     openglRotatef(Angle, 0, 0, 1);
 
  1171     openglRotatef(Angle, 0, 0, 1);
 
  1173 
  1172 
       
  1173 UpdateModelviewProjection;
 
       
  1174 
  1174 DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame);
 
  1175 DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame);
 
  1175 
  1176 
  1176 openglPopMatrix;
 
  1177 openglPopMatrix;
 
       
  1178 
       
  1179 UpdateModelviewProjection;
 
  1177 
  1180 
  1178 end;
 
  1181 end;
 
  1179 
  1182 
  1180 procedure DrawSpritePivotedF(Sprite: TSprite; X, Y, Frame, Dir, PivotX, PivotY: LongInt; Angle: real);
 
  1183 procedure DrawSpritePivotedF(Sprite: TSprite; X, Y, Frame, Dir, PivotX, PivotY: LongInt; Angle: real);
 
  1181 begin
 
  1184 begin
 
  1210     end;
 
  1213     end;
 
  1211 
  1214 
  1212 DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame);
 
  1215 DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame);
 
  1213 
  1216 
  1214 openglPopMatrix;
 
  1217 openglPopMatrix;
 
       
  1218 
       
  1219 UpdateModelviewProjection;
 
  1215 end;
 
  1220 end;
 
  1216 
  1221 
  1217 procedure DrawTextureRotated(Texture: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real);
 
  1222 procedure DrawTextureRotated(Texture: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real);
 
  1218 begin
 
  1223 begin
 
  1219 
  1224 
  1257 
  1262 
  1258 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1263 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1259 
  1264 
  1260 openglPopMatrix;
 
  1265 openglPopMatrix;
 
  1261 
  1266 
       
  1267 UpdateModelviewProjection;
 
  1262 end;
 
  1268 end;
 
  1263 
  1269 
  1264 procedure DrawSprite(Sprite: TSprite; X, Y, Frame: LongInt);
 
  1270 procedure DrawSprite(Sprite: TSprite; X, Y, Frame: LongInt);
 
  1265 var row, col, numFramesFirstCol: LongInt;
 
  1271 var row, col, numFramesFirstCol: LongInt;
 
  1266 begin
 
  1272 begin
 
  1340     UpdateModelviewProjection;
 
  1346     UpdateModelviewProjection;
 
  1341 
  1347 
  1342     DrawLineOnScreen(X0, Y0, X1, Y1, Width, r, g, b, a);
 
  1348     DrawLineOnScreen(X0, Y0, X1, Y1, Width, r, g, b, a);
 
  1343 
  1349 
  1344     openglPopMatrix();
 
  1350     openglPopMatrix();
 
       
  1351 
       
  1352     UpdateModelviewProjection;
 
  1345 end;
 
  1353 end;
 
  1346 
  1354 
  1347 procedure DrawLineOnScreen(X0, Y0, X1, Y1, Width: Single; r, g, b, a: Byte);
 
  1355 procedure DrawLineOnScreen(X0, Y0, X1, Y1, Width: Single; r, g, b, a: Byte);
 
  1348 begin
 
  1356 begin
 
  1349     glEnable(GL_LINE_SMOOTH);
 
  1357     glEnable(GL_LINE_SMOOTH);
 
  1374     exit;
 
  1382     exit;
 
  1375 if (abs(rect.y) > rect.h) and ((abs(rect.y + rect.h / 2 - (cScreenHeight / 2)) - rect.h / 2) * 2 > ViewHeight) then
 
  1383 if (abs(rect.y) > rect.h) and ((abs(rect.y + rect.h / 2 - (cScreenHeight / 2)) - rect.h / 2) * 2 > ViewHeight) then
 
  1376     exit;
 
  1384     exit;
 
  1377 
  1385 
  1378 EnableTexture(False);
 
  1386 EnableTexture(False);
 
  1379 
       
  1380 Tint(r, g, b, a);
 
  1387 Tint(r, g, b, a);
 
  1381 
  1388 
  1382 with rect do
 
  1389 with rect do
 
  1383 begin
 
  1390 begin
 
  1384     VertexBuffer[0].X:= x;
 
  1391     VertexBuffer[0].X:= x;
 
  1508     UpdateModelviewProjection;
 
  1515     UpdateModelviewProjection;
 
  1509 
  1516 
  1510     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1517     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  1511 
  1518 
  1512     openglPopMatrix;
 
  1519     openglPopMatrix;
 
       
  1520 
       
  1521     UpdateModelviewProjection;
 
  1513 end;
 
  1522 end;
 
  1514 
  1523 
  1515 procedure DrawScreenWidget(widget: POnScreenWidget);
 
  1524 procedure DrawScreenWidget(widget: POnScreenWidget);
 
  1516 {$IFDEF USE_TOUCH_INTERFACE}
 
  1525 {$IFDEF USE_TOUCH_INTERFACE}
 
  1517 var alpha: byte = $FF;
 
  1526 var alpha: byte = $FF;
 
  1902 glBindTexture(GL_TEXTURE_2D, SpritesData[sprite].Texture^.id);
 
  1911 glBindTexture(GL_TEXTURE_2D, SpritesData[sprite].Texture^.id);
 
  1903 
  1912 
  1904 SetVertexPointer(@VertexBuffer[0], 8);
 
  1913 SetVertexPointer(@VertexBuffer[0], 8);
 
  1905 SetTexCoordPointer(@TextureBuffer[0], 8);
 
  1914 SetTexCoordPointer(@TextureBuffer[0], 8);
 
  1906 
  1915 
  1907 UpdateModelviewProjection;
 
       
  1908 
       
  1909 glDrawArrays(GL_TRIANGLE_STRIP, first, count);
 
  1916 glDrawArrays(GL_TRIANGLE_STRIP, first, count);
 
  1910 
  1917 
  1911 untint;
 
  1918 untint;
 
  1912 
  1919 
  1913 end;
 
  1920 end;
 
  2006 
  2013 
  2007 
  2014 
  2008 procedure initModule;
 
  2015 procedure initModule;
 
  2009 begin
 
  2016 begin
 
  2010     LastTint:= cWhiteColor + 1;
 
  2017     LastTint:= cWhiteColor + 1;
 
       
  2018 {$IFNDEF GL2}
 
  2011     LastColorPointer    := nil;
 
  2019     LastColorPointer    := nil;
 
  2012     LastTexCoordPointer := nil;
 
  2020     LastTexCoordPointer := nil;
 
  2013     LastVertexPointer   := nil;
 
  2021     LastVertexPointer   := nil;
 
  2014 {$IFDEF GL2}
 
       
  2015     LastColorPointerN   :=   0;
 
       
  2016     LastTexCoordPointerN:=   0;
 
       
  2017     LastVertexPointerN  :=   0;
 
       
  2018 {$ENDIF}
 
  2022 {$ENDIF}
 
  2019 end;
 
  2023 end;
 
  2020 
  2024 
  2021 procedure freeModule;
 
  2025 procedure freeModule;
 
  2022 begin
 
  2026 begin
hedgewars