We had support for detecting aspect ratios and respecting them in the
render, but this allows people to not only see the aspect ratio in use,
but also override it with their own.
Allows dynamic switching between pointer/roll/slide since occasionally this
behavior is interchangeable. Fixes a lot of transition behavior (but not
all of it).
I had thought that the cursor may still have moved between the last
mouseMoveEvent and the mouseReleaseEvent, but that turns out to be false
making it completely unnecessary to call move functions in the release
function.
Since this action handles the key press, if it's checked value is not equal
to the real value, it will be a no-op first before it "syncs" with the
real value.
General code and functionality improvements. Moved more code out of the
OpenGL backend for portability. Implemented audio transitions.
Implemented basic transition animation curve settings.
Improves stability and cache reliability.
Earlier iterations were prone to skipping necessary signals (usually
leading to some sort of assert fail), particularly when track
optimizations were used. Those optimizations have been moved to the
viewer node so there's a higher degree of control over which signals
get optimized and in which ways.
While good in theory, a WYSIWYG rich text editor for large video frames
was unwieldy (and in many cases unhelpful). Instead the titler will
show plain text/HTML tags so the user can still write rich text but
without the unwieldy UI.
For a true WYSIWYG experience, we would probably need to write a true
graphical editor (a la Premiere's titler), but that's a later goal.
This titler will be sufficient in a good majority of cases and there
are plenty of dedicated graphics packages if more complex titling is
required for the timebeing.
I think there was an earlier commit with a similar name but turns out
I'd only done foundational work in that commit and never actually
properly set it up. Of course once I did, there were several issues that
needed fixing to make it work correctly, but now it works as expected.
Heavily optimizes larger projects by allowing cache jobs to only copy
what has changed.
Ensures their thread gets changed along with the viewer. The project
gets loaded/created in a background thread so the GUI can remain
responsive, and is then moved to the main thread for intended event
handling. However if the caches aren't parented, the hierarchy breaks
and the caches remain in a thread whose event loop is quickly destroyed.
Now that they're parented, events can be properly queued on them once
again.
Queuing the destructor caused a potential desync in the node graph that
disconnected blocks after they were reconnected elsewhere. Destroying
immediately keeps this logic synchronized.
Since auto-cache events start and stop fairly frequently (and are somewhat
heavy to create/destroy), we can save a lot of cycles over time by sharing
the same backend between them all.
Default TimeBasedWidget behavior is to jump to the playhead, but we want
the CurveView to zoom fit on open instead. So we set the input after the
timestamp to make this behavior possible.
* Implements "auto-fit" setting for curve view and sets it on open.
* Improves scroll zooming on all TimelineViewBase derivatives.
* Improves code sharing for better maintenance.
Previously the OpenGL instance was tied to each render/cache task,
creating and destroying it each time one started and stopped. This was
completely unnecessary since the instance holds no state and can be
shared by all of the render tasks without having to expensively start
a new one.
There were a lot of issues that arose from trying to make GUI changes
from another thread (even though we ran those functions in the right
thread). Now we store layout information until the end of the load and
make the changes then. This works much better from both a business logic
and user experience perspective.
Also prevents multiple sequences from taking focus during load and
starting a render job.
Viewer init was kind of too late since in many cases the sequence
would start caching and crash the app before the user could even read
the message. Moving to the startup makes it clearer from the beginning.
ProgressDialog doesn't have to worry about the platform anymore, now
MainWindow will determine what to do or whether to ignore certain progress
indicator functions.
Previously, audio was all queued first and would therefore all have to
finish before any video frames could start caching. No longer! Now they're
queued side by side so users won't have to wait for audio to finish before
their cached frames come in.
itsmattkc