View drawing: Add new capabilities to the SketchUp Ruby API to allow improved performance when drawing to a View (Tool#draw and Overlay#draw)

[mccs001]

These are feature requests (originally raised in the SketchUp MeetUp meeting on 8th March 2023: ThomThom asked me to raise them here)

The requests are to allow SketchUp Extensions to be able to draw large amounts of mainly-fixed geometry (in model coordinates, anyway) in a way that runs performantly (without introducing lag to the UI when orbiting/panning/zooming) and looks nice.

These can be achieved with some manual calls to C++ OpenGL functions (while in Tool#draw call - probably also with Overlay#draw but not tested yet) but it would be much better for them to be available with officially-documented SketchUp API functions that will continue to work with the new Graphics pipelines being introduced.

Please add the following capabilities:

1. Allow an extension to store fixed geometry that doesn't change (in model coordinates) between draw calls and render it quickly without needing to make the same individual View#draw calls each time.

• This is critical in order for the SketchUp UI to remain responsive when the custom tool has a lot of mainly-fixed geometry to render and the user does things like orbit, pan and scroll-zooming with the mouse wheel
• It can currently be achieved by making manual use of OpenGL display lists (with a bit of extra trickery needed since SU2017) but it would be much better for it to be supported in the Ruby API
• Note that the same extension should still be able to draw dynamic changing geometry (eg in response to the user moving the mouse with a button pressed) before or after the fixed geometry parts. It could be nice to allow a number of separately-referenced fixed parts (similar or OpenGL display lists)

2. Allow an extension to selectively enable something similar to OpenGL polygon offsetting

• This is more cosmetic but, right now, when drawing shapes with a concave edge (eg a box with a corner removed), those concave edges just don't look prominent enough.
• It can currently be achieved by making manual use of the OpenGL polygon offsetting mode but it would be much better for it to be supported in the Ruby API (or fixed in some other way)

3. Consider making it possible for C/C++ code to call an officially-supported draw function with plain C++ data types (eg arrays of doubles for points) - when called inside Tool#draw

• C++ code that's invoked from inside Tool#draw can already call the View#draw Ruby methods (with rb_funcall) but all arguments first have to be converted into Ruby types: that is, into a Ruby array of Geom::Point3d objects (or arrays of Ruby Float objects)
• Since the underlying View#draw implementation will presumably need to then convert those arguments back into a native representation anyway, it feels like there's the potential to remove this step.
• For example, there could be an officially-supported C-style function exported by the SketchUp.exe process (similar to other SketchUp C API functions) that accepts the same arguments as View#draw but in a native format (I don't think it would make sense to make it a Ruby function unless it's easy and safe for the caller to pass through some kind of object in the native representation)
• There'd need to be some strict rules around its use: that it must only be called by a Ruby extension that's within the Tool#draw or Overlay#draw methods
• But maybe this is a nice-to-have if the first request, above (to allow storing and fast drawing of any fixed geometry), is implemented.

Hope that all makes sense. I'll be happy to give more details if that would help and take part in any discussions around implementation ideas.

[Fredosixx]

Personally, I never found no major performance issues with view.draw methods.

For 3D drawing, storing the instructions (independent from the view camera) and calling the view.draw methods is good enough.

For 2D drawing (dependent on view camera), I only recompute the instructions when there is an observer event onViewChanged.

What would however be nice to have, is a method to draw any type of polygons. Currently, GL_POLYGON only works for convex polygons, not concave ones.

[DanRathbun]

• For example, there could be an officially-supported C-style function exported by the SketchUp.exe process (similar to other SketchUp C API functions) that accepts the same arguments as View#draw but in a native format (I don't think it would make sense to make it a Ruby function unless it's easy and safe for the caller to pass through some kind of object in the native representation)

We have talked about this in the past for the Live C API. A year and 9 months ago ... this request was opened:

Issue 853 : Implement SUViewDraw

[thomthom]

What would however be nice to have, is a method to draw any type of polygons. Currently, GL_POLYGON only works for convex polygons, not concave ones.

You can use Geom.tesselate to deal with convext and complex (with holes) polygons: https://ruby.sketchup.com/Geom.html#tesselate-class_method