WMO/Rendering

From wowdev
Revision as of 06:51, 9 November 2017 by Fallenoak (talk | contribs) (Stubbing out group rendering section)
Jump to navigation Jump to search

Lighting

Lighting for interior WMO groups is prebaked into vertex colors.

CMapObj::QueryLighting

In order to light entities like units, game objects, etc that exist within interior WMO groups, the game does the following:

  1. Query for the closest MOPY.
  2. Obtain the 3 relevant MOCV values for the MOPY.
  3. Create a CImVector color by interpolating the values based on the position of the entity relative to the MOPY (ie barycentric interpolation).

This queried color value is then fed in to the standard lighting logic.

Query with C3Segment

The following function is used to query lighting when the exact poly is not yet known. It uses a C3Segment to perform a ranged query against the BSP tree for relevant tris.

bool CMapObj::QueryLighting(CMapObj *this, uint32_t groupIndex, const C3Segment *seg, CImVector *color, bool *a5) {

  CMapObjGroup group = this->groupList[groupIndex];

  if (!this->unk6[16] || !(group->unk14 & 1) || group->flags & (SMOGroup::EXTERIOR | SMOGroup::EXTERIOR_LIT)) {

    return 0;

  }

  World::TriData::resultFlags = 0;
  World::TriData::nBatches = 0;
  World::TriData::nTriIndices = 0;
  World::TriData::nVertexIndices = 0;
  World::TriData::nMatrices = 0;

  float hitT = 1.0;

  // Query the BSP tree for the group to find appropriate tris

  bool triRes = CMapObjGroup::GetTris(group, seg, &hitT, 0, 0x8, (int)&a2 + 3, 0);

  if (!triRes) {

    return 0;

  }

  // Obtain point matching intersection between segment and tri

  C3Vector point;

  point.x = seg->start.x + hitT * (seg->end.x - seg->start.x);
  point.y = seg->start.y + hitT * (seg->end.y - seg->start.y);
  point.z = seg->start.z + hitT * (seg->end.z - seg->start.z);

  unsigned __int16 hitPoly = word_CD8094;

  bool lightRes = CMapObjGroup::QueryLighting(group, &point, hitPoly, color, a5);

  return lightRes;

}

Query with C3Vector and poly index

The following function is used to query lighting when the relevant poly is already known.

bool CMapObj::QueryLighting(CMapObj *this, uint32_t groupIndex, const C3Vector *point, uint16_t polyIdx, CImVector *color, bool *a5) {

  CMapObjGroup group = this->groupList[groupIndex];

  if (!this->unk6[16] || !(group->unk14 & 1) || group->flags & (SMOGroup::EXTERIOR | SMOGroup::EXTERIOR_LIT)) {

    return 0;

  }

  // Since the point and poly are already known, there's no need to query the BSP tree

  bool lightRes = CMapObjGroup::QueryLighting(group, point, polyIdx, color, a5);

  return lightRes;

}

CMapObjGroup::QueryLighting

Once a point and poly have been identified (see the other CMapObj lighting query functions), this function is used to calculate a CImVector color value.

Barycentric interpolation is used to combine the relevant vertex colors, and the CMapObj ambient color is added if the appropriate flag is set.

bool CMapObjGroup::QueryLighting(CMapObjGroup *this, const C3Vector *point, uint16_t polyIdx, CImVector *color, bool *a5) {

  // Poly is out of bounds

  if (polyIdx >= this->polyCount) {

    *color = this->parent->ambColor;
    *a5 = 0;

    return 1;

  }

  // Load xyAxisTable

  if (!(dword_D2DC18 & 1)) {

    dword_D2DC18 |= 1u;

    xyAxisTable[0] = { 1, 2 };
    xyAxisTable[1] = { 2, 0 };
    xyAxisTable[2] = { 0, 1 };

  }

  uint16_t* indices = &this->indexList[3 * polyIdx];

  C3Vector* vertices = this->vertexList;

  C3Vector* vert1 = &vertices[indices[0]];
  C3Vector* vert2 = &vertices[indices[1]];
  C3Vector* vert3 = &vertices[indices[2]];

  // Obtain normal for poly

  C4Plane plane;
  C4Plane::From3Pos(&plane, vert1, vert2, vert3);

  C3Vector::EAxis majAxis = C3Vector::MajorAxis(&plane.normal);

  // Obtain 2d coordinates for point and poly

  C2iVector xy = xyAxisTable[majAxis];

  C2Vector pt = { ((float *)(&point))[xy.x], ((float *)(&point))[xy.y] };
  C2Vector v1 = { ((float *)(&vert1))[xy.x], ((float *)(&vert1))[xy.y] };
  C2Vector v2 = { ((float *)(&vert2))[xy.x], ((float *)(&vert2))[xy.y] };
  C2Vector v3 = { ((float *)(&vert3))[xy.x], ((float *)(&vert3))[xy.y] };

  // Calculate barycentric weights
  // https://stackoverflow.com/a/26567573/6770172

  C2Vector sv2 = { v2.x - v1.x, v2.y - v1.y };
  C2Vector sv3 = { v3.x - v1.x, v3.y - v1.y };
  C2Vector spt = { pt.x - v1.x, pt.y - v1.y };

  // total area = cross(sub(v2, v1), sub(v3, v1))
  float at = sv2.x * sv3.y - sv2.y * sv3.x;

  // a3 = cross(sub(v2, v1), sub(pt, v1)) / total area
  float a3 = (sv2.x * spt.y - sv2.y * spt.x) / at;

  // a2 = cross(sub(pt, v1), sub(v3, v1)) / total area
  float a2 = (spt.x * sv3.y - spt.y * sv3.x) / at;

  // Calculate color weights

  int w3 = (a3 * 256.0) - 0.5;
  int w2 = (a2 * 256.0) - 0.5;
  int w1 = 256 - w3 - w2;

  // Adjust weights in cases where point is outside poly

  if (w3 < 0) {

    int o3 = (w3 * w2) / (w1 + w2);

    w2 += o3;
    w1 += w3 - o3;

    w3 = 0;

  }

  if (w2 < 0) {

    int o2 = (w2 * w3) / (w1 + w3);

    w3 += o2;
    w1 += w2 - o2;

    w2 = 0;

  }

  if (w1 < 0) {

    int o1 = (w1 * w2) / (w2 + w3);

    w2 += o1;
    w3 += w1 - o1;

    w1 = 0;

  }

  CImVector c1 = this->colorVertexList[indices[0]];
  CImVector c2 = this->colorVertexList[indices[1]];
  CImVector c3 = this->colorVertexList[indices[2]];

  // Interpolate color by weight

  color->a = (uint16_t)(w1 * c1.a + w2 * c2.a + w3 * c3.a) / 256;
  color->r = (uint16_t)(w1 * c1.r + w2 * c2.r + w3 * c3.r) / 256;
  color->g = (uint16_t)(w1 * c1.g + w2 * c2.g + w3 * c3.g) / 256;
  color->b = (uint16_t)(w1 * c1.b + w2 * c2.b + w3 * c3.b) / 256;

  // Double color RGB values -- not sure why?

  uint32_t v49 = 2 * color->r;
  uint32_t v50 = 2 * color->g;
  uint32_t v51 = 2 * color->b;

  // If MOHD.flags & 0x02, add CMapObj ambient color

  if (this->parent->header->flags & 0x2) {

    v49 += this->parent->ambColor.r;
    v50 += this->parent->ambColor.g;
    v51 += this->parent->ambColor.b;

  }

  // Clamp final color to 255

  color->r = v49 >= 0xFF ? 0xFF : v49;
  color->g = v50 >= 0xFF ? 0xFF : v50;
  color->b = v51 >= 0xFF ? 0xFF : v51;

  // MOPY.flags & 0x01 -- what is this used for?

  *a5 = this->polyList[polyIdx].flags & 0x1;

  return 1;

}

CMapObjGroup::FixColorVertexAlpha

When loading a CMapObjGroup, if SMOHeader->flags 0x8 is not set, a vertex color adjustment routine called FixColorVertexAlpha is run against all vertex colors present in colorVertexList.

if ((this->parent->header->flags & 0x8) == 0) {
  CMapObjGroup::FixColorVertexAlpha(this);
}

The logic is taken from build 3.3.5.12340. Later versions of the function may involve SMOHeader->ambColor and slightly different logic.

void CMapObjGroup::FixColorVertexAlpha(CMapObjGroup *this) {
  int firstNonTransIndex;

  if (this->transBatchCount > 0) {
    firstNonTransIndex = this->batchList[this->transBatchCount - 1]->maxIndex + 1;
  } else {
    firstNonTransIndex = 0;
  }

  if (this->colorVertexCount) {
    for (int i = 0; i < this->colorVertexCount; i++) {
      CImVector *color = &this->colorVertexList[i];

      // Adjust color in int or ext batch
      if (i >= firstNonTransIndex) {
        uint32_t r = (color->r + (((uint32_t)color->a * color->r) / 64)) / 2;
        uint32_t g = (color->g + (((uint32_t)color->a * color->g) / 64)) / 2;
        uint32_t b = (color->b + (((uint32_t)color->a * color->b) / 64)) / 2;

        color->r = r > 255 ? 255 : r;
        color->g = g > 255 ? 255 : g;
        color->b = b > 255 ? 255 : b;

        color->a = 255;
      // Adjust color in trans batch
      } else {
        color->r /= 2;
        color->g /= 2;
        color->b /= 2;
      }
    }
  }
}

WotLK Group Rendering

This section is applicable to Wrath of the Lich King. Cataclysm significantly changed the CMapObjGroup rendering paths.

Rendering of CMapObjGroups is handled by a pair of functions. One handles interior groups and the other handles exterior groups.

These functions can be replaced by debug rendering functions when CMapObj::s_renderMode is set to one of the various debug rendering modes.

CMapObj::RenderGroup_Int

CMapObj::RenderGroup_Ext