stage/include/ost/gfx/scene.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2010 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/mol/transform.hh>

#include "color.hh"
#include "gfx_object_fw.hh"
#include "gfx_node_fw.hh"
#include "gfx_node_visitor.hh"
#include "selection.hh"
#include "glwin_base.hh"
#include "scene_observer.hh"
#include "gfx_prim.hh"
#include "gl_include.hh"
#include "povray_fw.hh"

namespace ost { namespace gfx {

class InputEvent;

typedef std::vector<SceneObserver*>  SceneObserverList;

struct Viewport {
  int bottom;
  int left;
  int width;
  int height;
};

class DLLEXPORT_OST_GFX Scene {
 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 {
    mol::Transform transform;
    float fov;
    float znear,zfar;
  };

  typedef std::stack<SceneViewStackEntry> SceneViewStack;

 public:
  static Scene& Instance();

  void SetFog(bool f);

  void SetFogColor(const Color& c);

  void SetShadow(bool f);

  bool GetShadow();

  void SetShadowQuality(int q);
  


  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;

  void SetFogNearOffset(float o);

  float GetFogNearOffset() const;

  void SetFogFarOffset(float o);

  float GetFogFarOffset() const;

  void SetFogOffsets(float no, float fo);
  
  void Autoslab(bool fast=false, bool redraw=true);
  // \brief adjust clipping planes to fix maximal extent of all objects
  //        even under rotation
  void AutoslabMax();

  void AutoAutoslab(bool f);
  
  /*
    0=off
    1=quad-buffered
    2=interlaced variant #1
    3=interlaced variant #2
  */
  void Stereo(unsigned int);

  void SetStereoInverted(bool f);

  void SetStereoEye(unsigned int);

  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);

  /*
    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=true);

  void Export(const String& fname, bool transparent=true);

  void ExportPov(const std::string& fname, const std::string& wdir=".");

  void OnInput(const InputEvent& e);
  
  void InitGL();

  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 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(const mol::Transform& tf) const;

  mol::Transform GetTransform() const;

  void SetTransform(const mol::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);
  bool Rename(const String& old_name, const String& new_name);

  GfxObjP operator[](const String& name);

  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;

  static void SetOffscreenMode();

  void SetTestMode(bool t);

  float ElapsedTime() const;

  Viewport GetViewport() const;
  
  // temporary interface
  void ActivateShader(const String& name);

  void SetBlur(uint n);
  void BlurSnapshot();

  void RenderText(const TextPrim& t);

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

  mol::Transform transform_; // overall modelview transformation

  float fov_; // field of view
  float znear_,zfar_; // near and far clipping plane
  float fnear_,ffar_; // fog near and far offsets

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

  bool axis_flag_;
  bool fog_flag_;
  Color fog_color_;
  bool shadow_flag_;
  int shadow_quality_;
  GLuint texture_id_;
  bool auto_autoslab_;

  bool offscreen_flag_;

  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_;
  GLuint  glow_tex_;
  unsigned int stereo_;
  bool stereo_inverted_;
  unsigned int stereo_eye_;
  float stereo_eye_dist_,stereo_eye_offset_;

  void set_near(float n);
  void set_far(float f);
  void update_fog();
  void prep_shadow_map();
  void flag_all_dirty();
  void prep_glyphs();
  void prep_blur();
  void stereo_projection(unsigned int view);
  void render_interlaced_stereo();
  void render_quad_buffered_stereo();
  void render_scene_with_glow();
  bool IsNameAvailable(String name);
};

}} // ns

#endif

---