procedure InitializeRC;
const
  lightAmbient:array[0..3] of GLfloat=(1,1,1,1);
  lightDiffuse:array[0..3] of GLfloat=(1,1,1,1);
  lightSpecular:array[0..3] of GLfloat=(0,0,0,1);
  lightPosition:array[0..3] of GLfloat=(1000,10000,1000,0);
const
  FirstRC:boolean=True;
begin
  if not FirstRC then Exit;
  FirstRC:=False;
  glFrontFace(GL_CCW);
  glCullFace(GL_FRONT);
  glEnable(GL_CULL_FACE);
  glDepthFunc(GL_LEQUAL);
  glEnable(GL_DEPTH_TEST);
  glShadeModel(GL_FLAT);
  glClearColor(0,0,0,0);
  glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_FASTEST);
  glHint(GL_POLYGON_SMOOTH_HINT,GL_FASTEST);
  glDisable(GL_DITHER);
  glEnable(GL_LIGHTING);
  glLightfv(GL_LIGHT0,GL_AMBIENT,@lightAmbient);
  glLightfv(GL_LIGHT0,GL_DIFFUSE,@lightDiffuse);
  glLightfv(GL_LIGHT0,GL_SPECULAR,@lightSpecular);
  glLightfv(GL_LIGHT0,GL_POSITION,@lightPosition);
  glEnable(GL_LIGHT0);
  if AlphaBlending then
  begin
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  end;
{  glEnable(GL_FOG);
  glFog(GL_FOG_MODE,GL_LINEAR);
  glFog(GL_FOG_DENSITY,20);
  glFog(GL_FOG_START,10);
  glFog(GL_FOG_END,DrawingDistantion*2);
  glFogiv(GL_FOG_COLOR,@(white[0]));}
end;

procedure DrawObject(var AModel:GLint);
var
  i,j,k:GLint;
  LTex:integer;
begin
  LTex:=0;
  DistanceRequestFromObject:=True;
  if (ClippingAlgorithm=1) and (CalcDistance(0,0,0)>DrawingDistantion) then Exit;
  if Models[AModel].ListNumber<>ListNotBinded then
  begin
    glCallList(Models[AModel].ListNumber);
    Exit;
  end;
  Models[AModel].ListNumber:=glGenLists(1);
  glNewList(Models[AModel].ListNumber,GL_COMPILE);
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D,Models[AModel].Textures[LTex].TexNum);
  glBegin(GL_TRIANGLES);
  glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,@white);

  for i:=0 to Models[AModel].CSplines-1 do
  begin
    if Models[AModel].Splines[i].TextureNumber<>LTex then
    begin
      LTex:=Models[AModel].Splines[i].TextureNumber;
      glEnd;
      glBindTexture(GL_TEXTURE_2D,0);
      glBindTexture(GL_TEXTURE_2D,Models[AModel].Textures[LTex].TexNum);
      glBegin(GL_TRIANGLES);
      glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,@white);
    end;
    k:=Models[AModel].Splines[i].Aliases[0];
    glNormal3f(Models[AModel].Points[k].Nx,Models[AModel].Points[k].Ny,Models[AModel].Points[k].Nz);
    for j:=Models[AModel].Splines[i].PointsCount-1 downto 0 do
    begin
      k:=Models[AModel].Splines[i].Aliases[j];
      glTexCoord2f(Models[AModel].Points[k].TexX,Models[AModel].Points[k].TexY);
      glVertex3f(Models[AModel].Points[k].x,Models[AModel].Points[k].y,Models[AModel].Points[k].z);
    end;
  end;
  glEnd;
  glBindTexture(GL_TEXTURE_2D,0);
  glDisable(GL_TEXTURE_2D);
  glEndList;
end;

procedure DrawModelAtPoints(a,b:TRailPoint;AModel:GLint;aOrientation:TTrainOrientation);
var
  xe,ye,ze,xf,yf,zf:GLfloat;
begin
  CalcCoords(a);
  xe:=xmp;
  ye:=ymp;
  ze:=zmp;
  DistanceRequestFromObject:=False;
  if (ClippingAlgorithm=1) and (CalcDistance(xe,ye,ze)>(2*DrawingDistantion)) then Exit;
  CalcCoords(b);
  xf:=xmp;
  yf:=ymp;
  zf:=zmp;
  xmp:=(xe+xf)/2;
  ymp:=(ye+yf)/2;
  zmp:=(ze+zf)/2;
  glPushMatrix;
  glTranslatef(xmp,ymp,zmp);
  if ((xe-xmp)>=0) and ((ze-zmp)>=0) then
    glRotatef(arcsin((xe-xmp)/Sqrt(Sqr(xmp-xe)+Sqr(zmp-ze)))*180/PiConst,0,1,0)
  else if ((xe-xmp)>=0) and ((ze-zmp)<0) then
    glRotatef(-arcsin((xe-xmp)/Sqrt(Sqr(xmp-xe)+Sqr(zmp-ze)))*180/PiConst,0,1,0)
  else if ((xe-xmp)<0) and ((ze-zmp)>=0) then
    glRotatef(arcsin((xe-xmp)/Sqrt(Sqr(xmp-xe)+Sqr(zmp-ze)))*180/PiConst,0,1,0)
  else
    glRotatef(-arcsin((xe-xmp)/Sqrt(Sqr(xmp-xe)+Sqr(zmp-ze)))*180/PiConst,0,1,0);
  if aOrientation=toReverse then
    glRotatef(180,0,1,0);
  CalcRequestX:=xmp;
  CalcRequestY:=ymp;
  CalcRequestZ:=zmp;
  DrawObject(AModel);
  glPopMatrix;
end;

procedure DrawHouse(AHouse:THouse);
begin
  DistanceRequestFromObject:=False;
  if (ClippingAlgorithm=1) and (CalcDistance(AHouse.x,AHouse.y,AHouse.z)>(2*DrawingDistantion)) then Exit;
  glPushMatrix;
  glTranslatef(AHouse.x,AHouse.y,AHouse.z);
  glRotatef(AHouse.Angle,0,1,0);
  CalcRequestX:=AHouse.x;
  CalcRequestY:=AHouse.y;
  CalcRequestZ:=AHouse.z;
  DrawObject(AHouse.Model);
  glPopMatrix;
end;

procedure DrawTree(ATree:TTree);
begin
  DistanceRequestFromObject:=False;
//  if (ClippingAlgorithm=1) and (CalcDistance(ATree.x,ATree.y,ATree.z)>(2*DrawingDistantion)) then Exit;
  glPushMatrix;
  glTranslatef(ATree.x,ATree.y,ATree.z);
  CalcRequestX:=ATree.x;
  CalcRequestY:=ATree.y;
  CalcRequestZ:=ATree.z;
  DrawObject(ATree.Model);
  glPopMatrix;
end;

procedure DrawTrees;
var
  VisibleTrees:array of record
    TreeIndex:GLint;
    Distance:GLint;
  end;
  i:integer;
  a,b:GLint;

procedure QuickSort(iLo, iHi: Integer);
var
  Lo, Hi, Mid: Integer;
begin
  Lo := iLo;
  Hi := iHi;
  Mid := VisibleTrees[(Lo + Hi) div 2].Distance;
  repeat
    while VisibleTrees[Lo].Distance < Mid do Inc(Lo);
    while VisibleTrees[Hi].Distance > Mid do Dec(Hi);
    if Lo <= Hi then
    begin
      b:=VisibleTrees[Lo].TreeIndex;
      a:=VisibleTrees[Lo].Distance;
      VisibleTrees[Lo].TreeIndex:=VisibleTrees[Hi].TreeIndex;
      VisibleTrees[Lo].Distance:=VisibleTrees[Hi].Distance;
      VisibleTrees[Hi].TreeIndex:=b;
      VisibleTrees[Hi].Distance:=a;
      Inc(Lo);
      Dec(Hi);
    end;
  until Lo > Hi;
  if Hi > iLo then QuickSort(iLo, Hi);
  if Lo < iHi then QuickSort(Lo, iHi);
end;

begin
  DistanceRequestFromObject:=False;
  SetLength(VisibleTrees,0);
  for i:=0 to MaxTrees do
  begin
    a:=Round(CalcDistance(Trees[i].x,Trees[i].y,Trees[i].z));
    if (ClippingAlgorithm=1) and (a<=(2*DrawingDistantion)) then
    begin
      SetLength(VisibleTrees,Length(VisibleTrees)+1);
      VisibleTrees[High(VisibleTrees)].Distance:=a;
      VisibleTrees[High(VisibleTrees)].TreeIndex:=i;
    end;
  end;

  if Length(VisibleTrees)=0 then
  begin
    SetLength(VisibleTrees,0);
    Exit;
  end;

  QuickSort(Low(VisibleTrees),High(VisibleTrees));

  for i:=High(VisibleTrees) downto Low(VisibleTrees) do
    DrawTree(Trees[VisibleTrees[i].TreeIndex]);

  SetLength(VisibleTrees,0);
end;

function LoadTexture(var ATexture:PGLTexture;FileName:string;aType:TTextureType):boolean;
var
  f:file;
  i,j,k,l:GLint;
  BufferRGB:PRGBTexture;
  BufferRGBA:PRGBATexture;
  tsz,tml,tov,txs,tys:GLint;
  ra,ga,ba,aa:GLfloat;
  TGAHeader:record
    Data:array[0..11] of byte;
    Width,Height:word;
    Size:byte;
  end;
  ColorDepth:integer;
  s:string;
  LocalTexSize:GLint;
  a:GLuint;
  b:cardinal;
begin
  OutDbgMsg('----> LoadTexture: Loading '+FileName);
  if aType=tiTrain then
    LocalTexSize:=TrainTextureSize
  else if aType=tiScreen then
    LocalTexSize:=ScreensRes
  else
    LocalTexSize:=TextureSize;
  BufferRGB:=nil;
  BufferRGBA:=nil;
  LoadTexture:=False;
  GetMem(ATexture,SizeOf(TRGBAQuad)*LocalTexSize*LocalTexSize+SizeOf(GLuint)+SizeOf(cardinal));
  ATexture^.AllocatedSize:=SizeOf(TRGBAQuad)*LocalTexSize*LocalTexSize+SizeOf(GLuint)+SizeOf(cardinal);
  MemoryAllocated:=MemoryAllocated+SizeOf(TRGBAQuad)*LocalTexSize*LocalTexSize+SizeOf(GLuint)+SizeOf(cardinal);
  if ATexture=nil then
  begin
    s:='Нехватка памяти при размещении блока размером '+IntToStr(SizeOf(TGLTexture) div 1024)+' Кб.';
    MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
    Halt(0);
  end;
  try
    AssignFile(f,FileName);
    Reset(f,1);
    FillChar(TGAHeader,SizeOf(TGAHeader),0);
    BlockRead(f,TGAHeader,SizeOf(TGAHeader));
    if TGAHeader.Size=$20 then
      ColorDepth:=32
    else
      ColorDepth:=24;
    Seek(f,$12);
    if ColorDepth=24 then
    begin
      New(BufferRGB);
      MemoryAllocated:=MemoryAllocated+SizeOf(TRGBTexture);
      if BufferRGB=nil then
      begin
        s:='Нехватка памяти при размещении блока размером '+IntToStr(SizeOf(TRGBTexture) div 1024)+' Кб.';
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
        Halt(0);
      end;
      BlockRead(f,BufferRGB^,512*512*(ColorDepth div 8));
    end else
    begin
      New(BufferRGBA);
      MemoryAllocated:=MemoryAllocated+SizeOf(TRGBATexture);
      if BufferRGBA=nil then
      begin
        s:='Нехватка памяти при размещении блока размером '+IntToStr(SizeOf(TRGBATexture) div 1024)+' Кб.';
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
        Halt(0);
      end;
      BlockRead(f,BufferRGBA^,512*512*(ColorDepth div 8));
    end;
    CloseFile(f);
  except
    on E:EInOutError do
    begin
      s:='Файл '+FileName+' не найден или имеет неверный формат.';
      MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
      Exit;
    end;
  end;
  tsz:=LocalTexSize-1;
  tml:=512 div LocalTexSize;
  for i:=0 to tsz do
    for j:=0 to tsz do
    begin
      tov:=i*(tsz+1)+(tsz-j);
      txs:=tml*i;
      tys:=tml*j;
      ra:=0;
      ga:=0;
      ba:=0;
      aa:=0;
      for k:=0 to tml-1 do
        for l:=0 to tml-1 do
        begin
          if ColorDepth=24 then
          begin
            ra:=ra+BufferRGB^[(txs+k),511-(tys+l)].rgbtRed;
            ga:=ga+BufferRGB^[(txs+k),511-(tys+l)].rgbtGreen;
            ba:=ba+BufferRGB^[(txs+k),511-(tys+l)].rgbtBlue;
            aa:=aa+256;
          end else
          begin
            ra:=ra+BufferRGBA^[(txs+k),511-(tys+l)].rgbRed;
            ga:=ga+BufferRGBA^[(txs+k),511-(tys+l)].rgbGreen;
            ba:=ba+BufferRGBA^[(txs+k),511-(tys+l)].rgbBlue;
            aa:=aa+BufferRGBA^[(txs+k),511-(tys+l)].rgbReserved;
          end;
        end;
      ATexture^.Data[tov].r:=ra/(256*tml*tml);
      ATexture^.Data[tov].g:=ga/(256*tml*tml);
      ATexture^.Data[tov].b:=ba/(256*tml*tml);
      ATexture^.Data[tov].a:=aa/(256*tml*tml);
    end;
  if ColorDepth=24 then
  begin
    Dispose(BufferRGB);
    MemoryAllocated:=MemoryAllocated-SizeOf(TRGBTexture);
  end else
  begin
    Dispose(BufferRGBA);
    MemoryAllocated:=MemoryAllocated-SizeOf(TRGBATexture);
  end;
  if aType<>tiScreen then
  begin
    glEnable(GL_TEXTURE_2D);
    glGenTextures(1,@a);
    ATexture^.TexNum:=a;
    glBindTexture(GL_TEXTURE_2D,ATexture^.TexNum);
    gluBuild2DMipmaps(GL_TEXTURE_2D,4,LocalTexSize,LocalTexSize,GL_RGBA,GL_FLOAT,@(ATexture^.Data[0]));
    case aType of
      tiGround: begin
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
        if TextureFilter=tfFast then
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST)
        else
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
      end;
      tiRail: begin
        if TextureFilter=tfFast then
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST)
        else
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        if TextureFilter=tfFast then
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST)
        else
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
      end;
      tiLandscape: begin
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
      end;
      tiHouse: begin
        if TextureFilter=tfFast then
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST)
        else
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        if TextureFilter=tfFast then
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST)
        else
          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
      end;
    else
      if TextureFilter=tfFast then
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST)
      else
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    end;
    glBindTexture(GL_TEXTURE_2D,0);
    glDisable(GL_TEXTURE_2D);

    b:=ATexture^.AllocatedSize;
    FreeMem(ATexture,b);
    MemoryAllocated:=MemoryAllocated-SizeOf(TRGBAQuad)*LocalTexSize*LocalTexSize;
    GetMem(ATexture,SizeOf(GLuint)+SizeOf(cardinal));
    ATexture^.AllocatedSize:=SizeOf(GLuint)+SizeOf(cardinal);
    ATexture^.TexNum:=a;
  end else
    ATexture^.TexNum:=TexNotBinded;

  LoadTexture:=True;
  OutDbgMsg('----> LoadTexture: Texture successfully loaded.');
end;

function LoadModel(var ToModel:GLint;FileName:string;aType:TTextureType):boolean;
var
  f:textfile;
  s:string;
  z:GLint;
  a,b,c:GLfloat;
  i,d,e,g,m,h:GLint;
begin
  OutDbgMsg('--> LoadModel: '+FileName);
  LoadModel:=False;
  for i:=0 to MaxModels do
    if Models[i].FileName=FileName then
    begin
      ToModel:=i;
      LoadModel:=True;
      Exit;
    end;
  h:=MaxModels+1;
  SetLength(Models,h+1);
  MaxModels:=h;
  Models[h].FileName:=FileName;
  Models[h].ListNumber:=ListNotBinded;
  ToModel:=h;
  AssignFile(f,FileName);
  try
    Reset(f);
    try
      s:='';
      while Pos('Mesh',s)=0 do Readln(f,s);
      if Eof(f) then
      begin
        s:='Секция {Mesh} не найдена в файле '+FileName;
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
        Exit;
      end;
      if aType=tiTrain then
        Models[h].TextureSize:=TrainTextureSize
      else
        Models[h].TextureSize:=TextureSize;
      Read(f,Models[h].CPoints);
      SetLength(Models[h].Points,Models[h].CPoints);
      for i:=0 to Models[h].CPoints-1 do
      begin
        Read(f,a,b,c);
        Models[h].Points[i].x:=a;
        Models[h].Points[i].y:=b;
        Models[h].Points[i].z:=c;
      end;
      UpdateProgress;
      Read(f,Models[h].CSplines);
      SetLength(Models[h].Splines,Models[h].CSplines);
      for i:=0 to Models[h].CSplines-1 do
      begin
        Read(f,z,d,e,g);
        if z=0 then;
        Models[h].Splines[i].PointsCount:=3;
        Models[h].Splines[i].Aliases[0]:=d;
        Models[h].Splines[i].Aliases[1]:=e;
        Models[h].Splines[i].Aliases[2]:=g;
      end;

      while Pos('MaterialList',s)=0 do Readln(f,s);
      if Eof(f) then
      begin
        s:='Секция {Material} не найдена в файле '+FileName;
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
        Exit;
      end;
      Readln(f,m);
      SetLength(Models[h].Textures,m);
      Readln(f,s);
      for i:=0 to Models[h].CSplines-1 do
      begin
        Readln(f,d);
        Models[h].Splines[i].TextureNumber:=d;
      end;
      UpdateProgress;

      for i:=0 to m-1 do
      begin
        while Pos('Texture',s)=0 do Readln(f,s);
        if Eof(f) then
        begin
          s:='Секция {Texture} не найдена в файле '+FileName;
          MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
          Exit;
        end;
        Readln(f,s);
        s:=Copy(s,2,Length(s)-2);
        s:=ExtractFilePath(FileName)+s;
        if not LoadTexture(Models[h].Textures[i],s,aType) then
          raise EInOutError.Create('Не могу загрузить файл '+FileName+' с текстурой.');
      end;

      while Pos('MeshNormals',s)=0 do Readln(f,s);
      if Eof(f) then
      begin
        s:='Секция {MeshNormals} не найдена в файле '+FileName;
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
        Exit;
      end;
      Read(f,z);
      if z=0 then;
      for i:=0 to Models[h].CPoints-1 do
      begin
        Read(f,a,b,c);
        Models[h].Points[i].Nx:=a;
        Models[h].Points[i].Ny:=b;
        Models[h].Points[i].Nz:=c;
      end;

      while Pos('TextureCoords',s)=0 do Readln(f,s);
      if Eof(f) then
      begin
        s:='Секция {MeshTextureCoords} не найдена в файле '+FileName;
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
        Exit;
      end;
      Read(f,z);
      if z=0 then;
      for i:=0 to Models[h].CPoints-1 do
      begin
        Read(f,a,b);
        Models[h].Points[i].TexX:=-1+a;
        Models[h].Points[i].TexY:=-b;
      end;
      UpdateProgress;
      LoadModel:=True;
      OutDbgMsg('--> LoadModel: Model successfully loaded.');
    except
      on E:EInOutError do
      begin
        s:='Неверный формат файла '+FileName;
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
      end;
    end;
    CloseFile(f);
  except
    on E:EInOutError do
    begin
      s:='Файл '+FileName+' не найден.';
      MessageBox(0,@s[1],'Core3Da: Ошибка',mb_Ok or mb_IconStop);
    end;
  end;
end;

procedure LoadMap(FileName:string);
var
  b:TRail;
  w,h,a,i,l,j:integer;
  f:file;
  c:cardinal;
  Train:TTrainEx;
  Link:TLinkEx;
  House:THouseEx;
  Tree:TTreeEx;
  Light:TLightEx;
  s:string;
begin
  OutDbgMsg('Loading map '+FileName);
  AssignFile(f,FileName);
  try
    Reset(f,1);
    try
      SetLength(Rails,0);
      OutDbgMsg('LoadMap: Reading map version signature.');
      BlockRead(f,c,SizeOf(c));
      if c<>MapSignature then
      begin
        OutDbgMsg('LoadMap: ERROR LOADING MAP!!! UNSUPPORTED VERSION!!!');
        wglMakeCurrent(MainDC,0);
        ReleaseDC(Window,MainDC);
        CloseFile(f);
        MessageBox(0,'Формат не поддерживается. Используйте соответствующую версию '+
          'редактора карт.','Формат MAP файла',mb_Ok or mb_IconStop or mb_TaskModal);
        Halt(0);
      end;
      OutDbgMsg('LoadMap: Reading map size.');
      BlockRead(f,w,SizeOf(w));
      BlockRead(f,h,SizeOf(h));
      MapWidth:=w;
      MapHeight:=h;
      BlockRead(f,a,SizeOf(a));
      SetLength(Rails,a);
      OutDbgMsg('LoadMap: Creating rails.');
      MaxRails:=a-1;
      for i:=0 to a-1 do
      begin
        BlockRead(f,b,SizeOf(b));
        Rails[i]:=b;
        if (Rails[i].Kind=rkStraight) or (Rails[i].Kind=rkLeftPoint) or
          (Rails[i].Kind=rkRightPoint) or (Rails[i].Kind=rkThreePoint) then
        begin
          l:=Round(Rails[i].StraightLength) div sl;
          if (Round(Rails[i].StraightLength) mod sl)>0 then l:=l+1;
          Rails[i].Length:=l*sl;
        end;

        if Rails[i].Kind=rkRadius then
          Rails[i].Length:=Round((Rails[i].Angle*PiConst/180)*Rails[i].Radius);

        if (i mod 50)=0 then
          UpdateProgress;
      end;
      OutDbgMsg('LoadMap: Reading map parameters.');
      BlockRead(f,MapFlagX,SizeOf(MapFlagX));
      BlockRead(f,MapFlagZ,SizeOf(MapFlagZ));
      CameraX:=MapFlagX-400;
      CameraZ:=MapFlagZ-1000;

      OutDbgMsg('LoadMap: Creating trains.');
      BlockRead(f,a,SizeOf(a));
      SetLength(Trains,a);
      MaxTrains:=a-1;
      for i:=0 to a-1 do
      begin
        BlockRead(f,Train,SizeOf(Train));
        FillChar(Trains[i],SizeOf(TTrain),0);
        Trains[i].Rail:=Train.Rail;
        Trains[i].Position:=Train.Position;
        Trains[i].Orientation:=Train.Orientation;
        Trains[i].Direction:=Train.Direction;
        Trains[i].TrainType:=Train.TrainType;
        Trains[i].Length:=Train.Length;
        Trains[i].Name:=Train.Name;
        Trains[i].HiMesh:=Train.HiMesh;
        Trains[i].MidMesh:=Train.MidMesh;
        Trains[i].LoMesh:=Train.LoMesh;
        case TrainsDetalizationLevel of
          0: LoadModel(Trains[i].Train,DataPath+'\Machines\'+Train.LoMesh,tiTrain);
          1: LoadModel(Trains[i].Train,DataPath+'\Machines\'+Train.MidMesh,tiTrain);
          2: LoadModel(Trains[i].Train,DataPath+'\Machines\'+Train.HiMesh,tiTrain);
        else
          s:='Неверный формат файла карты '+FileName;
          MessageBox(0,@s[1],'Core3Da: Ошибка',mb_IconStop or mb_Ok);
          Halt(0);
        end;
      end;
      OutDbgMsg('LoadMap: Creating links.');
      BlockRead(f,a,SizeOf(a));
      SetLength(Links,a);
      for i:=0 to a-1 do
      begin
        BlockRead(f,Link,SizeOf(Link));
        FillChar(Links[i],SizeOf(TLink),0);
        Links[i].Head:=Link.Head;
        Links[i].Speed:=Link.Speed;
        SetLength(Links[i].Trains,Link.TrainsCount);
        for j:=0 to Link.TrainsCount-1 do
        begin
          BlockRead(f,w,SizeOf(w));
          Links[i].Trains[j]:=w;
        end;
        UpdateProgress;
      end;

      OutDbgMsg('LoadMap: Creating houses.');
      BlockRead(f,a,SizeOf(a));
      SetLength(Houses,a);
      MaxHouses:=a-1;
      for i:=0 to a-1 do
      begin
        BlockRead(f,House,SizeOf(House));
        FillChar(Houses[i],SizeOf(THouse),0);
        Houses[i].x:=House.x;
        Houses[i].y:=House.y;
        Houses[i].z:=House.z;
        Houses[i].Angle:=House.Angle;
        Houses[i].HouseType:=House.HouseType;
        Houses[i].HouseName:=House.HouseName;
        case DetalizationLevel of
          0,1: LoadModel(Houses[i].Model,DataPath+'\Houses\'+House.HouseName+'_min.x',tiHouse);
          2: LoadModel(Houses[i].Model,DataPath+'\Houses\'+House.HouseName+'.x',tiHouse);
        else
          s:='Неверный формат файла карты '+FileName;
          MessageBox(0,@s[1],'Core3Da: Ошибка',mb_IconStop or mb_Ok);
          Halt(0);
        end;
        UpdateProgress;
      end;

      OutDbgMsg('LoadMap: Creating trees.');
      BlockRead(f,a,SizeOf(a));
      SetLength(Trees,a);
      MaxTrees:=a-1;
      for i:=0 to a-1 do
      begin
        BlockRead(f,Tree,SizeOf(Tree));
        FillChar(Trees[i],SizeOf(TTree),0);
        Trees[i].x:=Tree.x;
        Trees[i].y:=Tree.y;
        Trees[i].z:=Tree.z;
        Trees[i].TreeType:=Tree.TreeType;
        LoadModel(Trees[i].Model,DataPath+'\Trees\Strom'+IntToStr(Tree.TreeType)+'.x',tiTree);
        UpdateProgress;
      end;
      OutDbgMsg('LoadMap: Creating landscape.');
      BlockRead(f,Landscape,SizeOf(Landscape));
      s:=DataPath+'\Skyboxes\Sky'+IntToStr(Landscape)+'\';
      LoadTexture(LandTex.Top,s+'top.tga',tiLandscape);
      LoadTexture(LandTex.Back,s+'back.tga',tiLandscape);
      LoadTexture(LandTex.Front,s+'front.tga',tiLandscape);
      LoadTexture(LandTex.Bottom,s+'bottom.tga',tiLandscape);
      LoadTexture(LandTex.Left,s+'left.tga',tiLandscape);
      LoadTexture(LandTex.Right,s+'right.tga',tiLandscape);

      OutDbgMsg('LoadMap: Creating lights.');
      BlockRead(f,a,SizeOf(a));
      SetLength(Lights,a);
      MaxLights:=a-1;
      for i:=0 to a-1 do
      begin
        BlockRead(f,Light,SizeOf(Light));
        SetLength(Lights[i].Script,Light.ScriptLength);
        BlockRead(f,Lights[i].Script[1],Light.ScriptLength);
        Lights[i].x:=Light.x;
        Lights[i].y:=Light.y;
        Lights[i].z:=Light.z;
        Lights[i].Angle:=Light.Angle;
        Lights[i].LightState:=Light.LightState;
        Lights[i].ScriptLength:=Light.ScriptLength;
        Lights[i].ScriptIsValid:=False;
        UpdateProgress;
      end;
    except
      on E:EInOutError do
      begin
        s:='Неверный формат файла карты '+FileName;
        MessageBox(0,@s[1],'Core3Da: Ошибка',mb_IconStop or mb_Ok);
      end;
    end;
    CloseFile(f);
    OutDbgMsg('*** Map structures successfully loaded.');
  except
    on E:EInOutError do
    begin
      s:='Файл '+FileName+' не найден.';
      MessageBox(0,@s[1],'Core3Da: Ошибка',mb_IconStop or mb_Ok);
    end;
  end;
end;