DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Header

Mercurial (e67641c2e4cc)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=4 et sw=4 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "DecomposeIntoNoRepeatTriangles.h"
#include "gfxMatrix.h"

namespace mozilla {
namespace gl {

void RectTriangles::AppendRectToCoordArray(InfallibleTArray<coord>& array,
                                           GLfloat x0, GLfloat y0, GLfloat x1,
                                           GLfloat y1) {
  coord* v = array.AppendElements(6);

  v[0].x = x0;
  v[0].y = y0;
  v[1].x = x1;
  v[1].y = y0;
  v[2].x = x0;
  v[2].y = y1;
  v[3].x = x0;
  v[3].y = y1;
  v[4].x = x1;
  v[4].y = y0;
  v[5].x = x1;
  v[5].y = y1;
}

void RectTriangles::addRect(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1,
                            GLfloat tx0, GLfloat ty0, GLfloat tx1, GLfloat ty1,
                            bool flip_y /* = false */) {
  if (flip_y) {
    std::swap(ty0, ty1);
  }
  AppendRectToCoordArray(mVertexCoords, x0, y0, x1, y1);
  AppendRectToCoordArray(mTexCoords, tx0, ty0, tx1, ty1);
}

static GLfloat WrapTexCoord(GLfloat v) {
  // This should return values in range [0, 1.0)
  return v - floorf(v);
}

void DecomposeIntoNoRepeatTriangles(const gfx::IntRect& aTexCoordRect,
                                    const gfx::IntSize& aTexSize,
                                    RectTriangles& aRects,
                                    bool aFlipY /* = false */) {
  // normalize this
  gfx::IntRect tcr(aTexCoordRect);
  while (tcr.X() >= aTexSize.width) tcr.MoveByX(-aTexSize.width);
  while (tcr.Y() >= aTexSize.height) tcr.MoveByY(-aTexSize.height);

  // Compute top left and bottom right tex coordinates
  GLfloat tl[2] = {GLfloat(tcr.X()) / GLfloat(aTexSize.width),
                   GLfloat(tcr.Y()) / GLfloat(aTexSize.height)};
  GLfloat br[2] = {GLfloat(tcr.XMost()) / GLfloat(aTexSize.width),
                   GLfloat(tcr.YMost()) / GLfloat(aTexSize.height)};

  // then check if we wrap in either the x or y axis; if we do,
  // then also use fmod to figure out the "true" non-wrapping
  // texture coordinates.

  bool xwrap = false, ywrap = false;
  if (tcr.X() < 0 || tcr.X() > aTexSize.width || tcr.XMost() < 0 ||
      tcr.XMost() > aTexSize.width) {
    xwrap = true;
    tl[0] = WrapTexCoord(tl[0]);
    br[0] = WrapTexCoord(br[0]);
  }

  if (tcr.Y() < 0 || tcr.Y() > aTexSize.height || tcr.YMost() < 0 ||
      tcr.YMost() > aTexSize.height) {
    ywrap = true;
    tl[1] = WrapTexCoord(tl[1]);
    br[1] = WrapTexCoord(br[1]);
  }

  NS_ASSERTION(tl[0] >= 0.0f && tl[0] <= 1.0f && tl[1] >= 0.0f &&
                   tl[1] <= 1.0f && br[0] >= 0.0f && br[0] <= 1.0f &&
                   br[1] >= 0.0f && br[1] <= 1.0f,
               "Somehow generated invalid texture coordinates");

  // If xwrap is false, the texture will be sampled from tl[0]
  // .. br[0].  If xwrap is true, then it will be split into tl[0]
  // .. 1.0, and 0.0 .. br[0].  Same for the Y axis.  The
  // destination rectangle is also split appropriately, according
  // to the calculated xmid/ymid values.

  // There isn't a 1:1 mapping between tex coords and destination coords;
  // when computing midpoints, we have to take that into account.  We
  // need to map the texture coords, which are (in the wrap case):
  // |tl->1| and |0->br| to the |0->1| range of the vertex coords.  So
  // we have the length (1-tl)+(br) that needs to map into 0->1.
  // These are only valid if there is wrap involved, they won't be used
  // otherwise.
  GLfloat xlen = (1.0f - tl[0]) + br[0];
  GLfloat ylen = (1.0f - tl[1]) + br[1];

  NS_ASSERTION(!xwrap || xlen > 0.0f, "xlen isn't > 0, what's going on?");
  NS_ASSERTION(!ywrap || ylen > 0.0f, "ylen isn't > 0, what's going on?");
  NS_ASSERTION(aTexCoordRect.Width() <= aTexSize.width &&
                   aTexCoordRect.Height() <= aTexSize.height,
               "tex coord rect would cause tiling!");

  if (!xwrap && !ywrap) {
    aRects.addRect(0.0f, 0.0f, 1.0f, 1.0f, tl[0], tl[1], br[0], br[1], aFlipY);
  } else if (!xwrap && ywrap) {
    GLfloat ymid = (1.0f - tl[1]) / ylen;
    aRects.addRect(0.0f, 0.0f, 1.0f, ymid, tl[0], tl[1], br[0], 1.0f, aFlipY);
    aRects.addRect(0.0f, ymid, 1.0f, 1.0f, tl[0], 0.0f, br[0], br[1], aFlipY);
  } else if (xwrap && !ywrap) {
    GLfloat xmid = (1.0f - tl[0]) / xlen;
    aRects.addRect(0.0f, 0.0f, xmid, 1.0f, tl[0], tl[1], 1.0f, br[1], aFlipY);
    aRects.addRect(xmid, 0.0f, 1.0f, 1.0f, 0.0f, tl[1], br[0], br[1], aFlipY);
  } else {
    GLfloat xmid = (1.0f - tl[0]) / xlen;
    GLfloat ymid = (1.0f - tl[1]) / ylen;
    aRects.addRect(0.0f, 0.0f, xmid, ymid, tl[0], tl[1], 1.0f, 1.0f, aFlipY);
    aRects.addRect(xmid, 0.0f, 1.0f, ymid, 0.0f, tl[1], br[0], 1.0f, aFlipY);
    aRects.addRect(0.0f, ymid, xmid, 1.0f, tl[0], 0.0f, 1.0f, br[1], aFlipY);
    aRects.addRect(xmid, ymid, 1.0f, 1.0f, 0.0f, 0.0f, br[0], br[1], aFlipY);
  }
}

}  // namespace gl
}  // namespace mozilla