displacement_handler.h

Go to the documentation of this file.

#ifndef DISPLACEMENT_HANDLER_H
#define DISPLACEMENT_HANDLER_H

#include <lwpp/plugin_handler.h>
#include <lwpp/point3d.h>
#include <lwpp/vector3d.h>
#include <lwdisplce.h>
#include <lwmeshes.h>

namespace lwpp
{
  /*
   *  The DisplacementAccess passed to the evaluation function contains two point positions, 
   *  the point ID, and a mesh info for the object the point belongs to.
  */
  class DisplacementAccess
  {
    protected:
      LWDisplacementAccess *access;
    public:
      DisplacementAccess(LWDisplacementAccess *acc) : access(acc) { ;}
      const Point3d getPointPosition( void ) const { return Point3d(access->oPos); }
      const Vector3d getSource( void ) const { return Vector3d(access->source); }
      const LWPntID getPointID( void ) const {return access->point;}
      const LWMeshInfo *getMeshInfo( void ) const { return access->info; }
      const Vector3d getAvgNormal( void ) const {return Vector3d(access->wNorm);}

      void setAvgNormal(Vector3d &normal)
      {
        access->wNorm[0] = normal.x;
        access->wNorm[1] = normal.y;
        access->wNorm[2] = normal.z;
      
      }
      void setSource(Point3d &sspt)
      {
        access->source[0] = sspt.x;
        access->source[1] = sspt.y;
        access->source[2] = sspt.z;   
      }
      void setSource(Point3f &sspt)
      {
        access->source[0] = (double) sspt.x;
        access->source[1] = (double) sspt.y;
        access->source[2] = (double) sspt.z;    
      }

  
  };


class DisplacementHandler : public InstanceHandler, public ItemHandler, public RenderHandler
{
  protected:
    LWItem Context;
  public:
    DisplacementHandler(void *g, void *context, LWError *err) : InstanceHandler(g, context, err, LWDISPLACEMENT_HCLASS )
    {
      Context.SetID( (LWItemID) context);
    }
    virtual ~DisplacementHandler() {;}
    virtual void Evaluate(LWDisplacementAccess *da)
    {
      ;
    }
    virtual unsigned int Flags() {return 0;}
};


template <class T, int maxVersion, int minVersion>
class DisplacementAdaptor : public InstanceAdaptor <T>, public ItemAdaptor <T>, public RenderAdaptor <T>
{
  public:
    DisplacementAdaptor(const char *name, ServerTagInfo *tags)
    {
      LWServer::AddPlugin(LWDISPLACEMENT_HCLASS, name, Activate, tags);
    }
    static int Activate (int version, GlobalFunc *global, LWInstance inst, void *serverData)
    {
      if ( version > maxVersion ) return AFUNC_BADVERSION;
      if ( version < minVersion ) return AFUNC_BADVERSION;
      try
      {
        UNUSED(serverData);
        lwpp::SetSuperGlobal(global);

        LWDisplacementHandler *plugin = static_cast<LWDisplacementHandler *>(inst);

        InstanceAdaptor<T>::Activate(plugin->inst);
        ItemAdaptor<T>::Activate(plugin->item);
        RenderAdaptor<T>::Activate(plugin->rend);
        plugin->evaluate = DisplacementAdaptor::Evaluate;
        plugin->flags   = DisplacementAdaptor::Flags;
        
        return AFUNC_OK;
      } 
      catch (std::exception &e)
      {
        lwpp::LWMessage::Error("An exception occured in Displacement::Activate():", e.what());
        return AFUNC_BADAPP;
      }
    }
  private:

    static void Evaluate (LWInstance instance, LWDisplacementAccess *da)
    {
      try
      {
        T *plugin = (T *) instance;
        plugin->Evaluate(DisplacementAccess(da));
      }
      catch (std::exception &e)
      {
        lwpp::LWMessage::Error("An exception occured in Displacement::Evaluate():", e.what());
      }
    }

    static unsigned int Flags (LWInstance instance)
    {
      try
      {
        T *plugin = (T *) instance;
        return plugin->Flags();
      } 
      catch (std::exception &e)
      {
        lwpp::LWMessage::Error("An exception occured in Displacement::Flags():", e.what());
        return 0;
      }
    }
};

IMPLEMENT_XPANELHANDLER(Displacement);
IMPLEMENT_XPANELADAPTOR(Displacement, LWPP_DISPLACEMENT_VERSION, LWPP_DISPLACEMENT_VERSION );

IMPLEMENT_LWPANELHANDLER(Displacement);
IMPLEMENT_LWPANELADAPTOR(Displacement, LWPP_DISPLACEMENT_VERSION, LWPP_DISPLACEMENT_VERSION );

} // end namespace

#endif // DISPLACEMENT_HANDLER_H