DGL • Thema anzeigen - Transparent Objects

Transparent Objects

Moderator: DGL-Team

Seite 1 von 1

[ 5 Beiträge ]

Druckansicht

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Stucuk

Betreff des Beitrags: Transparent Objects

Verfasst: Do Sep 16, 2004 16:03

DGL Member

Registriert: Mi Jul 21, 2004 22:39
Beiträge: 360
Wohnort: UK, Scotland

Im wondering if faces can become totaly transparent(doesn't matter what way u look at them) by some opengl settings without transparency. The reason i wonder is due to some RTCW(Return To Castle Wolfenstine) maps having "missing" features visualy. I know its related to some shaders (Quake 3 shaders not Opengl, Q3 shaders control the GL effects put on the textures and how the textures(and the face) should act, i.e Flags should destort like they are in the wind).

Below is a pic with shaders disabled and enabled.

EDIT: it doesn't seem to be: GL_CULL_FACE, GL_ALPHA_TEST, GL_DEPTH_TEST, glDepthMask, GL_BLEND.

Dateianhänge:

Dateikommentar: Shaders Disabled

_0075.jpg [163.16 KiB]
47-mal heruntergeladen
Dateikommentar: Shaders Enabled

_0076.jpg [150.39 KiB]
47-mal heruntergeladen

_________________
Free Map Editor - Game Requirements - Stucuk.Net
-Stu

Nach oben

Stucuk

Betreff des Beitrags:

Verfasst: Do Sep 16, 2004 16:28

DGL Member

Registriert: Mi Jul 21, 2004 22:39
Beiträge: 360
Wohnort: UK, Scotland

Surface Shader Code:

Code:

 
procedure TQuake3BSP.RenderSurfaceShader(faceIndex, shaderId: integer);
var shader : TShader;
    i, texId, planeIdx : integer;
    Face : PBSPFace;
begin
  try
  Face := @Faces[faceIndex];
  shader := ShaderManager[shaderId];
  // culling
  if shader.Cull = GL_NONE then
    glDisable(GL_CULL_FACE)
  else begin
    glEnable(GL_CULL_FACE);
    glCullFace(shader.cull);
  end;
 
  if multiTexture then begin
    glActiveTexture(GL_TEXTURE1);
    glDisable(GL_TEXTURE_2D);
 
    glActiveTexture(GL_TEXTURE0);
  end;
  glDisable(GL_TEXTURE_2D);
 
  glEnable(GL_COLOR);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glColor3ub(255,255,255);
 
  // prepare data for global deform operations - but texture coordinates must restored for each layer !!!!!
 
   for i := 0 to face.numMeshVerts-1 do
    inputBuffer[i] := Vertices[Face.startVertIndex+MeshVertices[face.meshVertIndex+i]];
 
  SetVertexCoords(shaderId, face.numMeshVerts);
  glVertexPointer(3, GL_FLOAT, sizeof(TBSPVertex), @inputBuffer[0].Position);
 
  if LockArrays then glLockArraysEXT(0, Face.numMeshVerts);
 
  if shader.numOfLayers > 0 then begin
    for i := 0 to shader.numOfLayers-1 do begin
      if (ShaderManager[shaderId].Layers[i].numOfrgbGen > 0) or (Face.FaceType = FACE_MESH) then begin
        SetVertexColors(shaderId, i, face.numMeshVerts);
        glColorPointer(4, GL_UNSIGNED_BYTE, 0, @colorBuffer[0]);
        glEnableClientState(GL_COLOR_ARRAY);
      end
      else
        glDisableClientState(GL_COLOR_ARRAY);
      if not pause then
      SetTextureCoordinates(shaderId, i, face.numMeshVerts);
 
      if multiTexture then
        glClientActiveTexture(GL_TEXTURE0);
      glTexCoordPointer(2, GL_FLOAT, 0,  @texCoordBuffer[0]);
 
      if (shader.Layers[i].UseLightmap) then begin
        if not multiTexture then begin
          texId := 0;
        end
        else begin
          glClientActiveTexture(GL_TEXTURE0);
          glTexCoordPointer(2, GL_FLOAT, sizeof(TBSPVERTEX), @inputBuffer[0].LightmapCoord);
          if (face.lightmapId > -1) and (Lightmaps[face.lightmapID] > -1) then
            texId := Lightmaps[face.lightmapID]
          else
            texId := 0;
        end;
      end
      else begin
        texId := shader.Layers[i].TextureId[shader.Layers[i].curTexture];
      end;
      glEnable(GL_TEXTURE_2D);
      glBindTexture(GL_TEXTURE_2D, texId);
 
      shaderManager.SetState(shaderId, i );
 
      glDrawArrays(GL_TRIANGLES, 0, Face.numMeshVerts);
      SetDefaults;
    end;
  end;
  if LockArrays then glUnlockArraysEXT();
  SetDefaults;
  if (numOfEffects > 0) and (Faces[faceIndex].effect > -1) and (not simpleRender) and (GetCvarB('Cg_Fog')) then begin
    //RenderFogFace(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside].plane );
    //RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, BrushSides[Effects[Faces[faceIndex].effect].visibleSide].plane);
    if (Effects[Faces[faceIndex].effect].visibleside >= 0) then
      planeIdx := BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside + Effects[Faces[faceIndex].effect].visibleside].plane
    else
      planeIdx :=  -1;
    RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, planeIdx);
    SetDefaults;
  end;
  except
    lastError := glGetError();
    lastErrorString := gluErrorString(lastError);
    {$IfDef HELIOS_CONSOLE}
    //if ShowDetails then
    Cons.AddIfDifferent('RenderSurfaceShader ' + lastErrorString + ' ' + IntToStr(faceIndex));
    {$EndIf}
//    if DumpErrors then AddError('RenderSurfaceShader ' + lastErrorString);
  end;
 
end;
 

Surface Code:

Code:

 
procedure TQuake3BSP.RenderSurface(faceIndex: integer);
var Face : PBSPFace;
    planeIdx : integer; 
begin
  try                                   
    Face := @Faces[faceIndex];
    glVertexPointer(3, GL_FLOAT, sizeof(TBSPVertex), @Vertices[Face.startVertIndex].Position);
 
    if multiTexture then begin
      glClientActiveTexture(GL_TEXTURE1);
      glDisableClientState(GL_COLOR_ARRAY);
      glTexCoordPointer(2, GL_FLOAT, sizeof(tBSPVertex), @Vertices[Face.startVertIndex].LightmapCoord);
      glClientActiveTexture(GL_TEXTURE0);
    end;
    glTexCoordPointer(2, GL_FLOAT, sizeof(tBSPVertex), @Vertices[Face.startVertIndex].TextureCoord);
 
    if Face.FaceType = FACE_MESH then begin
      glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(TBSPVertex), @Vertices[Face.startVertIndex].Color);
      glEnableClientState(GL_COLOR_ARRAY);
    end
    else
      glColor3ub(255,255,255);
//    if LockArrays then glLockArraysEXT(0, Face.numMeshVerts);
 
    BindTextures(Face.textureID, Face.lightmapID); //Faces[faceIndex].lightmapID);
    glDrawElements(GL_TRIANGLES, face.numMeshVerts, GL_UNSIGNED_INT, @MeshVertices[face.meshVertIndex]);
    if LockArrays then glUnlockArraysEXT();
    SetDefaults;
    if (numOfEffects > 0) and (Faces[faceIndex].effect > -1) and (not SimpleRender) and GetCvarB('Cg_Fog') then begin
      //RenderFogFace(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside].plane );
      //RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, 0);
      if (Effects[Faces[faceIndex].effect].visibleside >= 0) then
        planeIdx := BrushSides[Brushes[Effects[Faces[faceIndex].effect].brushIndex].brushside + Effects[Faces[faceIndex].effect].visibleside].plane
      else
        planeIdx :=  -1;
      RenderFog(faceIndex, Effects[Faces[faceIndex].effect].shaderIndex, planeIdx);
      SetDefaults;
    end;
  except
    lastError := glGetError();
    lastErrorString := gluErrorString(lastError);
    {$IfDef HELIOS_CONSOLE}
    if ShowDetails then
    Cons.AddIfDifferent('RenderSurface ' + lastErrorString + ' ' + IntToStr(faceIndex));
    {$EndIf}
//    if DumpErrors then AddError('RenderSurface ' + lastErrorString);
  end;
end;
 

Misc used by Surface Shader:

Code:

 
procedure TQuake3BSP.SetVertexCoords(shaderId, numOfVerts : integer);
var shader : TShader;
    i, j, nv : integer;
    args : TWaveFunc;
    startoff, off, wavesize, inc : single;
    p, v, middle, d, h : TVector3f;
    st : TVector2f;
const speed = 2.0;
begin
  shader := FShaderManager[shaderId];
  if shader.numOfDeformVertexes > 0 then begin
    startoff := 0;
    wavesize := 1;
    for i := 0 to shader.numOfDeformVertexes-1 do begin
      case shader.DeformVertexes[i].deformType of
        DEFORMVERTEXES_WAVE :
          begin
            args.func := enWave(trunc(shader.DeformVertexes[i].values[1]));
            args.base := shader.DeformVertexes[i].values[2];
            args.amp  := shader.DeformVertexes[i].values[3];
            wavesize := shader.DeformVertexes[i].values[0];
            startoff := shader.DeformVertexes[i].values[4];
            args.freq := shader.DeformVertexes[i].values[5];
            nv := numOfVerts;
            for j := 0 to numOfVerts-1 do begin
              v := inputBuffer[j].normal;
              p := inputBuffer[j].Position; // buffer it
              off := (p.x+p.y+p.z) / waveSize;
              args.phase := startoff + off;
              inc := Eval(args);
              inputBuffer[j].Position.x := p.x + inc*v.x;
              inputBuffer[j].Position.y := p.y + inc*v.y;
              inputBuffer[j].Position.z := p.z + inc*v.z;
            end;
          end;
        DEFORMVERTEXES_NORMAL :
          begin
            args.func := enWave(trunc(shader.DeformVertexes[i].values[1]));
            args.base := shader.DeformVertexes[i].values[2];
            args.amp  := shader.DeformVertexes[i].values[3];
            args.freq := shader.DeformVertexes[i].values[4];
            nv := numOfVerts;
            for j := 0 to numOfVerts-1 do begin
              v := inputBuffer[j].normal;
              p := inputBuffer[j].Position; // buffer it
              off := (p.x+p.y+p.z) / (speed*waveSize);
              args.phase := startoff + off;
              inc := Eval(args);
              inputBuffer[j].Normal.x := p.x + inc*v.x;
              inputBuffer[j].Normal.y := p.y + inc*v.y;
              inputBuffer[j].Normal.z := p.z + inc*v.z;
            end;
          end;
        DEFORMVERTEXES_MOVE :
          begin
            args.func := enWave(trunc(shader.DeformVertexes[i].values[3]));
            args.base := shader.DeformVertexes[i].values[4];
            args.amp  := shader.DeformVertexes[i].values[5];
            args.phase := shader.DeformVertexes[i].values[6];
            args.freq := shader.DeformVertexes[i].values[7];
            for j := 0 to numOfVerts-1 do begin
              inc := Eval(args);
              inputBuffer[j].position.x := inputBuffer[j].position.x + inc*shader.DeformVertexes[i].values[0];
              inputBuffer[j].position.y := inputBuffer[j].position.y + inc*shader.DeformVertexes[i].values[1];
              inputBuffer[j].position.z := inputBuffer[j].position.z + inc*shader.DeformVertexes[i].values[2];
            end;
          end;
        DEFORMVERTEXES_AUTOSPRITE :
          begin
            (*
            glGetFloatv(GL_MODELVIEW_MATRIX, @cam_mat);
            right := Make3DVector_f(cam_mat[0], cam_mat[4], cam_mat[8]);
            up := Make3DVector_f(cam_mat[1], cam_mat[5], cam_mat[9]);
            right := vec_normalize(right);
            up := vec_normalize(up);
            middle := Make3DVector_f(0,0,0);
            // Compute middle of quad
            for j := 0 to numOfVerts-1 do begin
              middle.X := middle.X + inputBuffer[j].position.x;
              middle.Y := middle.Y + inputBuffer[j].position.y;
              middle.Z := middle.Z + inputBuffer[j].position.z;
            end;
            middle := vec_scale(middle, 1/numOfVerts);
            //glColor3ub(255, 0, 0);
            //glPointSize(2);
            // middle point
            //glBegin(GL_POINTS);
            //  glVertex3f(middle.X, middle.y, middle.Z);
            //glEnd;
            //glPointSize(4);
            //glColor3ub(0, 0, 255);
            //glBegin(GL_POINTS);
            // world points
            for j := 0 to numOfVerts-1 do begin
              p.x := middle.X + (inputBuffer[j].Position.X - middle.x);
              p.y := middle.y + (inputBuffer[j].Position.y - middle.y);
              p.z := middle.z + (inputBuffer[j].Position.z - middle.z);
           //   glVertex3f(p.X, p.y, p.Z);
            end;
            //glEnd;
            //glPointSize(8);
            //glColor3ub(255, 255, 0);
            //glBegin(GL_POINTS);
            // billboard points
            for j := 0 to numOfVerts-1 do begin
              dx := (inputBuffer[j].Position.X - middle.x);
              dy := (inputBuffer[j].Position.y - middle.y);
              dz := (inputBuffer[j].Position.z - middle.z);
{              if (dx < 0) or (dz < 0) then
                if (dx < 0) and (dz < 0) then
                  dx := -Sqrt(dx*dx + dz*dz)
                else
                  dx :=  Sqrt(dx*dx + dz*dz)
              else
                dx := Sqrt(dx*dx + dz*dz);}
              p := vec_add(vec_scale(up, dy), vec_scale(right, dx));
              p := vec_add(middle, p);
            //  glVertex3f(p.X, p.y, p.Z);
              inputBuffer[j].Position := p;
            end;
            //glEnd;
            //glColor3ub(255, 255, 255);
            *)
          end;
        DEFORMVERTEXES_BULGE :
          begin
            args.func := WF_SIN;
            args.base := 0;
            args.amp  := shader.DeformVertexes[i].values[1];
            args.freq := 1/(speed*shader.DeformVertexes[i].values[0]);
            nv := numOfVerts;
            for j := 0 to numOfVerts-1 do begin
              st := inputBuffer[j].TextureCoord;
              v := inputBuffer[j].normal;
              p := inputBuffer[j].Position; // buffer it
              args.phase := st.X*speed*shader.DeformVertexes[i].values[2];
              inc := Eval(args);
              inputBuffer[j].Position.x := p.x + inc*v.x;
              inputBuffer[j].Position.y := p.y + inc*v.y;
              inputBuffer[j].Position.z := p.z + inc*v.z;
            end;
          end;
      end;
    end;
  end;
end;
 
procedure TQuake3BSP.SetVertexColors(shaderId, stageId, numOfVerts : integer);
var shader : TShader;
    i, j : integer;
    c : integer;
begin
  shader := FShaderManager[shaderId];
  for j := 0 to numOfVerts-1 do begin
    colorBuffer[j, 0] := inputBuffer[j].Color[0]; // red
    colorBuffer[j, 1] := inputBuffer[j].Color[1]; // green
    colorBuffer[j, 2] := inputBuffer[j].Color[2]; // blue
    colorBuffer[j, 3] := inputBuffer[j].Color[3]; // gamma
  end;
 
  if shader.numOfLayers > 0 then begin
    if shader.Layers[stageId].numOfrgbGen > 0 then begin
      case shader.Layers[stageId].rgbGen[0].rgbGType of
        rgbGen_IdentityLightning :
          begin
            for j := 0 to numOfVerts-1 do begin
              colorBuffer[j, 0] := 127; // red
              colorBuffer[j, 1] := 127; // green
              colorBuffer[j, 2] := 127; // blue
              colorBuffer[j, 3] := 255; // gamma
            end;
          end;
        rgbGen_Identity :
          begin
            for j := 0 to numOfVerts-1 do begin
              colorBuffer[j, 0] := 255; // red
              colorBuffer[j, 1] := 255; // green
              colorBuffer[j, 2] := 255; // blue
              colorBuffer[j, 3] := 255; // gamma
            end;
          end;
        rgbGen_Wave :
          begin
            c := Round(255*Eval(shader.Layers[stageId].rgbGen[0].Wave));
            if c < 0 then c := 0;
            if c > 255 then c := 255;
            for j := 0 to numOfVerts-1 do begin
              colorBuffer[j, 0] := c;   // red
              colorBuffer[j, 1] := c;   // green
              colorBuffer[j, 2] := c;   // blue
              colorBuffer[j, 3] := 255; // gamma
            end;
          end;
       else begin
        for j := 0 to numOfVerts-1 do begin
          colorBuffer[j, 0] := inputBuffer[j].Color[0]; // red
          colorBuffer[j, 1] := inputBuffer[j].Color[1]; // green
          colorBuffer[j, 2] := inputBuffer[j].Color[2]; // blue
          colorBuffer[j, 3] := inputBuffer[j].Color[3]; // gamma
        end;
       end;
      end;
    end
    else begin
      // no rgbgen use vertex colors
      for j := 0 to numOfVerts-1 do begin
        colorBuffer[j, 0] := inputBuffer[j].Color[0]; // red
        colorBuffer[j, 1] := inputBuffer[j].Color[1]; // green
        colorBuffer[j, 2] := inputBuffer[j].Color[2]; // blue
        colorBuffer[j, 3] := inputBuffer[j].Color[3]; // gamma
      end;
    end;
  end;
end;
 
procedure TQuake3BSP.SetTextureCoordinates(shaderId, stageId, numOfVerts : integer);
var i, j : integer;
    shader : TShader;
    dir : TVector3f;
    // tcmod
    angulo, cost, sint, factor : single;
    v, scroll : TVector2f;
    v2 : TVector3f;
    now : single;
    frame : integer;
begin
  shader := FShaderManager[shaderId];
(*  for j := 0 to numOfVerts-1 do
    texCoordBuffer[j] := inputBuffer[j].TextureCoord;
*)
  if shader.numOfLayers > 0 then begin
    //Animation
    if shader.Layers[StageID].animFreq <> 0 then begin
      frame := Trunc(gTimer.TotalTime *shader.Layers[StageID].animFreq) mod shader.Layers[StageID].numOfTextures;
      if frame >= shader.Layers[StageID].numOfTextures then
        frame := 0;
      Shader.Layers[StageID].curTexture := frame;
    end
    else
      Shader.Layers[StageID].curTexture := 0;
    // tcGen  ******************************************************************
    case shader.Layers[stageId].tcGen of
      TCGEN_LIGHTMAP :
        begin
          for j := 0 to numOfVerts-1 do
            texCoordBuffer[j] := inputBuffer[j].LightmapCoord;
        end;
      TCGEN_ENVIRONMENT :
        begin
          // wrong calc !!!!
          for j := 0 to numOfVerts-1 do begin
            dir := SubtractVector(inputBuffer[j].Position, Camera.Position);//vec_sub(inputBuffer[j].Position, Camera.Position);
            //dir := Normalize(dir);//vec_normalize(dir);
            Normalize(dir);
{            dir.x := dir.x + inputBuffer[j].Normal.X;
            dir.y := dir.y + inputBuffer[j].Normal.Y;
            texCoordBuffer[j].X := dir.x;
            texCoordBuffer[j].Y := dir.y;}
            dir.x := dir.x + inputBuffer[j].Normal.X;
            dir.z := dir.z + inputBuffer[j].Normal.z;
            texCoordBuffer[j].X := dir.x;
            texCoordBuffer[j].y := dir.z;
 
          end;
 
        end;
      else
        for j := 0 to numOfVerts-1 do
          texCoordBuffer[j] := inputBuffer[j].TextureCoord;
    end;
 
    // tcMod *******************************************************************
    if shader.Layers[stageId].numOftcMods > 0 then begin
      for i := 0 to numOfVerts-1 do begin
        for j := 0 to shader.layers[stageId].numOftcMods-1 do begin
          case shader.Layers[stageId].tcMods[j].modType of
            TCMOD_ROTATE :
              begin
                angulo := shader.Layers[stageId].tcMods[j].Values[0]*gTimer.TotalTime/M_180_PI;
                cost := cos(angulo);
                sint := sin(angulo);
                v := texCoordBuffer[i];
                v.x := v.x - 0.5;
                v.y := v.y + 0.5;
                texCoordBuffer[i].x := v.x*cost - v.y*sint + 0.5;
                texCoordBuffer[i].y := v.x*sint + v.y*cost + 0.5;
              end;
            TCMOD_SCALE :
              begin
                texCoordBuffer[i].x := (texCoordBuffer[i].x-0.5) * shader.Layers[stageId].tcMods[j].Values[0] + 0.5;
                texCoordBuffer[i].y := (texCoordBuffer[i].y-0.5) * shader.Layers[stageId].tcMods[j].Values[1] + 0.5;
              end;
            TCMOD_SCROLL :
              begin
                scroll.x := shader.Layers[stageId].tcMods[j].Values[0]*gTimer.TotalTime;
                scroll.y := shader.Layers[stageId].tcMods[j].Values[1]*gTimer.TotalTime;
                texCoordBuffer[i].x := texCoordBuffer[i].x + scroll.x;
                texCoordBuffer[i].y := texCoordBuffer[i].y - scroll.y;
              end;
            TCMOD_STRETCH :
              begin
                factor := (1/Eval(shader.Layers[StageID].tcMods[j].Wave));
                texCoordBuffer[i].x := (texCoordBuffer[i].x - 0.5) * factor + 0.5;
                texCoordBuffer[i].y := (texCoordBuffer[i].y - 0.5) * factor + 0.5;
              end;
            TCMOD_TRANSFORM :
              begin
                v := texCoordBuffer[i];
                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];
                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];
              end;
            TCMOD_TURB :
              begin
//                v2 := inputBuffer[i].Position;
                v2.x := texCoordBuffer[i].x;
                v2.y := texCoordBuffer[i].y;
                v2.z := inputBuffer[i].Position.z;
                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;
                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;
 
//                v := texCoordBuffer[i];
//                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;
//                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;
              end;
          end;
        end;
      end;
    end;
  end;
end;
 
procedure TQuake3BSP.SetDefaults;
begin
  glDepthFunc(GL_LEQUAL);
  glEnable(GL_DEPTH_TEST);
  glDisable(GL_ALPHA_TEST);
  glDepthMask(true);
  glDisable(GL_BLEND);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
  //  glDisable(GL_COLOR);
  if MultiTexture then begin
    glActiveTexture(GL_TEXTURE1);
    glDisableClientState(GL_COLOR_ARRAY);
    glActiveTexture(GL_TEXTURE0);
  end;
  glDisableClientState(GL_COLOR_ARRAY);
  glColor3ub(255,255,255);
  glCullFace(GL_FRONT);
  glEnable(GL_CULL_FACE);
end;
 

ShaderManagers Set State:

Code:

 
procedure TShaderManager.SetState(ShaderID, StageID : integer);
var shader :TShader;
begin
try             
  shader := Items[ShaderId];
  // Depth func
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(Items[ShaderID].Layers[StageID].DepthFunc);
 
  // Alpha
  if Items[ShaderID].Layers[StageID].doAlphaTest = True then begin
    glEnable(GL_ALPHA_TEST);
    glAlphaFunc(Items[ShaderID].Layers[StageID].AlphaFunc, Items[ShaderID].Layers[StageID].AlphaRef);
  end
  else
    glDisable(GL_ALPHA_TEST);
 
  if (Items[shaderId].Cull = GL_NONE) then
  glDisable(GL_CULL_FACE)
  else
  glEnable(GL_CULL_FACE);
 
  // Z-Buffer - needs sorted shaders
  if (Items[shaderId].Cull = GL_NONE) or (Items[shaderId].TotallyTrans) or (Items[ShaderID].Layers[StageID].doAlphaTest) then begin
    if Items[ShaderID].Layers[StageID].DepthWrite then
      glDepthMask(true)
    else
      glDepthMask(false);
  end
  else
    glDepthMask(true);
 
  // Blending
  if (Items[ShaderID].Layers[StageID].doBlending)  then begin
    glEnable(GL_BLEND);
    glBlendFunc(Items[shaderId].Layers[stageId].SrcBlend, Items[shaderId].Layers[stageId].DestBlend);
  end
  else
    glDisable(GL_BLEND);
 
  if Shader.Layers[StageID].TexClamp then begin
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  end
  else begin
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  end;
 
{  if Shader.Layers[StageID].tcGen = tcGen_Environment then begin
    glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
  end
  else begin
    glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);
  end;
}
  except
    ShowMessage('setStage');
  end;
end;
 

_________________
Free Map Editor - Game Requirements - Stucuk.Net
-Stu

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Do Sep 16, 2004 16:29

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Maybe the shader (I guess you mean a Q3-Shader, not something like a pixel- or vertexshader) sets the alpha-value to 0, and that will (even if GL_BLEND is disabled) result in a primitive not drawn, so check for that. Otherwise, I can't think of any other cause for that, but maybe the shader generates some sort of error.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

Stucuk

Betreff des Beitrags:

Verfasst: Do Sep 16, 2004 16:33

DGL Member

Registriert: Mi Jul 21, 2004 22:39
Beiträge: 360
Wohnort: UK, Scotland

I made it disable the alpha, blend, etc b4 it drew the array stuff. and it was still not visible. (Shadermanager.setstate, each bit inside was disabled, except the depth since it screws the world up if its disabled)

_________________
Free Map Editor - Game Requirements - Stucuk.Net
-Stu

Nach oben

Stucuk

Betreff des Beitrags:

Verfasst: Do Sep 16, 2004 17:26

DGL Member

Registriert: Mi Jul 21, 2004 22:39
Beiträge: 360
Wohnort: UK, Scotland

Found the problem, shaders sometimes have surfaceparams.

i.e

Code:

 
    surfaceparm nolightmap // added as test
    surfaceparm trans // added as test
    surfaceparm alphashadow 
 

There is also ones for footsteps(if player stands on a surface with metalsteps for example a sound of a person walking on metal steps is plaed when the player walks). RTCW introdces more surfaceparams, mainly footsteps, i.e woodsteps, or snowsteps. The program uses an integerhash(i still have no clue how it works ans why one would want to use it) which works out the number when u give the surface param. It was giving a value even tho the param was never entered into the hash, which caused the object to not be drawn.

EDIT: Added screenshot

Dateianhänge:

Dateikommentar: ESCAPE2.BSP - RTCW MAP

_0079.jpg [145.19 KiB]
20-mal heruntergeladen

_________________
Free Map Editor - Game Requirements - Stucuk.Net
-Stu

Nach oben

Seite 1 von 1

[ 5 Beiträge ]

Foren-Übersicht » English » English Programming Forum

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.