X-Git-Url: https://git.ucc.asn.au/?p=ipdf%2Fcode.git;a=blobdiff_plain;f=src%2Fdocument.cpp;h=4a5214a9d6ca447c14bdba1079fc0dbb30a0369b;hp=1e768bd92d47d752f733acc929174273e8faebb5;hb=d68c91a7a2a3a4b3a312a50cbab5a7539d4cd7d5;hpb=58a6719da2337b3e6e20b581885f170bbe5fc480 diff --git a/src/document.cpp b/src/document.cpp index 1e768bd..4a5214a 100644 --- a/src/document.cpp +++ b/src/document.cpp @@ -1,9 +1,11 @@ #include "document.h" #include "bezier.h" +#include "profiler.h" #include #include #include "../contrib/pugixml-1.4/src/pugixml.cpp" +#include "transformationtype.h" #include "stb_truetype.h" @@ -100,6 +102,7 @@ void Document::GenBaseQuadtree() int Document::ClipObjectToQuadChild(int object_id, QuadTreeNodeChildren type) { + PROFILE_SCOPE("Document::ClipObjectToQuadChild"); switch (m_objects.types[object_id]) { case RECT_FILLED: @@ -167,19 +170,25 @@ int Document::ClipObjectToQuadChild(int object_id, QuadTreeNodeChildren type) } QuadTreeIndex Document::GenQuadChild(QuadTreeIndex parent, QuadTreeNodeChildren type) { + PROFILE_SCOPE("Document::GenQuadChild()"); QuadTreeIndex new_index = m_quadtree.nodes.size(); - Debug("-------------- Generating Quadtree Node %d (parent %d) ----------------------", new_index, parent); - m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, parent, type, 0, 0, -1}); + Debug("-------------- Generating Quadtree Node %d (parent %d, type %d) ----------------------", new_index, parent, type); + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, parent, type, 0, 0, -1, true}); m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size(); - for (unsigned i = m_quadtree.nodes[parent].object_begin; i < m_quadtree.nodes[parent].object_end; ++i) + for (QuadTreeIndex overlay = parent; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay) { - if (IntersectsQuadChild(m_objects.bounds[i], type)) + for (unsigned i = m_quadtree.nodes[overlay].object_begin; i < m_quadtree.nodes[overlay].object_end; ++i) { - m_count += ClipObjectToQuadChild(i, type); + if (IntersectsQuadChild(m_objects.bounds[i], type)) + { + m_count += ClipObjectToQuadChild(i, type); + } } } m_quadtree.nodes[new_index].object_end = m_objects.bounds.size(); + // No objects are dirty. + m_quadtree.nodes[new_index].object_dirty = m_objects.bounds.size(); switch (type) { case QTC_TOP_LEFT: @@ -197,24 +206,154 @@ QuadTreeIndex Document::GenQuadChild(QuadTreeIndex parent, QuadTreeNodeChildren default: Fatal("Tried to add a QuadTree child of invalid type!"); } + m_document_dirty = true; return new_index; } +void Document::OverlayQuadChildren(QuadTreeIndex orig_parent, QuadTreeIndex parent, QuadTreeNodeChildren type) +{ + PROFILE_SCOPE("Document::OverlayQuadChildren()"); + QuadTreeIndex new_index = m_quadtree.nodes.size(); + Debug("-------------- Generating Quadtree Node %d (orig %d parent %d, type %d) ----------------------", new_index, orig_parent, parent, type); + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, orig_parent, type, 0, 0, -1, true}); + + m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size(); + for (unsigned i = m_quadtree.nodes[parent].object_dirty; i < m_quadtree.nodes[parent].object_end; ++i) + { + if (IntersectsQuadChild(m_objects.bounds[i], type)) + { + m_count += ClipObjectToQuadChild(i, type); + } + } + m_quadtree.nodes[new_index].object_end = m_objects.bounds.size(); + QuadTreeIndex orig_node = -1; + switch (type) + { + case QTC_TOP_LEFT: + orig_node = m_quadtree.nodes[orig_parent].top_left; + break; + case QTC_TOP_RIGHT: + orig_node = m_quadtree.nodes[orig_parent].top_right; + break; + case QTC_BOTTOM_LEFT: + orig_node = m_quadtree.nodes[orig_parent].bottom_left; + break; + case QTC_BOTTOM_RIGHT: + orig_node = m_quadtree.nodes[orig_parent].bottom_right; + break; + default: + Fatal("Tried to overlay a QuadTree child of invalid type!"); + } + if (orig_node == -1) + Fatal("Tried to overlay a QuadTree child that didn't exist!"); + + // Add us to the node's overlay linked list. + QuadTreeIndex prev_overlay = orig_node; + while (m_quadtree.nodes[prev_overlay].next_overlay != -1) prev_overlay = m_quadtree.nodes[prev_overlay].next_overlay; + Debug("- Original node %d, Previous overlay %d, new overlay %d", orig_node, prev_overlay, new_index); + m_quadtree.nodes[prev_overlay].next_overlay = new_index; + + // Recurse into any extant children. + if (m_quadtree.nodes[orig_node].top_left != -1) + OverlayQuadChildren(orig_node, new_index, QTC_TOP_LEFT); + if (m_quadtree.nodes[orig_node].top_right != -1) + OverlayQuadChildren(orig_node, new_index, QTC_TOP_RIGHT); + if (m_quadtree.nodes[orig_node].bottom_left != -1) + OverlayQuadChildren(orig_node, new_index, QTC_BOTTOM_LEFT); + if (m_quadtree.nodes[orig_node].bottom_right != -1) + OverlayQuadChildren(orig_node, new_index, QTC_BOTTOM_RIGHT); + + m_quadtree.nodes[new_index].object_dirty = m_quadtree.nodes[new_index].object_end; + m_quadtree.nodes[new_index].next_overlay = -1; + m_document_dirty = true; +} + +void Document::OverlayQuadParent(QuadTreeIndex orig_child, QuadTreeIndex child, QuadTreeNodeChildren type) +{ + PROFILE_SCOPE("Document::OverlayQuadParent()"); + QuadTreeIndex new_index = m_quadtree.nodes.size(); + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1, true}); + + m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size(); + m_quadtree.nodes[new_index].object_dirty = m_objects.bounds.size(); + for (QuadTreeIndex overlay = child; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay) + { + for (unsigned i = m_quadtree.nodes[overlay].object_begin; i < m_quadtree.nodes[overlay].object_end; ++i) + { + Rect new_bounds = TransformFromQuadChild(m_objects.bounds[i], type); + // If the object is too small to be seen, discard it. + if (!new_bounds.w || !new_bounds.h) continue; + m_objects.bounds.push_back(new_bounds); + m_objects.types.push_back(m_objects.types[i]); + m_objects.data_indices.push_back(m_objects.data_indices[i]); + m_count++; + } + } + m_quadtree.nodes[new_index].object_end = m_objects.bounds.size(); + QuadTreeIndex orig_node = m_quadtree.nodes[orig_child].parent; + if (orig_node == -1) + Fatal("Tried to overlay a QuadTree child that didn't exist!"); + + // Add us to the node's overlay linked list. + QuadTreeIndex prev_overlay = orig_node; + while (m_quadtree.nodes[prev_overlay].next_overlay != -1) prev_overlay = m_quadtree.nodes[prev_overlay].next_overlay; + m_quadtree.nodes[prev_overlay].next_overlay = new_index; + Debug("OverlayQuadParent(%d, %d, %d) = %d", orig_child, child, type, new_index); + + // Recurse into any extant parent. + if (m_quadtree.nodes[orig_node].parent != -1) + OverlayQuadParent(orig_node, new_index, m_quadtree.nodes[orig_node].child_type); + + m_quadtree.nodes[new_index].object_dirty = m_quadtree.nodes[new_index].object_end; + m_quadtree.nodes[new_index].next_overlay = -1; + m_document_dirty = true; +} + +void Document::PropagateQuadChanges(QuadTreeIndex node) +{ + for(QuadTreeIndex overlay = node; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay) + { + // We don't care about clean overlays. + if (m_quadtree.nodes[overlay].object_dirty == m_quadtree.nodes[overlay].object_end) continue; + // Recurse into our parent, should we have any. + if (m_quadtree.nodes[node].parent != -1) + OverlayQuadParent(node, overlay, m_quadtree.nodes[node].child_type); + // Recurse into any extant children. + if (m_quadtree.nodes[node].top_left != -1) + OverlayQuadChildren(node, overlay, QTC_TOP_LEFT); + if (m_quadtree.nodes[node].top_right != -1) + OverlayQuadChildren(node, overlay, QTC_TOP_RIGHT); + if (m_quadtree.nodes[node].bottom_left != -1) + OverlayQuadChildren(node, overlay, QTC_BOTTOM_LEFT); + if (m_quadtree.nodes[node].bottom_right != -1) + OverlayQuadChildren(node, overlay, QTC_BOTTOM_RIGHT); + + m_quadtree.nodes[overlay].object_dirty = m_quadtree.nodes[overlay].object_end; + } +} + // Reparent a quadtree node, making it the "type" child of a new node. QuadTreeIndex Document::GenQuadParent(QuadTreeIndex child, QuadTreeNodeChildren type) { QuadTreeIndex new_index = m_quadtree.nodes.size(); - m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1}); + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1, true}); m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size(); - for (unsigned i = m_quadtree.nodes[child].object_begin; i < m_quadtree.nodes[child].object_end; ++i) + for (QuadTreeIndex overlay = child; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay) { - m_objects.bounds.push_back(TransformFromQuadChild(m_objects.bounds[i], type)); - m_objects.types.push_back(m_objects.types[i]); - m_objects.data_indices.push_back(m_objects.data_indices[i]); - m_count++; + for (unsigned i = m_quadtree.nodes[overlay].object_begin; i < m_quadtree.nodes[overlay].object_end; ++i) + { + Rect new_bounds = TransformFromQuadChild(m_objects.bounds[i], type); + // If the object is too small to be seen, discard it. + if (!new_bounds.w || !new_bounds.h) continue; + m_objects.bounds.push_back(new_bounds); + m_objects.types.push_back(m_objects.types[i]); + m_objects.data_indices.push_back(m_objects.data_indices[i]); + m_count++; + } } m_quadtree.nodes[new_index].object_end = m_objects.bounds.size(); + m_quadtree.nodes[new_index].object_dirty = m_objects.bounds.size(); switch (type) { case QTC_TOP_LEFT: @@ -233,6 +372,7 @@ QuadTreeIndex Document::GenQuadParent(QuadTreeIndex child, QuadTreeNodeChildren Fatal("Tried to add a QuadTree child of invalid type!"); } return new_index; + m_document_dirty = true; } #endif @@ -324,30 +464,114 @@ unsigned Document::AddBezier(const Bezier & bezier) unsigned index = AddBezierData(data); return Add(BEZIER, bounds, index); } +// Adds an object to the Document, clipping it to m_clip_rect. +// Helper function called by Document::Add() +int Document::AddClip(ObjectType type, const Rect& bounds, unsigned data_index, const Rect& clip_rect) +{ + PROFILE_SCOPE("Document::AddAndClip"); + switch (type) + { + case RECT_FILLED: + case RECT_OUTLINE: + case PATH: + { + Rect obj_bounds = clip_rect.Clip(bounds); + m_objects.bounds.push_back(obj_bounds); + m_objects.types.push_back(type); + m_objects.data_indices.push_back(data_index); + return 1; + } + case BEZIER: + { + // If we're entirely within the clipping rect, no clipping need occur. + if (clip_rect.Contains(bounds)) + { + m_objects.bounds.push_back(bounds); + m_objects.types.push_back(type); + m_objects.data_indices.push_back(data_index); + return 1; + } + Rect clip_bezier_bounds = TransformRectCoordinates(bounds, clip_rect); + std::vector new_curves = m_objects.beziers[data_index].ClipToRectangle(clip_bezier_bounds); + for (size_t i = 0; i < new_curves.size(); ++i) + { + Bezier new_curve_data = new_curves[i].ToAbsolute(bounds); + Rect new_bounds = new_curve_data.SolveBounds(); + new_curve_data = new_curve_data.ToRelative(new_bounds); + unsigned index = AddBezierData(new_curve_data); + m_objects.bounds.push_back(new_bounds); + m_objects.types.push_back(BEZIER); + m_objects.data_indices.push_back(index); + } + return new_curves.size(); + } + default: + m_objects.bounds.push_back(bounds); + m_objects.types.push_back(type); + m_objects.data_indices.push_back(data_index); + return 1; + } + return 0; +} unsigned Document::Add(ObjectType type, const Rect & bounds, unsigned data_index, QuadTreeIndex qti) { - m_objects.types.push_back(type); - m_objects.bounds.push_back(bounds); - m_objects.data_indices.push_back(data_index); + PROFILE_SCOPE("Document::Add"); + Rect new_bounds = bounds; #ifndef QUADTREE_DISABLED + int num_added = 1; + if (qti == -1) qti = m_current_insert_node; if (qti != -1) { - if (m_count == m_quadtree.nodes[qti].object_end+1) + // Move the object to the quadtree node it should be in. + m_quadtree.GetCanonicalCoords(qti, new_bounds.x, new_bounds.y, this); + Rect cliprect = Rect(0,0,1,1); + num_added = AddClip(type, new_bounds, data_index, cliprect); + } + else +#endif + { + m_objects.types.push_back(type); + m_objects.bounds.push_back(new_bounds); + m_objects.data_indices.push_back(data_index); + } + m_document_dirty = true; +#ifndef QUADTREE_DISABLED + if (qti != -1) + { + QuadTreeIndex new_qti = qti; + while (m_quadtree.nodes[new_qti].next_overlay != -1) { - m_quadtree.nodes[qti].object_end++; + if (m_count == m_quadtree.nodes[new_qti].object_end+1) + { + m_quadtree.nodes[new_qti].object_end += num_added; + m_quadtree.nodes[new_qti].render_dirty = true; + new_qti = -1; + break; + } + new_qti = m_quadtree.nodes[new_qti].next_overlay; } - else + if (new_qti != -1) { QuadTreeIndex overlay = m_quadtree.nodes.size(); - m_quadtree.nodes.push_back(m_quadtree.nodes[qti]); + Debug("Adding new overlay, nqti = %d, overlay = %d", new_qti, overlay); + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1}); m_quadtree.nodes[overlay].object_begin = m_count; - m_quadtree.nodes[overlay].object_end = m_count+1; - m_quadtree.nodes[qti].next_overlay = overlay; + // All objects are dirty. + m_quadtree.nodes[overlay].object_dirty = m_count; + m_quadtree.nodes[overlay].object_end = m_count+num_added; + m_quadtree.nodes[overlay].next_overlay = -1; + m_quadtree.nodes[overlay].render_dirty = true; + m_quadtree.nodes[new_qti].next_overlay = overlay; + new_qti = overlay; } } + m_count += num_added; + return m_count-num_added; +#else // words fail me (still not amused) + return (m_count++); #endif - return (m_count++); // Why can't we just use the size of types or something? + } unsigned Document::AddBezierData(const Bezier & bezier) @@ -1043,28 +1267,43 @@ void Document::AddFontGlyphAtPoint(stbtt_fontinfo *font, int character, Real sca stbtt_FreeShape(font, instructions); } -void Document::TransformObjectBounds(const SVGMatrix & transform) +void Document::TransformObjectBounds(const SVGMatrix & transform, ObjectType type) { + #ifdef TRANSFORM_BEZIERS_TO_PATH + for (unsigned i = 0; i < m_objects.paths.size(); ++i) + { + Path & p = m_objects.paths[i]; + p.m_bounds.x = transform.a * p.m_bounds.x + transform.e; + p.m_bounds.y = transform.d * p.m_bounds.y + transform.f; + p.m_bounds.w *= transform.a; + p.m_bounds.h *= transform.d; + } + return; + #endif + for (unsigned i = 0; i < m_count; ++i) { - TransformXYPair(m_objects.bounds[i].x, m_objects.bounds[i].y, transform); - m_objects.bounds[i].w *= transform.a; - m_objects.bounds[i].h *= transform.d; + if (type == NUMBER_OF_OBJECT_TYPES || m_objects.types[i] == type) + { + TransformXYPair(m_objects.bounds[i].x, m_objects.bounds[i].y, transform); + m_objects.bounds[i].w *= transform.a; + m_objects.bounds[i].h *= transform.d; + } } } void Document::TranslateObjects(const Real & dx, const Real & dy, ObjectType type) { #ifdef TRANSFORM_BEZIERS_TO_PATH - for (unsigned i = 0; i < m_objects.paths.size(); ++i) - { - Path & p = m_objects.paths[i]; - p.x += dx; - p.y += dy; - } - return; - #endif - + for (unsigned i = 0; i < m_objects.paths.size(); ++i) + { + Path & p = m_objects.paths[i]; + p.m_bounds.x += dx; + p.m_bounds.y += dy; + } + return; + #endif + for (unsigned i = 0; i < m_count; ++i) { if (type == NUMBER_OF_OBJECT_TYPES || m_objects.types[i] == type) @@ -1081,14 +1320,14 @@ void Document::ScaleObjectsAboutPoint(const Real & x, const Real & y, const Real for (unsigned i = 0; i < m_objects.paths.size(); ++i) { Path & p = m_objects.paths[i]; - p.w /= scale_amount; - p.h /= scale_amount; - p.x -= x; - p.x /= scale_amount; - p.x += x; - p.y -= y; - p.y /= scale_amount; - p.y += y; + p.m_bounds.w /= scale_amount; + p.m_bounds.h /= scale_amount; + p.m_bounds.x -= x; + p.m_bounds.x /= scale_amount; + p.m_bounds.x += x; + p.m_bounds.y -= y; + p.m_bounds.y /= scale_amount; + p.m_bounds.y += y; } return; #endif