sceneinfo.h

Go to the documentation of this file.

#ifndef LWPP_SCENEINFO_H
#define LWPP_SCENEINFO_H

#include <lwpp/item.h>
#include <lwpp/matrix4x4.h>
#include <lwpp/camerainfo.h>
//#include <lwrender.h>

namespace lwpp
{
  class TimeInfo : public GlobalBase<LWTimeInfo>
  {
  public:
    TimeInfo() {  ; }
    LWTime Time() const
    {
      if (globPtr) return globPtr->time;
      else return 0;
    }
    LWFrame Frame() const
    {
      if (globPtr) return globPtr->frame;
      else return 0;
    }
  };

  inline LWFrame GetFrame()
  {
    TimeInfo ti;
    return ti.Frame();
  }

  inline LWTime GetTime()
  {
    TimeInfo ti;
    return ti.Time();
  }


  class SceneInfo  : protected GlobalBase<LWSceneInfo>
  {
    static const char *filterNames[];
  public:
    SceneInfo() { ; }

    bool isValid() const {return globPtr != 0;}
    const char *name() const {return globPtr->name;}

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

    int numPoints() const {return globPtr->numPoints;}

    int numPolygons() const {return globPtr->numPolygons;}

    int renderType() const {return globPtr->renderType;}

    int renderOpts() const {return globPtr->renderOpts;}

    LWFrame frameStart() const {return globPtr->frameStart;}

    LWFrame frameEnd() const {return globPtr->frameEnd;}

    LWFrame frameStep() const {return globPtr->frameStep;}

    double framesPerSecond() const {return globPtr->framesPerSecond;}

    int frameWidth() const {return globPtr->frameWidth;}

    int frameHeight() const {return globPtr->frameHeight;}
    double pixelAspect() const {return globPtr->pixelAspect;}
    int minSamplesPerPixel() const {return globPtr->minSamplesPerPixel;}
    int maxSamplesPerPixel() const {return globPtr->maxSamplesPerPixel;}
    int *limitedRegion() const {return globPtr->limitedRegion;}
    int recursionDepth() const {return globPtr->recursionDepth;}
    LWItemID renderCamera(LWTime time) const {return globPtr->renderCamera(time);}
    LWItemID  renderCamera ()
    {
      return renderCamera(GetTime());
    }
    int numThreads() const {return globPtr->numThreads;}
    const char *animFilename() const {return globPtr->animFilename;}
    const char *RGBPrefix() const {return globPtr->RGBPrefix;}
    const char *alphaPrefix() const {return globPtr->alphaPrefix;}
    int antialiasing() const {return globPtr->antialiasing;}
    bool enhancedAA() const {return globPtr->enhancedAA ? true : false;}
    const char *getAAName() const
    {
      static std::string ret;
      ret.clear();
      int aa = antialiasing();

      if (aa >= 100)
      {
        char buffer[256];
        sprintf(buffer,"PLD %i",aa - 99);
        ret = buffer;
      }
      else
      {
        if ((aa >= 0) && (aa < 5) && enhancedAA())  ret = "Enhanced ";
        switch (aa)
        {
          case 0: ret =  "none"; break;
          case 1: ret += "Low"; break;
          case 2: ret += "Medium"; break;
          case 3: ret += "High"; break;
          case 4: ret += "Extreme"; break;
          default: ret += "unknown"; break;
        }
      }
      if (adaptiveSampling())
      {
        char buffer[256];
        sprintf(buffer," - AS (%f)", adaptiveThreshold());
        ret += buffer;
      }
      return ret.c_str();
    }
    bool adaptiveSampling (void) const {return globPtr->adaptiveSampling ? true : false;}
    float adaptiveThreshold(void) const {return globPtr->adaptiveThreshold;}
    bool softfilter  (void) const {
      // we check the FIRST bit
      return (globPtr->filter | 0x0001) ? true : false;
    }

    // Enumeration for the filter names
    enum FilterTypes {
      CLASSIC,
      BOX, BOX_SHARP, BOX_SOFT,
      GAUSSIAN, GAUSSIAN_SHARP, GAUSSIAN_SOFT,
      MITCHELL, MITCHELL_SHARP, MITCHELL_SOFT,
      LANCZOS, LANCZOS_SHARP, LANCZOS_SOFT, UNKNOWN
    };


    FilterTypes reconstructionFilter () const
    {
      return static_cast<FilterTypes>((globPtr->filter >> 1) & 0x001F); // remove soft filter bit and mask out lower 5 bits
    }

    const char *reconstructionFilterName () const
    {
      FilterTypes filter = reconstructionFilter();
      if ((filter >= 0) && (filter < UNKNOWN))
      {
        return filterNames[filter];
      }
      else
      {
        return "unknown";
      }
     }

    // Returns a boolean value indicating if the area lights are double sided or not
    //bool dblSidedAreaLights(void) const {return globPtr->dblSidedAreaLights ? true : false;}

#if (LW_SDK >= 96)
    double getCausticsIntensity() const  { return globPtr->causticsIntensity; }
    int getCausticsAccuracy() const { return globPtr->causticsAccuracy; }
    int getCausticsSoftness() const { return globPtr->causticsSoftness; }
    int getRadiosityFlags() const { return globPtr->radiosityFlags; }
    double getDynamicsRangeMin() const  { return globPtr->dynamicsRangeMin; }
    double getDynamicsRangeMax() const  { return globPtr->dynamicsRangeMax; }
    double getSaturation() const  { return globPtr->saturation; }

    LWRENDERINGMODE GetRenderMode() const { return (LWRENDERINGMODE) globPtr->rendermode; }
    /*
    int         pixelFilterForceMT;
    int         has_multithreaded_filters;     
    int         useZminmax;
    double      zmin;
    double      zmax;
    int         calculateallnormals;  
    */
#endif
  };

  // Supporting functions

  Matrix4x4d getWorld2Screen(LWItemID id, LWTime time);

  Matrix4x4d getWorld2Screen(LWTime time);

  Matrix4x4d getWorld2Screen(LWItem cid, LWTime time);

  bool World2Screen(lwpp::Point3d pt, double scoord[2], lwpp::Matrix4x4d &CameraTransform, double frameAspect);

  bool World2Screen(lwpp::Vector3d dir, double scoord[2], lwpp::Matrix4x4d &CameraTransform, double frameAspect);


  bool World2Screen(lwpp::Point3d pt, double scoord[2], LWItemID camID, LWTime time, double pixelAspect);


  bool World2Screen(lwpp::Point3d pt, double scoord[2], LWTime time);
}

#endif // LWPP_SCENEINFO_H