Licar/renderer.h

/**
  3D renderer: implements 3D rendering.
*/

#ifndef _LCR_RENDERER_H
#define _LCR_RENDERER_H

#define S3L_RESOLUTION_X LCR_SETTING_RESOLUTION_X
#define S3L_RESOLUTION_Y LCR_SETTING_RESOLUTION_Y
#define S3L_PIXEL_FUNCTION LCR_pixelFunc3D

#define S3L_PERSPECTIVE_CORRECTION 2
#define S3L_NEAR_CROSS_STRATEGY 0

#define S3L_Z_BUFFER 1

#include "small3dlib.h"

/// Renderer specific unit, length of one map square.
#define LCR_RENDERER_UNIT S3L_FRACTIONS_PER_UNIT

struct
{
  S3L_Scene scene3D;
  S3L_Model3D models3D[3]; // TODO

  S3L_Model3D *mapModel;
  S3L_Unit mapVertices[LCR_SETTING_MAX_MAP_VERTICES * 3];
  S3L_Index mapTriangles[LCR_SETTING_MAX_MAP_TRIANGLES * 3];

  // pixel function precomputed values:
  int previousTriangleID;
  int triangleUVs[6];
} LCR_renderer;

void LCR_pixelFunc3D(S3L_PixelInfo *pixel)
{
  // once we get a new triangle, we precompute things for it:
  if (pixel->triangleIndex != LCR_renderer.previousTriangleID)
  {
    S3L_Index *t = LCR_renderer.mapTriangles + 3 * pixel->triangleIndex;

    S3L_Unit *v[3];

    for (int i = 0; i < 3; ++i)
      v[i] = LCR_renderer.mapVertices + 3 * t[i];

    uint8_t type = // 0: floor, 1: wall, 2: wall 90 degrees
      (v[0][0] == v[1][0] && v[1][0] == v[2][0]) +
      2 * (v[0][2] == v[1][2] && v[1][2] == v[2][2]);

    if (type == 0)
    {
      LCR_loadImage(3);

      if (v[0][1] != v[1][1] || v[1][1] != v[2][1])
        LCR_imageChangeBrightness(1);
      for (int i = 0; i < 6; ++i)
        LCR_renderer.triangleUVs[i] = ((
          (v[i / 2][(i % 2) * 2]) *
            LCR_IMAGE_SIZE) / LCR_RENDERER_UNIT);
    }
    else
    {
      LCR_loadImage(1);
      
      if (type == 1)
        LCR_imageChangeBrightness(0);

      for (int i = 0; i < 6; ++i)
      {
        LCR_renderer.triangleUVs[i] = ((
          (v[i / 2][i % 2 ? 1 : (type == 1 ? 2 : 0)]) *
            LCR_IMAGE_SIZE) / LCR_RENDERER_UNIT);

        if (i % 2)
          LCR_renderer.triangleUVs[i] = LCR_IMAGE_SIZE -
            LCR_renderer.triangleUVs[i];
      }
    }

    LCR_renderer.previousTriangleID = pixel->triangleIndex;
  }

  int barycentric[3];

  barycentric[0] = pixel->barycentric[0] / 8;
  barycentric[1] = pixel->barycentric[1] / 8;
  barycentric[2] = pixel->barycentric[2] / 8;

  uint16_t color = LCR_sampleImage(
    (barycentric[0] * LCR_renderer.triangleUVs[0] +
     barycentric[1] * LCR_renderer.triangleUVs[2] +
     barycentric[2] * LCR_renderer.triangleUVs[4])
     / (S3L_FRACTIONS_PER_UNIT / 8),
    (barycentric[0] * LCR_renderer.triangleUVs[1] +
     barycentric[1] * LCR_renderer.triangleUVs[3] +
     barycentric[2] * LCR_renderer.triangleUVs[5])
     / (S3L_FRACTIONS_PER_UNIT / 8)
    );

  LCR_drawPixelXYUnsafe(pixel->x,pixel->y,color);
}

S3L_Index _LCR_addMapVertex(S3L_Unit x, S3L_Unit y, S3L_Unit z)
{
  S3L_Index index = 0;
  S3L_Unit *vertices = LCR_renderer.mapVertices;

  while (index < LCR_renderer.mapModel->vertexCount) // if exists, return vertex index
  {
    if (vertices[0] == x && vertices[1] == y && vertices[2] == z)
      return index;

    vertices += 3;
    index++;
  }

  // if it doesn't exist, add it
  if (LCR_renderer.mapModel->vertexCount < LCR_SETTING_MAX_MAP_VERTICES)
  {
    *vertices = x;
    vertices++;
    *vertices = y;
    vertices++;
    *vertices = z;
    LCR_renderer.mapModel->vertexCount++;
    return LCR_renderer.mapModel->vertexCount - 1;
  }

  // TODO: error print
  return 0;  
}

void _LCR_addMapTriangle(S3L_Index a, S3L_Index b, S3L_Index c)
{
  if (LCR_renderer.mapModel->triangleCount < LCR_SETTING_MAX_MAP_TRIANGLES)
  {
    S3L_Index *t = &(LCR_renderer.mapTriangles[LCR_renderer.mapModel->triangleCount * 3]);

    *t = a; t++;
    *t = b; t++;
    *t = c;

    LCR_renderer.mapModel->triangleCount++;
  }
}

void _LCR_rendererSwapTriangles(S3L_Index *t1, S3L_Index *t2)
{
  S3L_Index tmp;

  for (int i = 0; i < 3; ++i)
  {
    tmp = t1[i];
    t1[i] = t2[i];
    t2[i] = tmp;
  }
}

int _LCR_quadCoversTriangle(const S3L_Unit quad[8], const S3L_Unit tri[6])
{
  for (int i = 0; i < 3; ++i) // for each triangle point
  {
    int covered = 0;

    for (int j = 0; j < 3; ++j) // for each quad subtriangle
    {
      uint8_t winds = 0;

      for (int k = 0; k < 3; ++k) // for each subtriangle side
      {
         S3L_Unit w = // triangle winding
          (quad[(2 * (j + ((k + 1) % 3))) % 8 + 1] -
            quad[(2 * (j + k)) % 8 + 1]) *
          (tri[2 * i] - quad[(2 * (j + (k + 1) % 3)) % 8]) -
          (quad[(2 * (j + ((k + 1) % 3))) % 8] - quad[(2 * (j + k)) % 8])
          * (tri[2 * i + 1] - quad[(2 * (j + (k + 1) % 3)) % 8 + 1]);

         if (w > 0)
           winds |= 1;
         else if (w < 0)
           winds |= 2;
      }

      if (winds != 3) // no opposite winds?
      {
        covered = 1;
        break;
      }
    }

    if (!covered)
      return 0;
  }

  return 1;
}

/**
  Checks whether two triangles (and potenrially their neighbors) cover each
  other, in return values lowest bit means whether t1 is covered and the second
  lowest bit means whether t2 is covered.
*/
uint8_t _LCR_rendererCheckMapTriangleCover(const S3L_Index *t1,
  const S3L_Index *t2)
{
  if ((t1[0] == t2[0] || t1[0] == t2[1] || t1[0] == t2[2]) &&
    (t1[1] == t2[0] || t1[1] == t2[1] || t1[1] == t2[2]) &&
    (t1[2] == t2[0] || t1[2] == t2[1] || t1[2] == t2[2]))
    return 0x03;

  uint8_t result = 0;
  int plane = -1;

  for (int i = 0; i < 3; ++i)
    if (LCR_renderer.mapVertices[3 * t1[0] + i] == LCR_renderer.mapVertices[3 * t1[1] + i] &&
        LCR_renderer.mapVertices[3 * t1[1] + i] == LCR_renderer.mapVertices[3 * t1[2] + i] &&
        LCR_renderer.mapVertices[3 * t1[2] + i] == LCR_renderer.mapVertices[3 * t2[0] + i] &&
        LCR_renderer.mapVertices[3 * t2[0] + i] == LCR_renderer.mapVertices[3 * t2[1] + i] &&
        LCR_renderer.mapVertices[3 * t2[1] + i] == LCR_renderer.mapVertices[3 * t2[2] + i])
    {
      plane = i;
      break;
    }

  if (plane >= 0) // both triangles in the same plane => then do more checks
  {
    for (int j = 0; j < 2; ++j)
    {
      S3L_Unit points2D[14]; // tri1, quad (tri2 + 1 extra vert)

      int coordX = plane == 0 ? 1 : 0,
          coordY = plane == 2 ? 1 : 2;

      for (int i = 0; i < 3; ++i)
      {
        points2D[i * 2]         = LCR_renderer.mapVertices[3 * t1[i] + coordX];
        points2D[i * 2 + 1]     = LCR_renderer.mapVertices[3 * t1[i] + coordY];
        points2D[6 + i * 2]     = LCR_renderer.mapVertices[3 * t2[i] + coordX];
        points2D[6 + i * 2 + 1] = LCR_renderer.mapVertices[3 * t2[i] + coordY];
      }

      points2D[12] = (4 * points2D[6] + 3 * points2D[8] + points2D[10]) / 8;
      points2D[13] = (4 * points2D[7] + 3 * points2D[9] + points2D[11]) / 8;

      // first: does the triangle alone cover the other one?
      if (_LCR_quadCoversTriangle(points2D + 6,points2D))
        result |= 1 << j;
      else
      {
        // now check if this triangle along with a neighbor cover the other one

        S3L_Index *t3 = LCR_renderer.mapTriangles;

        for (int i = 0; i < LCR_renderer.mapModel->triangleCount; ++i)
        {
          uint8_t sharedVerts =
            (t3[0] == t2[0] || t3[0] == t2[1] || t3[0] == t2[2]) |
            ((t3[1] == t2[0] || t3[1] == t2[1] || t3[1] == t2[2]) << 1) |
            ((t3[2] == t2[0] || t3[2] == t2[1] || t3[2] == t2[2]) << 2);

          if (
            t3 != t1 && t3 != t2 &&
            (sharedVerts == 3 || sharedVerts == 5 || sharedVerts == 6) &&
            LCR_renderer.mapVertices[3 * t3[0] + plane] ==
            LCR_renderer.mapVertices[3 * t3[1] + plane] &&
            LCR_renderer.mapVertices[3 * t3[1] + plane] ==
            LCR_renderer.mapVertices[3 * t3[2] + plane] &&
            LCR_renderer.mapVertices[3 * t3[0] + plane] ==
            LCR_renderer.mapVertices[3 * t1[0] + plane]
            )
          {
            // here shares exactly two vertices and is in the same plane

            uint8_t freeVert =
              sharedVerts == 3 ? 2 : (sharedVerts == 5 ? 1 : 0);

            points2D[12] = LCR_renderer.mapVertices[3 * t3[freeVert] + coordX];
            points2D[13] = LCR_renderer.mapVertices[3 * t3[freeVert] + coordY];
           
            if (_LCR_quadCoversTriangle(points2D + 6,points2D))
            {
              result |= 1 << j;
              break;
            }
          }

          t3 += 3;
        }

      }

      const S3L_Index *tmp = t1;
      t1 = t2;
      t2 = tmp;
    }
  }

  return result;
}

/**
  Removes map triangles that are covered by other triangles (and also vertices
  that by this become unused). This makes the map model smaller, faster and
  prevents bleeding through due to z-bugger imprecisions.
*/
void _LCR_rendererCullHiddenMapTriangles(void)
{
  int n = 0; // number of removed elements
  int i = 0;

  S3L_Index *t1 = LCR_renderer.mapTriangles, *t2;

  /*
    We'll be moving the covered triangles to the end of the array, then at the
    end we'll just shorten the array by number of removed triangles.
  */
  while (i < LCR_renderer.mapModel->triangleCount - n)
  {
    t2 = t1 + 3; // t2 is the the other triangle against which we check

    int t1Covered = 0;

    for (int j = i + 1; j < LCR_renderer.mapModel->triangleCount; ++j)
    {
      uint8_t cover = _LCR_rendererCheckMapTriangleCover(t1,t2);

      t1Covered |= cover & 0x01;

      if (cover & 0x02)
      {
        if (j < LCR_renderer.mapModel->triangleCount - n)
        {
          _LCR_rendererSwapTriangles(t2,LCR_renderer.mapTriangles +
            (LCR_renderer.mapModel->triangleCount - 1 - n) * 3);

          n++;
        }
      }
 
      t2 += 3; // check next triangle
    }

    if (t1Covered)
    {
      _LCR_rendererSwapTriangles(t1,LCR_renderer.mapTriangles +
        (LCR_renderer.mapModel->triangleCount - 1 - n) * 3);
      n++;
      // we stay at this position because we've swapped the triangle here
    }
    else
    {
      t1 += 3;
      i++;
    }
  }

  LCR_renderer.mapModel->triangleCount -= n; // cut off the removed triangles

  // remove unused vertices:

  i = 0;

  while (i < LCR_renderer.mapModel->vertexCount)
  {
    int used = 0;

    for (int j = 0; j < LCR_renderer.mapModel->triangleCount * 3; ++j)
      if (LCR_renderer.mapTriangles[j] == i)
      {
        used = 1;
        break;
      }

    if (used)
      i++;
    else
    {
      for (int j = 0; j < 3; ++j)
        LCR_renderer.mapVertices[3 * i + j] =
          LCR_renderer.mapVertices[(LCR_renderer.mapModel->vertexCount - 1) * 3 + j];

      for (int j = 0; j < LCR_renderer.mapModel->triangleCount * 3; ++j)
        if (LCR_renderer.mapTriangles[j] == LCR_renderer.mapModel->vertexCount - 1)
          LCR_renderer.mapTriangles[j] = i;

      LCR_renderer.mapModel->vertexCount--;
    }
  }
}

/**
  Builds the internal 3D model of the currently loaded map. Returns 1 on
  success, 0 otherwise (e.g. not enough space).
*/
uint8_t _LCR_rendererBuildMapModel(void)
{
  uint8_t blockShapeBytes[LCR_MAP_BLOCK_SHAPE_MAX_BYTES];
  uint8_t blockShapeByteCount;

  S3L_model3DInit(LCR_renderer.mapVertices,0,LCR_renderer.mapTriangles,0,LCR_renderer.mapModel);

  for (int j = 0; j < LCR_currentMap.blockCount; ++j)
  {
    uint8_t bx, by, bz;
    LCR_mapBlockGetCoords(LCR_currentMap.blocks + j * LCR_BLOCK_SIZE,
      &bx,&by,&bz);

    LCR_mapGetBlockShape(LCR_currentMap.blocks[j * LCR_BLOCK_SIZE],
      LCR_mapBlockGetTransform(LCR_currentMap.blocks + j  * LCR_BLOCK_SIZE),
      blockShapeBytes,&blockShapeByteCount);

    uint8_t vx, vy, vz, vi = 0,
      isAtFloor = by == 0,
      isAtCeiling = by == LCR_MAP_SIZE_BLOCKS - 1;
    S3L_Index triangleIndices[3];

    S3L_Unit originOffset = -1 * LCR_MAP_SIZE_BLOCKS / 2 * LCR_RENDERER_UNIT;

    for (int i = 0; i < blockShapeByteCount; ++i)
    {
      LCR_decodeMapBlockCoords(blockShapeBytes[i],&vx,&vy,&vz);

      isAtFloor &= vy == 0;
      isAtCeiling &= vy == 12; 

      triangleIndices[vi] = _LCR_addMapVertex(
        originOffset + (((S3L_Unit) bx) * LCR_RENDERER_UNIT) +       (LCR_RENDERER_UNIT * ((S3L_Unit) vx)) / 12,
        (originOffset + (((S3L_Unit) by) * LCR_RENDERER_UNIT)) / 2 + (LCR_RENDERER_UNIT / 2 * ((S3L_Unit) vy)) / 12,
        originOffset + (((S3L_Unit) bz) * LCR_RENDERER_UNIT) +       (LCR_RENDERER_UNIT * ((S3L_Unit) vz)) / 12);

      if (vi < 2)
        vi++;
      else
      {
        // don't add triangles completely at the floor or ceiling of the map
        if (!isAtFloor && !isAtCeiling)
          _LCR_addMapTriangle(
            triangleIndices[0],triangleIndices[1],triangleIndices[2]);

        vi = 0;
        isAtFloor = by == 0;
        isAtCeiling = by == LCR_MAP_SIZE_BLOCKS - 1;
      }
    }
  }

  // TODO: also cull the triangles in the loop by some N steps

  _LCR_rendererCullHiddenMapTriangles();

  return 1;
}

uint8_t LCR_rendererInit(void)
{
  LCR_renderer.mapModel = LCR_renderer.models3D;

  if (!_LCR_rendererBuildMapModel())
    return 0;

  S3L_sceneInit(LCR_renderer.models3D,1,&LCR_renderer.scene3D);

  return 1;
}

void LCR_rendererMoveCamera(LCR_SpaceUnit forwRightUpOffset[3],
  LCR_SpaceUnit yawPitchOffset[2])
{  
  S3L_Vec4 f, r, u;

  S3L_rotationToDirections(LCR_renderer.scene3D.camera.transform.rotation,
    S3L_FRACTIONS_PER_UNIT,&f,&r,&u);

  LCR_renderer.scene3D.camera.transform.translation.x +=
    ((f.x * forwRightUpOffset[0] + r.x * forwRightUpOffset[1] + 
    u.x * forwRightUpOffset[2]) * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;      
 
  LCR_renderer.scene3D.camera.transform.translation.y +=
    ((f.y * forwRightUpOffset[0] + r.y * forwRightUpOffset[1] + 
    u.y * forwRightUpOffset[2]) * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;      

  LCR_renderer.scene3D.camera.transform.translation.z +=
    ((f.z * forwRightUpOffset[0] + r.z * forwRightUpOffset[1] + 
    u.z * forwRightUpOffset[2]) * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;      
  
  LCR_renderer.scene3D.camera.transform.rotation.y +=
    (yawPitchOffset[0] * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;
  
  LCR_renderer.scene3D.camera.transform.rotation.x +=
    (yawPitchOffset[1] * S3L_FRACTIONS_PER_UNIT) / LCR_SQUARE_SIDE_LEN;

  if (LCR_renderer.scene3D.camera.transform.rotation.x > S3L_FRACTIONS_PER_UNIT / 4)
    LCR_renderer.scene3D.camera.transform.rotation.x = S3L_FRACTIONS_PER_UNIT / 4;

  if (LCR_renderer.scene3D.camera.transform.rotation.x < -1 * S3L_FRACTIONS_PER_UNIT / 4)
    LCR_renderer.scene3D.camera.transform.rotation.x = -1 * S3L_FRACTIONS_PER_UNIT / 4;
}

/**
  Draws background sky, offsets are in multiples of screen dimensions
  (e.g. S3L_FRACTIONS_PER_UNIT / 2 for offsetH means half the screen width).
*/
void LCR_rendererDrawSky(int sky, S3L_Unit offsetH, S3L_Unit offsetV)
{
  int anchorPoint[2], y;
  unsigned long pixelIndex;
  unsigned int topColor, bottomColor;

  sky = 8 + 4 * sky;

  LCR_loadImage(sky);
  topColor = LCR_sampleImage(0,0);

  LCR_loadImage(sky + 3);
  bottomColor = LCR_sampleImage(LCR_IMAGE_SIZE - 1,LCR_IMAGE_SIZE - 1);

  anchorPoint[0] = ((LCR_EFFECTIVE_RESOLUTION_X * offsetH)
    / S3L_FRACTIONS_PER_UNIT) %
    (2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE);

  if (anchorPoint[0] < 0)
    anchorPoint[0] += 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;

  anchorPoint[1] = 
    (LCR_EFFECTIVE_RESOLUTION_Y) / 3 - // 3: we place the center a bit more up
    (LCR_EFFECTIVE_RESOLUTION_Y * offsetV) / S3L_FRACTIONS_PER_UNIT
    - LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
  
  pixelIndex = 0;
  y = anchorPoint[1] < 0 ? anchorPoint[1] : 0;

  while (y < anchorPoint[1] && y < LCR_EFFECTIVE_RESOLUTION_Y) // top strip
  {
    for (int x = 0; x < LCR_EFFECTIVE_RESOLUTION_X; ++x)
    {
      LCR_drawPixel(pixelIndex,topColor);
      pixelIndex++;
    }

    y++;
  }

  anchorPoint[1] += 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
    
  int linesLeft = 0;
  int skyPart = 0;

  while (y < anchorPoint[1] && y < LCR_EFFECTIVE_RESOLUTION_Y) // image strip
  {
    if (!linesLeft)
    {
      LCR_loadImage(sky + skyPart);
      linesLeft = LCR_IMAGE_SIZE / 2;
      skyPart++;
    }

    if (y >= 0)
    {
      for (int ix = 0; ix < 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
        ix += LCR_SETTING_SKY_SIZE)
      {
        unsigned int color = LCR_getNextImagePixel();
        unsigned long startIndex = pixelIndex;

        for (int k = 0; k < LCR_SETTING_SKY_SIZE; ++k)
        {
          if (y + k >= LCR_EFFECTIVE_RESOLUTION_Y)
            break;

          for (int j = 0; j < LCR_SETTING_SKY_SIZE; ++j)
          {
            int x = anchorPoint[0] + ix + j;

            if (x >= 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE)
              x -= 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;

            while (x < LCR_EFFECTIVE_RESOLUTION_X)
            {
              LCR_drawPixel(startIndex + x,color);
              x += 2 * LCR_IMAGE_SIZE * LCR_SETTING_SKY_SIZE;
            }
          }

          startIndex += LCR_EFFECTIVE_RESOLUTION_X;
        }
      }
    
      pixelIndex += LCR_EFFECTIVE_RESOLUTION_X * LCR_SETTING_SKY_SIZE;
      y += LCR_SETTING_SKY_SIZE;
    }
    else
    {
      for (int ix = 0; ix < 2 * LCR_IMAGE_SIZE; ++ix)
        LCR_getNextImagePixel();
   
      for (int i = 0; i < LCR_SETTING_SKY_SIZE; ++i)
      {
        if (y >= 0)
          for (int x = 0; x < LCR_EFFECTIVE_RESOLUTION_X; ++x)
          {
            LCR_drawPixel(pixelIndex,topColor);
            pixelIndex++;
          }

        y++;
      }
    }

    linesLeft--;
  }

  while (y < 0) // can still be the case
    y = 0;

  while (y < LCR_EFFECTIVE_RESOLUTION_Y) // bottom strip
  {
    for (int x = 0; x < LCR_EFFECTIVE_RESOLUTION_X; ++x)
    {
      LCR_drawPixel(pixelIndex,bottomColor);
      pixelIndex++;
    }

    y++;
  }
}

void LCR_rendererDraw(void)
{
  LCR_renderer.previousTriangleID = -1;
  S3L_newFrame();

  LCR_rendererDrawSky(2,
    LCR_renderer.scene3D.camera.transform.rotation.y,
    -4 * LCR_renderer.scene3D.camera.transform.rotation.x);

  S3L_drawScene(LCR_renderer.scene3D);
}

#endif // guard