camerainfo.h

Go to the documentation of this file.

#ifndef LWPP_CAMINFO_H
#define LWPP_CAMINFO_H

#include <lwpp/global.h>
#include <lwrender.h>
#include <lwpp/lw_version.h>
#include <lwpp/math.h>

namespace lwpp
{

  class CameraInfo : protected GlobalBase<LWCameraInfo>
  {
  private:
    LWItemID camera;
  public:
    CameraInfo(LWItemID _camera = LWITEM_NULL)
      : camera(_camera) {;}

    LWItemID getID() const {return camera;}

    void setID(LWItemID _camera)             {camera = _camera;}

    double zoomFactor (LWTime time) {return globPtr->zoomFactor(camera, time);}

    double focalLength (LWTime time) {return globPtr->focalLength(camera, time);}

    double focalDistance (LWTime time) {return globPtr->focalDistance(camera, time);}

    double fStop (LWTime time) {return globPtr->fStop(camera, time);}

    double blurLength (LWTime time) {return globPtr->blurLength(camera, time);}

    void   fovAngles  (LWTime time, double *hfov, double *vfov) {globPtr->fovAngles (camera, time, hfov, vfov);}

    unsigned int flags ()  {return globPtr->flags(camera);}

    bool isStereo ()  {return (flags() & LWCAMF_STEREO);}

#ifndef LWCAMF_EYE
#define LWCAMF_EYE          (1<<9) /* In Stereo Rendering, This Indicates Which Eye Is Being Processed. */
#endif
    bool isRightEye ()  {return (flags() & LWCAMF_EYE) != 0;}

    bool hasLimitedRegion ()  {return (flags() & LWCAMF_LIMITED_REGION) != 0;}

    bool hasMask ()  {return (flags() & LWCAMF_MASK) != 0;}

    bool hasDOF ()  {return (flags() & LWCAMF_DOF) != 0;}

    bool hasParticleBlur()  {return (flags() & LWCAMF_PARTICLE_BLUR) != 0;}

    bool hasNoLRBorders ()  {return (flags() & LWCAMF_LR_NOBORDERS) != 0;}

    const char *whichField ()  {return (flags() & LWCAMF_FIELD) ? "Even/Upper First" : "Odd/Lower First";}

    bool usePlugin ()  {return (flags() & LWCAMF_USECAMTYPE) != 0;}

    bool supportsDOF () {return (flags() & LWCAMF_SUPPORTS_DOF) != 0;}

    void   resolution(int *w, int *h) {globPtr->resolution(camera, w, h);}

    double pixelAspect(LWTime time) {return globPtr->pixelAspect(camera, time);}

    double separation(LWTime time) {return globPtr->separation(camera, time);}

    void regionLimits(int *x0, int *y0, int *x1, int *y1) const {globPtr->regionLimits(camera, x0, y0, x1, y1);}

    void maskLimits(int *x0, int *y0, int *x1, int *y1) const {globPtr->maskLimits(camera, x0, y0, x1, y1);}

    void maskColor(LWDVector color) {globPtr->maskColor(camera, color);}

    unsigned int motionBlur() {return globPtr->motionBlur(camera);}

    unsigned int fieldRendering() {return globPtr->fieldRendering(camera);}

    bool hasNotFields() { return (this->fieldRendering() ==  LWCAMFIELDR_OFF) == 1;}

    bool evenFirst() { return (this->fieldRendering() == LWCAMFIELDR_EVENFIRST) == 1;}

    bool oddFirst() { return (this->fieldRendering() == LWCAMFIELDR_ODDFIRST) == 1;}

    int irisPos( LWTime time, int pass, float *irisx, float *irisy){return globPtr->irisPos(camera, time, pass, irisx, irisy);}

    bool usingGlobalResolution ()  {return (globPtr->usingGlobalResolution( camera ) == 1);}

    bool usingGlobalBlur ()  {return (globPtr->usingGlobalBlur( camera ) == 1);}

    bool usingGlobalMask ()  {return (globPtr->usingGlobalMask( camera ) == 1);}

    int motionBlurPasses(LWTime time) {return globPtr->motionBlurPasses(camera, time);}

    double shutterEfficiency( LWTime time ) {return globPtr->shutterEfficiency(camera, time);}

    unsigned int noiseSampler() {return globPtr->noiseSampler(camera);}

    void filmSize (double *width, double *height) {globPtr->filmSize(camera, width, height);}

    bool frameTiming (LWFrame frame, LWFrameTimingInfo *timingInfo) {return globPtr->frameTiming (camera, frame, timingInfo) ? true : false;}

    unsigned int antiAliasing ( LWTime time ) { return globPtr->antiAliasing (camera, time);}

    double  overSampling ( LWTime time) { return globPtr->overSampling(camera, time);}

    void  diaphragm( LWTime time, int *sides, double* rotation ) { globPtr->diaphragm(camera, time, sides, rotation);}

  };

  //added evaluator
  //Usage, CameraEvaluator myEvaluator(LWItemID cameraID);
  //then myEvaluator.Evaluate(imagex,imagey,CameraRay*);
  class CameraEvaluator : protected GlobalBase<LWCameraEvaluationFuncs>
  {
  private:
    LWCameraEvaluatorID cameraEvaluator;

    bool init;
    bool newframe;
    bool cleanup;
  public:
    LWCameraRay camRay;
    //Simple constructor, loads first camera
    CameraEvaluator() : init(false), newframe(false), cleanup(false), cameraEvaluator(0)
    {
      ItemInfo myItem;
      Create(myItem.first(LWI_CAMERA, NULL));
    }
    //Define which camera you want to use
    CameraEvaluator(LWItemID _camera) : init(false), newframe(false), cleanup(false), cameraEvaluator(0)
    {
      Create(_camera);
    }
        CameraEvaluator(CameraInfo _caminfo) : init(false), newframe(false), cleanup(false), cameraEvaluator(0)
    {
      Create(_caminfo.getID());
    }
    ~CameraEvaluator()
    {
      if(!cleanup)CleanUp();
      Destroy();
    }
    //Create evaluator
    void Create(LWItemID cameraID)
    {
      if(cameraEvaluator) Destroy();
      cameraEvaluator = globPtr->create(cameraID);
      init=false; newframe=false; cleanup=false;
    }

    void Destroy()
    {
      if(!cleanup) CleanUp();
      globPtr->destroy(cameraEvaluator);
    }

    LWError Init(int mode)
    {
      init=true;
      return globPtr->init(cameraEvaluator, mode);
    }

    void CleanUp()
    {
      cleanup=true;
      globPtr->cleanUp(cameraEvaluator);
    }

    LWError NewTime(LWFrame frame, LWTime time)
    {
      return globPtr->newTime(cameraEvaluator, frame, time);
    }

    int Preview(double lpx, double lpy, LWDMatrix4 projection)
    {
      return globPtr->preview(cameraEvaluator,  lpx, lpy, projection);
    }
    LWError NewFrame()
    {
      if(!init) Init(LWINIT_RENDER);
      newframe=true;
      return globPtr->newFrame(cameraEvaluator);
    }

    /*  Evaluation Functions
      Overloaded so you can use simple or complex calls
    */
    /* Full Evaluation function */
    int Evaluate(double fpx, double fpy, double lpx, double lpy, double fractime, LWCameraRay* mycamray)
    {
      if(!init) Init(LWINIT_RENDER);
      if(!newframe) NewFrame();
      int retValue = globPtr->evaluate(cameraEvaluator,fpx,fpy,lpx,lpy,fractime,mycamray);
      camRay = *mycamray;
      return retValue;
    }
    /* Simple, non DOF lens, takes image position and time only */
    inline int Evaluate(double fpx, double fpy, double fractime)
    {
      return Evaluate(fpx, fpy, 0.0, 0.0, fractime, &camRay);
    }
  };
}
#endif // LWPP_CAMINFO_H