Storyboard Engine ported to ITRON operating system.
Storyboard IO over TCP/IP has been introduced as a native functionality available on target platforms where TCP/IP connectivity is part of the standard configuration. This means that you can now send and receive Storyboard events over the network.
The Lua action has been enhanced to better support Lua object oriented programming techniques. Lua object modules can be referenced directly now as callbacks further encapsulating the context of execution and removing the need for some boilerplate glue logic.
Fill and rectangle render extensions now have a corner radius property for rounded rectangles. This feature can be used to help reduce the memory or storage footprint by replacing images that may have been used for the same visual effect.
For some shadowed scenarios where a rounded rectangle may not offer enough visual appeal nine-slice/nine-patch images can be used. Nine-patch images can now be rendered directly from flash and rotated using no additional memory for a scalable UI component and can be compressed as RLE for additional memory savings.
Storyboard Designer’s now includes the ability to turn performance logging and execution tracing on and off from the IO Connector. When coupled with the TCP/IP Storyboard transport this creates some very powerful remote analysis possibilities.
The performance log viewer includes event data plotting and visualization tools that allow you to look at the data gathered in performance trace logs and put it into context with triggering events and screens of execution.
Redraw time, CPU consumption and Memory Usage information is plotted on platforms where this information is available.
Individual animation variables can be plotted as they change over time.
Specific problem solving tasks are made easier with pre-configured data plots.
Statistical plotting functionality allows users to create their own plots by extracting metrics that are relevant for their areas of investigation.
A performance Lua API has been added that allows user applications to inject data markers and trace points into the performance log. Coupled with the plotting and visualization this can put user code execution in context of other metrics being considered.
New algorithms for software rendering scaling and rendering operations resulted in a 50% reduction of dynamic memory consumption when these operations are used independently.
The compare and merge operations on Storyboard Designer projects are more consistent and three way comparisons with source control systems (git/svn) are faster.
The Find References action is now partnered with a find that will search for the selection within other files of the project. Useful for finding model and image references in Lua files.
Component creation will now allow you to convert the original component source to a component itself. Copying and pasting a component within a project will maintain that component’s relationship as a component for future updates.
The animation preview now supports looping of the animation that is being previewed and limits the preview to the frames that will be shown by the runtime.
All animation step variable keys will be included in the refactoring operations that occur when the names of variables or model objects are changed.
Drag and Drop of model content now maintains consistent z-order.
Direct inline text editing uses the correct font and display.
Photoshop import and re-import does a more accurate job representing multi-line text and text with alignment attributes where it is possible to do so.
The C/C++ Event Header can now be built from the command line.
Layer and table scrolling can now be dynamically enabled/disabled through the new scroll_enabled attribute or grd_scroll_enabled variable.
Table resize operations will no longer reset the current scroll offset unless the scroll offset would result in the data not being visible.
Scrolling operations are smoother and snapping takes advantage of the direction to ensure that snapping operations occur to the right context boundary.
OpenGL rendering quality improvements:
Alpha layer blending blends smoothly over the full alpha value range.
3D model camera settings (Z in particular) properly show the model.
Single pixel offset incorrect for certain rectangles.
Custom shaders with UV wrap don’t need -oresource_mgr,image_block_size=-1
Removed custom shader requirement for -oresource_mgr,image=-1,font=-1 option
Proper format support for the GL_BGRA_EXT
Logging and verbosity can now be redirected over an SBIO channel as events.
Performance logging filename options now support appending, date and time stamps.
The fbdev software render manager allows the selection of framebuffers to render to.
Android and Windows will correctly restore themselves after coming back from sleep.
A new Lua API has been added to allow controls to be resized or moved in a relative sense using the same anchoring functionality available in Designer when working interactively. Scale controls with a single command without having to hit x/y/width/height values independently.
A new font-manager option, -ofont_mgr,linegap has been introduced to disable the linegap offset that Storyboard Engine inserts with certain fonts (notably Noto). This option is disabled by default to maintain compatibility with the current Storyboard Engine, but will be enabled by default in the next major version of Storyboard.
A new model-manager options, -omodel_mgr,block_sbio_sends has been introduced that will adjust the blocking behaviour of Storyboard Engine’s SBIO send operations. The default configuration is to not block sending calls from the UI as that has the effect of potentially deadlocking the UI, however clients can revert the behaviour to the older behaviour by indicating that sends should be blocked.
Multi-touch event compression enabled by default. This option should have no ill effect on clients but an option to remove all input event compression added
OpenGL rendering clients should see an improvement in visual quality for the 6.2 release but that improvement comes at the cost of more GLSL shader operations.
Some clients may observe a longer load time or a slight degradation in performance depending on the sophistication of their GPU technology.
Dynamic injection is used on the shaders and patterns such as:
gl_FragColor.r = grd_c_r;
gl_FragColor.g = grd_c_g;
gl_FragColor.b = grd_c_b;
gl_FragColor.a = col.a;
May require conversion to the style of:
gl_FragColor = vec4(grd_c_r, grd_c_g, grd_c_b, col.a);
Direct editing of clipped, multi-line, wrapped or ellipsis text will not show the cursor in the correct location.
Starting and stopping and appending results to the performance log may produce unusual display plots.
Animated GIFs consume memory for each frame that is rendered and the frames can’t be incrementally loaded making them poor choices for limited resource targets.
The Metrics View does not report on all static consumers of memory including the display framebuffers, canvas and external render extensions and rich text.
Debugging Lua on Linux systems may not work through the one click launcher, but the debugger connection may need to be launched before the main application.
Some exceptionally large Lua files may identify as corrupt and not show properly in the outline.