godot/thirdparty/thekla_atlas/nvmesh/raster/Raster.cpp

627 lines
21 KiB
C++
Raw Normal View History

// This code is in the public domain -- castanyo@yahoo.es
/** @file Raster.cpp
* @brief Triangle rasterization library using affine interpolation. Not
* specially optimized, but enough for my purposes.
**/
#include "nvmesh.h" // pch
#include "Raster.h"
#include "ClippedTriangle.h"
#include "nvcore/Utils.h" // min, max
#include "nvmath/Vector.inl"
#include "nvmath/ftoi.h"
#define RA_EPSILON 0.00001f
using namespace nv;
using namespace nv::Raster;
namespace
{
static inline float delta(float bot, float top, float ih)
{
return (bot - top) * ih;
}
static inline Vector2 delta(Vector2::Arg bot, Vector2::Arg top, float ih)
{
return (bot - top) * ih;
}
static inline Vector3 delta(Vector3::Arg bot, Vector3::Arg top, float ih)
{
return (bot - top) * ih;
}
// @@ The implementation in nvmath.h should be equivalent.
static inline int iround(float f)
{
// @@ Optimize this.
return int(floorf(f+0.5f));
//return int(round(f));
//return int(f);
}
/// A triangle vertex.
struct Vertex
{
Vector2 pos; // Position.
Vector3 tex; // Texcoord. (Barycentric coordinate)
};
/// A triangle for rasterization.
struct Triangle
{
Triangle(Vector2::Arg v0, Vector2::Arg v1, Vector2::Arg v2, Vector3::Arg t0, Vector3::Arg t1, Vector3::Arg t2);
bool computeDeltas();
bool draw(const Vector2 & extents, bool enableScissors, SamplingCallback cb, void * param);
bool drawAA(const Vector2 & extents, bool enableScissors, SamplingCallback cb, void * param);
bool drawC(const Vector2 & extents, bool enableScissors, SamplingCallback cb, void * param);
void flipBackface();
void computeUnitInwardNormals();
// Vertices.
Vector2 v1, v2, v3;
Vector2 n1, n2, n3; // unit inward normals
Vector3 t1, t2, t3;
// Deltas.
Vector3 dx, dy;
float sign;
bool valid;
};
/// Triangle ctor.
Triangle::Triangle(Vector2::Arg v0, Vector2::Arg v1, Vector2::Arg v2,
Vector3::Arg t0, Vector3::Arg t1, Vector3::Arg t2)
{
// Init vertices.
this->v1 = v0;
this->v2 = v2;
this->v3 = v1;
// Set barycentric coordinates.
this->t1 = t0;
this->t2 = t2;
this->t3 = t1;
// make sure every triangle is front facing.
flipBackface();
// Compute deltas.
valid = computeDeltas();
computeUnitInwardNormals();
}
/// Compute texture space deltas.
/// This method takes two edge vectors that form a basis, determines the
/// coordinates of the canonic vectors in that basis, and computes the
/// texture gradient that corresponds to those vectors.
bool Triangle::computeDeltas()
{
Vector2 e0 = v3 - v1;
Vector2 e1 = v2 - v1;
Vector3 de0 = t3 - t1;
Vector3 de1 = t2 - t1;
float denom = 1.0f / (e0.y * e1.x - e1.y * e0.x);
if (!isFinite(denom)) {
return false;
}
float lambda1 = - e1.y * denom;
float lambda2 = e0.y * denom;
float lambda3 = e1.x * denom;
float lambda4 = - e0.x * denom;
dx = de0 * lambda1 + de1 * lambda2;
dy = de0 * lambda3 + de1 * lambda4;
return true;
}
// compute unit inward normals for each edge.
void Triangle::computeUnitInwardNormals()
{
n1 = v1 - v2; n1 = Vector2(-n1.y, n1.x); n1 = n1 * (1.0f/sqrtf(n1.x*n1.x + n1.y*n1.y));
n2 = v2 - v3; n2 = Vector2(-n2.y, n2.x); n2 = n2 * (1.0f/sqrtf(n2.x*n2.x + n2.y*n2.y));
n3 = v3 - v1; n3 = Vector2(-n3.y, n3.x); n3 = n3 * (1.0f/sqrtf(n3.x*n3.x + n3.y*n3.y));
}
void Triangle::flipBackface()
{
// check if triangle is backfacing, if so, swap two vertices
if ( ((v3.x-v1.x)*(v2.y-v1.y) - (v3.y-v1.y)*(v2.x-v1.x)) < 0 ) {
Vector2 hv=v1; v1=v2; v2=hv; // swap pos
Vector3 ht=t1; t1=t2; t2=ht; // swap tex
}
}
bool Triangle::draw(const Vector2 & extents, bool enableScissors, SamplingCallback cb, void * param)
{
// 28.4 fixed-point coordinates
const int Y1 = iround(16.0f * v1.y);
const int Y2 = iround(16.0f * v2.y);
const int Y3 = iround(16.0f * v3.y);
const int X1 = iround(16.0f * v1.x);
const int X2 = iround(16.0f * v2.x);
const int X3 = iround(16.0f * v3.x);
// Deltas
const int DX12 = X1 - X2;
const int DX23 = X2 - X3;
const int DX31 = X3 - X1;
const int DY12 = Y1 - Y2;
const int DY23 = Y2 - Y3;
const int DY31 = Y3 - Y1;
// Fixed-point deltas
const int FDX12 = DX12 << 4;
const int FDX23 = DX23 << 4;
const int FDX31 = DX31 << 4;
const int FDY12 = DY12 << 4;
const int FDY23 = DY23 << 4;
const int FDY31 = DY31 << 4;
int minx, miny, maxx, maxy;
if (enableScissors) {
int frustumX0 = 0 << 4;
int frustumY0 = 0 << 4;
int frustumX1 = (int)extents.x << 4;
int frustumY1 = (int)extents.y << 4;
// Bounding rectangle
minx = (nv::max(min3(X1, X2, X3), frustumX0) + 0xF) >> 4;
miny = (nv::max(min3(Y1, Y2, Y3), frustumY0) + 0xF) >> 4;
maxx = (nv::min(max3(X1, X2, X3), frustumX1) + 0xF) >> 4;
maxy = (nv::min(max3(Y1, Y2, Y3), frustumY1) + 0xF) >> 4;
}
else {
// Bounding rectangle
minx = (min3(X1, X2, X3) + 0xF) >> 4;
miny = (min3(Y1, Y2, Y3) + 0xF) >> 4;
maxx = (max3(X1, X2, X3) + 0xF) >> 4;
maxy = (max3(Y1, Y2, Y3) + 0xF) >> 4;
}
// Block size, standard 8x8 (must be power of two)
const int q = 8;
// @@ This won't work when minx,miny are negative. This code path is not used. Leaving as is for now.
nvCheck(minx >= 0);
nvCheck(miny >= 0);
// Start in corner of 8x8 block
minx &= ~(q - 1);
miny &= ~(q - 1);
// Half-edge constants
int C1 = DY12 * X1 - DX12 * Y1;
int C2 = DY23 * X2 - DX23 * Y2;
int C3 = DY31 * X3 - DX31 * Y3;
// Correct for fill convention
if(DY12 < 0 || (DY12 == 0 && DX12 > 0)) C1++;
if(DY23 < 0 || (DY23 == 0 && DX23 > 0)) C2++;
if(DY31 < 0 || (DY31 == 0 && DX31 > 0)) C3++;
// Loop through blocks
for(int y = miny; y < maxy; y += q)
{
for(int x = minx; x < maxx; x += q)
{
// Corners of block
int x0 = x << 4;
int x1 = (x + q - 1) << 4;
int y0 = y << 4;
int y1 = (y + q - 1) << 4;
// Evaluate half-space functions
bool a00 = C1 + DX12 * y0 - DY12 * x0 > 0;
bool a10 = C1 + DX12 * y0 - DY12 * x1 > 0;
bool a01 = C1 + DX12 * y1 - DY12 * x0 > 0;
bool a11 = C1 + DX12 * y1 - DY12 * x1 > 0;
int a = (a00 << 0) | (a10 << 1) | (a01 << 2) | (a11 << 3);
bool b00 = C2 + DX23 * y0 - DY23 * x0 > 0;
bool b10 = C2 + DX23 * y0 - DY23 * x1 > 0;
bool b01 = C2 + DX23 * y1 - DY23 * x0 > 0;
bool b11 = C2 + DX23 * y1 - DY23 * x1 > 0;
int b = (b00 << 0) | (b10 << 1) | (b01 << 2) | (b11 << 3);
bool c00 = C3 + DX31 * y0 - DY31 * x0 > 0;
bool c10 = C3 + DX31 * y0 - DY31 * x1 > 0;
bool c01 = C3 + DX31 * y1 - DY31 * x0 > 0;
bool c11 = C3 + DX31 * y1 - DY31 * x1 > 0;
int c = (c00 << 0) | (c10 << 1) | (c01 << 2) | (c11 << 3);
// Skip block when outside an edge
if(a == 0x0 || b == 0x0 || c == 0x0) continue;
// Accept whole block when totally covered
if(a == 0xF && b == 0xF && c == 0xF)
{
Vector3 texRow = t1 + dy*(y0 - v1.y) + dx*(x0 - v1.x);
for(int iy = y; iy < y + q; iy++)
{
Vector3 tex = texRow;
for(int ix = x; ix < x + q; ix++)
{
//Vector3 tex = t1 + dx * (ix - v1.x) + dy * (iy - v1.y);
if (!cb(param, ix, iy, tex, dx, dy, 1.0)) {
// early out.
return false;
}
tex += dx;
}
texRow += dy;
}
}
else // Partially covered block
{
int CY1 = C1 + DX12 * y0 - DY12 * x0;
int CY2 = C2 + DX23 * y0 - DY23 * x0;
int CY3 = C3 + DX31 * y0 - DY31 * x0;
Vector3 texRow = t1 + dy*(y0 - v1.y) + dx*(x0 - v1.x);
for(int iy = y; iy < y + q; iy++)
{
int CX1 = CY1;
int CX2 = CY2;
int CX3 = CY3;
Vector3 tex = texRow;
for(int ix = x; ix < x + q; ix++)
{
if(CX1 > 0 && CX2 > 0 && CX3 > 0)
{
if (!cb(param, ix, iy, tex, dx, dy, 1.0))
{
// early out.
return false;
}
}
CX1 -= FDY12;
CX2 -= FDY23;
CX3 -= FDY31;
tex += dx;
}
CY1 += FDX12;
CY2 += FDX23;
CY3 += FDX31;
texRow += dy;
}
}
}
}
return true;
}
#define PX_INSIDE 1.0f/sqrt(2.0f)
#define PX_OUTSIDE -1.0f/sqrt(2.0f)
#define BK_SIZE 8
#define BK_INSIDE sqrt(BK_SIZE*BK_SIZE/2.0f)
#define BK_OUTSIDE -sqrt(BK_SIZE*BK_SIZE/2.0f)
// extents has to be multiple of BK_SIZE!!
bool Triangle::drawAA(const Vector2 & extents, bool enableScissors, SamplingCallback cb, void * param)
{
float minx, miny, maxx, maxy;
if (enableScissors) {
// Bounding rectangle
minx = floorf(max(min3(v1.x, v2.x, v3.x), 0.0f));
miny = floorf(max(min3(v1.y, v2.y, v3.y), 0.0f));
maxx = ceilf( min(max3(v1.x, v2.x, v3.x), extents.x-1.0f));
maxy = ceilf( min(max3(v1.y, v2.y, v3.y), extents.y-1.0f));
}
else {
// Bounding rectangle
minx = floorf(min3(v1.x, v2.x, v3.x));
miny = floorf(min3(v1.y, v2.y, v3.y));
maxx = ceilf( max3(v1.x, v2.x, v3.x));
maxy = ceilf( max3(v1.y, v2.y, v3.y));
}
// There's no reason to align the blocks to the viewport, instead we align them to the origin of the triangle bounds.
minx = floorf(minx);
miny = floorf(miny);
//minx = (float)(((int)minx) & (~((int)BK_SIZE - 1))); // align to blocksize (we don't need to worry about blocks partially out of viewport)
//miny = (float)(((int)miny) & (~((int)BK_SIZE - 1)));
minx += 0.5; miny +=0.5; // sampling at texel centers!
maxx += 0.5; maxy +=0.5;
// Half-edge constants
float C1 = n1.x * (-v1.x) + n1.y * (-v1.y);
float C2 = n2.x * (-v2.x) + n2.y * (-v2.y);
float C3 = n3.x * (-v3.x) + n3.y * (-v3.y);
// Loop through blocks
for(float y0 = miny; y0 <= maxy; y0 += BK_SIZE)
{
for(float x0 = minx; x0 <= maxx; x0 += BK_SIZE)
{
// Corners of block
float xc = (x0 + (BK_SIZE-1)/2.0f);
float yc = (y0 + (BK_SIZE-1)/2.0f);
// Evaluate half-space functions
float aC = C1 + n1.x * xc + n1.y * yc;
float bC = C2 + n2.x * xc + n2.y * yc;
float cC = C3 + n3.x * xc + n3.y * yc;
// Skip block when outside an edge
if( (aC <= BK_OUTSIDE) || (bC <= BK_OUTSIDE) || (cC <= BK_OUTSIDE) ) continue;
// Accept whole block when totally covered
if( (aC >= BK_INSIDE) && (bC >= BK_INSIDE) && (cC >= BK_INSIDE) )
{
Vector3 texRow = t1 + dy*(y0 - v1.y) + dx*(x0 - v1.x);
for (float y = y0; y < y0 + BK_SIZE; y++)
{
Vector3 tex = texRow;
for(float x = x0; x < x0 + BK_SIZE; x++)
{
if (!cb(param, (int)x, (int)y, tex, dx, dy, 1.0f))
{
return false;
}
tex += dx;
}
texRow += dy;
}
}
else // Partially covered block
{
float CY1 = C1 + n1.x * x0 + n1.y * y0;
float CY2 = C2 + n2.x * x0 + n2.y * y0;
float CY3 = C3 + n3.x * x0 + n3.y * y0;
Vector3 texRow = t1 + dy*(y0 - v1.y) + dx*(x0 - v1.x);
for(float y = y0; y < y0 + BK_SIZE; y++) // @@ This is not clipping to scissor rectangle correctly.
{
float CX1 = CY1;
float CX2 = CY2;
float CX3 = CY3;
Vector3 tex = texRow;
for (float x = x0; x < x0 + BK_SIZE; x++) // @@ This is not clipping to scissor rectangle correctly.
{
if (CX1 >= PX_INSIDE && CX2 >= PX_INSIDE && CX3 >= PX_INSIDE)
{
// pixel completely covered
Vector3 tex = t1 + dx * (x - v1.x) + dy * (y - v1.y);
if (!cb(param, (int)x, (int)y, tex, dx, dy, 1.0f))
{
return false;
}
}
else if ((CX1 >= PX_OUTSIDE) && (CX2 >= PX_OUTSIDE) && (CX3 >= PX_OUTSIDE))
{
// triangle partially covers pixel. do clipping.
ClippedTriangle ct(v1-Vector2(x,y), v2-Vector2(x,y), v3-Vector2(x,y));
ct.clipAABox(-0.5, -0.5, 0.5, 0.5);
Vector2 centroid = ct.centroid();
float area = ct.area();
if (area > 0.0f)
{
Vector3 texCent = tex - dx*centroid.x - dy*centroid.y;
//nvCheck(texCent.x >= -0.1f && texCent.x <= 1.1f); // @@ Centroid is not very exact...
//nvCheck(texCent.y >= -0.1f && texCent.y <= 1.1f);
//nvCheck(texCent.z >= -0.1f && texCent.z <= 1.1f);
//Vector3 texCent2 = t1 + dx * (x - v1.x) + dy * (y - v1.y);
if (!cb(param, (int)x, (int)y, texCent, dx, dy, area))
{
return false;
}
}
}
CX1 += n1.x;
CX2 += n2.x;
CX3 += n3.x;
tex += dx;
}
CY1 += n1.y;
CY2 += n2.y;
CY3 += n3.y;
texRow += dy;
}
}
}
}
return true;
}
} // namespace
/// Process the given triangle.
bool nv::Raster::drawTriangle(Mode mode, Vector2::Arg extents, bool enableScissors, const Vector2 v[3], SamplingCallback cb, void * param)
{
Triangle tri(v[0], v[1], v[2], Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1));
// @@ It would be nice to have a conservative drawing mode that enlarges the triangle extents by one texel and is able to handle degenerate triangles.
// @@ Maybe the simplest thing to do would be raster triangle edges.
if (tri.valid) {
if (mode == Mode_Antialiased) {
return tri.drawAA(extents, enableScissors, cb, param);
}
if (mode == Mode_Nearest) {
return tri.draw(extents, enableScissors, cb, param);
}
}
return true;
}
inline static float triangleArea(Vector2::Arg v1, Vector2::Arg v2, Vector2::Arg v3)
{
return 0.5f * (v3.x * v1.y + v1.x * v2.y + v2.x * v3.y - v2.x * v1.y - v3.x * v2.y - v1.x * v3.y);
}
/// Process the given quad.
bool nv::Raster::drawQuad(Mode mode, Vector2::Arg extents, bool enableScissors, const Vector2 v[4], SamplingCallback cb, void * param)
{
bool sign0 = triangleArea(v[0], v[1], v[2]) > 0.0f;
bool sign1 = triangleArea(v[0], v[2], v[3]) > 0.0f;
// Divide the quad into two non overlapping triangles.
if (sign0 == sign1) {
Triangle tri0(v[0], v[1], v[2], Vector3(0,0,0), Vector3(1,0,0), Vector3(1,1,0));
Triangle tri1(v[0], v[2], v[3], Vector3(0,0,0), Vector3(1,1,0), Vector3(0,1,0));
if (tri0.valid && tri1.valid) {
if (mode == Mode_Antialiased) {
return tri0.drawAA(extents, enableScissors, cb, param) && tri1.drawAA(extents, enableScissors, cb, param);
} else {
return tri0.draw(extents, enableScissors, cb, param) && tri1.draw(extents, enableScissors, cb, param);
}
}
}
else
{
Triangle tri0(v[0], v[1], v[3], Vector3(0,0,0), Vector3(1,0,0), Vector3(0,1,0));
Triangle tri1(v[1], v[2], v[3], Vector3(1,0,0), Vector3(1,1,0), Vector3(0,1,0));
if (tri0.valid && tri1.valid) {
if (mode == Mode_Antialiased) {
return tri0.drawAA(extents, enableScissors, cb, param) && tri1.drawAA(extents, enableScissors, cb, param);
} else {
return tri0.draw(extents, enableScissors, cb, param) && tri1.draw(extents, enableScissors, cb, param);
}
}
}
return true;
}
static bool drawPoint(const Vector2 & p, const Vector2 v[2], LineSamplingCallback cb, void * param) {
int x = ftoi_round(p.x);
int y = ftoi_round(p.y);
Vector2 ip = Vector2(float(x) + 0.5f, float(y) + 0.5f);
float t;
// Return minimum distance between line segment vw and point p
Vector2 dv = v[1] - v[0];
const float l2 = nv::lengthSquared(dv); // i.e. |w-v|^2 - avoid a sqrt
if (l2 == 0.0) {
t = 0; // v0 == v1 case
}
else {
// Consider the line extending the segment, parameterized as v + t (w - v).
// We find projection of point p onto the line.
// It falls where t = [(p-v) . (w-v)] / |w-v|^2
t = dot(ip - v[0], dv) / l2;
if (t < 0.0) {
t = 0; // Beyond the 'v0' end of the segment
}
else if (t > 1.0) {
t = 1; // Beyond the 'v1' end of the segment
}
}
Vector2 projection = v[0] + t * dv; // Projection falls on the segment
float d = distance(ip, projection);
return cb(param, x, y, t, saturate(1-d));
}
void nv::Raster::drawLine(bool antialias, Vector2::Arg extents, bool enableScissors, const Vector2 v[2], LineSamplingCallback cb, void * param)
{
nvCheck(antialias == true); // @@ Not implemented.
//nvCheck(enableScissors == false); // @@ Not implemented.
// Very crappy DDA implementation.
Vector2 p = v[0];
Vector2 dp, dpdy;
float dx = v[1].x - v[0].x;
float dy = v[1].y - v[0].y;
int n;
// Degenerate line.
if (dx == 0 && dy == 0) return;
if (fabsf(dx) >= fabsf(dy)) {
n = iround(fabsf(dx));
dp.x = dx / fabsf(dx);
dp.y = dy / fabsf(dx);
nvDebugCheck(fabsf(dp.y) <= 1.0f);
dpdy.x = 0;
dpdy.y = 1;
}
else {
n = iround(fabs(dy));
dp.x = dx / fabsf(dy);
dp.y = dy / fabsf(dy);
nvDebugCheck(fabsf(dp.x) <= 1.0f);
dpdy.x = 1;
dpdy.y = 0;
}
for (int i = 0; i <= n; i++) {
drawPoint(p, v, cb, param);
drawPoint(p + dpdy, v, cb, param);
drawPoint(p - dpdy, v, cb, param);
p += dp;
}
}
// Draw vertical or horizontal segments. For degenerate triangles.
/*bool nv::Raster::drawSegment(Vector2::Arg extents, bool enableScissors, const Vector2 v[2], LineSamplingCallback cb, void * param)
{
nvCheck(enableScissors == false);
if (v[0].x == v[1].x) { // Vertical segment.
}
else if (v[0].y == v[1].y) { // Horizontal segment.
int y = ftoi_round(v[0].y);
int x0 = ftoi_floor(v[0].x);
int x1 = ftoi_floor(v[0].x);
for (int x = x0; x <= x1; x++) {
cb(param, x, y, t,
}
}
return false; // Not a valid segment.
}
*/