Drawing in pixel coordinates

[dov]

I'd like to draw a rectangle in pixel size coordinates, e.g. (0,0)→(w,s) where s=40. My scene graph for such a rectangle is as follows:

root
   ↓
transRect : MatrixTransform
   ↓
quad

where the quad geometry was created with geomInfo.transform=vsg::translate(0.5,0.5,0) and thus lies on (0,0)→(1,1).

I have managed to create the transRect matrix during construction to fullfil the requirement as follows:

  this->trans = vsg::MatrixTransform::create();
  auto extent = camera->viewportState->getViewport();
  int w = extent.width;
  int h = extent.height;

  auto rect = Rectangle {vsg::dvec2(0.0, 0.0), vsg::dvec2(w, 40.0)};
  this->trans->matrix = vsg::translate(rect.pos.x / w, rect.pos.y / h, 0.0) *
        vsg::scale(rect.size.x / w, rect.size.y / h, 1.0);

So far so good.

But the problem is that once I resize my window I need to change the trans matrix.

I tried doing this by a visitor and overloading the configure event as follows:

void MyVisitor::apply(vsg::ConfigureWindowEvent& configureEvent)
{
  vsg::Inherit<vsg::Visitor, RulerViewVisitor>::apply(configureEvent);

  auto extent = this->view->camera->viewportState->getViewport();
  int w = extent.width;
  int h = extent.height;

  // Oops 1: configureEvent.width != extent.width

  auto rect = Rectangle {vsg::dvec2(0.0, 0.0), vsg::dvec2(w, 40.0)};

  this->view->trans->matrix = vsg::translate(rect.pos.x / w, rect.pos.y / h, 0.0) *
    vsg::scale(rect.size.x / w, rect.size.y / h, 1.0);
}

I'm using exactly the same calculation as during the construction, but the result is now wrong.

Oops number 1:

The configureEvent.width != extent.width. Thus it seems like the configureEvent is called "too early", i.e. before the window extent has been updated.

So my question how to solve this? How can I draw a pixel defined rectangle, and have it redrawn at its new coordinates when the window is resized?

[dov]

I have figured out the following regarding the resizing:

• In RenderGraph::accept(RecordTraversal&) the window extent is compared to the previous window extent and if the size has changed, then the method resized() is called.
• In resized() a traversal() is called on the windowResizeHandler and, which changes the projection and viewport transformations of all the views in the render graph.

So my question is what is the best way of selectively overriding this for my overlay views? Can I install into the render graph my own derived windowResizedHandler which calls the baseclass, and then resets the changed projection matrix for my overlay view?

Shouldn't this be a camera or a view property, whether you want the projectionMatrix to change on window resize?

[dov]

I managed to override the window ResizeHandler and override the projectionMatrix with code like the following:

class MyWindowResizeHandler : public vsg::Inherit<vsg::WindowResizeHandler, MyWindowResizeHandler>
{
  public:
  MyWindowResizeHandler()
    : vsg::Inherit<vsg::WindowResizeHandler, MyWindowResizeHandler>() {}

  void apply(vsg::View& view) override {
    vsg::Inherit<vsg::WindowResizeHandler, MyWindowResizeHandler>::apply(view);

    if (dontTouchProjectionViewsSet.count(&view) > 0)
      view.camera->projectionMatrix = vsg::Orthographic::create(0, 1, 0, 1, 1.0, 10000.0);
  };
  std::set<vsg::View*> dontTouchProjectionViewsSet;
};

However, I'd like something more generic, and here is an idea of how this can be implemented:

1. Add to View a virtual method virtual void resize() {} with an empty implementation.
2. In WindowResizeHandler::apply(view) add a call to this method at a suitable place.

Such a change would allow deriving from a View and implement custom behavior to be carried out on resize.

[xiaoxin0214]

I've experimented with overriding the changeExtent method in a custom orthographic class：

namespace vsg
{
    class MyOrthographic : public vsg::Inherit<vsg::Orthographic, MyOrthographic>
    {
    public:
        MyOrthographic(double l,double r, double b, double t,double n,double f) :
            Inherit(l,r,b,t,n,f)
        {
        }

        explicit MyOrthographic(const MyOrthographic& o, const CopyOp& copyop = {}) :
            Inherit(o, copyop)
        {
        }

        vsg::ref_ptr<Object> clone(const vsg::CopyOp& copyop = {}) const override { return MyOrthographic::create(*this, copyop); }

        void changeExtent(const VkExtent2D& prevExtent, const VkExtent2D& newExtent) override
        {
            //double oldRatio = static_cast<double>(prevExtent.width) / static_cast<double>(prevExtent.height);
            //double newRatio = static_cast<double>(newExtent.width) / static_cast<double>(newExtent.height);
            //left *= newRatio / oldRatio;
            //right *= newRatio / oldRatio;
        }
    };
}

it works. Can i do it in this way？Any suggestions would be greatly appreciated。

[dov]

Nice! This is indeed a simpler way of making sure that the camera projection matrix doesn't change! Much cleaner than my way of overriding and resetting the projectionMatrix when the view is resized. But the result is the same, that you have a predictable orthographic mapping of the unit square in the parent view. By dividing with the extent size, you can then draw pixel exact drawings in the view.

[dov]

For reference, I created a pull request that improves the pixel exact overlay handling by introducing the View::resize() virtual method mentioned in my previous comment. See: #1335