Actor.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef Actor_INCLUDE_ONCE
#define Actor_INCLUDE_ONCE

#include <vlGraphics/link_config.hpp>
#include <vlCore/Collection.hpp>
#include <vlCore/Sphere.hpp>
#include <vlCore/AABB.hpp>
#include <vlCore/Transform.hpp>
#include <vlGraphics/Effect.hpp>
#include <vlGraphics/Renderable.hpp>
#include <vlGraphics/LODEvaluator.hpp>
#include <vlGraphics/UniformSet.hpp>
#include <vlGraphics/Scissor.hpp>

namespace vl
{
  //------------------------------------------------------------------------------
  // ActorEventCallback
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT ActorEventCallback: public Object
  {
    VL_INSTRUMENT_ABSTRACT_CLASS(vl::ActorEventCallback, Object)

  public:
    ActorEventCallback(): mEnabled(true) {}

    virtual void onActorRenderStarted(Actor* actor, real frame_clock, const Camera* cam, Renderable* renderable, const Shader* shader, int pass) = 0;

    virtual void onActorDelete(Actor* actor) = 0;

    void setEnabled(bool enabled) { mEnabled = enabled; }
    bool isEnabled() const { return mEnabled; }

  protected:
    bool mEnabled;
  };

  //------------------------------------------------------------------------------
  // Actor
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT Actor: public Object
  {
    VL_INSTRUMENT_CLASS(vl::Actor, Object)

  public:
    Actor(Renderable* renderable = NULL, Effect* effect = NULL, Transform* transform = NULL, int block = 0, int rank = 0):
      mEffect(effect), mTransform(transform), mRenderBlock(block), mRenderRank(rank),
      mTransformUpdateTick(-1), mBoundsUpdateTick(-1), mEnableMask(0xFFFFFFFF), mOcclusionQuery(0), mOcclusionQueryTick(0xFFFFFFFF), mIsOccludee(true), mEnabled(true)
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mActorEventCallbacks.setAutomaticDelete(false);
      setLod(0,renderable);
      // actor user data
      #ifdef VL_USER_DATA_ACTOR
        mActorUserData = NULL;
      #endif
    }

    virtual ~Actor();

    void setLod(int lod_index, Renderable* renderable)
    {
      mRenderables[lod_index] = renderable;

      // schedule update of the Actor's bounds.
      if (lod_index == 0)
      {
        mBoundsUpdateTick = -1;
        mAABB.setNull();
        mSphere.setNull();
      }
    }

    const Renderable* lod(int lod_index) const { return mRenderables[lod_index].get(); }

    Renderable* lod(int lod_index) { return mRenderables[lod_index].get(); }

    void setLODs(Renderable* lod0, Renderable* lod1=NULL, Renderable* lod2=NULL, Renderable* lod3=NULL, Renderable* lod4=NULL, Renderable* lod5=NULL);

    void setTransform(Transform* transform)
    {
      mTransform = transform;
      mTransformUpdateTick = -1;
      mBoundsUpdateTick    = -1;
    }

    Transform* transform()  { return mTransform.get(); }

    const Transform* transform() const { return mTransform.get(); }

    void setEffect(Effect* effect) { mEffect = effect; }

    Effect* effect() { return mEffect.get(); }

    const Effect* effect() const { return mEffect.get(); }

    const AABB& boundingBox() const { return mAABB; }

    const Sphere& boundingSphere() const { return mSphere; }

    const AABB& boundingBoxSafe() { computeBounds(); return mAABB; }

    const Sphere& boundingSphereSafe() { computeBounds(); return mSphere; }

    void computeBounds();

    bool boundsDirty() const;

    void setRenderRank(int rank) { mRenderRank = rank; }

    void setRenderBlock(int block) { mRenderBlock = block; }

    int renderRank() const { return mRenderRank; }

    int renderBlock() const { return mRenderBlock; }

    void setLODEvaluator(LODEvaluator* lod_evaluator) { mLODEvaluator = lod_evaluator; }

    LODEvaluator* lodEvaluator() { return mLODEvaluator.get(); }

    const LODEvaluator* lodEvaluator() const { return mLODEvaluator.get(); }

    int evaluateLOD(Camera* camera);

    void setEnableMask(unsigned int mask) { mEnableMask = mask; }

    unsigned int enableMask() const { return mEnableMask; }

    void setEnabled(bool enabled) { mEnabled = enabled; }
    bool isEnabled() const { return mEnabled; }

    // uniforms methods

    void setUniform(Uniform* uniform);

    const std::vector< ref<Uniform> >& uniforms() const;

    std::vector< ref<Uniform> >& uniforms();

    void eraseUniform(const char* name);

    void eraseUniform(const Uniform* uniform);

    void eraseAllUniforms();

    Uniform* gocUniform(const char* name);

    Uniform* getUniform(const char* name);

    const Uniform* getUniform(const char* name) const;

    void setUniformSet(UniformSet* uniforms) { mUniformSet = uniforms; }

    const UniformSet* getUniformSet() const { return mUniformSet.get(); }

    UniformSet* getUniformSet() { return mUniformSet.get(); }

    UniformSet* gocUniformSet() { if (!mUniformSet) mUniformSet = new UniformSet; return mUniformSet.get(); }

    const Collection<ActorEventCallback>* actorEventCallbacks() const { return &mActorEventCallbacks; }

    Collection<ActorEventCallback>* actorEventCallbacks() { return &mActorEventCallbacks; }

    void dispatchOnActorRenderStarted( real frame_clock, const Camera* camera, Renderable* renderable, const Shader* shader, int pass)
    {
      for(size_t i=0; i<actorEventCallbacks()->size(); ++i)
      {
        ActorEventCallback& cb = *actorEventCallbacks()->at(i);
        if (cb.isEnabled())
          cb.onActorRenderStarted(this, frame_clock, camera, renderable, shader, pass);
      }
    }

    void dispatchOnActorDelete()
    {
      for(size_t i=0; i<actorEventCallbacks()->size(); ++i)
      {
        ActorEventCallback& cb = *actorEventCallbacks()->at(i);
        cb.onActorDelete(this);
      }
    }

    void setScissor(Scissor* scissor) { mScissor = scissor; }
    const Scissor* scissor() const { return mScissor.get(); }

    Scissor* scissor() { return mScissor.get(); }

    void setOccludee(bool is_occludee) { mIsOccludee = is_occludee; }

    bool isOccludee() const { return mIsOccludee; }

    void createOcclusionQuery();

    void deleteOcclusionQuery();

    GLuint occlusionQuery() const { return mOcclusionQuery; }

    void setOcclusionQueryTick(unsigned tick) { mOcclusionQueryTick = tick; }

    unsigned occlusionQueryTick() const { return mOcclusionQueryTick; }

#ifdef VL_USER_DATA_ACTOR
  public:
    const Object* actorUserData() const { return mActorUserData.get(); }
    Object* actorUserData() { return mActorUserData.get(); }
    void setActorUserData(Object* user_data) { mActorUserData = user_data; }

  private:
    ref<Object> mActorUserData;
#endif

  protected:
    AABB mAABB;
    Sphere mSphere;
    ref<Effect> mEffect;
    ref<Renderable> mRenderables[VL_MAX_ACTOR_LOD];
    ref<Transform> mTransform;
    ref<LODEvaluator> mLODEvaluator;
    ref<UniformSet> mUniformSet;
    ref<Scissor> mScissor;
    Collection<ActorEventCallback> mActorEventCallbacks;
    int mRenderBlock;
    int mRenderRank;
    long long mTransformUpdateTick;
    long long mBoundsUpdateTick;
    unsigned int mEnableMask;
    GLuint mOcclusionQuery;
    unsigned mOcclusionQueryTick;
    bool mIsOccludee;
    bool mEnabled;
  };
  //---------------------------------------------------------------------------
  class ActorCollection: public Collection<Actor> {};
  //---------------------------------------------------------------------------
}

#endif