Public API Reference

csplugincommon/rendermanager/renderview.h

Go to the documentation of this file.

/*
    Copyright (C) 2007-2008 by Marten Svanfeldt
                  1998-2001 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSPLUGINCOMMON_RENDERMANAGER_RENDERVIEW_H__
#define __CS_CSPLUGINCOMMON_RENDERMANAGER_RENDERVIEW_H__

#include "csutil/pooledscfclass.h"
#include "csutil/scf_implementation.h"
#include "iengine/engine.h"
#include "iengine/portal.h"
#include "iengine/rview.h"
#include "ivaria/view.h"
#include "cstool/rviewclipper.h"
#include "csutil/refcount.h"
#include "csutil/weakref.h"

namespace CS
{
namespace RenderManager
{

  class CS_CRYSTALSPACE_EXPORT RenderView : 
    public scfImplementationPooled<scfImplementation1<RenderView, iRenderView> >
  {
  private:
    uint32 context_id;

    csRenderContext* ctxt;

    iEngine* engine;
    iGraphics3D* g3d;
    iGraphics2D* g2d;
    iCamera* original_camera;

    float leftx, rightx, topy, boty;

    void UpdateFrustum ();
    void SetFrustumFromBox (const csBox2& box);
    
    int viewWidth, viewHeight;

    CS::Utility::MeshFilter meshFilter;
  public:
    RenderView ();
    RenderView (iCamera* c);
    RenderView (iCamera* c, iClipper2D* v, iGraphics3D* ig3d);
    RenderView (iView* v);
    RenderView (const RenderView& other);
    RenderView (const RenderView& other, bool keepCamera);

    virtual ~RenderView ();

    void InitialiseFromView (iView* view);

    void InitialiseFromCamera (iCamera* camera);

    void SetEngine (iEngine* engine);
    void SetCamera (iCamera* camera);
    void SetOriginalCamera (iCamera* camera);
    virtual iCamera* GetOriginalCamera () const { return original_camera; }

    csRenderContext* GetCsRenderContext () const { return ctxt; }
    void SetCsRenderContext (csRenderContext* c) { ctxt = c; }

    void CreateRenderContext ();
    void RestoreRenderContext ();

    iCamera* CreateNewCamera ();

    void SetPreviousSector (iSector* s) { ctxt->previous_sector = s; }
    void SetThisSector (iSector* s) { ctxt->this_sector = s; }

    int GetRenderRecursionLevel () const { return ctxt->draw_rec_level; }
    void SetRenderRecursionLevel (int rec)
    {
      ctxt->draw_rec_level = rec;
    }
    void SetLastPortal (iPortal* por)
    {
      ctxt->last_portal = por;
    }
    void SetClipper (iClipper2D* clip);
    void SetFrustum (float lx, float rx, float ty, float by);

    void UseClipPlane (bool u) { ctxt->do_clip_plane = u; }
    void UseClipFrustum (bool u) { ctxt->do_clip_frustum = u; }
    void SetClipPlane (const csPlane3& p) { ctxt->clip_plane = p; }
    bool GetClipPlane (csPlane3& pl) const
    {
      pl = ctxt->clip_plane;
      return ctxt->do_clip_plane;
    }
    const csPlane3& GetClipPlane () const
    {
      return ctxt->clip_plane;
    }
    csPlane3& GetClipPlane ()
    {
      return ctxt->clip_plane;
    }
    bool IsClipperRequired () const { return ctxt->do_clip_frustum; }

    csFogInfo* GetFirstFogInfo () { return ctxt->fog_info; }
    void SetFirstFogInfo (csFogInfo* fi)
    {
      ctxt->fog_info = fi;
      ctxt->added_fog_info = true;
    }
    bool AddedFogInfo () const { return ctxt->added_fog_info; }
    void ResetFogInfo () { ctxt->added_fog_info = false; }

    virtual csRenderContext* GetRenderContext () { return ctxt; }

    virtual iEngine* GetEngine ();
    virtual iGraphics2D* GetGraphics2D () { return g2d; }
    virtual iGraphics3D* GetGraphics3D () { return g3d; }
    virtual void GetFrustum (float& lx, float& rx, float& ty, float& by)
    {
      lx = leftx;
      rx = rightx;
      ty = topy;
      by = boty;
    }
    
    int GetViewWidth() const { return viewWidth; }
    int GetViewHeight() const { return viewHeight; }
    void SetViewDimensions (int w, int h) { viewWidth = w; viewHeight = h; }

    //-----------------------------------------------------------------
    // The following functions operate on the current render context.
    //-----------------------------------------------------------------

    virtual iClipper2D* GetClipper () { return ctxt->iview; }

    virtual iCamera* GetCamera () { return ctxt->icamera; }

    virtual iSector* GetThisSector () { return ctxt->this_sector; }

    virtual iSector* GetPreviousSector () { return ctxt->previous_sector; }

    virtual iPortal* GetLastPortal () { return ctxt->last_portal; }

    virtual uint GetCurrentFrameNumber () const;

    virtual void DestroyRenderContext (csRenderContext* context);

    const CS::Utility::MeshFilter& GetMeshFilter () const { return meshFilter; }

    void SetMeshFilter (const CS::Utility::MeshFilter& filter);
  };

  class CS_CRYSTALSPACE_EXPORT RenderViewCache
  {
  public:
    RenderView* GetRenderView (iView* view);

    RenderView* GetRenderView (RenderView* view, iPortal* portal, iCamera* camera);

    csPtr<RenderView> CreateRenderView ();

    csPtr<RenderView> CreateRenderView (RenderView* view);

    csPtr<RenderView> CreateRenderView (RenderView* view, bool keepCamera);

  private:
    RenderView::Pool renderViewPool;

    struct View2RenderView : public csRefCount
    {
      csWeakRef<iView> view;
      csRef<RenderView> rview;

      View2RenderView (iView* view, CS::RenderManager::RenderView* rview)
        : view (view), rview (rview) {}
    };

    csRefArray<View2RenderView> iView2RenderViews;

    struct RViewPortal2RenderView : public csRefCount
    {
      csWeakRef<RenderView> view;
      csWeakRef<iPortal> portal;
      csRef<RenderView> rview;

      RViewPortal2RenderView (RenderView* view, iPortal* portal, CS::RenderManager::RenderView* rview)
        : view (view), portal (portal), rview (rview) {}
    };

    csRefArray<RViewPortal2RenderView> rViewPortal2RenderViews;
  };

}
}

#endif

---