/************************************************************************
* Copyright (c) 2005-2007 tok@openlinux.org.uk                          *
*                                                                       *
* This software is provided as-is, without any express or implied       *
* warranty. In no event will the authors be held liable for any         *
* damages arising from the use of this software.                        *
*                                                                       *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute   *
* it freely, subject to the following restrictions:                     *
*                                                                       *
* 1. The origin of this software must not be misrepresented; you must   *
* not claim that you wrote the original software. If you use this       *
* software in a product, an acknowledgment in the product documentation *
* would be appreciated but is not required.                             *
*                                                                       *
* 2. Altered source versions must be plainly marked as such, and must   *
* not be misrepresented as being the original software.                 *
*                                                                       *
* 3. This notice may not be removed or altered from any source          *
* distribution.                                                         *
************************************************************************/
#include <cmath>
#include <cassert>
#include "gl_cityview.h"
#include "gl_spritecache.h"
#include "spritemanager.h"
#include "buffercache.h"
#include "gl_camera.h"
#include "dataholder.h"
#include "math3d.h"
#include "localplayer.h"
#include "log.h"
#include "gl_screen.h"
#include "blockdata.h"
#include "image_loader.h"
#include "blockanim.h"
#include "id_sys.h"
#include "map_helper.h"

float slope_height_offset(unsigned char slope_type, float dx, float dz);
namespace OpenGTA {

/*
  float slope_raw_data[45][5][4][3] = {
#include "slope1_data.h"
  };
  float slope_tex_data[45][4][4][2] = {
#include "slope1_tcoords.h"
  };

  float lid_normal_data[45][3] = { 
#include "lid_normal_data.h"
  };
*/

/*
  GLuint createGLTexture(GLsizei w, GLsizei h, bool rgba, const void* pixels) {
    GLuint tex;
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    if (rgba)
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
      //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
    else
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
      //gluBuild2DMipmaps(GL_TEXTURE_2D, 3, w, h, GL_RGB, GL_UNSIGNED_BYTE, pixels);

    GL_CHECKERROR;
    return tex;
  }
*/
  struct GLColor {
    GLfloat rgb[3];
    GLColor() { rgb[0] = rgb[1] = rgb[2] = 0; }
    GLColor(GLfloat i) { rgb[0] = rgb[1] = rgb[2] = i; }
    GLColor(GLfloat r, GLfloat g, GLfloat b) { rgb[0] = r; rgb[1] = g; rgb[2] = b; }
  };

  GLColor block_colors[8] = {
    GLColor(1), // air 
    GLColor(0, 0, 1), // water
    GLColor(0, 1, 1), // road
    GLColor(1, 0, 0), // pavement
    GLColor(0, 1, 0), // field
    GLColor(1, 1, 0), // building
    GLColor(1), // unused
    GLColor(1) // unused
  };

  GLfloat* map_block_type_color(uint8_t k) {
    // k = 6  now used to fix pavement cols
    if (k == 7)
      WARN << "block-type: " << int(k) << " should be unused!" << std::endl;
    if (k < 8)
      return block_colors[k].rgb;
    ERROR << "Invalid block-type: " << int(k) << std::endl;
    return block_colors[0].rgb;
  }

  CityView::CityView() {
    setNull();
    /*
    Pedestrian p(Vector3D(0.5f, 0.5f, 0.5f), Vector3D(4, 5.01f, 4), 0xffffffff);
    p.m_control = &LocalPlayer::Instance();
    SpriteManagerHolder::Instance().addPed(p);
    */
  }
  void CityView::setNull() {
    loadedMap = NULL;
    sideCache = NULL;
    lidCache  = NULL;
    auxCache  = NULL;
    blockAnims = NULL;
    camVec[0] = 0.0f;
    camVec[1] = 1.0f;
    camVec[2] = 0.0f;
    zoomLevel = 1.0f;
    visibleRange = 15;
    topDownView = true;
    drawTextured = true;
    drawLines = false;
    drawLinesBlockType = true;
    setPosition(0.0f, 0.0f, 20.0f);

    scene_display_list = 0;
    texFlipTest = 0;
    drawHeadingMarkers = false;
    current_sector = NULL;
  }
  CityView::~CityView() {
    cleanup();
  }
  void CityView::resetTextures() {
    sideCache->clearAll();
    lidCache->clearAll();
    auxCache->clearAll();
  }
  void CityView::setVisibleRange(int r) {
    visibleRange = r;
    scene_is_dirty = true;
  }
  int CityView::getVisibleRange() {
    return visibleRange;
  }
  bool CityView::getDrawTextured() { return drawTextured; }
  bool CityView::getDrawLines() { return drawLines; }
  bool CityView::getDrawLinesBlockColor() { return drawLinesBlockType; }
  void CityView::setDrawTextured(bool v) { drawTextured = v; }
  void CityView::setDrawLines(bool v) { drawLines= v; }
  void CityView::setDrawLinesBlockColor(bool v) { drawLinesBlockType= v; }
  void CityView::cleanup() {
    //if (loadedMap)
    //  delete loadedMap;
    if (sideCache)
      delete sideCache;
    if (lidCache)
      delete lidCache;
    if (auxCache)
      delete auxCache;
    if (blockAnims)
      delete blockAnims;
    if (scene_display_list)
      glDeleteLists(scene_display_list, 1);
    setNull();
  }
  void CityView::setViewMode(bool topDown) {
    topDownView = topDown;
  }
  void CityView::loadMap(const std::string &map, const std::string &style_f) {
    cleanup();
    //loadedMap = new Map(map);
    MapHolder::Instance().load(map);
    loadedMap = &MapHolder::Instance().get();
    StyleHolder::Instance().load(style_f);
    style = &StyleHolder::Instance().get();
    style->setDeltaHandling(true);
    /*
    for (size_t i = 0; i < style->carInfos.size(); ++i) {
      OpenGTA::GraphicsBase::CarInfo * cinfo = style->carInfos[i];
      assert(cinfo);
      INFO << cinfo->numDoors << std::endl;
    }*/

    sideCache = new OpenGL::TextureCache<uint8_t>("SideCache");
    lidCache = new OpenGL::TextureCache<uint8_t>("LidCache");
    auxCache = new OpenGL::TextureCache<uint8_t>("AuxCache");
    sideCache->setClearMagic(5);
    lidCache->setClearMagic(8);
    auxCache->setClearMagic(5);
    blockAnims = new BlockAnimCtrl(style->animations);
    scene_is_dirty = true;
    lastCacheEmptyTicks = 0;

    scene_display_list = glGenLists(1);

    SpriteManagerHolder::Instance().clear();

    // safeguard against double car entries (in nyc.cmp)
    Util::MapOfPair2Int d_car_map;
    for (PHYSFS_uint16 oc = 0; oc < loadedMap->numObjects; oc++) {
      OpenGTA::Map::ObjectPosition & op = loadedMap->objects[oc];
      if (op.remap >= 128) {
        if (Util::item_count(d_car_map, op.x, op.y) == 0)
          Util::register_item1(d_car_map, op.x, op.y);
        else
          continue;
      }      
      createLevelObject(&loadedMap->objects[oc]);
    }
    //SpriteManagerHolder::Instance().trainSystem.loadStations(*loadedMap);
    activeRect.x = activeRect.y = 0;
    activeRect.w = activeRect.h = 0;
  }
  void CityView::createLevelObject(OpenGTA::Map::ObjectPosition *obj) {
    SpriteManager & s_man = SpriteManagerHolder::Instance();
    uint32_t id = TypeIdBlackBox::requestId();
    if (obj->remap >= 128) {
      Car car(*obj, id);
      s_man.add(car);
    }
    else {
      SpriteObject gobj(*obj, id);
      s_man.add(gobj);
    }
  }
  void CityView::setZoom(const GLfloat zoom) {
    zoomLevel = zoom; 
  }
  void CityView::setPosition(const GLfloat & x, const GLfloat & y, const GLfloat & z) {
    camPos[0] = x;
    camPos[1] = y;
    camPos[2] = z;
    scene_is_dirty = true;
    //INFO << "Position: " << x << ", " << z << " (" << y << ")" << std::endl;
    if (loadedMap) {
      PHYSFS_uint8 _x = PHYSFS_uint8((x >= 1.0f) ? ((x < 255.0f) ? x : 254) : 1); // FIXME: crashes on 0 or 255
      PHYSFS_uint8 _y = PHYSFS_uint8((z >= 1.0f) ? ((z < 255.0f) ? z : 254) : 1); // why???
      NavData::Sector* in_sector = loadedMap->nav->getSectorAt(_x, _y);
      assert(in_sector);
      if (in_sector != current_sector) {
        current_sector = in_sector;
      }
    }

    //if (loadedMap && !topDownView)
    //  getTerrainHeight(camPos[0], camPos[1], camPos[2]);
  }

  NavData::Sector* CityView::getCurrentSector() {
    return current_sector;
  }

/*
  void CityView::setCamVector(const GLfloat & x, const GLfloat & y, const GLfloat & z) {
    camVec[1] = x;
    camVec[2] = y;
    camVec[3] = z;
    scene_is_dirty = true;
  }
*/

  void CityView::setTopDownView(const GLfloat & height) {
    camPos[1] = height;
    scene_is_dirty = true;
    setViewMode(true);
  }

  void CityView::getTerrainHeight(GLfloat & x, GLfloat & y, GLfloat & z) {
    int xi = int(x);
    int yi = int(z);
    //int zi = int(z);
    float h = 0.5f;
    WARN << "THIS FUNCTION SHOULD NOT BE USED!" << std::endl;
    PHYSFS_uint16 emptycount = loadedMap->getNumBlocksAt(xi, yi);
    for (int c=6-emptycount; c >= 1; c--) {
      OpenGTA::Map::BlockInfo* bi = loadedMap->getBlockAt(xi, yi, c);
      if (bi->blockType() == 0) {
        //camPos[1] = h;
        break;
      }

      /*INFO << "block " << c << " lid: " << int(bi->lid) << std::endl;
      if (bi->blockType() > 0) {
        INFO << "not air but: " << int(bi->blockType()) << std::endl;
      }*/
      h += 1.0f;
    }
    y = h;
  }

  OpenGL::PagedTexture CityView::renderMap2Texture() {
    OpenGL::Screen & screen = OpenGL::ScreenHolder::Instance();
    uint32_t width = screen.getWidth();
    uint32_t height = screen.getHeight();

    uint32_t gl_h = 1;
    while (gl_h < height)
      gl_h <<= 1;


    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glFinish();
    Vector3D v_off(0,0,0);
    int persp_find_done = 0;
    int break_loop_safe = 500;
    while (persp_find_done != 3) {
      OpenGL::ScreenHolder::Instance().set3DProjection();
      glRotatef(180, 0, 0, 1);

      gluLookAt(128+v_off.x, 230, 128+v_off.y, 128+v_off.x, 0, 128+v_off.y, 0.0f, 0.0f, 1.0f);

      GLint viewport[4];
      GLdouble mvmatrix[16], projmatrix[16];
      GLdouble winx, winy, winz;
      glGetIntegerv (GL_VIEWPORT, viewport);
      glGetDoublev (GL_MODELVIEW_MATRIX, mvmatrix);
      glGetDoublev (GL_PROJECTION_MATRIX, projmatrix);
      gluProject(0, 0, 0, mvmatrix, projmatrix, viewport, &winx, &winy, &winz);
      if (winx > 0.5f)
        v_off.x += 0.2f;
      else if (winx < -0.5f)
        v_off.x -= 0.2f;
      else
        persp_find_done |= 1;
      INFO << winx << " " << winy << std::endl;
      gluProject(256, 0, 256, mvmatrix, projmatrix, viewport, &winx, &winy, &winz);
      if (winy < -0.5f)
        v_off.y += 0.2f;
      else if (winy > 0.5f)
        v_off.y -= 0.2f;
      else
        persp_find_done |= 2;
      break_loop_safe--;
      if (break_loop_safe == 0) {
        WARN << "breaking out of loop - NOT GOOD!" << std::endl;
        persp_find_done = 3;
      }
      INFO << winx << " " << winy << std::endl;
    }

    //glTranslatef(-35, 0, 0);
    for (int i = 0; i <= 255; i++) {
      for (int j= 0; j <= 255; j++) {
        glPushMatrix();
        glTranslatef(1.0f*j, 0.0f, 1.0f*i);
        PHYSFS_uint16 maxcount = loadedMap->getNumBlocksAtNew(j,i);
        for (int c=0; c < maxcount; ++c) {
          glPushMatrix();
          drawBlock(loadedMap->getBlockAtNew(j, i, c));
          glPopMatrix();
          glTranslatef(0.0f, 1.0f, 0.0f);
        }
        glPopMatrix();
      }
    }
    GL_CHECKERROR;

    glFinish();
/*
    GLuint txtnumber;
    glGenTextures(1, &txtnumber);					// Create 1 Texture
	  glBindTexture(GL_TEXTURE_2D, txtnumber);			// Bind The Texture
    GL_CHECKERROR;
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, gl_h, gl_h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
    GL_CHECKERROR;
    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width/2, height/2);
    GL_CHECKERROR;
    //glViewport(0, 0, width, height);
    return OpenGL::PagedTexture(txtnumber, 0, 0, 1, 1);
*/
    uint32_t img_size = gl_h * gl_h * 3; 
    uint8_t *img_buf = Util::BufferCacheHolder::Instance().requestBuffer(img_size);

    glReadBuffer(GL_BACK);
    //for (uint32_t i = 0; i < gl_h; i++) {
    //  glReadPixels(0, i, gl_h, 1, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)(img_buf + gl_h * 3 * i));
    //}
    glReadPixels(0, 0, gl_h, gl_h, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)img_buf);
    GL_CHECKERROR;

    sideCache->sink();
    sideCache->sink();
    lidCache->sink();
    lidCache->sink();
    sideCache->clear();
    lidCache->clear();

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    uint32_t y_off = 100;
    uint32_t x = 0;
    while (*(img_buf + y_off * gl_h * 3 + x) == 0 && *(img_buf + y_off * gl_h * 3 + x+1) == 0 &&
      *(img_buf + y_off * gl_h * 3 + x + 2) == 0)
      x += 3;
    INFO << "color after x = " << x/3 << std::endl;
    x = gl_h-3;
     while (*(img_buf + y_off * gl_h * 3 + x) == 0 && *(img_buf + y_off * gl_h * 3 + x+1) == 0 &&
      *(img_buf + y_off * gl_h * 3 + x+2) == 0)
      x -= 3;
    INFO << "color after x = " << x/3 << std::endl;


    GLuint tex = ImageUtil::createGLTexture(gl_h, gl_h, false, img_buf);
    float f_h = float(height) / gl_h;
    float f_w = float(width)  / gl_h;
    //float horiz_corr = (1.0f - f_w) / 2.0f;
    //return OpenGL::PagedTexture(tex, 0+horiz_corr, 0, f_w+horiz_corr, f_h);
    
    return OpenGL::PagedTexture(tex, 0, 0, f_h, f_h);
  }

  void CityView::draw(Uint32 ticks) {
    GL_CHECKERROR;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    /*
    sideCache->clearStats();
    lidCache->clearStats();
    */
    glLoadIdentity();
    int x1, y1, x2, y2;
    if (topDownView) {
      glRotatef(180, 0, 0, 1);
      gluLookAt(camPos[0], camPos[1], camPos[2], camPos[0], 0.0f, camPos[2], 0.0f, 0.0f, 1.0f);

      x1 = int(camPos[0]) - visibleRange;
      y1 = int(camPos[2]) - visibleRange;
      x2 = int(camPos[0]) + visibleRange;
      y2 = int(camPos[2]) + visibleRange;

    }
    else {
      OpenGL::Camera & cam = OpenGL::CameraHolder::Instance();
      //gluLookAt(camPos[0], camPos[1], camPos[2], camPos[0]+5, 0, (camPos[2])+5, camVec[0], camVec[1], camVec[2]);
      cam.update(ticks);
      Vector3D & e = cam.getEye();
      //INFO << "eye: " << e.x << ", " << e.y << ", " << e.z << std::endl;
      setPosition(e.x, e.y, e.z);
      x1 = int(e.x) - visibleRange;
      y1 = int(e.z) - visibleRange;
      x2 = int(e.x) + visibleRange;
      y2 = int(e.z) + visibleRange;
      //PHYSFS_uint16 emptycount = loadedMap->getNumBlocksAt(int(e.x),int(e.z));
      //INFO << "cam-h is " << int(e.y)<< " ec: " << emptycount << std::endl;
/*
      int cc = 0;
      for (int i = 6 - emptycount; i >= 0; i--) {
         OpenGTA::Map::BlockInfo* bi = loadedMap->getBlockAt(int(e.x), int(e.z), i);
         //INFO << i << " type: "<< int(bi->blockType()) <<  " lid: " << int(bi->lid)<< std::endl;
         if (bi->blockType() >=2 && bi->blockType() <= 4) {
          c.y = c.y - e.y + float(cc)+1.0f;
          e.y = float(cc)+1.0f;
          break;
         }
         cc++;
      }
*/

      //getTerrainHeight(e.x, e.y, e.z);
    }
    frustum.CalculateFrustum();

    if (x1 < 0)
      x1 = 0;
    if (y1 < 0)
      y1 = 0;
    if (x2 > 255)
      x2 = 255;
    if (y2 > 255)
      y2 = 255;

    //INFO << activeRect.x << ", " << activeRect.y << " -> " << 
    //  activeRect.x+activeRect.w << ", " << activeRect.y + activeRect.h << std::endl;
    activeRect.x = x1;
    activeRect.y = y1;
    activeRect.w = x2 - x1;
    activeRect.h = y2 - y1;
    //INFO << "Active area: " << x1 << " - " << x2 << " , " << y1 << " - " << y2 << std::endl;
    int xd1, xd2, yd1, yd2;
    xd2 = 0;
    yd2 = 0;
    xd1 = x2;
    yd1 = y2;

    bool use_display_list = false;

    GL_CHECKERROR;
    if ((!scene_is_dirty) && (use_display_list)) {
      glCallList(scene_display_list);
    }
    else {
      scene_rendered_blocks = scene_rendered_vertices = 0;

      if (use_display_list)
        glNewList(scene_display_list, GL_COMPILE);
      for (int i = y1; i <= y2; i++) {
        //glPushMatrix();
        //glTranslatef(0.0f, 0.0f, 1.0f*i);
        for (int j= x1; j <= x2; j++) {
          if (!frustum.BlockInFrustum(0.5f+j, 0.5f+i, 0.5f))
            continue;
          if (j < xd1)
            xd1 = j;
          xd2 = j;
          if (i < yd1)
            yd1 = i;
          yd2 = i;
          glPushMatrix();
          glTranslatef(1.0f*j, 0.0f, 1.0f*i);
          //PHYSFS_uint16 emptycount = loadedMap->getNumBlocksAt(j,i);
          PHYSFS_uint16 maxcount = loadedMap->getNumBlocksAtNew(j,i);
          //for (int c=6-emptycount; c >= 1; c--) {
          for (int c=0; c < maxcount; ++c) {
            ++scene_rendered_blocks;
            glPushMatrix();
            if (c < maxcount - 1) {
              Map::BlockInfo * bi = loadedMap->getBlockAtNew(j, i, c + 1);
              aboveBlockType = bi->blockType();
            }
            else
              aboveBlockType = loadedMap->getBlockAtNew(j, i, c)->blockType();
            drawBlock(loadedMap->getBlockAtNew(j, i, c));
            glPopMatrix();
            glTranslatef(0.0f, 1.0f, 0.0f);
          }
          glPopMatrix();
        }
        //glPopMatrix();
      }
      drawnRect.x = xd1;
      drawnRect.y = yd1;
      drawnRect.w = xd2 - xd1;
      drawnRect.h = yd2 - yd1;
      //INFO << "area drawn: " << xd1 << " - " << xd2 << " , " << yd1 << " - " << yd2 << std::endl;
      if (use_display_list) {
        glEndList();
        glCallList(scene_display_list);
        scene_is_dirty = false;
      }
      //INFO << scene_rendered_blocks << " blocks drawn with " << scene_rendered_vertices << " vertices" << std::endl;
    }
    GL_CHECKERROR;
    /*
    for (PHYSFS_uint16 oc = 0; oc < loadedMap->numObjects; oc++) {
      if (frustum.BlockInFrustum((loadedMap->objects[oc].x >> 6) + 0.5f, 
        (loadedMap->objects[oc].y >> 6) + 0.5f, 0.5f))
        drawObject(&loadedMap->objects[oc]);
    }*/
    GL_CHECKERROR;
    SpriteManagerHolder::Instance().drawInRect(activeRect);
    
    lastCacheEmptyTicks += ticks;
    if (lastCacheEmptyTicks > 4000) {
      lidCache->sink();
      lidCache->sink();
      sideCache->sink();
      sideCache->clear();
      lidCache->clear();
      lastCacheEmptyTicks = 0;
      //lidCache->status();
      //sideCache->status();
    }
    GL_CHECKERROR;
  }

#if 0
  OpenGL::PagedTexture CityView::createSprite(size_t sprite_num, GraphicsBase::SpriteInfo* info) {
    unsigned char* src = style->getSpriteBitmap(sprite_num, -1 , 0);
    unsigned int glwidth = 1;
    unsigned int glheight = 1;

    while(glwidth < info->w)
      glwidth <<= 1;
    while(glheight < info->h)
      glheight <<= 1;
    unsigned char* dst = Util::BufferCacheHolder::Instance().requestBuffer(glwidth * glheight * 4);
    Util::BufferCacheHolder::Instance().unlockBuffer(src);
    assert(dst != NULL);
    unsigned char * t = dst;
    unsigned char * r = src;
    for (unsigned int i = 0; i < info->h; i++) {
      memcpy(t, r, info->w * 4);
      t += glwidth * 4;
      r += info->w * 4;
    }
    GLuint texid;
    glGenTextures(1, &texid);
    glBindTexture(GL_TEXTURE_2D, texid);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, glwidth, glheight, 0, GL_RGBA, GL_UNSIGNED_BYTE, dst);
    return OpenGL::PagedTexture(texid, 0, 0, 
      float(info->w)/float(glwidth), float(info->h)/float(glheight));
  }
#endif

  void CityView::drawObject(OpenGTA::Map::ObjectPosition* obj) {
    
    float w, h;
    float x = float(obj->x >> 6) + float(obj->x % 64)/64.0f;
    float y = float(obj->y >> 6) + float(obj->y % 64)/64.0f;
    float z = float(obj->z >> 6) + float(obj->z % 64)/64.0f;
    size_t spriteNumAbs, sprNum;
    GraphicsBase::SpriteInfo *info = NULL;
    GraphicsBase::SpriteNumbers::SpriteTypes st;
    if (obj->remap >= 128) { // car
      GraphicsBase::CarInfo* cinfo = style->findCarByModel(obj->type);
      assert(cinfo);
      sprNum = cinfo->sprNum;
      spriteNumAbs = style->spriteNumbers.reIndex(cinfo->sprNum, GraphicsBase::SpriteNumbers::CAR);
      info = style->getSprite(spriteNumAbs);
      w = float(info->w) / 64.0f;
      h = float(info->h) / 64.0f;
      st = GraphicsBase::SpriteNumbers::CAR;
    }
    else {
      spriteNumAbs = style->spriteNumbers.reIndex(style->objectInfos[obj->type]->sprNum, GraphicsBase::SpriteNumbers::OBJECT);
      sprNum = style->objectInfos[obj->type]->sprNum;
      info = style->getSprite(spriteNumAbs);
      assert(info);
      w = float(info->w) / 64.0f;
      h = float(info->h) / 64.0f;
      st = GraphicsBase::SpriteNumbers::OBJECT;
    }
    
    OpenGL::PagedTexture t;
    if (OpenGL::SpriteCacheHolder::Instance().has(spriteNumAbs))
      t = OpenGL::SpriteCacheHolder::Instance().get(spriteNumAbs);
    else {
      //t = createSprite(spriteNum, info);
      //OpenGL::SpriteCacheHolder::Instance().add(spriteNum, t);
      t = OpenGL::SpriteCacheHolder::Instance().create(sprNum, st, -1);
    }

    glPushMatrix();
    glTranslatef(x, 6.1f - z, y); // ups, seems: up<->down
    glRotatef(obj->rotation / 1035.0f * 360.0f, 0, 1, 0); // 1035 is guesswork!
    //glDisable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, t.inPage);
    glBegin(GL_QUADS);
      glTexCoord2f(t.coords[0].u, t.coords[1].v);
      glVertex3f(-w/2, 0.0f, h/2);
      glTexCoord2f(t.coords[1].u, t.coords[1].v);
      glVertex3f(w/2,  0.0f, h/2);
      glTexCoord2f(t.coords[1].u, t.coords[0].v);
      glVertex3f(w/2,  0.0f, -h/2);
      glTexCoord2f(t.coords[0].u, t.coords[0].v);
      glVertex3f(-w/2, 0.0f, -h/2);
    glEnd();
    glPopMatrix();
    //glEnable(GL_TEXTURE_2D);
  }

  void CityView::drawBlock(OpenGTA::Map::BlockInfo* bi) {

    GL_CHECKERROR;
    /*
       std::cout << "is flat: " << bi->isFlat() << " up ok: " << bi->upOk() <<
       " down " << bi->downOk() << " left " << bi->leftOk() << " right " << bi->rightOk() << std::endl;
       std::cout << "block type: "<< int(bi->blockType()) << " slope " << int(bi->slopeType()) <<
       " rotation: " << int(bi->rotation()) << " remap: " << int(bi->remapIndex()) <<
       " TB " << bi->flipTopBottom() << " LR " << bi->flipLeftRight() << std::endl;
       */
    uint8_t which = bi->slopeType();
    float nx = LID_NORMAL_DATA[which][0];
    float ny = LID_NORMAL_DATA[which][1];
    float nz = LID_NORMAL_DATA[which][2];

    int jj = 0;
    GLfloat lidTex[8] = {0.0f, 1.0f,  1.0f, 1.0f,  1.0f, 0.0f,  0.0f, 0.0f};
    //GLfloat sideTex1_bak[8] = {1.0f, 0.0f,  0.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f};
    GLfloat sideTex1[8] = {1.0f, 0.0f,  0.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f};

#ifdef MSWAP
#undef MSWAP
#endif
#define MSWAP(a,b) { GLfloat tmp = sideTex1[a]; sideTex1[a] = sideTex1[b]; sideTex1[b] = tmp; }

#define SLOPE_TEX_CP(k) memcpy(sideTex1, SLOPE_TEX_DATA[which][k], 8 * sizeof(GLfloat))
#ifdef GLTEX_HELPER
#undef GLTEX_HELPER
#endif
#define GLTEX_HELPER \
    glTexCoord2f(lidTex[jj], lidTex[jj+1]); jj += 2; if (jj > 6) { jj = 0; }
#define GLTEX1_HELPER \
    glTexCoord2f(sideTex1[jj], sideTex1[jj+1]); jj += 2; if (jj > 6) { jj = 0; }

    bool is_flat = bi->isFlat(); // transparency in the texture ?
    GLuint lid_tex = 0, left_tex = 0, right_tex = 0, top_tex = 0, bottom_tex = 0;

    // FIXME: no remaps used!
    if (bi->lid) {
      int frame_num = -1;//style->checkBlockAnimation(0, bi->lid);
      BlockAnim * banim = blockAnims->getAnim(1, bi->lid);
      if (banim) {
        frame_num = banim->getCurrentFrameNumber();
      }
      if (frame_num <= 0) {
        if (!lidCache->hasTexture(bi->lid)) {
          lid_tex = ImageUtil::createGLTexture(64, 64, is_flat, 
              style->getLid(static_cast<unsigned int>(bi->lid), 0, is_flat));
          lidCache->addTexture(bi->lid, lid_tex); 
        }
        else
          lid_tex = lidCache->getTextureWithId(bi->lid);
      }
      else {
        uint8_t aux_id = banim->getFrame(frame_num - 1);
        if (!auxCache->hasTexture(aux_id)) {
          lid_tex = ImageUtil::createGLTexture(64, 64, is_flat, 
              style->getAux(static_cast<unsigned int>(aux_id), 0, is_flat));
          auxCache->addTexture(aux_id, lid_tex); 
        }
        else
          lid_tex = auxCache->getTextureWithId(aux_id);
      }
    }
    if (bi->left) {
      int frame_num = -1;
      BlockAnim * banim = blockAnims->getAnim(0, bi->left);
      if (banim) {
        frame_num = banim->getCurrentFrameNumber();
      }
      if (frame_num <= 0) {
        if (!sideCache->hasTexture(bi->left)) {
          left_tex = ImageUtil::createGLTexture(64, 64, is_flat,
              style->getSide(static_cast<unsigned int>(bi->left), 0, is_flat));
          sideCache->addTexture(bi->left, left_tex); 
        }
        else
          left_tex = sideCache->getTextureWithId(bi->left);
      }
      else {
        uint8_t aux_id = banim->getFrame(frame_num - 1);
        if (!auxCache->hasTexture(aux_id)) {
          left_tex = ImageUtil::createGLTexture(64, 64, is_flat, 
              style->getAux(static_cast<unsigned int>(aux_id), 0, is_flat));
          auxCache->addTexture(aux_id, left_tex); 
        }
        else
          left_tex = auxCache->getTextureWithId(aux_id);

      }
    }
    if (bi->right) {
      int frame_num = -1;
      BlockAnim * banim = blockAnims->getAnim(0, bi->right);
      if (banim) {
        frame_num = banim->getCurrentFrameNumber();
      }
      if (frame_num <= 0) {
        if (!sideCache->hasTexture(bi->right)) {
          right_tex = ImageUtil::createGLTexture(64, 64, is_flat,
              style->getSide(static_cast<unsigned int>(bi->right), 0, is_flat));
          sideCache->addTexture(bi->right, right_tex); 
        }
        else
          right_tex = sideCache->getTextureWithId(bi->right);
      }
      else {
        uint8_t aux_id = banim->getFrame(frame_num - 1);
        if (!auxCache->hasTexture(aux_id)) {
          right_tex = ImageUtil::createGLTexture(64, 64, is_flat, 
              style->getAux(static_cast<unsigned int>(aux_id), 0, is_flat));
          auxCache->addTexture(aux_id, right_tex); 
        }
        else
          right_tex = auxCache->getTextureWithId(aux_id);
      }
    }
    if (bi->top) {
      int frame_num = -1;
      BlockAnim * banim = blockAnims->getAnim(0, bi->top);
      if (banim) {
        frame_num = banim->getCurrentFrameNumber();
      }
      if (frame_num <= 0) {

        if (!sideCache->hasTexture(bi->top)) {
          top_tex = ImageUtil::createGLTexture(64, 64, is_flat,
              style->getSide(static_cast<unsigned int>(bi->top), 0, is_flat));
          sideCache->addTexture(bi->top, top_tex);
        }
        else
          top_tex = sideCache->getTextureWithId(bi->top);
      }
      else {
        uint8_t aux_id = banim->getFrame(frame_num - 1);
        if (!auxCache->hasTexture(aux_id)) {
          top_tex = ImageUtil::createGLTexture(64, 64, is_flat, 
              style->getAux(static_cast<unsigned int>(aux_id), 0, is_flat));
          auxCache->addTexture(aux_id, top_tex); 
        }
        else
          top_tex = auxCache->getTextureWithId(aux_id);
      }
    }
    if (bi->bottom) {
      int frame_num = -1;
      BlockAnim * banim = blockAnims->getAnim(0, bi->bottom);
      if (banim) {
        frame_num = banim->getCurrentFrameNumber();
      }
      if (frame_num <= 0) {

        if (!sideCache->hasTexture(bi->bottom)) {
          bottom_tex = ImageUtil::createGLTexture(64, 64, is_flat,
              style->getSide(static_cast<unsigned int>(bi->bottom), 0, is_flat));
          sideCache->addTexture(bi->bottom, bottom_tex); 
        }
        else
          bottom_tex = sideCache->getTextureWithId(bi->bottom);
      }
      else {
        uint8_t aux_id = banim->getFrame(frame_num - 1);
        if (!auxCache->hasTexture(aux_id)) {
          bottom_tex = ImageUtil::createGLTexture(64, 64, is_flat, 
              style->getAux(static_cast<unsigned int>(aux_id), 0, is_flat));
          auxCache->addTexture(aux_id, bottom_tex); 
        }
        else
          bottom_tex = auxCache->getTextureWithId(aux_id);

      }
    }
    
#define RESET_COLOR glColor3f(1, 1, 1)
#define COLOR_OFF if (drawLinesBlockType) RESET_COLOR
#define COLOR_BY_BLOCK(idx) { GLfloat *_c = map_block_type_color(idx); glColor3f(_c[0], _c[1], _c[2]); }
#define COLOR_ON  if (drawLinesBlockType) COLOR_BY_BLOCK(aboveBlockType)
//#define COLOR_ON  if (drawLinesBlockType) COLOR_BY_BLOCK(bi->blockType())

if (drawLinesBlockType)

    // handle flat/transparent case
    if (is_flat) {
      if (bi->lid) {
        jj = 0;
        if (bi->typeMap & 16384) {
          jj += 2;
        }
        if (bi->typeMap & 32768) {
          jj += 4;
        }
        if(drawTextured) {
          glBindTexture(GL_TEXTURE_2D, lid_tex);
          glBegin(GL_QUADS);
          glNormal3f(nx, ny, nz);
          for (int j=0; j < 4; j++) {
            GLTEX_HELPER;
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][0][j][0],
                SLOPE_RAW_DATA[which][0][j][1],
                SLOPE_RAW_DATA[which][0][j][2]);
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][0][j][0],
                SLOPE_RAW_DATA[which][0][j][1],
                SLOPE_RAW_DATA[which][0][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][0][0][0],
              SLOPE_RAW_DATA[which][0][0][1],
              SLOPE_RAW_DATA[which][0][0][2]);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }
#undef MSWAP
#define MSWAP(a, b) { sideTex1[a] = 1.0f - sideTex1[a]; sideTex1[b] = 1.0f - sideTex1[b]; }
      jj = 0; // only 'lid' rotated
      if (bi->top) {
        SLOPE_TEX_CP(1);
        if (bi->flipTopBottom()) {
          MSWAP(0, 2);
          MSWAP(4, 6);
        }
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, top_tex);
          glBegin(GL_QUADS);
          for (int j=0; j < 4; j++) {
            GLTEX1_HELPER;
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][2][j][0],
                SLOPE_RAW_DATA[which][2][j][1],
                SLOPE_RAW_DATA[which][2][j][2]);
          }
          jj = 0;
          SLOPE_TEX_CP(0);
          if (!bi->flipTopBottom()) {
            MSWAP(0, 2);
            MSWAP(4, 6);
          }
          for (int j=0; j < 4; j++) {
            GLTEX1_HELPER;
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][1][j][0],
                SLOPE_RAW_DATA[which][1][j][1],
                SLOPE_RAW_DATA[which][1][j][2]-1.001f);  // -1.001f
            // offset by .001 to fix NYC bridges; polygon z-fighting
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][2][j][0],
                SLOPE_RAW_DATA[which][2][j][1],
                SLOPE_RAW_DATA[which][2][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][2][0][0],
              SLOPE_RAW_DATA[which][2][0][1],
              SLOPE_RAW_DATA[which][2][0][2]);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][1][j][0],
                SLOPE_RAW_DATA[which][1][j][1],
                SLOPE_RAW_DATA[which][1][j][2]-1.001f);
          }
          glVertex3f(SLOPE_RAW_DATA[which][1][0][0],
              SLOPE_RAW_DATA[which][1][0][1],
              SLOPE_RAW_DATA[which][1][0][2]-1.001f);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }
      jj = 0;
      //memcpy(sideTex1, sideTex1_bak, 8*sizeof(GLfloat));
      if (bi->left) {
        SLOPE_TEX_CP(2);
        if (bi->flipLeftRight()) {
           MSWAP(0, 2);
           MSWAP(4, 6);
        }
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, left_tex);
          glBegin(GL_QUADS);
          for (int j=0; j < 4; j++) {
            GLTEX1_HELPER;
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][3][j][0],
                SLOPE_RAW_DATA[which][3][j][1],
                SLOPE_RAW_DATA[which][3][j][2]);
          }
          jj = 0;
          SLOPE_TEX_CP(3);
          if (!bi->flipLeftRight()) {
            MSWAP(0, 2);
            MSWAP(4, 6);
          }
          for (int j=0; j < 4; j++) {
            GLTEX1_HELPER;
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][4][j][0]-1.001f,  // -1.001f
                SLOPE_RAW_DATA[which][4][j][1],
                SLOPE_RAW_DATA[which][4][j][2]);
          }
          glEnd();        
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][3][j][0],
                SLOPE_RAW_DATA[which][3][j][1],
                SLOPE_RAW_DATA[which][3][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][3][0][0],
              SLOPE_RAW_DATA[which][3][0][1],
              SLOPE_RAW_DATA[which][3][0][2]);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][4][j][0]-1.001f,
                SLOPE_RAW_DATA[which][4][j][1],
                SLOPE_RAW_DATA[which][4][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][4][0][0]-1.001f,
              SLOPE_RAW_DATA[which][4][0][1],
              SLOPE_RAW_DATA[which][4][0][2]);
          glEnd();
          COLOR_OFF;
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
        }
      }
    }
    else {
      if (bi->lid) {
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, lid_tex);
          jj = 0;
          if (bi->typeMap & 16384) {
            jj += 2;
          }
          if (bi->typeMap & 32768) {
            jj += 4;
          }
          glBegin(GL_QUADS);
          glNormal3f(nx, ny, nz);
          for (int j=0; j < 4; j++) {
            GLTEX_HELPER;
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][0][j][0],
                SLOPE_RAW_DATA[which][0][j][1],
                SLOPE_RAW_DATA[which][0][j][2]);
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][0][j][0],
                SLOPE_RAW_DATA[which][0][j][1],
                SLOPE_RAW_DATA[which][0][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][0][0][0],
              SLOPE_RAW_DATA[which][0][0][1],
              SLOPE_RAW_DATA[which][0][0][2]);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }
      jj = 0; // only 'lid' rotated
#undef MSWAP
#define MSWAP(a, b) { sideTex1[a] = 1.0f - sideTex1[a]; sideTex1[b] = 1.0f - sideTex1[b]; }
      /*
      if (bi->flipTopBottom()) {
        //MSWAP(1, 5);
        //MSWAP(3, 7);
        
        MSWAP(0, 2);
        MSWAP(4, 6);
      }*/
      if (bi->top && (which != 42)) {
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, top_tex);
          glBegin(GL_QUADS);
          SLOPE_TEX_CP(1);
          if (bi->flipTopBottom()) {
            MSWAP(0, 2);
            MSWAP(4, 6);
          }
          for (int j=0; j < 4; j++) {
            //if (!bi->flipTopBottom())
            GLTEX1_HELPER;
            /*
               glTexCoord2f(SLOPE_TEX_DATA[which][1][j][0],
               SLOPE_TEX_DATA[which][1][j][1]);
               */
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][2][j][0],
                SLOPE_RAW_DATA[which][2][j][1],
                SLOPE_RAW_DATA[which][2][j][2]);
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][2][j][0],
                SLOPE_RAW_DATA[which][2][j][1],
                SLOPE_RAW_DATA[which][2][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][2][0][0],
              SLOPE_RAW_DATA[which][2][0][1],
              SLOPE_RAW_DATA[which][2][0][2]);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }
      jj = 0;
      if (bi->bottom && (which != 41)) {
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, bottom_tex);
          glBegin(GL_QUADS);
          SLOPE_TEX_CP(0);
          if (bi->flipTopBottom()) {
            MSWAP(0, 2);
            MSWAP(4, 6);
          }

          for (int j=0; j < 4; j++) {
            //if (!bi->flipTopBottom())
            GLTEX1_HELPER;
            /*
               glTexCoord2f(SLOPE_TEX_DATA[which][0][j][0],
               SLOPE_TEX_DATA[which][0][j][1]);
               */
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][1][j][0],
                SLOPE_RAW_DATA[which][1][j][1],
                SLOPE_RAW_DATA[which][1][j][2]);
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][1][j][0],
                SLOPE_RAW_DATA[which][1][j][1],
                SLOPE_RAW_DATA[which][1][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][1][0][0],
              SLOPE_RAW_DATA[which][1][0][1],
              SLOPE_RAW_DATA[which][1][0][2]);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }
      /*memcpy(sideTex1, sideTex1_bak, 8 * sizeof(GLfloat));
      if (bi->flipLeftRight()) {
        MSWAP(0, 2);
        MSWAP(4, 6);
      }*/

      jj = 0;
      if (bi->left && (which != 44)) {
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, left_tex);
          glBegin(GL_QUADS);
          SLOPE_TEX_CP(2);
          if (bi->flipLeftRight()) {
            MSWAP(0, 2);
            MSWAP(4, 6);
          }

          for (int j=0; j < 4; j++) {
            //if (!bi->flipLeftRight())
            GLTEX1_HELPER;
            /*
               glTexCoord2f(SLOPE_TEX_DATA[which][2][j][0],
               SLOPE_TEX_DATA[which][2][j][1]);
               */
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][3][j][0],
                SLOPE_RAW_DATA[which][3][j][1],
                SLOPE_RAW_DATA[which][3][j][2]);
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][3][j][0],
                SLOPE_RAW_DATA[which][3][j][1],
                SLOPE_RAW_DATA[which][3][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][3][0][0],
              SLOPE_RAW_DATA[which][3][0][1],
              SLOPE_RAW_DATA[which][3][0][2]);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }
      jj = 0;
      if (bi->right && (which != 43)) {
        if (drawTextured) {
          glBindTexture(GL_TEXTURE_2D, right_tex);
          glBegin(GL_QUADS);
          SLOPE_TEX_CP(3);
          if (bi->flipLeftRight()) {
            MSWAP(0, 2);
            MSWAP(4, 6);
          }

          for (int j=0; j < 4; j++) {
            //if (!bi->flipLeftRight())
            GLTEX1_HELPER;
            /*
               glTexCoord2f(SLOPE_TEX_DATA[which][3][j][0],
               SLOPE_TEX_DATA[which][3][j][1]);
               */
            scene_rendered_vertices += 1;
            glVertex3f(SLOPE_RAW_DATA[which][4][j][0],
                SLOPE_RAW_DATA[which][4][j][1],
                SLOPE_RAW_DATA[which][4][j][2]);
          }
          glEnd();
        }
        // lines
        if (drawLines) {
          glDisable(GL_TEXTURE_2D);
          COLOR_ON;
          glBegin(GL_LINE_STRIP);
          for (int j=0; j < 4; j++) {
            glVertex3f(SLOPE_RAW_DATA[which][4][j][0],
                SLOPE_RAW_DATA[which][4][j][1],
                SLOPE_RAW_DATA[which][4][j][2]);
          }
          glVertex3f(SLOPE_RAW_DATA[which][4][0][0],
              SLOPE_RAW_DATA[which][4][0][1],
              SLOPE_RAW_DATA[which][4][0][2]);
          glEnd();
          glEnable(GL_TEXTURE_2D);
          // end-of-lines
          COLOR_OFF;
        }
      }


#if 0
      
      for (int i = 0; i < 5; ++i) { // RESEARCH ME: is this correct? needed above as well?
        if ((which == 41) && (i == 1))
          continue;
        if ((which == 42) && (i == 2))
          continue;
        if ((which == 43) && (i == 4))
          continue;
        if ((which == 44) && (i == 3))
          continue;

        jj = 0;
        if (i == 0)
          if (!bi->lid)
            continue;
          else {
            glBindTexture(GL_TEXTURE_2D, lidCache->getTextureWithId(bi->lid));
            if (bi->typeMap & 16384) {
              jj += 2;
            }
            if (bi->typeMap & 32768) {
              jj += 4;
            }
        }

        if (i == 2)
          if (!bi->top)
            continue;
          else
            glBindTexture(GL_TEXTURE_2D, sideCache->getTextureWithId(bi->top));
        if (i == 1)
          if (!bi->bottom)
            continue;
          else
            glBindTexture(GL_TEXTURE_2D, sideCache->getTextureWithId(bi->bottom));
        if (i == 4)
          if (!bi->right)
            continue;
          else
            glBindTexture(GL_TEXTURE_2D, sideCache->getTextureWithId(bi->right));
        if (i == 3)
          if (!bi->left)
            continue;
          else
            glBindTexture(GL_TEXTURE_2D, sideCache->getTextureWithId(bi->left));

        glBegin(GL_QUADS);
        // FIXME: normals are completely fucked up
        switch(i) {
          case 0:
            glNormal3f(nx, ny, nz);
            break;
          case 1:
            glNormal3f(0.0f, 0.0f, 1.0f);
            break;
          case 2:
            glNormal3f(0.0f, 0.0f, -1.0f);
            break;
          case 3:
            glNormal3f(-1.0f, 0.0f, 0.0f);
            break;
          case 4:
            glNormal3f(1.0f, 0.0f, 0.0f);
            break;
        }
        for (int j=0; j < 4; j++) {
          GLTEX_HELPER;
          scene_rendered_vertices += 3;
          glVertex3f(SLOPE_RAW_DATA[which][i][j][0],
              SLOPE_RAW_DATA[which][i][j][1],
              SLOPE_RAW_DATA[which][i][j][2]);
        }
        glEnd();
      }
#endif
    } // else

    if (!drawHeadingMarkers)
      return;
    float offset_correction = 0.1f;
    if (which == 0)
      offset_correction = -0.9f;
    //glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
#define HEIGHT_VERTEX(a, b, c) glVertex3f(a, offset_correction + slope_height_offset(which, a, c), c)
    if (bi->downOk()) {
      glBegin(GL_LINES);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.2f);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.8f);
      HEIGHT_VERTEX(0.45f, 0.1f, 0.7f);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.8f);
      HEIGHT_VERTEX(0.55f, 0.1f, 0.7f);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.8f);
      glEnd();
    }
    if (bi->upOk()) {
      glBegin(GL_LINES);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.8f);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.2f);
      HEIGHT_VERTEX(0.45f, 0.1f, 0.3f);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.2f);
      HEIGHT_VERTEX(0.55f, 0.1f, 0.3f);
      HEIGHT_VERTEX(0.5f, 0.1f, 0.2f);
      glEnd();
    }
    if (bi->leftOk()) {
      glBegin(GL_LINES);
      HEIGHT_VERTEX(0.2f, 0.1f, 0.5f);
      HEIGHT_VERTEX(0.8f, 0.1f, 0.5f);
      HEIGHT_VERTEX(0.3f, 0.1f, 0.45f);
      HEIGHT_VERTEX(0.2f, 0.1f, 0.5f);
      HEIGHT_VERTEX(0.3f, 0.1f, 0.55f);
      HEIGHT_VERTEX(0.2f, 0.1f, 0.5f);
      glEnd();
    }
    if (bi->rightOk()) {
      glBegin(GL_LINES);
      HEIGHT_VERTEX(0.8f, 0.1f, 0.5f);
      HEIGHT_VERTEX(0.2f, 0.1f, 0.5f);
      HEIGHT_VERTEX(0.7f, 0.1f, 0.45f);
      HEIGHT_VERTEX(0.8f, 0.1f, 0.5f);
      HEIGHT_VERTEX(0.7f, 0.1f, 0.55f);
      HEIGHT_VERTEX(0.8f, 0.1f, 0.5f);
      glEnd();
    }
    // block lid normals
//#if 0
    glColor3f(1, 0, 0); 
#define NORMAL_POS(a, b) glVertex3f(a, slope_height_offset(which, a, b), b)
#define NORMAL_POS2(a, b) glVertex3f(a + nx, slope_height_offset(which, a, b) + ny, b + nz)
    glBegin(GL_LINES);
    if (bi->lid) {
      NORMAL_POS(0.5f, 0.5f);
      NORMAL_POS2(0.5f, 0.5f);
    }
    glColor3f(0, 1, 0);
    if (bi->left) {
      glVertex3f(0, 0.5f, 0.5f);
      glVertex3f(-0.4f, 0.5f, 0.5f);
    }
    glColor3f(0, 0, 1);
    if (bi->right && !bi->isFlat()) {
      glVertex3f(1, 0.5f, 0.5f);
      glVertex3f(1.4f, 0.5f, 0.5f);
    }
    glColor3f(0, 1, 0);
    if (bi->top) {
      glVertex3f(0.5f, 0.5f, 0.0f);
      glVertex3f(0.5f, 0.5f, -0.4f);
    }
    glColor3f(0, 0, 1);
    if (bi->bottom && !bi->isFlat()) {
      glVertex3f(0.5f, 0.5f, 1.0f);
      glVertex3f(0.5f, 0.5f, 1.4f);
    }
    glEnd();
    glColor3f(1, 1, 1);
//#endif
    glEnable(GL_TEXTURE_2D);
    
    GL_CHECKERROR;
  }
}