DGL
https://delphigl.com/forum/

Invalid Enumerant 2829
https://delphigl.com/forum/viewtopic.php?f=19&t=3167		 Seite 1 von 1
Autor:  Stucuk [ Di Aug 17, 2004 17:27 ]
Betreff des Beitrags:  Invalid Enumerant 2829
The error pops up in

Code:
  1.  
  2.  
  3. procedure TQuake3BSP.RenderSurfaceShader(faceIndex, shaderId: integer);
  4. var shader : TShader;
  5.     i, texId, planeIdx : integer;
  6.     Face : PBSPFace;
  7. begin
  8.   try
  9.   Face := @Faces[faceIndex];
  10.   shader := ShaderManager[shaderId];
  11.   // culling
  12.   if shader.Cull = GL_NONE then
  13.     glDisable(GL_CULL_FACE)
  14.   else begin
  15.     glEnable(GL_CULL_FACE);
  16.     glCullFace(shader.cull);
  17.   end;
  18.  
  19.   if multiTexture then begin
  20.     glActiveTexture(GL_TEXTURE1);
  21.     glDisable(GL_TEXTURE_2D);
  22.  
  23.     glActiveTexture(GL_TEXTURE0);
  24.   end;
  25.   glDisable(GL_TEXTURE_2D);
  26.  
  27.   glEnable(GL_COLOR);
  28.   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  29.   glColor3ub(255,255,255);
  30.  
  31.   // prepare data for global deform operations - but texture coordinates must restored for each layer !!!!!
  32.  
  33.    for i := 0 to face.numMeshVerts-1 do
  34.     inputBuffer[i] := Vertices[Face.startVertIndex+MeshVertices[face.meshVertIndex+i]];
  35.  
  36.   SetVertexCoords(shaderId, face.numMeshVerts);
  37.   glVertexPointer(3, GL_FLOAT, sizeof(TBSPVertex), @inputBuffer[0].Position);
  38.  
  39.   if LockArrays then glLockArraysEXT(0, Face.numMeshVerts);
  40.  
  41.   if shader.numOfLayers > 0 then begin
  42.     for i := 0 to shader.numOfLayers-1 do begin
  43.       if (ShaderManager[shaderId].Layers[i].numOfrgbGen > 0) or (Face.FaceType = FACE_MESH) then begin
  44.         SetVertexColors(shaderId, i, face.numMeshVerts);
  45.         glColorPointer(4, GL_UNSIGNED_BYTE, 0, @colorBuffer[0]);
  46.         glEnableClientState(GL_COLOR_ARRAY);
  47.       end
  48.       else
  49.         glDisableClientState(GL_COLOR_ARRAY);
  50.     //  if not pause then
  51.       SetTextureCoordinates(shaderId, i, face.numMeshVerts);
  52.  
  53.       if multiTexture then
  54.         glClientActiveTexture(GL_TEXTURE0);
  55.       glTexCoordPointer(2, GL_FLOAT, 0,  @texCoordBuffer[0]);
  56.  
  57.       if (shader.Layers[i].UseLightmap) then begin
  58.         if not multiTexture then begin
  59.           texId := 0;
  60.         end
  61.         else begin
  62.           glClientActiveTexture(GL_TEXTURE0);
  63.           glTexCoordPointer(2, GL_FLOAT, sizeof(TBSPVERTEX), @inputBuffer[0].LightmapCoord);
  64.           if (face.lightmapId > -1) and (Lightmaps[face.lightmapID] > -1) then
  65.             texId := Lightmaps[face.lightmapID]
  66.           else
  67.             texId := 0;
  68.         end;
  69.       end
  70.       else begin
  71.         texId := shader.Layers[i].TextureId[shader.Layers[i].curTexture];
  72.       end;
  73.       glEnable(GL_TEXTURE_2D);
  74.       glBindTexture(GL_TEXTURE_2D, texId);
  75.  
  76.       shaderManager.SetState(shaderId, i );
  77.       glDrawArrays(GL_TRIANGLES, 0, Face.numMeshVerts);
  78.       //SetDefaults;
  79.     end;
  80.   end;
  81.   if LockArrays then glUnlockArraysEXT();
  82.   SetDefaults;
  83.   if (numOfEffects > 0) and (Faces[faceIndex].effect > -1) and (not simpleRender) and (GetCvarB('Show_Fog')) then begin
  84.     //RenderFogFace(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside].plane );
  85.     //RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, BrushSides[Effects[Faces[faceIndex].effect].visibleSide].plane);
  86.     if (Effects[Faces[faceIndex].effect].visibleside >= 0) then
  87.       planeIdx := BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside + Effects[Faces[faceIndex].effect].visibleside].plane
  88.     else
  89.       planeIdx :=  -1;
  90.     RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, planeIdx);
  91.     SetDefaults;
  92.   end;
  93.   except
  94.     lastError := glGetError();
  95.     lastErrorString := gluErrorString(lastError);
  96.     {$IfDef HELIOS_CONSOLE}
  97.     //if ShowDetails then
  98.     Cons.AddIfDifferent('RenderSurfaceShader ' + lastErrorString + ' ' + IntToStr(faceIndex));
  99.     {$EndIf}
  100. //    if DumpErrors then AddError('RenderSurfaceShader ' + lastErrorString);
  101.   end;
  102.  
  103. end;
  104.  
  105.  


For Q3BSP Code check Here (i havn't touched the rendersurfaceshader procedure).

I use to have this problem with the skyboxes (Sphere ones) on some Quake 3 maps, but i "fixed" that by drawing it "manualy" insted of using the array method.

Screenshots below.

Note: the error only appears in parts of the map, other parts cause no errors.

Dateianhänge:
Dateikommentar: Console Displaying the error
_0037.jpg [139.51 KiB]
93-mal heruntergeladen
Dateikommentar: The Access Violation
accessviolation.JPG
accessviolation.JPG [ 15.29 KiB | 6219-mal betrachtet ]
Autor:  BTierens [ Di Aug 17, 2004 20:12 ]
Betreff des Beitrags: 
It would be verry useful if you would locate the error by adding showMessageDlg commands to your code. When you get the exception dialog, go back to the last message dialog and locate the error.
Autor:  Stucuk [ Di Aug 17, 2004 21:31 ]
Betreff des Beitrags: 
It will b the glDrawArrays , which doesn't help. Something gets set to an invalid thing. Last time i looked for info on the error i found nothing useful.
Autor:  Sascha Willems [ Di Aug 17, 2004 21:41 ]
Betreff des Beitrags: 
I don't think your problem is the glDrawArrays. It's more likeley in glVertexPointer, as your stride parameter seems to be wrong. Many people make the mistake and set this to the size of their vertex structure, which is wrong. The stride parameter contains the offset between two vertices. So if you have something like this :
Code:
  1. type
  2.  TVertex = record
  3.    x,y,z : Single;
  4.   end;
  5. ...
  6. var
  7.   VA : array of TVertex;


Then the stride parameter must be set to zero, cause all vertices are tightly packed in that array (i.e. there is nothing between two vertices). An error in glVertexPointer also would explain your Access Violation.
Autor:  LarsMiddendorf [ Di Aug 17, 2004 21:58 ]
Betreff des Beitrags: 
I'm using a 32 Byte packed Vertex record and I've set stride to 32. It seems that stride=0 is a special case.
Autor:  Stucuk [ Di Aug 17, 2004 23:09 ]
Betreff des Beitrags: 
I never actualy made that procedure so i don't know how the glVertexPointer works.

Code:
  1.  
  2. inputBuffer : array[0..16383] of TBSPVertex;
  3.  


Code:
  1.  
  2. type TBSPVertex = record
  3.   Position      : TVector3f;             // (x, y, z) position.
  4.   TextureCoord  : TVector2f;             // (u, v) texture coordinate
  5.   LightmapCoord : TVector2f;             // (u, v) lightmap coordinate
  6.   Normal        : TVector3f;             // (x, y, z) normal vector
  7.   Color         : array[0..3] of Byte    // RGBA color for the vertex
  8. end;
  9.  


EDIT:

setting the stride to 0 creates a screwed up world.

EDIT2:

I turned shaders off and it doens't create the error, so it seem that something happening in the shader routines arn't liked by the array method (going by the skybox which was screwing up with the array method in some maps, actualy works perfectly drawing it "manualy"....)

Dateianhänge:
Dateikommentar: Lovley 0 stride world (screwed)
_0038.jpg [144.16 KiB]
51-mal heruntergeladen
Dateikommentar: Normal World
_0039.jpg [187.25 KiB]
51-mal heruntergeladen
Autor:  Flash [ Mi Aug 18, 2004 00:33 ]
Betreff des Beitrags: 
Your engine looks fine! The style of the level has something of the old Heretic game (by Raven soft). The only thing I miss is water (chanels an such things).

But...this is OT. 8)
Autor:  Sascha Willems [ Mi Aug 18, 2004 00:44 ]
Betreff des Beitrags: 
Someone plz correct me when I'm wrong (it's late ;) ) :

First, you should use a "packed record" instead of only a record, so you can be sure that Delphi won't change something on your record's alignement :
Code:
  1. type TBSPVertex = packed record
  2.   Position      : TVector3f;             // (x, y, z) position.
  3.   TextureCoord  : TVector2f;             // (u, v) texture coordinate
  4.   LightmapCoord : TVector2f;             // (u, v) lightmap coordinate
  5.   Normal        : TVector3f;             // (x, y, z) normal vector
  6.   Color         : array[0..3] of Byte    // RGBA color for the vertex
  7. end;


After that, you need to calculate your stride. I guess your vectors are made of single, so you calculate your stride like this :
Code:
  1. Your TBSPVertex structure :
  2. First Vertex in array
  3. Byte 0  : Position.x <-Start
  4. Byte 4  : Position.y
  5. Byte 8  : Position.z
  6. // all that now follows isn't needed and must be added to stride
  7. Byte 12 : TextureCoord.s
  8. Byte 16 : TextureCoord.t
  9. Byte 20 : LightmapCoord.s
  10. Byte 24 : LightmapCoord.t
  11. Byte 28 : Normal.x
  12. Byte 32 : Normal.y
  13. Byte 36 : Normal.z
  14. Byte 40 : Color
  15. Byte 44 : END


So that means, that between two vertices (TBSPVertex.Position) is a stride of 44-12 -> 32 Bytes, i.e. 32 Bytes after the first position of a vertex, the next position follows in your array :

Code:
  1. glVertexPointer(3, GL_FLOAT, 32, @inputBuffer[0].Position);


So I hope (and also think ;) ) that this should work.
Autor:  Stucuk [ Mi Aug 18, 2004 01:15 ]
Betreff des Beitrags: 
Flash hat geschrieben:
Your engine looks fine! The style of the level has something of the old Heretic game (by Raven soft). The only thing I miss is water (chanels an such things).

But...this is OT. 8)


Actualy Helios uses Q3MapView as a base (well its files, so the level rendering was already made, tho seems to have some bugs....). The map is Q3DM2 (Quake 3).

anway, Back on topic. Its definatly not the glvertexpointer, the rendersurface (used by textures with no q3 shader(not to b confused with opengl/direct x shaders)) has the same line in it and it works perfectly.

Also changing the stride to 32 makes it look similer to with it set to 0.(only seems to work when its, its own size).

Code:
  1.  
  2. procedure TQuake3BSP.RenderSurface(faceIndex: integer);
  3. var Face : PBSPFace;
  4.     planeIdx : integer;
  5. begin
  6.   try                                  
  7.     Face := @Faces[faceIndex];
  8.     glVertexPointer(3, GL_FLOAT, sizeof(TBSPVertex), @Vertices[Face.startVertIndex].Position);
  9.  
  10.     if multiTexture then begin
  11.       glClientActiveTexture(GL_TEXTURE1);
  12.       glDisableClientState(GL_COLOR_ARRAY);
  13.       glTexCoordPointer(2, GL_FLOAT, sizeof(tBSPVertex), @Vertices[Face.startVertIndex].LightmapCoord);
  14.       glClientActiveTexture(GL_TEXTURE0);
  15.     end;
  16.     glTexCoordPointer(2, GL_FLOAT, sizeof(tBSPVertex), @Vertices[Face.startVertIndex].TextureCoord);
  17.  
  18.     if Face.FaceType = FACE_MESH then begin
  19.       glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(TBSPVertex), @Vertices[Face.startVertIndex].Color);
  20.       glEnableClientState(GL_COLOR_ARRAY);
  21.     end
  22.     else
  23.       glColor3ub(255,255,255);
  24. //    if LockArrays then glLockArraysEXT(0, Face.numMeshVerts);
  25.  
  26.     BindTextures(Face.textureID, Face.lightmapID); //Faces[faceIndex].lightmapID);
  27.     glDrawElements(GL_TRIANGLES, face.numMeshVerts, GL_UNSIGNED_INT, @MeshVertices[face.meshVertIndex]);
  28.     if LockArrays then glUnlockArraysEXT();
  29.     SetDefaults;
  30.     if (numOfEffects > 0) and (Faces[faceIndex].effect > -1) and (not SimpleRender) and GetCvarB('Show_Fog') then begin
  31.       //RenderFogFace(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside].plane );
  32.       //RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, 0);
  33.       if (Effects[Faces[faceIndex].effect].visibleside >= 0) then
  34.         planeIdx := BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside + Effects[Faces[faceIndex].effect].visibleside].plane
  35.       else
  36.         planeIdx :=  -1;
  37.       RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, planeIdx);
  38.       SetDefaults;
  39.     end;
  40.   except
  41.     lastError := glGetError();
  42.     lastErrorString := gluErrorString(lastError);
  43.     {$IfDef HELIOS_CONSOLE}
  44.     if ShowDetails then
  45.     Cons.AddIfDifferent('RenderSurface ' + lastErrorString + ' ' + IntToStr(faceIndex));
  46.     {$EndIf}
  47. //    if DumpErrors then AddError('RenderSurface ' + lastErrorString);
  48.   end;
  49. end;
  50.  
Autor:  Stucuk [ Mi Aug 18, 2004 15:50 ]
Betreff des Beitrags: 
The following are procedures that modify the vertex position, texture position, etc depending on the shader for the texture.

Code:
  1.  
  2. procedure TQuake3BSP.SetVertexCoords(shaderId, numOfVerts : integer);
  3. var shader : TShader;
  4.     i, j, nv : integer;
  5.     args : TWaveFunc;
  6.     startoff, off, wavesize, inc : single;
  7.     p, v, middle, d, h : TVector3f;
  8.     st : TVector2f;
  9. const speed = 2.0;
  10. begin
  11.   shader := FShaderManager[shaderId];
  12.   if shader.numOfDeformVertexes > 0 then begin
  13.     startoff := 0;
  14.     wavesize := 1;
  15.     for i := 0 to shader.numOfDeformVertexes-1 do begin
  16.       case shader.DeformVertexes[i].deformType of
  17.         DEFORMVERTEXES_WAVE :
  18.           begin
  19.             args.func := enWave(trunc(shader.DeformVertexes[i].values[1]));
  20.             args.base := shader.DeformVertexes[i].values[2];
  21.             args.amp  := shader.DeformVertexes[i].values[3];
  22.             wavesize := shader.DeformVertexes[i].values[0];
  23.             startoff := shader.DeformVertexes[i].values[4];
  24.             args.freq := shader.DeformVertexes[i].values[5];
  25.             nv := numOfVerts;
  26.             for j := 0 to numOfVerts-1 do begin
  27.               v := inputBuffer[j].normal;
  28.               p := inputBuffer[j].Position; // buffer it
  29.               off := (p.x+p.y+p.z) / waveSize;
  30.               args.phase := startoff + off;
  31.               inc := Eval(args);
  32.               inputBuffer[j].Position.x := p.x + inc*v.x;
  33.               inputBuffer[j].Position.y := p.y + inc*v.y;
  34.               inputBuffer[j].Position.z := p.z + inc*v.z;
  35.             end;
  36.           end;
  37.         DEFORMVERTEXES_NORMAL :
  38.           begin
  39.             args.func := enWave(trunc(shader.DeformVertexes[i].values[1]));
  40.             args.base := shader.DeformVertexes[i].values[2];
  41.             args.amp  := shader.DeformVertexes[i].values[3];
  42.             args.freq := shader.DeformVertexes[i].values[4];
  43.             nv := numOfVerts;
  44.             for j := 0 to numOfVerts-1 do begin
  45.               v := inputBuffer[j].normal;
  46.               p := inputBuffer[j].Position; // buffer it
  47.               off := (p.x+p.y+p.z) / (speed*waveSize);
  48.               args.phase := startoff + off;
  49.               inc := Eval(args);
  50.               inputBuffer[j].Normal.x := p.x + inc*v.x;
  51.               inputBuffer[j].Normal.y := p.y + inc*v.y;
  52.               inputBuffer[j].Normal.z := p.z + inc*v.z;
  53.             end;
  54.           end;
  55.         DEFORMVERTEXES_MOVE :
  56.           begin
  57.             args.func := enWave(trunc(shader.DeformVertexes[i].values[3]));
  58.             args.base := shader.DeformVertexes[i].values[4];
  59.             args.amp  := shader.DeformVertexes[i].values[5];
  60.             args.phase := shader.DeformVertexes[i].values[6];
  61.             args.freq := shader.DeformVertexes[i].values[7];
  62.             for j := 0 to numOfVerts-1 do begin
  63.               inc := Eval(args);
  64.               inputBuffer[j].position.x := inputBuffer[j].position.x + inc*shader.DeformVertexes[i].values[0];
  65.               inputBuffer[j].position.y := inputBuffer[j].position.y + inc*shader.DeformVertexes[i].values[1];
  66.               inputBuffer[j].position.z := inputBuffer[j].position.z + inc*shader.DeformVertexes[i].values[2];
  67.             end;
  68.           end;
  69.         DEFORMVERTEXES_AUTOSPRITE :
  70.           begin
  71.             (*
  72.             glGetFloatv(GL_MODELVIEW_MATRIX, @cam_mat);
  73.             right := Make3DVector_f(cam_mat[0], cam_mat[4], cam_mat[8]);
  74.             up := Make3DVector_f(cam_mat[1], cam_mat[5], cam_mat[9]);
  75.             right := vec_normalize(right);
  76.             up := vec_normalize(up);
  77.             middle := Make3DVector_f(0,0,0);
  78.             // Compute middle of quad
  79.             for j := 0 to numOfVerts-1 do begin
  80.               middle.X := middle.X + inputBuffer[j].position.x;
  81.               middle.Y := middle.Y + inputBuffer[j].position.y;
  82.               middle.Z := middle.Z + inputBuffer[j].position.z;
  83.             end;
  84.             middle := vec_scale(middle, 1/numOfVerts);
  85.             //glColor3ub(255, 0, 0);
  86.             //glPointSize(2);
  87.             // middle point
  88.             //glBegin(GL_POINTS);
  89.             //  glVertex3f(middle.X, middle.y, middle.Z);
  90.             //glEnd;
  91.             //glPointSize(4);
  92.             //glColor3ub(0, 0, 255);
  93.             //glBegin(GL_POINTS);
  94.             // world points
  95.             for j := 0 to numOfVerts-1 do begin
  96.               p.x := middle.X + (inputBuffer[j].Position.X - middle.x);
  97.               p.y := middle.y + (inputBuffer[j].Position.y - middle.y);
  98.               p.z := middle.z + (inputBuffer[j].Position.z - middle.z);
  99.            //   glVertex3f(p.X, p.y, p.Z);
  100.             end;
  101.             //glEnd;
  102.             //glPointSize(8);
  103.             //glColor3ub(255, 255, 0);
  104.             //glBegin(GL_POINTS);
  105.             // billboard points
  106.             for j := 0 to numOfVerts-1 do begin
  107.               dx := (inputBuffer[j].Position.X - middle.x);
  108.               dy := (inputBuffer[j].Position.y - middle.y);
  109.               dz := (inputBuffer[j].Position.z - middle.z);
  110. {              if (dx < 0) or (dz < 0) then
  111.                 if (dx < 0) and (dz < 0) then
  112.                   dx := -Sqrt(dx*dx + dz*dz)
  113.                 else
  114.                   dx :=  Sqrt(dx*dx + dz*dz)
  115.               else
  116.                 dx := Sqrt(dx*dx + dz*dz);}
  117.               p := vec_add(vec_scale(up, dy), vec_scale(right, dx));
  118.               p := vec_add(middle, p);
  119.             //  glVertex3f(p.X, p.y, p.Z);
  120.               inputBuffer[j].Position := p;
  121.             end;
  122.             //glEnd;
  123.             //glColor3ub(255, 255, 255);
  124.             *)
  125.           end;
  126.         DEFORMVERTEXES_BULGE :
  127.           begin
  128.             args.func := WF_SIN;
  129.             args.base := 0;
  130.             args.amp  := shader.DeformVertexes[i].values[1];
  131.             args.freq := 1/(speed*shader.DeformVertexes[i].values[0]);
  132.             nv := numOfVerts;
  133.             for j := 0 to numOfVerts-1 do begin
  134.               st := inputBuffer[j].TextureCoord;
  135.               v := inputBuffer[j].normal;
  136.               p := inputBuffer[j].Position; // buffer it
  137.               args.phase := st.X*speed*shader.DeformVertexes[i].values[2];
  138.               inc := Eval(args);
  139.               inputBuffer[j].Position.x := p.x + inc*v.x;
  140.               inputBuffer[j].Position.y := p.y + inc*v.y;
  141.               inputBuffer[j].Position.z := p.z + inc*v.z;
  142.             end;
  143.           end;
  144.       end;
  145.     end;
  146.   end;
  147. end;
  148.  


Code:
  1.  
  2. procedure TQuake3BSP.SetTextureCoordinates(shaderId, stageId, numOfVerts : integer);
  3. var i, j : integer;
  4.     shader : TShader;
  5.     dir : TVector3f;
  6.     // tcmod
  7.     angulo, cost, sint, factor : single;
  8.     v, scroll : TVector2f;
  9.     v2 : TVector3f;
  10.     now : single;
  11.     frame : integer;
  12. begin
  13.   shader := FShaderManager[shaderId];
  14. (*  for j := 0 to numOfVerts-1 do
  15.     texCoordBuffer[j] := inputBuffer[j].TextureCoord;
  16. *)
  17.   if shader.numOfLayers > 0 then begin
  18.     //Animation
  19.     if shader.Layers[StageID].animFreq <> 0 then begin
  20.       frame := Trunc(gTimer.TotalTime *shader.Layers[StageID].animFreq) mod shader.Layers[StageID].numOfTextures;
  21.       if frame >= shader.Layers[StageID].numOfTextures then
  22.         frame := 0;
  23.       Shader.Layers[StageID].curTexture := frame;
  24.     end
  25.     else
  26.       Shader.Layers[StageID].curTexture := 0;
  27.     // tcGen  ******************************************************************
  28.     case shader.Layers[stageId].tcGen of
  29.       TCGEN_LIGHTMAP :
  30.         begin
  31.           for j := 0 to numOfVerts-1 do
  32.             texCoordBuffer[j] := inputBuffer[j].LightmapCoord;
  33.         end;
  34.       TCGEN_ENVIRONMENT :
  35.         begin
  36.           // wrong calc !!!!
  37.           for j := 0 to numOfVerts-1 do begin
  38.             dir := SubtractVector(inputBuffer[j].Position, Camera.Position);//vec_sub(inputBuffer[j].Position, Camera.Position);
  39.             //dir := Normalize(dir);//vec_normalize(dir);
  40.             Normalize(dir);
  41. {            dir.x := dir.x + inputBuffer[j].Normal.X;
  42.             dir.y := dir.y + inputBuffer[j].Normal.Y;
  43.             texCoordBuffer[j].X := dir.x;
  44.             texCoordBuffer[j].Y := dir.y;}
  45.             dir.x := dir.x + inputBuffer[j].Normal.X;
  46.             dir.z := dir.z + inputBuffer[j].Normal.z;
  47.             texCoordBuffer[j].X := dir.x;
  48.             texCoordBuffer[j].y := dir.z;
  49.  
  50.           end;
  51.  
  52.         end;
  53.       else
  54.         for j := 0 to numOfVerts-1 do
  55.           texCoordBuffer[j] := inputBuffer[j].TextureCoord;
  56.     end;
  57.  
  58.     // tcMod *******************************************************************
  59.     if shader.Layers[stageId].numOftcMods > 0 then begin
  60.       for i := 0 to numOfVerts-1 do begin
  61.         for j := 0 to shader.layers[stageId].numOftcMods-1 do begin
  62.           case shader.Layers[stageId].tcMods[j].modType of
  63.             TCMOD_ROTATE :
  64.               begin
  65.                 angulo := shader.Layers[stageId].tcMods[j].Values[0]*gTimer.TotalTime/M_180_PI;
  66.                 cost := cos(angulo);
  67.                 sint := sin(angulo);
  68.                 v := texCoordBuffer[i];
  69.                 v.x := v.x - 0.5;
  70.                 v.y := v.y + 0.5;
  71.                 texCoordBuffer[i].x := v.x*cost - v.y*sint + 0.5;
  72.                 texCoordBuffer[i].y := v.x*sint + v.y*cost + 0.5;
  73.               end;
  74.             TCMOD_SCALE :
  75.               begin
  76.                 texCoordBuffer[i].x := (texCoordBuffer[i].x-0.5) * shader.Layers[stageId].tcMods[j].Values[0] + 0.5;
  77.                 texCoordBuffer[i].y := (texCoordBuffer[i].y-0.5) * shader.Layers[stageId].tcMods[j].Values[1] + 0.5;
  78.               end;
  79.             TCMOD_SCROLL :
  80.               begin
  81.                 scroll.x := shader.Layers[stageId].tcMods[j].Values[0]*gTimer.TotalTime;
  82.                 scroll.y := shader.Layers[stageId].tcMods[j].Values[1]*gTimer.TotalTime;
  83.                 texCoordBuffer[i].x := texCoordBuffer[i].x + scroll.x;
  84.                 texCoordBuffer[i].y := texCoordBuffer[i].y - scroll.y;
  85.               end;
  86.             TCMOD_STRETCH :
  87.               begin
  88.                 factor := (1/Eval(shader.Layers[StageID].tcMods[j].Wave));
  89.                 texCoordBuffer[i].x := (texCoordBuffer[i].x - 0.5) * factor + 0.5;
  90.                 texCoordBuffer[i].y := (texCoordBuffer[i].y - 0.5) * factor + 0.5;
  91.               end;
  92.             TCMOD_TRANSFORM :
  93.               begin
  94.                 v := texCoordBuffer[i];
  95.                 texCoordBuffer[i].x := v.x*shader.Layers[stageId].tcMods[j].Values[0] + v.y*shader.Layers[stageId].tcMods[j].Values[2] + shader.Layers[stageId].tcMods[j].Values[4];
  96.                 texCoordBuffer[i].y := v.x*shader.Layers[stageId].tcMods[j].Values[1] + v.y*shader.Layers[stageId].tcMods[j].Values[3] + shader.Layers[stageId].tcMods[j].Values[5];
  97.               end;
  98.             TCMOD_TURB :
  99.               begin
  100. //                v2 := inputBuffer[i].Position;
  101.                 v2.x := texCoordBuffer[i].x;
  102.                 v2.y := texCoordBuffer[i].y;
  103.                 v2.z := inputBuffer[i].Position.z;
  104.                 texCoordBuffer[i].x := texCoordBuffer[i].x + Sin((v2.x+v2.z)*0.1*shader.Layers[stageId].tcMods[j].Values[3] + gTimer.TotalTime + shader.Layers[stageId].tcMods[j].Values[2])*shader.Layers[stageId].tcMods[j].Values[1]*0.5;
  105.                 texCoordBuffer[i].y := texCoordBuffer[i].y + Sin((v2.y     )*0.1*shader.Layers[stageId].tcMods[j].Values[3] + gTimer.TotalTime + shader.Layers[stageId].tcMods[j].Values[2])*shader.Layers[stageId].tcMods[j].Values[1]*0.5;
  106.  
  107. //                v := texCoordBuffer[i];
  108. //                texCoordBuffer[i].x := texCoordBuffer[i].x + Sin((v.x     )*0.1*shader.Layers[stageId].tcMods[j].Values[3] + gTimer.TotalTime + shader.Layers[stageId].tcMods[j].Values[2])*shader.Layers[stageId].tcMods[j].Values[1]*0.5;
  109. //                texCoordBuffer[i].y := texCoordBuffer[i].y + Sin((v.y     )*0.1*shader.Layers[stageId].tcMods[j].Values[3] + gTimer.TotalTime + shader.Layers[stageId].tcMods[j].Values[2])*shader.Layers[stageId].tcMods[j].Values[1]*0.5;
  110.               end;
  111.           end;
  112.         end;
  113.       end;
  114.     end;
  115.   end;
  116. end;
  117.  


Code:
  1.  
  2. procedure TQuake3BSP.SetVertexColors(shaderId, stageId, numOfVerts : integer);
  3. var shader : TShader;
  4.     i, j : integer;
  5.     c : integer;
  6. begin
  7.   shader := FShaderManager[shaderId];
  8.   for j := 0 to numOfVerts-1 do begin
  9.     colorBuffer[j, 0] := inputBuffer[j].Color[0]; // red
  10.     colorBuffer[j, 1] := inputBuffer[j].Color[1]; // green
  11.     colorBuffer[j, 2] := inputBuffer[j].Color[2]; // blue
  12.     colorBuffer[j, 3] := inputBuffer[j].Color[3]; // gamma
  13.   end;
  14.  
  15.   if shader.numOfLayers > 0 then begin
  16.     if shader.Layers[stageId].numOfrgbGen > 0 then begin
  17.       case shader.Layers[stageId].rgbGen[0].rgbGType of
  18.         rgbGen_IdentityLightning :
  19.           begin
  20.             for j := 0 to numOfVerts-1 do begin
  21.               colorBuffer[j, 0] := 127; // red
  22.               colorBuffer[j, 1] := 127; // green
  23.               colorBuffer[j, 2] := 127; // blue
  24.               colorBuffer[j, 3] := 255; // gamma
  25.             end;
  26.           end;
  27.         rgbGen_Identity :
  28.           begin
  29.             for j := 0 to numOfVerts-1 do begin
  30.               colorBuffer[j, 0] := 255; // red
  31.               colorBuffer[j, 1] := 255; // green
  32.               colorBuffer[j, 2] := 255; // blue
  33.               colorBuffer[j, 3] := 255; // gamma
  34.             end;
  35.           end;
  36.         rgbGen_Wave :
  37.           begin
  38.             c := Round(255*Eval(shader.Layers[stageId].rgbGen[0].Wave));
  39.             if c < 0 then c := 0;
  40.             if c > 255 then c := 255;
  41.             for j := 0 to numOfVerts-1 do begin
  42.               colorBuffer[j, 0] := c;   // red
  43.               colorBuffer[j, 1] := c;   // green
  44.               colorBuffer[j, 2] := c;   // blue
  45.               colorBuffer[j, 3] := 255; // gamma
  46.             end;
  47.           end;
  48.        else begin
  49.         for j := 0 to numOfVerts-1 do begin
  50.           colorBuffer[j, 0] := inputBuffer[j].Color[0]; // red
  51.           colorBuffer[j, 1] := inputBuffer[j].Color[1]; // green
  52.           colorBuffer[j, 2] := inputBuffer[j].Color[2]; // blue
  53.           colorBuffer[j, 3] := inputBuffer[j].Color[3]; // gamma
  54.         end;
  55.        end;
  56.       end;
  57.     end
  58.     else begin
  59.       // no rgbgen use vertex colors
  60.       for j := 0 to numOfVerts-1 do begin
  61.         colorBuffer[j, 0] := inputBuffer[j].Color[0]; // red
  62.         colorBuffer[j, 1] := inputBuffer[j].Color[1]; // green
  63.         colorBuffer[j, 2] := inputBuffer[j].Color[2]; // blue
  64.         colorBuffer[j, 3] := inputBuffer[j].Color[3]; // gamma
  65.       end;
  66.     end;
  67.   end;
  68. end;
  69.  


I think the problem is in one of these since:

1. Its something relating to a shader
2. they modify the data depending on the shaders

And incase anyone wonders what a q3 shader looks like here is one:

Code:
  1.  
  2. textures/base_floor/techfloor2
  3. {
  4.         cull disable
  5.         //surfaceparm trans
  6.         surfaceparm nomarks
  7.         //nomipmaps
  8.  
  9.         {
  10.             clampmap textures/base_floor/techfloor2.tga
  11.         alphaFunc GE128
  12.                 tcmod rotate 70
  13.                 tcMod stretch sin .8 0.2 0 .3
  14.             rgbGen identity
  15.     }
  16.         {
  17.                 clampmap textures/base_floor/techfloor2.tga
  18.                 alphaFunc GE128
  19.                 tcmod rotate -50
  20.                 tcMod stretch sin .8 0.2 0 .2
  21.                 rgbGen identity
  22.     }
  23.         {
  24.             clampmap textures/base_floor/techfloor2.tga
  25.         alphaFunc GE128
  26.                 tcmod rotate 30
  27.                 tcMod stretch sin .8 0.2 0 .1
  28.             rgbGen identity
  29.     }
  30.         {
  31.         map $lightmap
  32.         rgbGen identity
  33.         blendFunc GL_DST_COLOR GL_ZERO
  34.         depthFunc equal
  35.     }
  36.  
  37. }
  38.  
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/