gl_model.pas

delphi编的不错的贪吃蛇

  corner: vec3_t;
begin
  for i := 0 to 2 do
    if fabs(mins[i]) > fabs(maxs[i]) then
      corner[i] := fabs(mins[i])
    else
      corner[i] := fabs(maxs[i]);

  Result := VectorLength(corner);
end;

{*
=================
Mod_LoadSubmodels
=================
*}

procedure Mod_LoadSubmodels(l: lump_p);
var
  _in: dmodel_p;
  _out: mmodel_p;
  i, j,
    count: integer;
begin
  _in := Pointer(Cardinal(mod_base) + l^.fileofs);
  if (l^.filelen mod sizeof(_in^)) <> 0 then
    ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: funny lump size in %s', loadmodel^.name);
  count := l^.filelen div sizeof(_in^);
  _out := Hunk_Alloc(count * sizeof(_out^));

  loadmodel^.submodels := _out;
  loadmodel^.numsubmodels := count;

  for i := 0 to count - 1 do
  begin
    for j := 0 to 2 do
    begin
      // spread the mins / maxs by a pixel
      _out^.mins[j] := LittleFloat(_in^.mins[j]) - 1;
      _out^.maxs[j] := LittleFloat(_in^.maxs[j]) + 1;
      _out^.origin[j] := LittleFloat(_in^.origin[j]);
    end;
    _out^.radius := RadiusFromBounds(_out^.mins, _out^.maxs);
    _out^.headnode := LittleLong(_in^.headnode);
    _out^.firstface := LittleLong(_in^.firstface);
    _out^.numfaces := LittleLong(_in^.numfaces);
    Inc(_in);
    Inc(_out);
  end;
end;

{*
=================
Mod_LoadEdges
=================
*}

procedure Mod_LoadEdges(l: lump_p);
var
  _in: dedge_p;
  _out: medge_p;
  i,
    count: integer;
begin
  _in := Pointer(Cardinal(mod_base) + l^.fileofs);
  if (l^.filelen mod sizeof(_in^)) <> 0 then
    ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: funny lump size in %s', loadmodel.name);
  count := l^.filelen div sizeof(_in^);
  _out := Hunk_Alloc((count + 1) * sizeof(_out^));

  loadmodel^.edges := Pointer(_out);
  loadmodel^.numedges := count;

  for i := 0 to count - 1 do
  begin
    _out^.v[0] := word(LittleShort(_in^.v[0]));
    _out^.v[1] := word(LittleShort(_in^.v[1]));
    Inc(_in);
    Inc(_out);
  end;
end;

{*
=================
Mod_LoadTexinfo
=================
*}

procedure Mod_LoadTexinfo(l: lump_p);
var
  _in: texinfo_p;
  _out,
    step: mtexinfo_p;
  i, j,
    count: integer;
  name: array[0..MAX_QPATH - 1] of char;
  next: integer;
begin
  _in := Pointer(Cardinal(mod_base) + l^.fileofs);
  if (l^.filelen mod sizeof(_in^)) <> 0 then
    ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: funny lump size in %s', loadmodel.name);
  count := l^.filelen div sizeof(_in^);
  _out := Hunk_Alloc(count * sizeof(_out^));

  loadmodel^.texinfo := _out;
  loadmodel^.numtexinfo := count;

  for i := 0 to count - 1 do
  begin
    for j := 0 to 7 do
      _out^.vecs[0][j] := LittleFloat(_in^.vecs[0][j]);

    _out^.flags := LittleLong(_in.flags);
    next := LittleLong(_in.nexttexinfo);
    if (next > 0) then
      _out.next := Pointer(Cardinal(loadmodel.texinfo) + next * sizeof(mTexInfo_t))
    else
      _out.next := nil;
    Com_sprintf(name, sizeof(name), 'textures/%s.wal', [_in.texture]);

    _out.image := GL_FindImage(name, it_wall);
    if (_out.image = nil) then
    begin
      ri.Con_Printf(PRINT_ALL, 'Couldn''t load %s'#10, name);
      _out.image := r_notexture;
    end;
    Inc(_in);
    Inc(_out);
  end;

  // count animation frames
  for i := 0 to count - 1 do
  begin
    _out := @mTexinfo_arrp(loadmodel.texinfo)^[i];
    _out^.numframes := 1;
    step := _out^.Next;
    while (step <> nil) and (step <> _out) do
    begin
      Inc(_out^.NumFrames);
      step := step^.next;
    end;
  end;
end;

{*
================
CalcSurfaceExtents

Fills in s->texturemins[] and s->extents[]
================
*}

procedure CalcSurfaceExtents(s: msurface_p);
var
  mins,
    maxs: array[0..1] of Single;
  val: Single;
  i, j, e: integer;
  v: mvertex_p;
  tex: mtexinfo_p;
  bmins,
    bmaxs: array[0..1] of integer;
begin
  mins[1] := 999999;
  mins[0] := mins[1];
  maxs[1] := -99999;
  maxs[0] := maxs[1];

  tex := s.texinfo;

  for i := 0 to s.numedges - 1 do
  begin
    e := PIntegerArray(loadmodel.surfedges)^[s.firstedge + i];
    if (e >= 0) then
      v := @loadmodel.vertexes[loadmodel.edges[e].v[0]]
    else
      v := @loadmodel.vertexes[loadmodel.edges[-e].v[1]];

    for j := 0 to 1 do
    begin
      val := v.position[0] * tex.vecs[j][0] +
        v.position[1] * tex.vecs[j][1] +
        v.position[2] * tex.vecs[j][2] +
        tex.vecs[j][3];
      if (val < mins[j]) then
        mins[j] := val;
      if (val > maxs[j]) then
        maxs[j] := val;
    end;
  end;

  for i := 0 to 1 do
  begin
    bmins[i] := Floor(mins[i] / 16);
    bmaxs[i] := Ceil(maxs[i] / 16);

    s.texturemins[i] := bmins[i] * 16;
    s.extents[i] := (bmaxs[i] - bmins[i]) * 16;

//id_soft 	if ( !(tex->flags & TEX_SPECIAL) && s->extents[i] > 512 /* 256 */ )
//id_soft 	ri.Sys_Error (ERR_DROP, "Bad surface extents");
  end;
end;

{*
=================
Mod_LoadFaces
=================
*}
procedure Mod_LoadFaces(l: lump_p);
var
  _in: dface_p;
  _out: msurface_p;
  i, count, surfnum,
  planenum, side,
  ti: integer;
begin
  _in := Pointer(Cardinal(mod_base) + l^.fileofs);
  if (l.filelen mod sizeof(_in^)) <> 0 then
    ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: funny lump size in %s', loadmodel.name);
  count := l.filelen div sizeof(_in^);
  _out := Hunk_Alloc(count * sizeof(_out^));

  loadmodel.surfaces := Pointer(_out);
  loadmodel.numsurfaces := count;

  currentmodel := loadmodel;

  GL_BeginBuildingLightmaps(loadmodel);

  for surfnum := 0 to count - 1 do
  begin
    _out.firstedge := LittleLong(_in.firstedge);
    _out.numedges := LittleShort(_in.numedges);
    _out.flags := 0;
    _out.polys := nil;

    planenum := LittleShort(_in.planenum);
    side := LittleShort(_in.side);
    if (side <> 0) then
      _out.flags := _out.flags or SURF_PLANEBACK;

    _out.plane := Pointer(Cardinal(loadmodel.planes) + planenum * sizeof(cplane_t));

    ti := LittleShort(_in.texinfo);
    if (ti < 0) or (ti >= loadmodel.numtexinfo) then
      ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: bad texinfo number', []);
    _out.texinfo := Pointer(Cardinal(loadmodel.texinfo) + ti * sizeof(mTexinfo_t));

    CalcSurfaceExtents(_out);

  // lighting info

    for i := 0 to MAXLIGHTMAPS - 1 do
      _out.styles[i] := _in.styles[i];
    i := LittleLong(_in.lightofs);
    if (i = -1) then
      _out.samples := nil
    else
      _out.samples := Pointer(Cardinal(loadmodel.lightdata) + i);

  // set the drawing flags

    if (_out.texinfo.flags and SURF_WARP) <> 0 then
    begin
      _out.flags := _out.flags or SURF_DRAWTURB;
      for i := 0 to 1 do
      begin
        _out.extents[i] := 16384;
        _out.texturemins[i] := -8192;
      end;
      GL_SubdivideSurface(_out); // cut up polygon for warps
    end;

    // create lightmaps and polygons
    if ((_out.texinfo.flags and (SURF_SKY or SURF_TRANS33 or SURF_TRANS66 or SURF_WARP)) = 0) then
      GL_CreateSurfaceLightmap(_out);

    if ((_out.texinfo.flags and SURF_WARP) = 0) then
      GL_BuildPolygonFromSurface(_out);
    Inc(_in);
    Inc(_out);
  end;

  GL_EndBuildingLightmaps();
end;

{*
=================
Mod_SetParent
=================
*}

procedure Mod_SetParent(node, parent: mnode_p);
begin
  node.parent := parent;
  if (node.contents <> -1) then
    Exit;
  Mod_SetParent(node.children[0], node);
  Mod_SetParent(node.children[1], node);
end;

{*
=================
Mod_LoadNodes
=================
*}

procedure Mod_LoadNodes(l: lump_p);
var
  i, j,
    count, p: integer;
  _in: dnode_p;
  _out: mnode_p;
begin
  _in := Pointer(Integer(mod_base) + l^.fileofs);
  if (l^.filelen mod SizeOf(_in^)) <> 0 then
    ri.Sys_Error(ERR_DROP, PChar('MOD_LoadBmodel: funny lump size in ' + string(loadmodel^.name)));
  count := Trunc(l^.filelen / sizeof(_in^));
  _out := Hunk_Alloc(count * sizeof(_out^));

  loadmodel^.nodes := _out;
  loadmodel^.numnodes := count;

  for i := 0 to count - 1 do
  begin
    for j := 0 to 2 do
    begin
      _out^.minmaxs[j] := LittleShort(_in^.mins[j]);
      _out^.minmaxs[3 + j] := LittleShort(_in^.maxs[j]);
    end;

    p := LittleLong(_in^.planenum);
    _out^.plane := @cplane_arrp(loadmodel^.planes)^[p];

    _out^.firstsurface := LittleShort(_in^.firstface);
    _out^.numsurfaces := LittleShort(_in^.numfaces);
    _out^.contents := -1; // differentiate from leafs

    for j := 0 to 1 do
    begin
      p := LittleLong(_in^.children[j]);
      if p >= 0 then
        _out^.children[j] := @mnode_arrp(loadmodel^.nodes)^[p]
      else
        _out^.children[j] := mnode_p(@mleaf_arrp(loadmodel^.leafs)^[-1 - p]); // CAK - Huh?????
    end;
    inc(_in);
    inc(_out);
  end {next i};
  Mod_SetParent(loadmodel^.nodes, nil); // sets nodes and leafs
end;

{*
=================
Mod_LoadLeafs
=================
*}

procedure Mod_LoadLeafs(l: lump_p);
var
  _in: dleaf_p;
  _out: mleaf_p;
  i, j,
    count, p: integer;
//	glpoly_t	*poly;
begin
  _in := Pointer(Cardinal(mod_base) + l^.fileofs);
  if (l.filelen mod sizeof(_in^)) <> 0 then
    ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: funny lump size in %s', loadmodel.name);
  count := l.filelen div sizeof(_in^);
  _out := Hunk_Alloc(count * sizeof(_out^));

  loadmodel.leafs := _out;
  loadmodel.numleafs := count;

  for i := 0 to count - 1 do
  begin
    for j := 0 to 2 do
    begin
      _out^.minmaxs[j] := LittleShort(_in^.mins[j]);
      _out^.minmaxs[3 + j] := LittleShort(_in^.maxs[j]);
    end;

    _out^.contents := LittleLong(_in^.contents);
    _out^.cluster := LittleShort(_in^.cluster);
    _out^.area := LittleShort(_in^.area);

    _out^.firstmarksurface := Pointer(Integer(loadmodel^.marksurfaces) + (LittleShort(_in^.firstleafface) * Sizeof(msurface_p)));
    _out^.nummarksurfaces := LittleShort(_in^.numleaffaces);
    inc(_in);
    inc(_out);
(*
          // gl underwater warp
          if (out->contents & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_THINWATER) )
          {
                  for (j=0 ; j<out->nummarksurfaces ; j++)
                  {
                          out->firstmarksurface[j]->flags |= SURF_UNDERWATER;
                          for (poly = out->firstmarksurface[j]->polys ; poly ; poly=poly->next)
                                  poly->flags |= SURF_UNDERWATER;
                  }
          }
*)
  end;
end;

{*
=================
Mod_LoadMarksurfaces
=================
*}

procedure Mod_LoadMarksurfaces(l: lump_p);
var
  i, j, count: integer;
  in_: PSmallInt;
  out_: msurface_pp;
begin
  in_ := Pointer(Cardinal(mod_base) + l^.fileofs);
  if (l.filelen mod sizeof(in_^)) <> 0 then
    ri.Sys_Error(ERR_DROP, 'MOD_LoadBmodel: funny lump size in %s', loadmodel.name);
  count := l.filelen div sizeof(in_^);
  out_ := Hunk_Alloc(count * sizeof(out_^));

  loadmodel.marksurfaces := out_;
  loadmodel.nummarksurfaces := count;

  for i := 0 to count - 1 do
  begin
    j := LittleShort(in_^);
    if j >= loadmodel^.numsurfaces then
      ri.Sys_Error(ERR_DROP, 'Mod_ParseMarksurfaces: bad surface number');
    out_^ := @(msurface_arrp(loadmodel^.surfaces)^[j]);
    inc(Integer(in_), SizeOf(in_^));
    inc(Integer(out_), SizeOf(out_^));
  end;
end;

{*
=================
Mod_LoadSurfedges
=================
*}

procedure Mod_LoadSurfedges(l: lump_p);
var
  i, count: integer;