p = p.Plus(camera.offset);

Vector r;

r.x = p.Dot(camera.projRight);

r.y = p.Dot(camera.projUp);

r.z = p.Dot(camera.projRight.Cross(camera.projUp));

double w = 1 + r.z*camera.tangent*camera.scale;

return r.ScaledBy(camera.scale/w);

for(const SEdge &e : el.l) {

edges[hcs].AddEdge(ProjectPoint3RH(camera, e.a),

ProjectPoint3RH(camera, e.b));

}

if(!CanOutputCurves())

return false;

for(const SBezier &b : bl.l) {

SBezier pb = camera.ProjectBezier(b);

beziers[hcs].l.Add(&pb);

}

return true;

Vector projDir = camera.projRight.Cross(camera.projUp);

for(const SOutline &o : ol.l) {

if(drawAs == DrawOutlinesAs::EMPHASIZED_AND_CONTOUR &&

!(o.IsVisible(projDir) || o.tag != 0))

continue;

if(drawAs == DrawOutlinesAs::EMPHASIZED_WITHOUT_CONTOUR &&

!(!o.IsVisible(projDir) && o.tag != 0))

continue;

if(drawAs == DrawOutlinesAs::CONTOUR_ONLY &&

!(o.IsVisible(projDir)))

continue;

edges[hcs].AddEdge(ProjectPoint3RH(camera, o.a),

ProjectPoint3RH(camera, o.b));

}

const Vector &o, const Vector &u, const Vector &v,

hStroke hcs) {

auto traceEdge = [&](Vector a, Vector b) {

edges[hcs].AddEdge(ProjectPoint3RH(camera, a),

ProjectPoint3RH(camera, b));

};

VectorFont::Builtin()->Trace(height, o, u, v, text, traceEdge, camera);

hFill hcf) {

Fill *fill = fills.FindById(hcf);

ssassert(fill->layer == Layer::NORMAL ||

fill->layer == Layer::DEPTH_ONLY ||

fill->layer == Layer::FRONT ||

fill->layer == Layer::BACK, "Unexpected mesh layer");

Vector zOffset = {};

if(fill->layer == Layer::BACK) {

zOffset.z -= 1e6;

} else if(fill->layer == Layer::FRONT) {

zOffset.z += 1e6;

}

zOffset.z += camera.scale * fill->zIndex;

STriMeta meta = {};

if(fill->layer != Layer::DEPTH_ONLY) {

meta.color = fill->color;

}

Vector ta = ProjectPoint3RH(camera, a).Plus(zOffset),

tb = ProjectPoint3RH(camera, b).Plus(zOffset),

tc = ProjectPoint3RH(camera, c).Plus(zOffset),

td = ProjectPoint3RH(camera, d).Plus(zOffset);

mesh.AddTriangle(meta, tc, tb, ta);

mesh.AddTriangle(meta, ta, td, tc);

Stroke *stroke = strokes.FindById(hcs);

Fill fill = {};

fill.layer = stroke->layer;

fill.zIndex = stroke->zIndex;

fill.color = stroke->color;

hFill hcf = GetFill(fill);

Vector u = camera.projRight.ScaledBy(stroke->width/2.0/camera.scale),

v = camera.projUp.ScaledBy(stroke->width/2.0/camera.scale);

DrawQuad(o.Minus(u).Minus(v), o.Minus(u).Plus(v),

o.Plus(u).Plus(v), o.Plus(u).Minus(v), hcf);

SMesh m = {};

p.TriangulateInto(&m);

DrawMesh(m, hcf, {});

m.Clear();

hFill hcfFront, hFill hcfBack) {

Fill *fill = fills.FindById(hcfFront);

ssassert(fill->layer == Layer::NORMAL ||

fill->layer == Layer::DEPTH_ONLY, "Unexpected mesh layer");

Vector l0 = (lighting.lightDirection[0]).WithMagnitude(1),

l1 = (lighting.lightDirection[1]).WithMagnitude(1);

for(STriangle tr : m.l) {

tr.a = ProjectPoint3RH(camera, tr.a);

tr.b = ProjectPoint3RH(camera, tr.b);

tr.c = ProjectPoint3RH(camera, tr.c);

if(CanOutputTriangles() && fill->layer == Layer::NORMAL) {

if(fill->color.IsEmpty()) {

// Compute lighting, since we're going to draw the shaded triangles.

Vector n = tr.Normal().WithMagnitude(1);

double intensity = lighting.ambientIntensity +

max(0.0, (lighting.lightIntensity[0])*(n.Dot(l0))) +

max(0.0, (lighting.lightIntensity[1])*(n.Dot(l1)));

double r = min(1.0, tr.meta.color.redF() * intensity),

g = min(1.0, tr.meta.color.greenF() * intensity),

b = min(1.0, tr.meta.color.blueF() * intensity);

tr.meta.color = RGBf(r, g, b);

} else {

// We're going to draw this triangle, but it's not shaded.

tr.meta.color = fill->color;

}

} else {

// This triangle is just for occlusion testing.

tr.meta.color = {};

}

mesh.AddTriangle(&tr);

}

Fill *fill = fills.FindById(hcf);

ssassert(fill->layer == Layer::NORMAL ||

fill->layer == Layer::DEPTH_ONLY, "Unexpected mesh layer");

Vector zOffset = {};

zOffset.z += camera.scale * fill->zIndex;

size_t facesSize = faces.size();

for(STriangle tr : m.l) {

uint32_t face = tr.meta.face;

for(size_t j = 0; j < facesSize; j++) {

if(faces[j] != face) continue;

if(!fill->color.IsEmpty()) {

tr.meta.color = fill->color;

}

mesh.AddTriangle(tr.meta,

ProjectPoint3RH(camera, tr.a).Plus(zOffset),

ProjectPoint3RH(camera, tr.b).Plus(zOffset),

ProjectPoint3RH(camera, tr.c).Plus(zOffset));

break;

}

}

const Vector &o, const Vector &u, const Vector &v,

const Point2d &ta, const Point2d &tb, hFill hcf) {

dbp("Not implemented");

bbox.minp = {VERY_POSITIVE, VERY_POSITIVE, VERY_POSITIVE};

bbox.maxp = {VERY_NEGATIVE, VERY_NEGATIVE, VERY_NEGATIVE};

for(auto &it : edges) {

SEdgeList &el = it.second;

for(SEdge &e : el.l) {

bbox.Include(e.a);

bbox.Include(e.b);

}

}

for(auto &it : beziers) {

SBezierList &bl = it.second;

for(SBezier &b : bl.l) {

for(int i = 0; i <= b.deg; i++) {

bbox.Include(b.ctrl[i]);

}

}

}

for(STriangle &tr : mesh.l) {

for(int i = 0; i < 3; i++) {

bbox.Include(tr.vertices[i]);

}

}

for(auto &it : beziers) {

hStroke hcs = it.first;

SBezierList &bl = it.second;

SEdgeList &el = edges[hcs];

for(const SBezier &b : bl.l) {

if(b.deg == 1) {

el.AddEdge(b.ctrl[0], b.ctrl[1]);

} else {

List<Vector> lv = {};

b.MakePwlInto(&lv, chordTolerance);

for(int i = 1; i < lv.n; i++) {

el.AddEdge(lv[i-1], lv[i]);

}

lv.Clear();

}

}

bl.l.Clear();

}

beziers.clear();

// Perform occlusion testing, if necessary.

if(mesh.l.IsEmpty())

return;

// We can't perform hidden line removal on exact curves.

ConvertBeziersToEdges();

// Remove hidden lines (on NORMAL layers), or remove visible lines (on OCCLUDED layers).

SKdNode *root = SKdNode::From(&mesh);

root->ClearTags();

int cnt = 1234;

for(auto &eit : edges) {

hStroke hcs = eit.first;

SEdgeList &el = eit.second;

Stroke *stroke = strokes.FindById(hcs);

if(stroke->layer != Layer::NORMAL &&

stroke->layer != Layer::OCCLUDED) continue;

SEdgeList nel = {};

for(const SEdge &e : el.l) {

SEdgeList oel = {};

oel.AddEdge(e.a, e.b);

root->OcclusionTestLine(e, &oel, cnt);

if(stroke->layer == Layer::OCCLUDED) {

for(SEdge &oe : oel.l) {

oe.tag = !oe.tag;

}

}

oel.l.RemoveTagged();

oel.MergeCollinearSegments(e.a, e.b);

for(const SEdge &oe : oel.l) {

nel.AddEdge(oe.a, oe.b);

}

oel.Clear();

cnt++;

}

el.l.Clear();

el.l = nel.l;

}

// Sort our strokes in paint order.

std::vector<std::pair<Layer, int>> paintOrder;

paintOrder.emplace_back(Layer::NORMAL, 0); // mesh

for(const Stroke &cs : strokes) {

paintOrder.emplace_back(cs.layer, cs.zIndex);

}

const Layer stackup[] = {

Layer::BACK, Layer::NORMAL, Layer::DEPTH_ONLY, Layer::OCCLUDED, Layer::FRONT

};

std::sort(paintOrder.begin(), paintOrder.end(),

[&](std::pair<Layer, int> a, std::pair<Layer, int> b) {

Layer aLayer = a.first,

bLayer = b.first;

int aZIndex = a.second,

bZIndex = b.second;

size_t aLayerIndex =

std::find(std::begin(stackup), std::end(stackup), aLayer) - std::begin(stackup);

size_t bLayerIndex =

std::find(std::begin(stackup), std::end(stackup), bLayer) - std::begin(stackup);

if(aLayerIndex == bLayerIndex) {

return aZIndex < bZIndex;

} else {

return aLayerIndex < bLayerIndex;

}

});

auto last = std::unique(paintOrder.begin(), paintOrder.end());

paintOrder.erase(last, paintOrder.end());

// Output geometry in paint order.

OutputStart();

for(auto &it : paintOrder) {

Layer layer = it.first;

int zIndex = it.second;

if(layer == Layer::NORMAL && zIndex == 0) {

SMesh mp = {};

SBsp3 *bsp = SBsp3::FromMesh(&mesh);

if(bsp) bsp->GenerateInPaintOrder(&mp);

for(const STriangle &tr : mp.l) {

// Cull back-facing and invisible triangles.

if(tr.Normal().z < 0) continue;

if(tr.meta.color.IsEmpty()) continue;

OutputTriangle(tr);

}

mp.Clear();

}

for(const auto &eit : edges) {

hStroke hcs = eit.first;

const SEdgeList &el = eit.second;

Stroke *stroke = strokes.FindById(hcs);

if(stroke->layer != layer || stroke->zIndex != zIndex) continue;

for(const SEdge &e : el.l) {

OutputBezier(SBezier::From(e.a, e.b), hcs);

}

}

for(auto &bit : beziers) {

hStroke hcs = bit.first;

const SBezierList &bl = bit.second;

Stroke *stroke = strokes.FindById(hcs);

if(stroke->layer != layer || stroke->zIndex != zIndex) continue;

for(const SBezier &b : bl.l) {

OutputBezier(b, hcs);

}

}

}

OutputEnd();

Canvas::Clear();

for(auto &eit : edges) {

SEdgeList &el = eit.second;

el.l.Clear();

}

edges.clear();

for(auto &bit : beziers) {

SBezierList &bl = bit.second;

bl.l.Clear();

}

beziers.clear();

mesh.Clear();

// Arbitrary choice of tolerance; make it a little finer than pwl tolerance since

// it should be easier to achieve that with the smooth curves.

SBezierList bl;

b.MakeNonrationalCubicInto(&bl, chordTolerance / 2);

for(const SBezier &cb : bl.l) {

OutputBezier(cb, hcs);

}

bl.Clear();