texture.h

Go to the documentation of this file.

#ifndef LWPP_TEXTURE_H
#define LWPP_TEXTURE_H

#include <lwpp/global.h>
#include <lwpp/vector3d.h>
#include <lwtxtr.h>

namespace lwpp
{
  class TextureLayer;

  class Texture : protected GlobalBase<LWTextureFuncs>
  {
  private:
    LWTextureID txtr_id;
  public:
    Texture( LWTextureID _txtr_id = 0) : txtr_id(_txtr_id) {;}

    LWTextureID getID() const { return txtr_id; }

    // CONTEXTS

    LWTxtrContextID contextCreate (LWTxtrParamFuncs lwtxtparamfunc) { return globPtr->contextCreate (lwtxtparamfunc); }

    void contextDestroy (LWTxtrContextID lwtxtrcontextid){ globPtr->contextDestroy (lwtxtrcontextid); }

    void contextAddParam (LWTxtrContextID lwtxtrcontextid, LWTxtrParamDesc pdesc) { globPtr->contextAddParam (lwtxtrcontextid, pdesc); }

    // HANDLERS CALLS

    void create (int returntype, const char *name, LWTxtrContextID lwtxtrcontextid = 0, void *userdata = 0)
    {
      txtr_id = globPtr->create (returntype, name, lwtxtrcontextid, &userdata);
    }

    void destroy ( ){ globPtr->destroy(txtr_id);}


    void copy(LWTextureID to, LWTextureID from){ globPtr->copy(to, from);}

    void newtime (LWTime time, LWFrame frame){ globPtr->newtime(txtr_id, time, frame);}

    void cleanup ( ){ globPtr->cleanup(txtr_id);}

    void load( const LWLoadState *loadstate ) { globPtr->load(txtr_id, loadstate);}

    void save( const LWSaveState *savestate ) { globPtr->save(txtr_id, savestate);}


    double evaluate (LWMicropolID lwmp, double *value) { return globPtr->evaluate(txtr_id, lwmp, value);}

    // TEXTURE DATA


    void setEnvGroup (LWChanGroupID txtr_group_id);



    TextureLayer layerAdd (int type);
    TextureLayer firstLayer();
    TextureLayer lastLayer();

    TextureLayer nextLayer(TextureLayer layer);

    LWTLayerID layerAddID (int type) { return globPtr->layerAdd (txtr_id, type); }

    LWTLayerID firstLayerID( ) { return globPtr->firstLayer(txtr_id); }

    LWTLayerID lastLayerID( ) { return globPtr->lastLayer(txtr_id); }


    LWTLayerID nextLayerID(LWTLayerID lid) {  return globPtr->nextLayer(txtr_id, lid); }

    // @}

    const char * name() { return globPtr->name(txtr_id); }


    int getDataType () { return globPtr->type(txtr_id); }

    LWTxtrContextID context (void) { return globPtr->context(txtr_id); }

  };

  // LAYERS

  class TextureLayer : public GlobalBase<LWTextureFuncs>
  {
  private:
    LWTLayerID id;
  public:
    TextureLayer(LWTLayerID _id = 0) : id(_id) {;}

    LWTLayerID getID() const {return id;}
    bool isValid () const {return id != 0;}

    LWTextureID getTextureID() { return globPtr->texture(id); }

    int getType() { return globPtr->layerType(id); }


    void setType(int type) { globPtr->layerSetType(id, type); }



    template <typename T>
    int setParam (int tag, T &data) { return globPtr->setParam(id, tag, &data); }


    int setParam (int tag, int data) { return globPtr->setParam(id, tag, &data); }


    int setParam (int tag, double data) { return globPtr->setParam(id, tag, &data); }


    int setParam (int tag, double data[]) { return globPtr->setParam(id, tag, data); }


    int setPosition (double position[3]) { return setParam(TXTAG_POSI, position); }


    int setRotation (double rotation[3]) { return setParam(TXTAG_ROTA, rotation); }


    int setSize (double size[3]) { return setParam(TXTAG_SIZE, size); }


    int setFalloff (double falloff[3]) { return setParam(TXTAG_FALL, falloff); }


    int setProjection (int projection) { return setParam(TXTAG_PROJ, projection); }


    int setAxis (int axis) { return setParam(TXTAG_AXIS, axis); }


    int setWidthWrap(double widthwrap) { return setParam(TXTAG_WWRP, widthwrap); }


    int setHeightWrap (double heightwrap) { return setParam(TXTAG_WWRP, heightwrap); }


    int setCoordSystem (int coordsys) { return setParam(TXTAG_COORD, coordsys); }


    int setImageID (LWImageID  imageID) { return setParam(TXTAG_IMAGE, imageID); }


    int setVMapID (LWID  vmapID) { return setParam(TXTAG_VMAP, vmapID); }


    int setReferenceItem (LWItemID refObjID) { return setParam(TXTAG_ROBJ, refObjID); }


    int setLayerOpacity (double layerOpacity) { return setParam(TXTAG_OPAC, layerOpacity); }


    int setAntialiasing (bool antialiasing)
    {
      return setParam(TXTAG_AA, antialiasing ? 1 : 0);
    }


    int setAAThreshold (double aaThreshold) { return getParam(TXTAG_AAVAL, &aaThreshold); }


    int setPixelBlending (bool pixelblending)
    {
      return setParam(TXTAG_PIXBLEND, pixelblending ? 1: 0);
    }


    int setWidthWrapBehavior(int widthwrap) { return setParam(TXTAG_WREPEAT, widthwrap); }


    int setHeightWrapBehavior (int heightwrap) { return setParam(TXTAG_HREPEAT, heightwrap); }

    bool activate(  ) {
      return (setParam(TXTAG_ACTIVE, 1) == 1) ? true: false;
    }

    bool deActivate(  ) {
      return (setParam(TXTAG_ACTIVE, 0) == 1) ? true: false;
    }

    bool invert(  ) {
      return (setParam(TXTAG_INVERT, 1) == 1) ? true: false;
    }


    int setBlendingMode (int blendmode) { return getParam(TXTAG_BLEND, &blendmode); }


    int setInputParameterIndex (int inputparameterindex) { return setParam(TXTAG_INPUT , inputparameterindex); }


    int setAuvName (char *auvName) { return setParam(TXTAG_AUVN , auvName); }


    int setAuvUser (char *auvUser) { return setParam(TXTAG_AUVU , auvUser); }


    int setAuvArrayByteCount (int *auvArrByteCount) { return setParam(TXTAG_AUVC , auvArrByteCount); }


    int setAuvPluginOpts (char *auvplugopts) { return setParam(TXTAG_AUVO , auvplugopts); }




    int getParam (int tag, void *data) { return globPtr->getParam(id, tag, data); }

    template <typename T>
    T getParam (int tag) {
      T d;
      getParam(tag, &d);
      return d;
    }


    int getPosition (double position[3]) { return getParam(TXTAG_POSI, position); }


    int getRotation (double rotation[3]) { return getParam(TXTAG_ROTA, rotation); }

    int getSize (double size[3]) { return getParam(TXTAG_SIZE, size); }

    int getFalloff (double falloff[3]) { return getParam(TXTAG_FALL, falloff); }


    int getProjection (int *projection) { return getParam(TXTAG_PROJ, projection); }


    int getAxis (int *axis) { return getParam(TXTAG_AXIS, axis); }

    double getWidthWrap() { return getParam<double>(TXTAG_WWRP); }

    double getHeightWrap() { return getParam<double>(TXTAG_HWRP); }


    int getCoordSystem (int *coordsys) { return getParam(TXTAG_COORD, coordsys); }


    int getImageID (LWImageID  *imageID) { return getParam(TXTAG_IMAGE, imageID); }


    int getVMapID (LWID  *vmapID) { return getParam(TXTAG_VMAP, &vmapID); }


    int getReferenceItem (LWItemID *refObjID) { return getParam(TXTAG_ROBJ, refObjID); }


    int getLayerOpacity (double *layerOpacity) { return getParam(TXTAG_OPAC, layerOpacity); }

    bool isAntialiased ( void )
    {
      int *isAA;
      getParam(TXTAG_AA, isAA);
      return (isAA != 0);
    }


    int getAAThreshold (double *aaThreshold) { return getParam(TXTAG_AAVAL, aaThreshold); }

    bool hasPixelBlending (  )
    {
      int hasPB;
      getParam(TXTAG_PIXBLEND, &hasPB);
      return (hasPB != 0);
    }


    int getWidthWrapBehavior(int *widthwrap) { return getParam(TXTAG_WREPEAT, widthwrap); }


    int getHeightWrapBehavior (int *heightwrap) { return getParam(TXTAG_HREPEAT, heightwrap); }
    bool isActive( )
    {
      int isAct;
      getParam(TXTAG_ACTIVE, &isAct);
      return ( isAct != 0);
    }

    bool isInverted( )
    {
      int isInv;
      getParam(TXTAG_INVERT, &isInv);
      return (isInv != 0);
    }


    int blendingmode (int *blendmode) { return getParam(TXTAG_BLEND, blendmode); }


    int inputParameterIndex (int *inputparameterindex) { return getParam(TXTAG_INPUT , inputparameterindex); }


    int auvName (char *auvName) { return getParam(TXTAG_AUVN , auvName); }


    int auvUser (char *auvUser) { return getParam(TXTAG_AUVU , auvUser); }


    int auvArrayByteCount (int *auvArrByteCount) { return getParam(TXTAG_AUVC , auvArrByteCount); }


    int auvPluginOpts (char *auvplugopts) { return getParam(TXTAG_AUVO , auvplugopts); }


    void evaluateUV( int wAxis, int oAxis, double oPos[3], double wPos[3], double uv[2])
    {
      globPtr->evaluateUV( id, wAxis, oAxis, oPos, wPos, uv);
    }

    // @}


    double noise( double pos[3] )
    {
      return globPtr->noise(pos);
    }

    LWChanGroupID getChannelGroup( void ) { return globPtr->layerEnvGroup(id); }

    bool nextLayer()
    {
      id = globPtr->nextLayer(getTextureID(), id);
      return isValid();
    }
  };

} // namespace lwpp

#endif // LWPP_TEXTURE_H