SceneDecorator.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agxOSG/export.h>
 
 
#include <agx/Vec3.h>
#include <agx/Vec4.h>
 
#include <agx/PushDisableWarnings.h> // Disabling warnings. Include agx/PopDisableWarnings.h below!
#include <osg/Referenced>
#include <osg/Group>
#include <osg/Texture2D>
#include <osg/MatrixTransform>
#include <osg/Projection>
#include <osg/StateSet>
#include <osg/PositionAttitudeTransform>
#include <osg/Switch>
#include <osg/Material>
#include <osgShadow/ShadowedScene>
#include <osgShadow/ShadowTechnique>
#include <osg/LightSource>
#include <osg/Geometry>
#include <agx/PopDisableWarnings.h> // End of disabled warnings.
#include <agxOSG/LightSource.h>
 
 
namespace agxRender
{
  class Color;
}
 
namespace osgText
{
  class Text;
}
 
namespace agxOSG
{
 
  class AGXOSG_EXPORT SceneDecorator : public osg::Group
  {
  public:
 
    SceneDecorator( int windowSizeX, int windowSizeY, int enabledLights = LIGHT0 | LIGHT1 );
 
    void setEnableShadows( bool flag );
 
    bool getEnableShadows() const;
 
    void setEnable( bool flag );
 
    bool getEnable() const;
 
    bool isEnabled() const;
 
    enum LogoLocation {
      UPPER_LEFT = 0x1,
      LOWER_LEFT = 0x2,
      UPPER_RIGHT = 0x3,
      LOWER_RIGHT = 0x4,
      FREE               
    };
 
    void setLogoLocation( LogoLocation l );
 
    LogoLocation getLogoLocation() const;
 
    void setLogoPosition(float x, float y);
 
    void setEnableLogo( bool flag );
 
    bool getEnableLogo() const;
 
    bool setLogoFile(const std::string& filename, float density = 1.0);
 
    void setText( int row, const agx::String& text );
    void setText( int row, const agx::String& text, const agx::Vec4f& color );
 
    void setEnableShaderState( bool flag, bool lock=false );
 
    bool getEnableShaderState( ) const;
 
    void clearText();
    bool setBaseTexture(const std::string& imagePath);
 
    const osg::Vec2& getLogoDimension();
 
    osg::Vec2 getMaximumLogoDimension();
 
    void setMaximumLogoDimension(float x, float y);
 
    static osg::Vec2 getDefaultLogoPosition();
 
    osg::MatrixTransform* getHud() { return m_hudRoot.get(); }
 
    // Overriding add/remove child methods
    virtual bool insertChild( unsigned int index, osg::Node *child ) { return m_currentRoot->insertChild(index, child); }
    virtual bool addChild(osg::Node *child) { return m_currentRoot->addChild(child); }
    inline bool removeChild( osg::Node *child ) { return m_currentRoot->removeChild(child); }
    inline bool removeChild( unsigned int pos, unsigned int numChildrenToRemove=1 ) { return m_currentRoot->removeChild(pos, numChildrenToRemove); }
    virtual bool replaceChild( osg::Node *origChild, osg::Node* newChild ) { return m_currentRoot->replaceChild(origChild, newChild); }
    virtual bool setChild( unsigned  int i, osg::Node* node ) { return m_currentRoot->setChild(i, node); }
    virtual bool removeChildren(unsigned int pos,unsigned int numChildrenToRemove) { return m_currentRoot->removeChildren(pos, numChildrenToRemove); }
 
    void calculateLightPositions(osg::Node* bound_node = nullptr);
 
    void calculateLightPositions( const osg::BoundingBox& boundingBox );
 
    void calculateLightPositions( const osg::BoundingSphere& boundingSphere );
 
    std::string getFontName() const;
 
    void setFontName(const std::string& fontName);
 
    void updateWindowSize(int sizeX, int sizeY);
 
    agx::Vec2i32 getWindowSize() const;
 
    void setScreenPixelScale(float scale);
 
    float getFontSize() const;
 
    void setFontSize(const float& fontSize);
 
    osg::LightSource* getShadowLightSource();
 
    enum Lights {
      LIGHT0 = 0x1,
      LIGHT1 = 0x2,
      LIGHT2 = 0x4,
      ALL = LIGHT0 | LIGHT1 | LIGHT2
    };
 
 
    static size_t lightToIndex(Lights l);
 
    void setEnableCalculateLightPositions( Lights l, bool f );
 
    bool getEnableCalculateLightPositions(Lights l) const;
 
    bool setShadowLightSource( Lights l);
 
    osg::StateSet* getDecoratorStateSet() { return m_decoratorStateSet; }
 
    osg::LightSource* getOSGLight(Lights l);
 
    agxOSG::LightSource getLightSource(Lights l);
 
    enum ShadowMethod {
      SOFT_SHADOWMAP,
      SHADOWMAP,
      SHADOWVOLUME, 
      PARALLELLSPLIT_SHADOWMAP,
      LIGHTSPACEPERSPECTIVE_SHADOWMAP,
      SHADOWTEXTURE,
      NO_SHADOWS
    };
 
    void setShadowMethod(ShadowMethod m);
 
    ShadowMethod getShadowMethod() const { return m_shadowMethod; }
 
    void setBackgroundColor(const agx::Vec4f& color);
 
    void setBackgroundColor(const agx::Vec4f& color1, const agx::Vec4f& color2);
 
    void setBackgroundColor(const agx::Vec4f& colorUL, const agx::Vec4f& colorUR, const agx::Vec4f& colorLL, const agx::Vec4f& colorLR);
 
 
    void setBackgroundColor(agx::Vec3 color);
 
    void setBackgroundColor(agx::Vec3 upper, agx::Vec3 lower);
 
    void setBackgroundColor(agx::Vec3 colorUL, agx::Vec3 colorUR, agx::Vec3 colorLL, agx::Vec3 colorLR);
 
    void setEnableLights(int lightMask = ALL);
 
    void setEnableRenderedCursor( bool enable );
    bool getEnableRenderedCursor() const;
    void updateCursorPosition( float x, float y );
 
    osg::Texture2D* getLogo();
 
    void setLogo(osg::Texture2D* logo, float density = 1.0);
 
    // Will reset the rendering HUD.
    void resetHUD();
 
    osg::Group* getShadowedScene() const;
 
    osg::Group* getNonShadowedScene() const;
 
    static const osg::Material* getDefaultDecoratorMaterial();
 
  protected:
    void updateLogo();
    void createHUD();
 
    void createLogo();
    void createBackground();
 
    void init(Lights l);
 
    osg::ref_ptr<osg::Group> m_enabledRoot;
    osg::ref_ptr<osg::Group> m_enabledNonShadowRoot;
    osg::ref_ptr<osg::Group> m_currentRoot;
    osg::ref_ptr<osg::Group> m_disabledRoot;
    osg::ref_ptr<osg::Group> m_disabledNonShadowRoot;
    osg::ref_ptr<osg::Switch> m_backgroundRoot;
    osg::observer_ptr<osg::Geometry> m_backgroundQuad;
    LogoLocation m_logoLocation;
    osg::ref_ptr<osg::Texture2D> m_logoTexture;
    osg::ref_ptr<osg::PositionAttitudeTransform> m_logoTransform;
    osg::ref_ptr<osg::Switch> m_logoSwitch;
    osg::ref_ptr<osg::MatrixTransform> m_hudRoot;
    osg::ref_ptr<osg::StateSet> m_logoStateSet;
    osg::Vec2 m_logoPosition;
    bool m_enabledShadows;
    bool m_enabled;
    bool m_logoEnabled;
    ShadowMethod m_shadowMethod;
    std::string m_baseTexturePath;
    agx::Vector<osgText::Text *> m_text;
    std::string m_fontName;
    float m_fontSize;
    int m_windowSizeX;
    int m_windowSizeY;
    float m_maximumLogoDimensionX;
    float m_maximumLogoDimensionY;
    osg::Vec2 m_logoSize;
    float m_logoPixelDensity;
    float m_screenPixelScale;
 
    osg::ref_ptr<osgShadow::ShadowedScene> m_shadowedScene;
    osg::ref_ptr<osgShadow::ShadowTechnique> m_shadowTechnique;
 
    osg::ref_ptr<osg::StateSet> m_decoratorStateSet;
 
    agx::Vector<osg::ref_ptr<osg::LightSource> > m_lightSources;
    osg::ref_ptr<osg::LightSource> m_ShadowlightSource;
    osg::ref_ptr<osg::Vec3Array> m_backgroundColors;
 
    void createDecoratorState();
 
    virtual ~SceneDecorator();
 
    bool m_calculateLightPosition[3];
 
    osg::ref_ptr<osg::Node> m_cursorTransform;
    osg::ref_ptr<osg::Camera> m_hudCamera;
    osg::ref_ptr<osg::Projection> m_hudProjection;
 
    bool m_useShaderState;
    bool m_shaderSupportAvailable;
 
    static osg::ref_ptr<osg::Material> s_decoratorMaterial;
  };
}