scene.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
#ifndef OST_SCENE_HH
#define OST_SCENE_HH
 
/*
  Author: Ansgar Philippsen
*/
 
#include <map>
#include <stack>
#include <vector>
 
#include <boost/shared_array.hpp>
 
#include <ost/gfx/module_config.hh>
#include <ost/geom/transform.hh>
#include <ost/mol/atom_handle.hh>
 
#include "gl_include.hh"
#include "color.hh"
#include "gfx_object_fw.hh"
#include "gfx_node_fw.hh"
#include "gfx_node_visitor.hh"
#include "glwin_base.hh"
#include "scene_observer.hh"
#include "gfx_prim.hh"
#include "povray_fw.hh"
#include "exporter_fw.hh"
#include "gradient.hh"
#include "bitmap_io.hh"
 
namespace ost { namespace gfx {
 
class InputEvent;
 
typedef std::vector<SceneObserver*>  SceneObserverList;
 
struct Viewport {
  int x;
  int y;
  int width;
  int height;
};
 
namespace impl {class SceneFX;}
 
class DLLEXPORT_OST_GFX Scene {
  friend class impl::SceneFX;
 private:
   
  // TODO: this struct may be the seed for a proper
  // refactoring of the scene it into a management
  // and a view part
  struct SceneViewStackEntry {
    geom::Transform transform;
    float fov;
    float znear,zfar;
  };
 
  typedef std::stack<SceneViewStackEntry> SceneViewStack;
 
 public:
  static Scene& Instance();
 
  void SetFog(bool f);
  bool GetFog() const;
  void SetFogColor(const Color& c);
  Color GetFogColor() const;
 
  void SetShadow(bool f);
  bool GetShadow() const;
  void SetShadowQuality(int q);
  int GetShadowQuality() const;
  void SetShadowWeight(float w);
  float GetShadowWeight() const;
 
  void SetDepthDarkening(bool f);
  void SetDepthDarkeningWeight(float f);
 
  void SetAmbientOcclusion(bool f);
  bool GetAmbientOcclusion() const;
  void SetAmbientOcclusionWeight(float f);
  float GetAmbientOcclusionWeight() const;
  void SetAmbientOcclusionMode(uint m);
  uint GetAmbientOcclusionMode() const;
  void SetAmbientOcclusionQuality(uint q);
  uint GetAmbientOcclusionQuality() const;
  void SetAmbientOcclusionSize(float f);
  float GetAmbientOcclusionSize() const;
 
  void SetHemiParams(const geom::Vec4&);
  geom::Vec4 GetHemiParams() const {return hemi_param_;}
 
  void SetShadingMode(const std::string& smode);
 
  geom::Mat4 GetProjection() const {return pmat_;}
  geom::Mat4 GetInvertedProjection() const {return ipmat_;}
 
 
  float GetNear() const;
  
  void SetNear(float n);
  
  float GetFar() const;
  
  void SetFar(float f);
  
  void SetNearFar(float n, float f);
 
  void SetFOV(float f);
 
  // \brief get the field of view
  float GetFOV() const;
 
  float GetAspect() const {return aspect_ratio_;}
 
  void SetFogNearOffset(float o);
 
  float GetFogNearOffset() const;
 
  void SetFogFarOffset(float o);
 
  float GetFogFarOffset() const;
 
  void SetFogOffsets(float no, float fo);
  
  void Autoslab(bool fast);
 
  void Autoslab(bool fast, bool);
 
  void AutoslabMax();
 
  void Autoslab();
 
  void SetAutoslabMode(int mode) {
    autoslab_mode_=std::min(2,std::max(0,mode));
  }
 
  int GetAutoslabMode() const {
    return autoslab_mode_;
  }
 
  void AutoAutoslab(bool f);
  
  bool GetAutoAutoslab() const { return auto_autoslab_; }
 
 
  void SetStereoMode(unsigned int mode);
  int GetStereoMode() const {return stereo_mode_;}
 
  void SetStereoFlip(bool f);
  bool GetStereoFlip() const {return stereo_inverted_;}
  
  void SetStereoView(int);
  int GetStereoView() const {return stereo_eye_;}
 
  void SetStereoIOD(Real);
  Real GetStereoIOD() const {return stereo_iod_;}
 
  void SetStereoDistance(Real);
  Real GetStereoDistance() const {return stereo_distance_;}
  
  void SetStereoAlg(unsigned int);
  unsigned int GetStereoAlg() const {return stereo_alg_;}
  
  void SetLightDir(const geom::Vec3& dir);
  void SetLightProp(const Color& amb, const Color& diff, const Color& spec);
  void SetLightProp(float amb, float diff, float spec);
  geom::Vec3 GetLightDir() const {return light_dir_;}
  geom::Mat3 GetLightRot() const {return light_rot_;}
 
  /*
    bad style for now: 0=(reserved), 1=atom, 2=residue, 3=chain, 4=bond, 5=torsion
  */
  void SetSelectionMode(uint m);
  uint GetSelectionMode() const;
 
 
  void Export(const String& fname, unsigned int w,
              unsigned int h, bool transparent=false);
  void Export(const String& fname, unsigned int w,
              unsigned int h, int max_samples, bool transparent=false);
 
  void Export(const String& fname, bool transparent=false);
 
  void ExportPov(const std::string& fname, const std::string& wdir=".");
 
  void Export(Exporter* ex) const;
 
  void OnInput(const InputEvent& e);
  
  void InitGL(bool full=true);
 
  void Resize(int w, int h);
 
  void Pick(int mx, int my, int mask);
  
  float GetDefaultTextSize();
 
  std::pair<GfxObjP, mol::AtomHandle> PickAtom(int mx, int my);
  
  void RenderGL();
 
  void RequestRedraw();
  
  void StatusMessage(const String& s);
 
  void SetViewport(int w, int h);
 
  void SetBackground(const Color& c);
 
  void SetBackground(const Gradient& g);
 
  void SetBackground(const Bitmap& bm);
 
  Color GetBackground() const;
 
  void SetBackgroundStereoMode(bool);
  bool GetBackgroundStereoMode() const {return bg_stereo_mode_;}
 
  void SetBackgroundStereoOffset(float);
  float GetBackgroundStereoOffset() const {return bg_stereo_offset_;}
 
  void SetCenter(const geom::Vec3& cen);
  
  geom::Vec3 GetCenter() const;
 
  void CenterOn(const String& s);
 
  void CenterOn(const GfxObjP& s);
 
  geom::Vec3 Project(const geom::Vec3& v, bool ignore_vp=false) const;
  
  geom::Vec3 UnProject(const geom::Vec3& v, bool ignore_vp=false) const;
 
 
  geom::AlignedCuboid GetBoundingBox(bool use_tf=true) const;
 
  geom::AlignedCuboid GetBoundingBox(const geom::Transform& tf) const;
 
  geom::Transform GetTransform() const;
 
  void SetTransform(const geom::Transform& t);
 
  geom::Mat4 GetRTC() const;
 
  void SetRTC(const geom::Mat4& rtc);
  
  void PushView();
 
  void PopView();
 
  void ResetProjection();
 
  void Register(GLWinBase* win);
  void Unregister(GLWinBase* win);
  
 
  void Add(const GfxNodeP& go, bool redraw=true);
  void Remove(const GfxNodeP& go);
  void Remove(const String& name);
  
  void RemoveAll();
  
  bool Rename(const String& old_name, const String& new_name);
 
  GfxObjP operator[](const String& name);
 
  bool HasNode(const String& name) const;
  
  void Apply(const InputEvent& ie, bool request_redraw=true);
 
  void Apply(GfxNodeVisitor& v) const;
  
  size_t GetNodeCount() const;
  
  GfxNodeP GetRootNode() const;
  
  void AttachObserver(SceneObserver* o);
  void DetachObserver(SceneObserver* o);
 
  void SetTestMode(bool t);
 
  float ElapsedTime() const;
 
  Viewport GetViewport() const;
 
 
  void SetShowCenter(bool f);
 
  bool GetShowCenter() const {return cor_flag_;}
 
  void SetFixCenter(bool f) {fix_cor_flag_=f;}
 
  bool GetFixCenter() const {return fix_cor_flag_;}
  
  void SetBlur(uint n);
  void BlurSnapshot();
 
  void RenderText(const TextPrim& t);
 
  void SetBeacon(int wx, int wy);
  void SetBeaconOff();
 
  void SetExportAspect(float a);
  float GetExportAspect() const {return export_aspect_;}
  void SetShowExportAspect(bool f);
  bool GetShowExportAspect() const {return show_export_aspect_;}
 
  bool HasMultisample() const {return ms_flag_;}
 
  void SetAlphaBias(Real bias);
 
  void ContextSwitch();
  
protected:
  friend class GfxObj; 
  friend class GfxNode;
 
  // TODO: this is really a hack and not clean communication
  friend class Entity;
  
  void ObjectChanged(const String& name);
  void SelectionChanged(const String& name, const mol::EntityView& sel);
  void NodeTransformed(const GfxObjP& object);
  void NodeAdded(const GfxNodeP& node);
  void RenderModeChanged(const String& name);
 
private:  
 
  template <typename ACTION>
  void NotifyObservers(const ACTION& action) {
    std::for_each(observers_.begin(), observers_.end(), action);
  }
  Scene();
  Scene(const Scene&) {}
  Scene& operator=(const Scene&) {return *this;}
  ~Scene();
 
  // The GL Context gets typically handled externally, e.g. using QT when
  // calling InitGL(), RenderGL() etc. However, there is no guarantee that the 
  // desired GLContext is active when calling gl related functions in other 
  // occasions. This can be enforced by ActivateGLContext()
  void ActivateGLContext() const;
 
  GLWinBase*           win_; // target gl window
 
  mutable GfxNodeP     root_node_; // mutable is slightly hackish
  SceneObserverList    observers_;
 
  geom::Transform transform_; // overall modelview transformation
 
  bool gl_init_;
 
  float fov_; // field of view
  float znear_,zfar_; // near and far clipping plane
  float fnear_,ffar_; // fog near and far offsets
 
  geom::Mat4 pmat_,ipmat_; // projection and inverted projection matrix
  unsigned int vp_width_,vp_height_; // viewport
 
  SceneViewStack scene_view_stack_;
 
  float aspect_ratio_; // aspect ratio for viewport
 
  Color background_; // background (clear) color
 
  geom::Vec3 light_dir_; // infinite light source direction
  geom::Mat3 light_rot_; // transform needed for the shadow map
  Color light_amb_;
  Color light_diff_;
  Color light_spec_;
  geom::Vec4 hemi_param_;
 
  bool cor_flag_;
  bool fix_cor_flag_;
  bool fog_flag_;
  Color fog_color_;
  bool auto_autoslab_; // run autoslab on each scene update
  bool do_autoslab_;   // run autoslab on next scene update
  int autoslab_mode_;  // 0: fast, 1:precise, 2: max
 
  std::string def_shading_mode_;
 
  uint selection_mode_;
 
  bool test_flag_;
  std::vector<unsigned char> tmp_tex_;
 
  GLuint glyph_tex_id_;
  std::vector<geom::Vec2> glyph_map_;
  float def_text_size_;
 
  uint blur_count_;
  std::vector<boost::shared_array<unsigned char> > blur_buffer_;
 
  unsigned int stereo_mode_;
  unsigned int stereo_alg_;
  bool stereo_inverted_;
  int stereo_eye_;
  Real stereo_iod_,stereo_distance_;
  unsigned int scene_left_tex_;
  unsigned int scene_right_tex_;
  unsigned int bg_mode_;
  bool update_bg_;
  bool bg_stereo_mode_;
  float bg_stereo_offset_;
  Gradient bg_grad_;
  Bitmap bg_bm_;
  unsigned int bg_tex_;
  
  bool ms_flag_; // multisample flag
 
  float export_aspect_; 
  bool show_export_aspect_;
 
  void set_near(float n);
  void set_far(float f);
  void flag_all_dirty();
  void prep_glyphs();
  void prep_blur();
  void stereo_projection(int view);
  void render_bg();
  void render_export_aspect();
  void render_scene();
  void render_glow();
  void render_stereo();
  void set_bg();
  void do_autoslab();
 
  bool IsNameAvailable(const String& name) const;
 
};
 
}} // ns
 
#endif