#include "document.h"
#include "bezier.h"
+#include "profiler.h"
#include <cstdio>
#include <fstream>
int Document::ClipObjectToQuadChild(int object_id, QuadTreeNodeChildren type)
{
+ PROFILE_SCOPE("Document::ClipObjectToQuadChild");
switch (m_objects.types[object_id])
{
case RECT_FILLED:
}
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, 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});
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});
switch (type)
{
case QTC_TOP_LEFT:
- orig_node = m_quadtree.nodes[orig_parent].top_left = new_index;
+ orig_node = m_quadtree.nodes[orig_parent].top_left;
break;
case QTC_TOP_RIGHT:
- orig_node = m_quadtree.nodes[orig_parent].top_right = new_index;
+ orig_node = m_quadtree.nodes[orig_parent].top_right;
break;
case QTC_BOTTOM_LEFT:
- orig_node = m_quadtree.nodes[orig_parent].bottom_left = new_index;
+ orig_node = m_quadtree.nodes[orig_parent].bottom_left;
break;
case QTC_BOTTOM_RIGHT:
- orig_node = m_quadtree.nodes[orig_parent].bottom_right = new_index;
+ orig_node = m_quadtree.nodes[orig_parent].bottom_right;
break;
default:
Fatal("Tried to overlay a QuadTree child of invalid type!");
// Add us to the node's overlay linked list.
QuadTreeIndex prev_overlay = orig_node;
- while (m_quadtree.nodes[prev_overlay].next_overlay != -1);
+ 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.
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});
+
+ 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)
+ {
+ 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++;
+ }
+ }
+ 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;
+
+ // 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)
{
// 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[overlay].child_type);
// Recurse into any extant children.
if (m_quadtree.nodes[node].top_left != -1)
OverlayQuadChildren(node, overlay, QTC_TOP_LEFT);
Fatal("Tried to add a QuadTree child of invalid type!");
}
return new_index;
+ m_document_dirty = true;
}
#endif
unsigned Document::Add(ObjectType type, const Rect & bounds, unsigned data_index, QuadTreeIndex qti)
{
+ PROFILE_SCOPE("Document::Add");
+ Rect new_bounds = bounds;
+#ifndef QUADTREE_DISABLED
+ if (qti == -1) qti = m_current_insert_node;
+ if (qti != -1)
+ {
+ // I am ashamed, yes.
+ m_quadtree.GetCanonicalCoords(qti, new_bounds.x, new_bounds.y, this);
+ }
+#endif
m_objects.types.push_back(type);
- m_objects.bounds.push_back(bounds);
+ m_objects.bounds.push_back(new_bounds);
m_objects.data_indices.push_back(data_index);
#ifndef QUADTREE_DISABLED
if (qti != -1)
}
done: // matches is not amused, but sulix is nice and moved it inside the #ifdef for him.
m_count++;
- PropagateQuadChanges(qti);
}
+ return m_count-1;
+#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)
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.m_bounds.x += dx;
- p.m_bounds.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)