626 lines
21 KiB
C++
626 lines
21 KiB
C++
// 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.
|
|
}
|
|
*/
|