GEO_PrimCamera.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GEO_PrimCamera.h ( GEO Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GEO_PrimCamera__
#define __GEO_PrimCamera__

#include "GEO_API.h"
#include "GEO_Primitive.h"

#include <UT/UT_BoundingRect.h>
#include <UT/UT_CameraParms.h>
#include <GA/GA_Types.h>
#include <GA/GA_Detail.h>

class GEO_API GEO_PrimCamera : public GEO_Primitive
{
protected:
    /// NOTE: The constructor should only be called from subclass
    ///       constructors.
    GEO_PrimCamera(GEO_Detail *d, GA_Offset offset = GA_INVALID_OFFSET);

    /// NOTE: The destructor should only be called from subclass
    ///       destructors.
    ~GEO_PrimCamera() override {}

public:

    // necessary overrides
    bool isDegenerate() const override;
    bool getBBox(UT_BoundingBox *bbox) const override;
    bool enlargeBoundingBox(UT_BoundingRect &box, 
                            const GA_Attribute *P) const override;
    bool enlargeBoundingBox(UT_BoundingBox &b,
                            const GA_Attribute *P) const override;
    void reverse() override;
    
    UT_Vector3D computeNormalD() const override;
    UT_Vector3 computeNormal() const override;

    int detachPoints(GA_PointGroup &grp) override;    
    GA_DereferenceStatus    dereferencePoint(GA_Offset point,
                                             bool dry_run=false) override;
    GA_DereferenceStatus    dereferencePoints(const GA_RangeMemberQuery &pt_q,
                                              bool dry_run=false) override;

    const GA_PrimitiveJSON *getJSON() const override;
    
    bool evaluatePointRefMap(GA_Offset result_vtx, GA_AttributeRefMap &hlist,
                             fpreal u, fpreal v,
                             uint du, uint dv) const override;
    
    int evaluatePointV4(UT_Vector4 &pos, float u, float v = 0,unsigned du = 0, 
                        unsigned dv = 0) const override;
    
    /// The fast point offset accessor
    SYS_FORCE_INLINE
    GA_Offset           getPointOffset() const
    { return GEO_Primitive::getPointOffset(0); }

    /// The fast point index accessor
    SYS_FORCE_INLINE
    GA_Index            getPointIndex() const
    { return GEO_Primitive::getPointIndex(0); }
    
    /// The fast vertex offset accessor
    SYS_FORCE_INLINE
    GA_Offset           getVertexOffset() const
    { return GEO_Primitive::getVertexOffset(0); }
    
    /// The fast vertex index accessor
    SYS_FORCE_INLINE
    GA_Index            getVertexIndex() const
    { return GEO_Primitive::getVertexIndex(0); }
        
    SYS_FORCE_INLINE
    void setPointOffset(GA_Offset ptoff)
    { GEO_Primitive::setPointOffset(0, ptoff); }
        
    SYS_FORCE_INLINE
    void setVertexPoint(GA_Offset pt)
    {
        setPointOffset(pt);
    }
    /// This method assigns a preallocated vertex to the camera, optionally
    /// creating the topological link between the primitive and new vertex.
    void assignVertex(GA_Offset new_vtx, bool update_topology);
    
    
    UT_Vector3 baryCenter() const override;

    GEO_Primitive *copy(int preserve_shared_pts = 0) const override;
    void copyPrimitive(const GEO_Primitive *src) override;
    void copySubclassData(const GA_Primitive *source) override;
    
    void stashed(bool beingstashed, 
                 GA_Offset offset = GA_INVALID_OFFSET) override;

    /// builds a new camera. Reuses offset if valid
    static GEO_PrimCamera *build(GA_Detail *gdp, 
                            GA_Offset exisiting_ptoff = GA_INVALID_OFFSET);

    // // make sure transforming cameras updates the right attributes

    void transform(const UT_Matrix4 &xform) override;
    
    void getTransform4(UT_Matrix4D &mat) const;
    void setTransform4(const UT_Matrix4D &mat);
    
    void getLocalTransform(UT_Matrix3D &matrix) const override;    
    void setLocalTransform(const UT_Matrix3D &matrix) override;
    

    // specific to GEO_PrimCamera

    const UT_CameraParms &getParms() const { return mySettings; }
    const UT_Matrix3D    &getTransform() const { return myXform; }
    
    UT_Vector3D    getPosition() const { return GEO_Primitive::getPos3(0); }
    
    const UT_OptionsHolder getParmsOptions() const;
    
    fpreal      getAperture() const { return mySettings.aperture; }
    fpreal      getPixelAspect() const { return mySettings.pixelaspect; }
    fpreal      getFocal() const { return mySettings.focal; }
    fpreal      getFocusDistance() const { return mySettings.focusdistance; }
    fpreal      getImagingDistance() const { return mySettings.imagingdistance; }
    fpreal      getFstop() const { return mySettings.fstop; }
    fpreal      getOrthoZoom() const { return mySettings.orthozoom; } 
    fpreal      getGuideScale() const { return mySettings.guidescale; }

    /// Shutter
    fpreal      getShutterOpen() const { return mySettings.shutteropen; }
    fpreal      getShutterClose() const { return mySettings.shutterclose; }
    void        getShutter(fpreal &sopen, fpreal &sclose) const 
    { 
        sopen = mySettings.shutteropen;
        sclose = mySettings.shutterclose; 
    }
    
    const UT_Vector2T<fpreal> getShutter() const 
    {
        return UT_Vector2T<fpreal>(mySettings.shutteropen, 
                                   mySettings.shutterclose );
    } 

    /// Projection
    OBJ_ProjectionType getProjection() const { return mySettings.projection; }
    const char *getProjectionToken() const;
    bool isOrthographic() const { return mySettings.isOrthographic(); }

    /// Resolution
    const UT_Vector2T<exint> getResolution() const 
    { 
        return UT_Vector2T<exint>(mySettings.resx, mySettings.resy); 
    }  

    void getResolution(exint &rx, exint &ry) const
    {
        rx = mySettings.resx;
        ry = mySettings.resy;
    }

    exint getResolutionX() const
    {
        return mySettings.resx;
    }

    exint getResolutionY() const
    {
        return mySettings.resy;
    }
    /// Crop
    const UT_Vector4T<fpreal> getCrop() const
    {
        return UT_Vector4T<fpreal>(mySettings.cropx[0], mySettings.cropx[1],
                                   mySettings.cropy[0], mySettings.cropy[1]);
    }

    const UT_Vector2T<fpreal> getCropMin() const
    {
        return UT_Vector2T<fpreal>(mySettings.cropx[0], mySettings.cropy[0]);
    }

    void getCropMin(fpreal &xmin, fpreal &ymin) const
    {
        xmin = mySettings.cropx[0]; 
        ymin = mySettings.cropy[0];
    }

    const UT_Vector2T<fpreal> getCropMax() const
    {
        return UT_Vector2T<fpreal>(mySettings.cropx[1], mySettings.cropy[1]);
    }

    void getCropMax(fpreal &xmax, fpreal &ymax) const
    {
        xmax = mySettings.cropx[1]; 
        ymax = mySettings.cropy[1];
    }
    
    void getCrop(UT_Vector2T<fpreal> &cropmin, UT_Vector2T<fpreal> &cropmax)
    {
        cropmin.x() = mySettings.cropx[0];
        cropmin.y() = mySettings.cropy[0];
        cropmax.x() = mySettings.cropx[1];
        cropmax.y() = mySettings.cropy[1];
    }

    /// Window
    const UT_Vector4T<fpreal> getWindow() const
    {
        return UT_Vector4T<fpreal>(mySettings.winx[0], mySettings.winx[1],
                                   mySettings.winy[0], mySettings.winy[1]);
    }

    const UT_Vector2T<fpreal> getWindowMin() const
    {
        return UT_Vector2T<fpreal>(mySettings.winx[0], mySettings.winy[0]);
    }

    void getWindowMin(fpreal &xmin, fpreal &ymin) const
    {
        xmin = mySettings.winx[0]; 
        ymin = mySettings.winy[0];
    }

    const UT_Vector2T<fpreal> getWindowMax() const
    {
        return UT_Vector2T<fpreal>(mySettings.winx[1], mySettings.winy[1]);
    }

    void getWindowMax(fpreal &xmax, fpreal &ymax) const
    {
        xmax = mySettings.winx[1]; 
        ymax = mySettings.winy[1];
    }
    
    void getWindow(UT_Vector2T<fpreal> &winmin, UT_Vector2T<fpreal> &winmax)
    {
        winmin.x() = mySettings.winx[0];
        winmin.y() = mySettings.winy[0];
        winmax.x() = mySettings.winx[1];
        winmax.y() = mySettings.winy[1];
    }

    /// Clipping Planes
    const UT_Vector2T<fpreal> getClippingPlanes() const
    {
        return UT_Vector2T<fpreal>(mySettings.clipnear, mySettings.clipfar);    
    }

    void getClippingPlanes(fpreal &n, fpreal &f) const
    {
        n = mySettings.clipnear;
        f = mySettings.clipfar;
    }

    fpreal getNearClippingPlane() const { return mySettings.clipnear; }
    fpreal getFarClippingPlane() const { return mySettings.clipfar; }

    /// Metadata
    const UT_OptionsHolder &getMetadata() const { return mySettings.metadata; }

    void setParms(const UT_CameraParms &parms);
    void setParms(const UT_OptionsHolder &parms);
    
    void setTransform(const UT_Matrix3D &xform) { myXform = xform; }
    
    void setPosition(const UT_Vector3D &pos) 
    { GEO_Primitive::setPos3(0, pos); }

    void setMetadata(const UT_OptionsHolder &opts) { mySettings.metadata = opts; }

    void setAperture(const fpreal value) { mySettings.aperture = value; }
    void setPixelAspect(const fpreal value) { mySettings.pixelaspect = value; }
    void setFocal(const fpreal value) { mySettings.focal = value; }
    void setFocusDistance(const fpreal value) { mySettings.focusdistance = value; }
    void setImagingDistance(const fpreal value) { mySettings.imagingdistance = value; }
    void setFstop(const fpreal value) { mySettings.fstop = value; }
    void setOrthoZoom(const fpreal value) { mySettings.orthozoom = value; }
    void setGuideScale(const fpreal value) { mySettings.guidescale = value; }
    
    void setResolution(const UT_Vector2T<exint> &resolution)
    {
        mySettings.resx = resolution.x();
        mySettings.resy = resolution.y();
    }

    void setResolution(const exint rx, const exint ry)
    {
        mySettings.resx = rx;
        mySettings.resy = ry;
    }

    void setResolutionX(const exint rx)
    {
        mySettings.resx = rx;
    }

    void setResolutionY(const exint ry)
    {
        mySettings.resy = ry;
    }

    void setShutter(const UT_Vector2T<fpreal> &stime)
    {
        mySettings.shutteropen = stime.x();
        mySettings.shutterclose = stime.y();
    }

    void setShutter(const fpreal sopen, const fpreal sclose)
    {
        mySettings.shutteropen = sopen;
        mySettings.shutterclose = sclose;
    }

    void setShutterOpen(const fpreal sopen)
    {
        mySettings.shutteropen = sopen;
    }

    void setShutterClose(const fpreal sclose)
    {
        mySettings.shutterclose = sclose;
    }
    
    void setClippingPlanes(const UT_Vector2T<fpreal> &planes) 
    {
        mySettings.clipnear = planes.x();
        mySettings.clipfar = planes.y();    
    }
    void setClippingPlanes(const fpreal n, const fpreal f) 
    {
        mySettings.clipnear = n;
        mySettings.clipfar = f;    
    }
    void setNearClippingPlane(const fpreal n)
    {
        mySettings.clipnear = n;
    }
    void setFarClippingPlane(const fpreal f)
    {
        mySettings.clipfar = f;
    }

    void setProjection(const OBJ_ProjectionType projection) 
    { 
        mySettings.projection = projection; 
    }

    void setCropMin(const fpreal xmin, const fpreal ymin)
    {
        mySettings.cropx[0] = xmin;
        mySettings.cropy[0] = ymin;
    }

    void setCropMin(const UT_Vector2T<fpreal> &xymin)
    {
        mySettings.cropx[0] = xymin.x();
        mySettings.cropy[0] = xymin.y();
    }

    void setCropMax(const fpreal xmax, const fpreal ymax)
    {
        mySettings.cropx[1] = xmax;
        mySettings.cropy[1] = ymax;
    }
    
    void setCropMax(const UT_Vector2T<fpreal> &xymax)
    {
        mySettings.cropx[1] = xymax.x();
        mySettings.cropy[1] = xymax.y();
    }
    
    void setWindowMin(const fpreal xmin, const fpreal ymin)
    {
        mySettings.winx[0] = xmin;
        mySettings.winy[0] = ymin;
    }
    
    void setWindowMin(const UT_Vector2T<fpreal> &xymin)
    {
        mySettings.winx[0] = xymin.x();
        mySettings.winy[0] = xymin.y();
    }

    void setWindowMax(const fpreal xmax, const fpreal ymax)
    {
        mySettings.winx[1] = xmax;
        mySettings.winy[1] = ymax;
    }
    
    void setWindowMax(const UT_Vector2T<fpreal> &xymax)
    {
        mySettings.winx[1] = xymax.x();
        mySettings.winy[1] = xymax.y();
    }
        
protected:
    /// Register intrinsic attributes
    GA_DECLARE_INTRINSICS(override)
    
    static GA_PrimitiveFamilyMask buildFamilyMask(){ return GA_FAMILY_NONE; }

private:

    UT_Matrix3D myXform;
    UT_CameraParms mySettings;

};


#endif