Mercurial Mercurial > sheepy-clone / 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/uStore.pas
changeset 7188 580cd247511e
parent 7186 013deb83086b
child 7291 ad4b6c2b09e8
equal deleted inserted replaced
7186:013deb83086b 7188:580cd247511e 
    47 
    47 
    48 {$IFDEF GL2}
 
    48 {$IFDEF GL2}
 
    49 procedure UpdateModelviewProjection;
 
    49 procedure UpdateModelviewProjection;
 
    50 {$ENDIF}
 
    50 {$ENDIF}
 
    51 
    51 
       
    52 procedure Tint(r, g, b, a: Byte); inline;
 
       
    53 procedure Tint(c: Longword); inline;
 
       
    54 procedure SetTexCoordPointer(p: Pointer);
 
       
    55 procedure SetVertexPointer(p: Pointer);
 
       
    56 procedure SetColorPointer(p: Pointer);
 
       
    57 procedure BeginWater;
 
       
    58 procedure EndWater;
 
       
    59 
    52 implementation
 
    60 implementation
 
    53 uses uMisc, uConsole, uMobile, uVariables, uUtils, uTextures, uRender, uRenderUtils, uCommands,
 
    61 uses uMisc, uConsole, uMobile, uVariables, uUtils, uTextures, uRender, uRenderUtils, uCommands,
 
    54      uDebug{$IFDEF USE_CONTEXT_RESTORE}, uWorld{$ENDIF}, uMatrix;
 
    62      uDebug{$IFDEF USE_CONTEXT_RESTORE}, uWorld{$ENDIF}, uMatrix;
 
    55 
    63 
    56 //type TGPUVendor = (gvUnknown, gvNVIDIA, gvATI, gvIntel, gvApple);
 
    64 //type TGPUVendor = (gvUnknown, gvNVIDIA, gvATI, gvIntel, gvApple);
 
    61     SDLGLcontext: PSDL_GLContext;
 
    69     SDLGLcontext: PSDL_GLContext;
 
    62 {$ELSE}
 
    70 {$ELSE}
 
    63     SDLPrimSurface: PSDL_Surface;
 
    71     SDLPrimSurface: PSDL_Surface;
 
    64 {$ENDIF}
 
    72 {$ENDIF}
 
    65 {$IFDEF GL2}
 
    73 {$IFDEF GL2}
 
    66     Shader: GLuint;
 
    74     shaderMain: GLuint;
 
    67     uMVPLocation: GLint;
 
    75     shaderWater: GLuint;
 
    68 {$ENDIF}
 
    76 
       
    77     // attributes
 
       
    78 const
 
       
    79     aVertex: GLint   = 0;
 
       
    80     aTexCoord: GLint = 1;
 
       
    81     aColor: GLint    = 2;
 
       
    82 
       
    83 var
 
       
    84     uCurrentMVPLocation: GLint;
 
       
    85 
       
    86     uMainMVPLocation: GLint;
 
       
    87     uMainTintLocation: GLint;
 
       
    88 
       
    89     uWaterMVPLocation: GLint;
 
       
    90 
       
    91 {$ENDIF}
 
       
    92     LastTint: LongWord = 0;
 
       
    93 
    69 
    94 
    70 function WriteInRect(Surface: PSDL_Surface; X, Y: LongInt; Color: LongWord; Font: THWFont; s: ansistring): TSDL_Rect;
 
    95 function WriteInRect(Surface: PSDL_Surface; X, Y: LongInt; Color: LongWord; Font: THWFont; s: ansistring): TSDL_Rect;
 
    71 var w, h: LongInt;
 
    96 var w, h: LongInt;
 
    72     tmpsurf: PSDL_Surface;
 
    97     tmpsurf: PSDL_Surface;
 
    73     clr: TSDL_Color;
 
    98     clr: TSDL_Color;
 
   662         source:= source + line + #10;
 
   687         source:= source + line + #10;
 
   663     end;
 
   688     end;
 
   664     
   689     
   665     CloseFile(f);
 
   690     CloseFile(f);
 
   666 
   691 
   667     writeln('Compiling shader: ' + Pathz[ptShaders] + '/' + shaderFile);
 
   692     WriteLnToConsole('Compiling shader: ' + Pathz[ptShaders] + '/' + shaderFile);
 
   668 
   693 
   669     sourceA:=PChar(source);
 
   694     sourceA:=PChar(source);
 
   670     lengthA:=Length(source);
 
   695     lengthA:=Length(source);
 
   671 
   696 
   672     shader:=glCreateShader(shaderType);
 
   697     shader:=glCreateShader(shaderType);
 
   677 
   702 
   678     if logLength > 1 then
 
   703     if logLength > 1 then
 
   679     begin
 
   704     begin
 
   680         GetMem(log, logLength);
 
   705         GetMem(log, logLength);
 
   681         glGetShaderInfoLog(shader, logLength, nil, log);
 
   706         glGetShaderInfoLog(shader, logLength, nil, log);
 
   682         writeln('========== Compiler log  ==========');
 
   707         WriteLnToConsole('========== Compiler log  ==========');
 
   683         writeln(log);
 
   708         WriteLnToConsole(log);
 
   684         writeln('===================================');
 
   709         WriteLnToConsole('===================================');
 
   685         FreeMem(log, logLength);
 
   710         FreeMem(log, logLength);
 
   686     end;
 
   711     end;
 
   687 
   712 
   688     if compileResult <> GL_TRUE then
 
   713     if compileResult <> GL_TRUE then
 
   689     begin
 
   714     begin
 
   690         writeln('Shader compilation failed, halting');
 
   715         WriteLnToConsole('Shader compilation failed, halting');
 
   691         halt(-1);
 
   716         halt(-1);
 
   692     end;
 
   717     end;
 
   693 
   718 
   694     CompileShader:= shader;
 
   719     CompileShader:= shader;
 
   695 end;
 
   720 end;
 
   705     program_:= glCreateProgram();
 
   730     program_:= glCreateProgram();
 
   706     vs:= CompileShader(shaderName + '.vs', GL_VERTEX_SHADER);
 
   731     vs:= CompileShader(shaderName + '.vs', GL_VERTEX_SHADER);
 
   707     fs:= CompileShader(shaderName + '.fs', GL_FRAGMENT_SHADER);
 
   732     fs:= CompileShader(shaderName + '.fs', GL_FRAGMENT_SHADER);
 
   708     glAttachShader(program_, vs);
 
   733     glAttachShader(program_, vs);
 
   709     glAttachShader(program_, fs);
 
   734     glAttachShader(program_, fs);
 
       
   735 
       
   736     glBindAttribLocation(program_, aVertex, 'vertex');
 
       
   737     glBindAttribLocation(program_, aTexCoord, 'texcoord');
 
       
   738     glBindAttribLocation(program_, aColor, 'color');
 
       
   739 
   710     glLinkProgram(program_);
 
   740     glLinkProgram(program_);
 
   711     glDeleteShader(vs);
 
   741     glDeleteShader(vs);
 
   712     glDeleteShader(fs);
 
   742     glDeleteShader(fs);
 
   713 
   743 
   714     glGetProgramiv(program_, GL_LINK_STATUS, @linkResult);
 
   744     glGetProgramiv(program_, GL_LINK_STATUS, @linkResult);
 
   716 
   746 
   717     if logLength > 1 then
 
   747     if logLength > 1 then
 
   718     begin
 
   748     begin
 
   719         GetMem(log, logLength);
 
   749         GetMem(log, logLength);
 
   720         glGetProgramInfoLog(program_, logLength, nil, log);
 
   750         glGetProgramInfoLog(program_, logLength, nil, log);
 
   721         writeln('========== Compiler log  ==========');
 
   751         WriteLnToConsole('========== Compiler log  ==========');
 
   722         writeln(log);
 
   752         WriteLnToConsole(log);
 
   723         writeln('===================================');
 
   753         WriteLnToConsole('===================================');
 
   724         FreeMem(log, logLength);
 
   754         FreeMem(log, logLength);
 
   725     end;
 
   755     end;
 
   726 
   756 
   727     if linkResult <> GL_TRUE then
 
   757     if linkResult <> GL_TRUE then
 
   728     begin
 
   758     begin
 
   729         writeln('Linking program failed, halting');
 
   759         WriteLnToConsole('Linking program failed, halting');
 
   730         halt(-1);
 
   760         halt(-1);
 
   731     end;
 
   761     end;
 
   732 
   762 
   733     CompileProgram:= program_;
 
   763     CompileProgram:= program_;
 
   734 end;
 
   764 end;
 
       
   765 
   735 {$ENDIF}
 
   766 {$ENDIF}
 
   736 
   767 
   737 procedure SetupOpenGL;
 
   768 procedure SetupOpenGL;
 
   738 //var vendor: shortstring = '';
 
   769 //var vendor: shortstring = '';
 
   739 var buf: array[byte] of char;
 
   770 var buf: array[byte] of char;
 
   791     AddFileLog('  \----- Extensions: ' + shortstring(pchar(glGetString(GL_EXTENSIONS))));
 
   822     AddFileLog('  \----- Extensions: ' + shortstring(pchar(glGetString(GL_EXTENSIONS))));
 
   792     //TODO: don't have the Extensions line trimmed but slipt it into multiple lines
 
   823     //TODO: don't have the Extensions line trimmed but slipt it into multiple lines
 
   793 
   824 
   794 {$IFDEF GL2}
 
   825 {$IFDEF GL2}
 
   795     Load_GL_VERSION_2_0;
 
   826     Load_GL_VERSION_2_0;
 
   796     Shader:= CompileProgram('default');
 
   827 
   797     glUseProgram(Shader);
 
   828     shaderWater:= CompileProgram('water');
 
   798     glUniform1i(glGetUniformLocation(Shader, 'tex'), 0);
 
   829     glUseProgram(shaderWater);
 
   799     uMVPLocation:= glGetUniformLocation(Shader, 'mvp');
 
   830     glUniform1i(glGetUniformLocation(shaderWater, 'tex0'), 0);
 
   800 
   831     uWaterMVPLocation:= glGetUniformLocation(shaderWater, 'mvp');
 
       
   832 
       
   833     shaderMain:= CompileProgram('default');
 
       
   834     glUseProgram(shaderMain);
 
       
   835     glUniform1i(glGetUniformLocation(shaderMain, 'tex0'), 0);
 
       
   836     uMainMVPLocation:= glGetUniformLocation(shaderMain, 'mvp');
 
       
   837     uMainTintLocation:= glGetUniformLocation(shaderMain, 'tint');
 
       
   838 
       
   839     uCurrentMVPLocation:= uMainMVPLocation;
 
       
   840 
       
   841     Tint(255, 255, 255, 255);
 
       
   842     UpdateModelviewProjection;
 
   801 {$ENDIF}
 
   843 {$ENDIF}
 
   802 
   844 
   803 {$IFNDEF S3D_DISABLED}
 
   845 {$IFNDEF S3D_DISABLED}
 
   804     if (cStereoMode = smHorizontal) or (cStereoMode = smVertical) or (cStereoMode = smAFR) then
 
   846     if (cStereoMode = smHorizontal) or (cStereoMode = smVertical) or (cStereoMode = smAFR) then
 
   805     begin
 
   847     begin
 
   856     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
 
   898     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
 
   857     // disable dithering
 
   899     // disable dithering
 
   858     glDisable(GL_DITHER);
 
   900     glDisable(GL_DITHER);
 
   859     // enable common states by default as they save a lot
 
   901     // enable common states by default as they save a lot
 
   860     glEnable(GL_TEXTURE_2D);
 
   902     glEnable(GL_TEXTURE_2D);
 
       
   903 
       
   904 {$IFDEF GL2}
 
       
   905     glEnableVertexAttribArray(aVertex);
 
       
   906     glEnableVertexAttribArray(aTexCoord);
 
       
   907 {$ELSE}
 
   861     glEnableClientState(GL_VERTEX_ARRAY);
 
   908     glEnableClientState(GL_VERTEX_ARRAY);
 
   862     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
   909     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
       
   910 {$ENDIF}
 
       
   911 end;
 
       
   912 
       
   913 
       
   914 procedure Tint(r, g, b, a: Byte); inline;
 
       
   915 var
 
       
   916     nc, tw: Longword;
 
       
   917 const
 
       
   918     scale = 1.0/255.0;
 
       
   919 begin
 
       
   920     nc:= (a shl 24) or (b shl 16) or (g shl 8) or r;
 
       
   921 
       
   922     if nc = lastTint then
 
       
   923         exit;
 
       
   924 
       
   925     if GrayScale then
 
       
   926         begin
 
       
   927         tw:= round(r * RGB_LUMINANCE_RED + g * RGB_LUMINANCE_GREEN + b * RGB_LUMINANCE_BLUE);
 
       
   928         if tw > 255 then
 
       
   929             tw:= 255;
 
       
   930         r:= tw;
 
       
   931         g:= tw;
 
       
   932         b:= tw
 
       
   933         end;
 
       
   934 
       
   935     {$IFDEF GL2}
 
       
   936     glUniform4f(uMainTintLocation, r*scale, g*scale, b*scale, a*scale);
 
       
   937     glColor4ub(r, g, b, a);
 
       
   938     {$ELSE}
 
       
   939     glColor4ub(r, g, b, a);
 
       
   940     {$ENDIF}
 
       
   941     lastTint:= nc;
 
       
   942 end;
 
       
   943 
       
   944 procedure Tint(c: Longword); inline;
 
       
   945 begin
 
       
   946     Tint(((c shr 24) and $FF), ((c shr 16) and $FF), (c shr 8) and $FF, (c and $FF))
 
       
   947 end;
 
       
   948 
       
   949 procedure SetTexCoordPointer(p: Pointer);
 
       
   950 begin
 
       
   951     {$IFDEF GL2}
 
       
   952     glVertexAttribPointer(aTexCoord, 2, GL_FLOAT, GL_FALSE, 0, p);
 
       
   953     {$ELSE}
 
       
   954     glTexCoordPointer(2, GL_FLOAT, 0, p);
 
       
   955     {$ENDIF}
 
       
   956 end;
 
       
   957 
       
   958 procedure SetVertexPointer(p: Pointer);
 
       
   959 begin
 
       
   960     {$IFDEF GL2}
 
       
   961     glVertexAttribPointer(aVertex, 2, GL_FLOAT, GL_FALSE, 0, p);
 
       
   962     {$ELSE}
 
       
   963     glVertexPointer(2, GL_FLOAT, 0, p);
 
       
   964     {$ENDIF}
 
       
   965 end;
 
       
   966 
       
   967 procedure SetColorPointer(p: Pointer);
 
       
   968 begin
 
       
   969     {$IFDEF GL2}
 
       
   970     glVertexAttribPointer(aColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, p);
 
       
   971     {$ELSE}
 
       
   972     glColorPointer(4, GL_UNSIGNED_BYTE, 0, p);
 
       
   973     {$ENDIF}
 
   863 end;
 
   974 end;
 
   864 
   975 
   865 {$IFDEF GL2}
 
   976 {$IFDEF GL2}
 
   866 procedure UpdateModelviewProjection;
 
   977 procedure UpdateModelviewProjection;
 
   867 var
 
   978 var
 
   868     mvp: TMatrix4x4f;
 
   979     mvp: TMatrix4x4f;
 
   869 begin
 
   980 begin
 
   870     MatrixMultiply(mvp, mProjection, mModelview);
 
   981     MatrixMultiply(mvp, mProjection, mModelview);
 
   871     glUniformMatrix4fv(uMVPLocation, 1, GL_FALSE, @mvp[0, 0]);
 
   982     glUniformMatrix4fv(uCurrentMVPLocation, 1, GL_FALSE, @mvp[0, 0]);
 
   872 end;
 
   983 end;
 
   873 {$ENDIF GL2}
 
   984 {$ENDIF GL2}
 
   874 
   985 
   875 procedure UpdateProjection;
 
   986 procedure UpdateProjection;
 
   876 var
 
   987 var
 
   897     //if cScaleFactor <> f then
 
  1008     //if cScaleFactor <> f then
 
   898     //begin
 
  1009     //begin
 
   899         cScaleFactor:=f;
 
  1010         cScaleFactor:=f;
 
   900         UpdateProjection;
 
  1011         UpdateProjection;
 
   901     //end;
 
  1012     //end;
 
       
  1013 end;
 
       
  1014 
       
  1015 procedure BeginWater;
 
       
  1016 begin
 
       
  1017     {$IFDEF GL2}
 
       
  1018     glUseProgram(shaderWater);
 
       
  1019     uCurrentMVPLocation:=uWaterMVPLocation;
 
       
  1020     UpdateModelviewProjection;
 
       
  1021     glDisableVertexAttribArray(aTexCoord);
 
       
  1022     glEnableVertexAttribArray(aColor);
 
       
  1023     {$ELSE}
 
       
  1024     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 
       
  1025     glEnableClientState(GL_COLOR_ARRAY);
 
       
  1026     {$ENDIF}
 
       
  1027 end;
 
       
  1028 
       
  1029 procedure EndWater;
 
       
  1030 begin
 
       
  1031     {$IFDEF GL2}
 
       
  1032     glUseProgram(shaderMain);
 
       
  1033     uCurrentMVPLocation:=uMainMVPLocation;
 
       
  1034     UpdateModelviewProjection;
 
       
  1035     glDisableVertexAttribArray(aColor);
 
       
  1036     glEnableVertexAttribArray(aTexCoord);
 
       
  1037     {$ELSE}
 
       
  1038     glDisableClientState(GL_COLOR_ARRAY);
 
       
  1039     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
       
  1040     {$ENDIF}
 
   902 end;
 
  1041 end;
 
   903 
  1042 
   904 ////////////////////////////////////////////////////////////////////////////////
 
  1043 ////////////////////////////////////////////////////////////////////////////////
 
   905 procedure AddProgress;
 
  1044 procedure AddProgress;
 
   906 var r: TSDL_Rect;
 
  1045 var r: TSDL_Rect;
 
  1282 end;
 
  1421 end;
 
  1283 
  1422 
  1284 procedure freeModule;
 
  1423 procedure freeModule;
 
  1285 begin
 
  1424 begin
 
  1286 {$IFDEF GL2}
 
  1425 {$IFDEF GL2}
 
  1287     glDeleteProgram(Shader);
 
  1426     glDeleteProgram(shaderMain);
 
       
  1427     glDeleteProgram(shaderWater);
 
  1288 {$ENDIF}
 
  1428 {$ENDIF}
 
  1289     StoreRelease(false);
 
  1429     StoreRelease(false);
 
  1290     TTF_Quit();
 
  1430     TTF_Quit();
 
  1291 {$IFDEF SDL13}
 
  1431 {$IFDEF SDL13}
 
  1292     SDL_GL_DeleteContext(SDLGLcontext);
 
  1432     SDL_GL_DeleteContext(SDLGLcontext);
sheepy-clone