Don't write past the end of a GPU mem buffer.

(It causes crashiness)

Re-fix QuadTree GPU rendering, discard groups

Attempt Shading + Bezier Bounds (hopefully) correct

Turns out I can't do high school calculus despite 4 years of Physics study.

The shading algorithm I envisioned has several rather hilarious
things wrong with it...

Although that 'j' does look damn good if you set the zoom *just* right...

Make bezier control point coordinates relative

So the quad tree should just have to care about bounding rectangles.
Also so the GPU renderer now doesn't need transforming but CPU renderer does now.

AddBezier assumes absolute coordinates and transforms to relative coordinates
AddBezierData is assuming relative coordinates.

Totally clear.

PS: Basically whatever is convenient/efficient for the GPU is inconvenient/inefficient for the CPU
and vice versa. Fun!

Fix ymax in GROUP bounding box

svg-tests/circlepath.svg has the right box now

BTW: Segfaults in previous commit occur only for quadtree enabled

SVG tests are 100% less symlinky

That's the good news.
The bad news is that somewhere along the way a bunch of them became 100% more segfaulty.

Groups are a thing and sort of have a bounding box now

That was what I forgot in the last commit; I added "GROUP".

So, the idea is that GROUP can be used to shade a path.
Maybe. Eventually.

Or, it could just be used to make quad tree magic easier (?)

Or it could do both! (Since you can pretty easily just turn off the shading...
 but we're getting ahead of ourselves a bit there)

Or, if it gets given a name, then it can be used to implement the <use> SVG tag.
And then we can allow recursion (which regular SVG doesn't support).

Wouldn't it be nice...

Bezier bounds rectangles are calculated correctly

CPU rendering and SVG parsing uses absolute coordinates.
GPU rendering uses relative coordinates (relative to the bounding box).

The Objects struct stores the absolute bounding boxes now.

Previously it was just using {0,0,1,1} (and thus the GPU's relative coordinates were
equivelant to the CPU's absolute coordinates).

I might have fixed some other things but I can't remember.

Support some more SVG stuff.

Can now get a dodgy, slightly hacked bit of gnuplot output to
render.

Clipping for RECT types. Breaks a little.

When using QuadTrees, RECT_OUTLINE and RECT_FILLED are clipped to
the quadtree node.

This lets you zoom in forever on rectangles with a couple of caveats:
1. This is technically wrong for RECT_OUTLINE, as more lines will be added.
2. There are a couple of issues related to the fact that only one node is
   visible at a time. Notably:
   (a) You lose the infinite precision when stradling a quadtree boundary,
       which will happen eventually.
   (b) Zooming out will show random broken things.

However, if you look at shape.svg, you can see how moving the camera around when
both the RECT and the BEZIER are in view, the RECT moves smoothly and the BEZIER
doesn't.

Use correct font metrics from truetype files.

Kerning, etc. should now be correct, but we use a monospace font
so it doesn't matter.

Automatically generate quadtree children.

This mostly works, and does the view reparenting. It doesn't do any clipping,
so we still hit precision issues as (for example) bézier control points are
outside the quadtree node's coordinate system, and become very, very large.

There are some issues with the boundaries of quadtree nodes, as the system
currently can't display two nodes at once. To compensate, it traverses up the
tree until it finds a single node which contains both, though this will be
a distant anscestor if the nodes are distantly related.

Quadtrees are still disabled by default. There are also a couple of minor
changes to the GL code to make it spit out fewer error messages and run
slightly faster on some hardware.

I am an idiot: the quadtree code is now fixed.

tl;dr: needed more * by 2.

iab;wtd*: The index buffers on the GPU contain _two_ elements per object,
one for the top left of the object's bounding box, one for the bottom-right.
We were taking that into account when computing the number of indices to give
the DrawElements() call, but not when calculating the offset into the buffer.

Oops.

*: I am bored; want tedious detail

A bunch of OpenGL debug annotations.

(Which will probably break compiling on cabellera)

SVG transforms now less broken

They work for rabbit_simple.svg now; that's pretty cool
Still appear slightly broken for more complicated SVGs (eg: the fox in ipdf/sam).

svg-tests/recursive.svg produces this error in eye of mate:
(eom:7883): librsvg-WARNING **: Circular SVG reference noticed, dropping

(If you have only one group referencing itself, there is no error but no recursion).

Merge branch 'master' of git.ucc.asn.au:ipdf/code

Still-broken quadtree shenanigans!

Quadtrees are, therefore, still disabled by default.

Only slightly totally broken SVG transformations

Argh

The matrices are ((a c e) (b d f) (0 0 1))

*Not* ((a b c) (d e f) (0 0 1))

I guess it's better than the Rect bounds crap.
But still broken.

SVG text and line elements

Totally not done properly but whatever

Make adding text to the document easier

tl;dr Use Document::AddText() to put text in places
Pass the font file in the Document constructor or call Document::SetFont() to change fonts

ts;iwtrm I am not freeing the font data buffer because I strongly suspect we will want to keep it.

You might be able to have arbitrary precision text only documents really easily if you
just re-add the glyphs at a new scale. That might be better than reparenting each individual bezier.

We could add a Document::Finalize() to free memory like the font data
which is used in creating the document but not needed afterwards.

But I want to be able to interactively add text anyway, so there doesn't seem
to be much point at the moment.

Deal with groups in SVG parsing

ParseSVGNode will recursively parse <svg>, <g> and <group> nodes.

Basically just going to try and implement a bunch more of SVG now.

The "transform" attribute would be a useful one to deal with because svg editors (at least, inkscape)
seem to be rather liberal in using it.

I hope the timestamp for this is correct, I ran git commit --amend but
I don't know if that will fix it.

Merge branch 'master' of git://git.ucc.asn.au/ipdf/code

Yes, we do need to delete m_op somehow.

"fixed" Rational::ToDouble().

Previously if the numerator or denominator was > the range of a double,
Rational.ToDouble() would return NaN. We now check for this case, and
discard precision accordingly.

Fix compiling with Arbint/Gmpint rationals

Fix SVG rendering of glyphs.svg

- Convert Quadratics -> Cubics properly
- Correctly handle relative movements in LineTo.

The power of truetype font rendering!

Make it work on Cabellera (again)

I keep forgetting I shouldn't use C++11 features
THEY ARE JUST SO CONVENIENT!

:(

Clownfish has C++11 but the open source AMD drivers don't like
geometry shaders and sulix threatened me with dire consequences
of installing fglrx...

Also fix the symlinks in svg-tests

Merge branch 'master' of git.ucc.asn.au:/ipdf/code

Dammit I hate merges

Cubic Beziers and more SVG stuff

Cubic Beziers!
Actually transform the coordinates properly!

Sort of maybe kind of render shape.svg correctly*

* Shading and stroke width will be available in the premium edition, order today for $99.99

Merge branch 'master' of git.ucc.asn.au:ipdf/code

Some QuadTree fixes.

Merge branch 'master' of git.ucc.asn.au:/ipdf/code

At least I set my time correctly this time. ho ho.

The view size is not 640x480 and hasn't been for a long time

So taking that plus some other stuff into account, the CPU renderer
for Beziers now uses the same number of lines as the GPU renderer!

Except when the bezier is a straight line. Then it just uses 1.

They still look slightly different. There is probably something wrong
with my Bresenham implementation.

QuadTree should segfault less frequently.

Still gives incorrect results w/ GPU transform.

Fix Bézier CPU rendering.

Fix beziers on GPU.

We can now render an SVG correctly(ish)! Woah!

Fix a huge bunch of memory corruption bugs in GL

It now is equally broken across Intel and nVidia.

The brokenness can be very pretty, though.

Don't try to unmap buffers which aren't mapped.

Fixes the GL_INAVLID_OPERATION that snuck in: this would occur
when calling GraphicsBuffer::Resize() on an unmapped, non-invalidated buffer.

Perpetrate SVG on the codebase

Well, parts of it.
We can have black and white SVG only.
I think it's currently buggy.

I figure we should probably be able to actually parse a document format.
And SVG, despite being XML, seems like the least terrible.

Using pugixml for XML parsing and horrible string tokenising because
SVG is not really a DOM language because of the "d" attribute (-_-)

Did I mention it was the least terrible?

Also, there seem to be lots and lots of bugs with things,
including Quadtree rendering of Beziers and actually just  GPU rendering of more than one
Bezier in general.

Also I compiled atril without zoom limits but it crashes
due to things not related to precision. So we're beating atril I guess. Woo!

CS Lab machines have met their nemesis

The ongoing adventures of overcomplicated makefile land.

David is dictating this commit message by the way,

PS:
 They are i686 and only g++0x from before 0x

Tune in next week for another exciting episode (or installment, you, the
viewer, decide!) of randomly ifdefing things out! Will our heroes
successfully defeat the 32 bit long? Or will they perish in an integer
overflow?

(I think the project is beginning to affect our minds)

Apparently things were done

Remove terrible "pow()" functions

There are many reasons why that was terrible and it finally all came apart
in a segfaultastic display.

We now have Power which only works for integer powers
But we only need those at the moment anyway.

VFPU derpage fixed

In my defence, hex and binary are only 14 digits apart

Add VFPU::Float (but it is broken)

Fails every single realops test.
Also it's stuck at 32 bits still.

Use "Real" in CPU renderer for filled circles

Get it compiling on Cabellera (g++0x not c++11)

... But at what cost?

More QuadTree code.

Fix some quadtree rendering bugs.

Quadtree Rendering for CPU transorm+render

QuadTree Rendering with GPU coord transform.

We should compile even if REAL is not 5

Actually add the Quadtree coordinate code

Quadtree transforms

Merge branch 'master' of git.ucc.asn.au:ipdf/code

Quadtrees! (Almost)

Change Rational<Arbint> -> Rational<Gmpint>

Works better (not surprising). Can change back @real.h:52

Now with GNU MultiPrecision (GMP) integers

gmpint.h is (in theory) mostly inline and shouldn't add much overhead
and was simpler than trying to understand the C++ "binding".

The Str() function is kind of terrible but that can't be helped.

Also fixed bug in realops tester (even the testers have bugs...)
And removed asm tester because the asm function is gone.

The bezier testers now don't compile, I don't think we need them anymore.

Merge branch 'master' of git.ucc.asn.au:ipdf/code

Zooming is now sligtly less slow.

C++11 lambdas - are they really worth it?

Divide some numbers by 5.

Fix GPU rendering a bit. Will probably break >1 ob

Merge branch 'master' of git.ucc.asn.au:/ipdf/code

We both fixed bugs.

Clear the carry/borrow flag before add/sub

Arbint subtraction/addition deal with borrow/carry correctly, maybe

Eventually they will be right.

This still doesn't fix the wierd bezier bug or the growing digits really fast (exponential?). I suspect the former is related
to pow(Rational<Arbint>, Rational<Arbint>) and the latter probably makes sense if you do the theory (considering how fast Rational<int64_t> overflowed).

Arbint subtraction should work* now

Yes I was being clever and resizing if sub.m_digits.size() > this->m_digits.size()
But I forgot about when this->m_digits.size() > sub.m_digits.size()

Passes tests/realops.test now!

On the other hand, CPU rendering of Beziers doesn't work anymore.
I think it's just drawing two lines instead of lots of them.

More debugging, harder realops test

Maybe this is more correct. realops likes it.

digit_t is now unsigned, asm division for 1 digit

We now do the "two's complement" in SubBasic by hand. It is maybe even
correct.

Rational<Arbint> now passes realops.test

Arbint now does sign in division correctly

The tester still sometimes picks up a fith Rational<Arbint> /= operation though.

More testing particularly of negatives

Merge branch 'master' of git.ucc.asn.au:/ipdf/code

Dammit I forgot to `git stash; git pull; git stash apply`

Improved "realops" tester

And there are signs of serious problems in Arbint too!

Slightly less memory errors

Using more std::vector and less memcpy/memset etc.
Still seems to have issues but not segfaulting as much.

Fixed m_sign missing in = operator

Fix a warning/compile error.

Horribly unreliable Arbint's and Rational<Arbint>'s

Changes from before: Arbint's use a division algorithm based on bitshifting.

So, you might get a random segfault (if you scroll you will definitely get a random segfault)
and pretty much every single operation with Rational<Arbints> gives you an accuracy warning...

And yet somehow I can render a Bezier. Really slowly.

Some initial QuadTree goodness.

Render object range on the CPU

Render part of a document (incorrectly) on the GPU

In order to get QuadTrees working, we're going to need to
render small "parts" of a document individually. The way this works
is that, when calling RenderObjectsOnGPU, we now pass a range of
object IDs. The ObjectRenderer will then find (in O(N) time, sadly)
the range of indices needed for that object type and then render those.

Béziers, and other objects which rely on the ObjectID on the GPU being
correct might be broken by this (in some cases), though if so it shouldn't
be too hard to fix by passing an offset in as a uniform.

now with fewer midnight-isms

This might help: divide an arbint by a uint64

Add assembly sources to git

Division less buggy, still slow

Ok I need to put more thought into this. Or just look it up.

It compiles... and runs with FPS of zero

Well I suppose this shouldn't have been totally unexpected...

Arbint class implemented

Seems to not explode, at least, when it only has one digit...

Inner step of multiplication in x64 assembly

Just does the multiplication of the array by one digit, taking into account overflows.
I hope. It's kind of difficult to test.

What I need is a VM with equivelant instruction set but magically uses decimals instead of binary 64 bit, so I can test with numbers
that my feeble human brain understands directly...

Arbint class with += and -= operators

Using x64 assembly routines for addition and subtraction loops,
but C++ for memory management through std::vector

Dealing with the sign is a bit annoying.

(Get it?)

Use the lea instruction to reduce number of "inc"s

More moronic bugs

So that P/-Q simplifies to -P/Q, -P/-Q simplifies to P/Q, properly this time

Arbitrary integer addition in x64 assembly

Who needs portability?

Also yes I could probably just use a library but that seems like cheating.

Maybe don't use all of the lines. Or maybe do.

The CPU version. CPU rendering still looks slightly different to GPU.
Replicates behaviour in 54798ed9050d0742c6cdab067fad0cc364b1d6b2

Also actually use the right +/- operators for Rational.
Oh and compile as rational by default because we like things to explode right?

Moronic bug identified, also Backtrace is a thing now

Copy/Paste bug @rational.h:123

At least division and addition both involve maths right?

Rational representation

Buggy, partly due to integer overflows, partly due to moronic bugs that have yet to be determined.

Maybe don't use all of the lines. Or maybe do.

Fix the missing bit of GPU béziers.

Off by one!

Béziers on the GPU.

So this was a terrible thing in many ways.

What we're doing:
- Converting all of the coefficients to floats (+ doing a bit of
  preprocessing) and uploading the the GPU.
- Uploading the data_indices array from the document to the GPU.
- Using the vertex ids in the IBO when rendering béziers to get
  the object id, then looking up the data_indices array (as a texture)
  to find which bézier coefficients to use, then reading the bézier
  coefficients from another buffer texture and finally having the
  geometry shader generate 100 lines much as the CPU one does.

We're using buffer textures to access these things because they don't
have fixed sizes (and can get big), so we can't use uniform buffers and
because shader storage buffer objects need OpenGL 4.3, which only graphics
cards manufactured in the last 45 seconds actually support.

The Béziers are quadratic not cubic...

I can maths

Béziers

It's hard to type the ́e so I will just call them Beziers from now.

New struct represents a cubic bezier, can be evaluated. The Objects struct contains a vector of beziers, and a vector of indices for each object.
If an ObjectType is BEZIER than the index can be used to look up the bezier control points. Control points are relative to the bounding rectangle;
so we can reuse the same curves (eg: For fonts).

Rendering happens on CPU only, sub divide and use Bresenham lines.
Bresenham lines are not quite optimal but I eventually gave up.

So we don't have a "line" type, but you can make one by creating a Bezier where x1,y1 == x0,y0
They look kind of wobbly.

Save/Load not tested. It might break. But it will have to be pretty heavily rewritten soon anyway.