OpenPaperOpt/RndRay.h

Go to the documentation of this file.

#ifndef RNDRAY_H
#define RNDRAY_H

#ifndef MAX_THREADS

#define MAX_THREADS  2 //Controlls number of tagslots in render objects
                       //and thus the maximum number of CPU's that can be                       
                                           //used simultaniously
#endif

#include "utilities.h"
#include "V3.h"
#include "FiberStatic.h"
#include "Staticsheet.h"
#include "RndFiber.h"
#include "OrientClipBox.h"
#include "RndFiberSeg.h"
#include "RndHitSortTag.h"
#include "RndVolume.h"


namespace p3d{
        
#define CURMAT_OUTSIDE         1 //Outside volume
#define CURMAT_AIR             2 //Traced outside fiber
#define CURMAT_FIBER           3 //Traced into fiber
#define CURMAT_LUMEN           4 //Traced into lumen
#define CURMAT_VOID            5 //No hit

        
        class RndRay {
        
        private:
                V3 <double>  mOrgin;            //Position in world.  Used only when tracing outside fibers
                int          mOrginRx,mOrginRy; //What repetition mOrgin is in.
                int          mLatX,mLatY,mLatZ; //Current lattice point (in range [0..lat-1]
                V3 <double>  mDir;

                double       mTtoHit;   //accumulated distance traveled since last reset (increased when
                            //changing lattice boxes, entering lumen, hiting fiber wall)

                int          mMaterial; //Current material, CURMAT_xxx

                //Current and next lattice if mMaterial==CURMAT_AIR
                int          mNumAccX,mNumAccY,mNumAccZ;     //Copied from mVol
                int          mNextLatX,mNextLatY,mNextLatZ;  //Next lattice point
                double       mNextLatT;                      //T of swap from current position


                //Environment
                int          mThreadNo;     //What slot to use when tagging
                int          mRayNo;        //This ray number (used for tagging)
                vector<RndHitSortTag>*   mpRaySortVec;   //Threads own sort-vector

                RndVolume*   mpVol;

                //HitFlags
                int          mIntersectType; //Traced into CURMAT_xxx

                //Params/vars/retvals used by IntersectPolyFromAir and TraceInsideLumen
                RndFiber*    mpHitFiber;
                double       mPolyIntersectLimit;
                const RndFiberSeg* mpHitSeg;
                int          mHitPlane; //0-15 plane, 16-capping begin, 17-capping end
                V3 <double>  mHitPoint; //Translated to correct fiber position
                V3 <double>  mHitPlaneNormal;
                V3 <double>  mHitNormal;

                //Lumen & fiber tracing
                RndFiber*          mpCurFiber;
                V3 <double>        mTrnOrg;     //Translated orgin. Used when tracing inside fibers
                V3 <double>        mTrnOrgDisp; //Displacement between mTrnOrg and mOrgin
                int                mTrnOrgRx,mTrnOrgRy; //What repetition mTrnOrg is in.
                const RndFiberSeg* mpCurSeg;   //Current segment we'r in
        
        public:

                RndRay(RndVolume* vol,V3 <double> pos,V3 <double> dir,int threadNo=0);
                RndRay(const RndRay& rRay,V3 <double> dir,int* discon);

                V3 <double>   Test(int level=0,int disp=0);
                
                //=================Accessors============================
                
                int         GetMaterial()       const {return mMaterial;}
                int         GetIntersectType()  const {return mIntersectType;}
                V3 <double> GetPosition()       const {if ((mMaterial==CURMAT_FIBER)||(mMaterial==CURMAT_LUMEN)) 
                                                                                                   return mTrnOrg-mTrnOrgDisp;
                                                                                                return mOrgin;}
                double    GetTraceLen()       const {return mTtoHit;}
                const V3 <double>& GetDirection()      const {return mDir;}

                const V3 <double>& GetHitNormal()      const {return mHitNormal;}
                const V3 <double>& GetHitPlaneNormal() const {return mHitPlaneNormal;}

                int                     GetLatZ()       const{return mLatZ;}
                int                     GetNumAccZ() const{return mNumAccZ;}
                //=================Mutators===============================
        
                void      SetNewDir(V3 <double>& rNdir); 

                void      NormalizeDir()       {mDir.Normalize();}
                
                //=================Trace-ops - mode: CURMAT_AIR / CURMAT_OUTSIDE==============

                //-----------------Trace-ops, lattice-----------------------------------------
                int  TraceToLattice();         
                int  FindNextLatticeExit();
                int  MoveToNextLatticePoint(); 

                //------------------Trace-ops, clipboxes-------------------------------------
                inline int TestSingleBox(double dispX,double dispY,OrientClipBox* cb,double& rTHit); 
                int  IntersectRayClipboxes();  

                //------------------Trace-ops, pollys--------------------------------------
                int  IntersectPolysFromAir(OrientClipBox* box,double dispX,double dispY);
                void EstimateFromAirNormal();
        
                //=================Trace-ops - mode: CURMAT_LUMEN===========================

                void EnterLumenFromAir();
                int  TraceInsideLumen();
                void LeaveLumenToAir();       
                void EstimateFromLumenNormal();
        
                //===============Trace-ops - mode: CURMAT_FIBER=======================
                void EnterFiberFrom_x();       
                int  LeaveFiberTo_x();        
                int  TraceInsideFiber(double* limit=0);
                                   
                void EstimateFromFiberNormal();
                void FindLatXYFromOrgin();
        };
}

#endif