scene.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2011 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;
class OffscreenBuffer;

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);
  
  bool InOffscreenMode() const;

  void SetTestMode(bool t);

  float ElapsedTime() const;

  Viewport GetViewport() const;

  bool StartOffscreenMode(unsigned int w, unsigned int h, int max_samples);
  bool StartOffscreenMode(unsigned int w, unsigned int h);

  void StopOffscreenMode();

  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_;}
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;}

  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

  bool offscreen_flag_; // a simple indicator whether in offscreen mode or not
  OffscreenBuffer* main_offscreen_buffer_; // not null if a main offscreen buffer is present
  uint old_vp_[2]; // used by the offline rendering code
  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 update_fog();
  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