gl_rmain.pas

delphi编的不错的贪吃蛇

  if (r_speeds.value <> 0) then
  begin
    c_brush_polys := 0;
    c_alias_polys := 0;
  end;

  R_PushDlights();

  if (gl_finish.value <> 0) then
    qglFinish();

  R_SetupFrame();

  R_SetFrustum();

  R_SetupGL();

  R_MarkLeaves(); // done here so we know if we're in water

  R_DrawWorld();

  R_DrawEntitiesOnList();

  R_RenderDlights();

  R_DrawParticles();

  R_DrawAlphaSurfaces();

  R_Flash();

  if (r_speeds.value <> 0) then
    ri.Con_Printf(PRINT_ALL, '%4i wpoly %4i epoly %i tex %i lmaps'#10,
      c_brush_polys,
      c_alias_polys,
      c_visible_textures,
      c_visible_lightmaps);
end;


procedure R_SetGL2D;
begin
  // set 2D virtual screen size
  qglViewport(0, 0, vid.width, vid.height);
  qglMatrixMode(GL_PROJECTION);
  qglLoadIdentity();
  qglOrtho(0, vid.width, vid.height, 0, -99999, 99999);
  qglMatrixMode(GL_MODELVIEW);
  qglLoadIdentity();
  qglDisable(GL_DEPTH_TEST);
  qglDisable(GL_CULL_FACE);
  qglDisable(GL_BLEND);
  qglEnable(GL_ALPHA_TEST);
  qglColor4f(1, 1, 1, 1);
end;

procedure GL_DrawColoredStereoLinePair(r, g, b, y: Single);
begin
  qglColor3f(r, g, b);
  qglVertex2f(0, y);
  qglVertex2f(vid.width, y);
  qglColor3f(0, 0, 0);
  qglVertex2f(0, y + 1);
  qglVertex2f(vid.width, y + 1);
end;

procedure GL_DrawStereoPattern;
var
  i: Integer;
begin
  if (gl_config.renderer and GL_RENDERER_INTERGRAPH) = 0 then
    exit;

  if (not gl_state.stereo_enabled) then
    exit;

  R_SetGL2D();

  qglDrawBuffer(GL_BACK_LEFT);

  for i := 0 to 19 do
  begin
    qglBegin(GL_LINES);
    GL_DrawColoredStereoLinePair(1, 0, 0, 0);
    GL_DrawColoredStereoLinePair(1, 0, 0, 2);
    GL_DrawColoredStereoLinePair(1, 0, 0, 4);
    GL_DrawColoredStereoLinePair(1, 0, 0, 6);
    GL_DrawColoredStereoLinePair(0, 1, 0, 8);
    GL_DrawColoredStereoLinePair(1, 1, 0, 10);
    GL_DrawColoredStereoLinePair(1, 1, 0, 12);
    GL_DrawColoredStereoLinePair(0, 1, 0, 14);
    qglEnd();

    GLimp_EndFrame();
  end;
end;

{*
====================
R_SetLightLevel

====================
*}

procedure R_SetLightLevel;
var
  shadelight: vec3_t;
begin
  if (r_newrefdef.rdflags and RDF_NOWORLDMODEL) <> 0 then
    Exit;

  // save off light value for server to look at (BIG HACK!)

  R_LightPoint(vec3_t(r_newrefdef.vieworg), shadelight);

  // pick the greatest component, which should be the same
  // as the mono value returned by software
  if (shadelight[0] > shadelight[1]) then
  begin
    if (shadelight[0] > shadelight[2]) then
      r_lightlevel.value := 150 * shadelight[0]
    else
      r_lightlevel.value := 150 * shadelight[2]
  end
  else
  begin
    if (shadelight[1] > shadelight[2]) then
      r_lightlevel.value := 150 * shadelight[1]
    else
      r_lightlevel.value := 150 * shadelight[2];
  end;
end; //procedure

{*
@@@@@@@@@@@@@@@@@@@@@
R_RenderFrame

@@@@@@@@@@@@@@@@@@@@@
*}

procedure R_RenderFrame(fd: refdef_p); cdecl;
begin
  R_RenderView(fd);
  R_SetLightLevel();
  R_SetGL2D();
end; //procedure

procedure R_Register;
begin
  r_lefthand := ri.Cvar_Get('hand', '0', CVAR_USERINFO or CVAR_ARCHIVE);
  r_norefresh := ri.Cvar_Get('r_norefresh', '0', 0);
  r_fullbright := ri.Cvar_Get('r_fullbright', '0', 0);
  r_drawentities := ri.Cvar_Get('r_drawentities', '1', 0);
  r_drawworld_ := ri.Cvar_Get('r_drawworld', '1', 0);
  r_novis := ri.Cvar_Get('r_novis', '0', 0);
  r_nocull := ri.Cvar_Get('r_nocull', '0', 0);
  r_lerpmodels := ri.Cvar_Get('r_lerpmodels', '1', 0);
  r_speeds := ri.Cvar_Get('r_speeds', '0', 0);

  r_lightlevel := ri.Cvar_Get('r_lightlevel', '0', 0);

  gl_nosubimage := ri.Cvar_Get('gl_nosubimage', '0', 0);
  gl_allow_software := ri.Cvar_Get('gl_allow_software', '0', 0);

  gl_particle_min_size := ri.Cvar_Get('gl_particle_min_size', '2', CVAR_ARCHIVE);
  gl_particle_max_size := ri.Cvar_Get('gl_particle_max_size', '40', CVAR_ARCHIVE);
  gl_particle_size := ri.Cvar_Get('gl_particle_size', '40', CVAR_ARCHIVE);
  gl_particle_att_a := ri.Cvar_Get('gl_particle_att_a', '0.01', CVAR_ARCHIVE);
  gl_particle_att_b := ri.Cvar_Get('gl_particle_att_b', '0.0', CVAR_ARCHIVE);
  gl_particle_att_c := ri.Cvar_Get('gl_particle_att_c', '0.01', CVAR_ARCHIVE);

  gl_modulate_ := ri.Cvar_Get('gl_modulate', '1', CVAR_ARCHIVE);
  gl_log := ri.Cvar_Get('gl_log', '0', 0);
  gl_bitdepth := ri.Cvar_Get('gl_bitdepth', '0', 0);
  gl_mode := ri.Cvar_Get('gl_mode', '3', CVAR_ARCHIVE);
  gl_lightmap := ri.Cvar_Get('gl_lightmap', '0', 0);
  gl_shadows := ri.Cvar_Get('gl_shadows', '0', CVAR_ARCHIVE);
  gl_dynamic := ri.Cvar_Get('gl_dynamic', '1', 0);
  gl_nobind := ri.Cvar_Get('gl_nobind', '0', 0);
  gl_round_down := ri.Cvar_Get('gl_round_down', '1', 0);
  gl_picmip := ri.Cvar_Get('gl_picmip', '0', 0);
  gl_skymip := ri.Cvar_Get('gl_skymip', '0', 0);
  gl_showtris := ri.Cvar_Get('gl_showtris', '0', 0);
  gl_ztrick := ri.Cvar_Get('gl_ztrick', '0', 0);
  gl_finish := ri.Cvar_Get('gl_finish', '0', CVAR_ARCHIVE);
  gl_clear_ := ri.Cvar_Get('gl_clear', '0', 0);
  gl_cull := ri.Cvar_Get('gl_cull', '1', 0);
  gl_polyblend := ri.Cvar_Get('gl_polyblend', '1', 0);
  gl_flashblend := ri.Cvar_Get('gl_flashblend', '0', 0);
  gl_playermip := ri.Cvar_Get('gl_playermip', '0', 0);
  gl_monolightmap := ri.Cvar_Get('gl_monolightmap', '0', 0);
  gl_driver := ri.Cvar_Get('gl_driver', 'opengl32', CVAR_ARCHIVE);
  gl_texturemode_ := ri.Cvar_Get('gl_texturemode', 'GL_LINEAR_MIPMAP_NEAREST', CVAR_ARCHIVE);
  gl_texturealphamode_ := ri.Cvar_Get('gl_texturealphamode', 'default', CVAR_ARCHIVE);
  gl_texturesolidmode_ := ri.Cvar_Get('gl_texturesolidmode', 'default', CVAR_ARCHIVE);
  gl_lockpvs := ri.Cvar_Get('gl_lockpvs', '0', 0);

  gl_vertex_arrays := ri.Cvar_Get('gl_vertex_arrays', '0', CVAR_ARCHIVE);

  gl_ext_swapinterval := ri.Cvar_Get('gl_ext_swapinterval', '1', CVAR_ARCHIVE);
  gl_ext_palettedtexture := ri.Cvar_Get('gl_ext_palettedtexture', '1', CVAR_ARCHIVE);
  gl_ext_multitexture := ri.Cvar_Get('gl_ext_multitexture', '1', CVAR_ARCHIVE);
  gl_ext_pointparameters := ri.Cvar_Get('gl_ext_pointparameters', '1', CVAR_ARCHIVE);
  gl_ext_compiled_vertex_array := ri.Cvar_Get('gl_ext_compiled_vertex_array', '1', CVAR_ARCHIVE);

  gl_drawbuffer := ri.Cvar_Get('gl_drawbuffer', 'GL_BACK', 0);
  gl_swapinterval := ri.Cvar_Get('gl_swapinterval', '1', CVAR_ARCHIVE);

  gl_saturatelighting := ri.Cvar_Get('gl_saturatelighting', '0', 0);

  gl_3dlabs_broken := ri.Cvar_Get('gl_3dlabs_broken', '1', CVAR_ARCHIVE);

  vid_fullscreen := ri.Cvar_Get('vid_fullscreen', '0', CVAR_ARCHIVE);
  vid_gamma := ri.Cvar_Get('vid_gamma', '1.0', CVAR_ARCHIVE);
  vid_ref := ri.Cvar_Get('vid_ref', 'soft', CVAR_ARCHIVE);

  ri.Cmd_AddCommand('imagelist', GL_ImageList_f);
  ri.Cmd_AddCommand('screenshot', GL_ScreenShot_f);
  ri.Cmd_AddCommand('modellist', Mod_Modellist_f);
  ri.Cmd_AddCommand('gl_strings', GL_Strings_f);
end; //procedure

{*
==================
R_SetMode
==================
*}

function R_SetMode: qboolean;
var
  err: rserr_t;
  fullscreen: qboolean;
begin
  if (vid_fullscreen.modified) and (not gl_config.allow_cds) then
  begin
    ri.Con_Printf(PRINT_ALL, 'R_SetMode() - CDS not allowed with this driver'#10, []);
    ri.Cvar_SetValue('vid_fullscreen', Integer(not Boolean(Trunc(vid_fullscreen.value))));
    vid_fullscreen.modified := false;
  end;

  fullscreen := (vid_fullscreen.value <> 0);

  vid_fullscreen.modified := false;
  gl_mode.modified := false;

  err := GLimp_SetMode(vid.width, vid.height, Trunc(gl_mode.value), fullscreen);
  if (err = rserr_ok) then
    gl_state.prev_mode := Trunc(gl_mode.value)
  else
  begin
    if (err = rserr_invalid_fullscreen) then
    begin
      ri.Cvar_SetValue('vid_fullscreen', 0);
      vid_fullscreen.modified := false;
      ri.Con_Printf(PRINT_ALL, 'ref_gl::R_SetMode() - fullscreen unavailable in this mode'#10, []);
      err := GLimp_SetMode(vid.width, vid.height, Trunc(gl_mode.value), false); 
      if (err = rserr_ok) then
      begin
        Result := true;
        Exit;
      end;
    end
    else
      if (err = rserr_invalid_mode) then
      begin
        ri.Cvar_SetValue('gl_mode', gl_state.prev_mode);
        gl_mode.modified := false;
        ri.Con_Printf(PRINT_ALL, 'ref_gl::R_SetMode() - invalid mode'#10, []);
      end;

    // try setting it back to something safe
    err := GLimp_SetMode(vid.width, vid.height, gl_state.prev_mode, false);
    if (err <> rserr_ok) then
    begin
      ri.Con_Printf(PRINT_ALL, 'ref_gl::R_SetMode() - could not revert to safe mode'#10, []);
      Result := false;
      Exit;
    end;
  end;
  Result := true;
end;

{*
===============
R_Init
===============
*}
function R_Init(hinstance: HINST; hWnd: pointer): integer; cdecl;
var
  renderer_buffer,
  vendor_buffer: array[0..1000 - 1] of Char;

  err: integer;
  j: integer;
begin
  for j := 0 to 255 do
    r_turbsin[j] := r_turbsin[j] * 0.5;

  ri.Con_Printf(PRINT_ALL, 'ref_gl version: ' + REF_VERSION + #10, []);

  Draw_GetPalette();

  R_Register();

  // initialize our QGL dynamic bindings
  if not QGL_Init(gl_driver.string_) then
  begin
    QGL_Shutdown();
    ri.Con_Printf(PRINT_ALL, 'ref_gl::R_Init() - could not load "%s"'#10, gl_driver.string_);
    Result := -1;
    Exit;
  end;

  // initialize OS-specific parts of OpenGL
  if not GLimp_Init(hinstance, hWnd) then
  begin
    QGL_Shutdown();
    Result := -1;
    Exit;
  end;

  // set our "safe" modes
  gl_state.prev_mode := 3;

  // create the window and set up the context
  if not R_SetMode() then
  begin
    QGL_Shutdown();
    ri.Con_Printf(PRINT_ALL, 'ref_gl::R_Init() - could not R_SetMode()'#10, []);
    Result := -1;
    Exit;
  end;

  ri.Vid_MenuInit();

  {*
  ** get our various GL strings
  *}
  gl_config.vendor_string := PChar(qglGetString(GL_VENDOR));
  ri.Con_Printf(PRINT_ALL, 'GL_VENDOR: %s'#10, gl_config.vendor_string);
  gl_config.renderer_string := PChar(qglGetString(GL_RENDERER));
  ri.Con_Printf(PRINT_ALL, 'GL_RENDERER: %s'#10, gl_config.renderer_string);
  gl_config.version_string := PChar(qglGetString(GL_VERSION));
  ri.Con_Printf(PRINT_ALL, 'GL_VERSION: %s'#10, gl_config.version_string);
  gl_config.extensions_string := PChar(qglGetString(GL_EXTENSIONS));
  ri.Con_Printf(PRINT_ALL, 'GL_EXTENSIONS: %s'#10, gl_config.extensions_string);

  CPas.strcpy(renderer_buffer, gl_config.renderer_string);
//  strlwr( renderer_buffer );

  CPas.strcpy(vendor_buffer, gl_config.vendor_string);
//  strlwr( vendor_buffer );

  if (CPas.strstr(renderer_buffer, 'voodoo') <> nil) then
  begin
//    if (!strstr (renderer_buffer, 'rush'))
    if (CPas.strstr(renderer_buffer, 'rush') = nil) then
      gl_config.renderer := GL_RENDERER_VOODOO
    else
      gl_config.renderer := GL_RENDERER_VOODOO_RUSH;
  end
  else
  begin
    if (CPas.strstr(vendor_buffer, 'sgi') <> nil) then
      gl_config.renderer := GL_RENDERER_SGI
    else
      if (CPas.strstr(renderer_buffer, 'permedia') <> nil) then
        gl_config.renderer := GL_RENDERER_PERMEDIA2
      else
        if (CPas.strstr(renderer_buffer, 'glint') <> nil) then
          gl_config.renderer := GL_RENDERER_GLINT_MX
        else
          if (CPas.strstr(renderer_buffer, 'glzicd') <> nil) then
            gl_config.renderer := GL_RENDERER_REALIZM
          else
            if (CPas.strstr(renderer_buffer, 'gdi') <> nil) then
              gl_config.renderer := GL_RENDERER_MCD
            else
              if (CPas.strstr(renderer_buffer, 'pcx2') <> nil) then
                gl_config.renderer := GL_RENDERER_PCX2
              else
                if (CPas.strstr(renderer_buffer, 'verite') <> nil) then
                  gl_config.renderer := GL_RENDERER_RENDITION
                else
                  gl_config.renderer := GL_RENDERER_OTHER;
  end; //else

//  if ( toupper( gl_monolightmap.string[1] ) != 'F' )
  if (UpCase(gl_monolightmap.string_[1]) <> 'F') then
  begin
    if (gl_config.renderer = GL_RENDERER_PERMEDIA2) then
    begin
      ri.Cvar_Set('gl_monolightmap', 'A');
      ri.Con_Printf(PRINT_ALL, '...using gl_monolightmap ''a'''#10, []);
    end
    else
      if (gl_config.renderer and GL_RENDERER_POWERVR) <> 0 then
        ri.Cvar_Set('gl_monolightmap', '0')
      else
        ri.Cvar_Set('gl_monolightmap', '0');
  end;

  // power vr can't have anything stay in the framebuffer, so
  // the screen needs to redraw the tiled background every frame
  if (gl_config.renderer and GL_RENDERER_POWERVR) <> 0 then
    ri.Cvar_Set('scr_drawall', '1')
  else
    ri.Cvar_Set('scr_drawall', '0');

  // MCD has buffering issues
  if (gl_config.renderer = GL_RENDERER_MCD) then
    ri.Cvar_SetValue('gl_finish', 1);

  if (gl_config.renderer and GL_RENDERER_3DLABS) <> 0 then
  begin
    if (gl_3dlabs_broken.value <> 0) then
      gl_config.allow_cds := false
    else
      gl_config.allow_cds := true;
  end
  else
    gl_config.allow_cds := true;

  if (gl_config.allow_cds) then
    ri.Con_Printf(PRINT_ALL, '...allowing CDS'#10, [])
  else
    ri.Con_Printf(PRINT_ALL, '...disabling CDS'#10, []);

  {*
   ** grab extensions
   *}
  if (CPas.strstr(gl_config.extensions_string, 'GL_EXT_compiled_vertex_array') <> nil) or
    (CPas.strstr(gl_config.extensions_string, 'GL_SGI_compiled_vertex_array') <> nil) then
  begin
    ri.Con_Printf(PRINT_ALL, '...enabling GL_EXT_compiled_vertex_array'#10, []);
    qglLockArraysEXT := qwglGetProcAddress('glLockArraysEXT');
    qglUnlockArraysEXT := qwglGetProcAddress('glUnlockArraysEXT');
  end
  else
    ri.Con_Printf(PRINT_ALL, '...GL_EXT_compiled_vertex_array not found'#10, []);