ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/RpictSimulManager.h
(Generate patch)

Comparing ray/src/rt/RpictSimulManager.h (file contents):
Revision 2.1 by greg, Wed Aug 14 20:05:23 2024 UTC vs.
Revision 2.10 by greg, Thu Oct 10 21:02:52 2024 UTC

# Line 13 | Line 13
13   #include "RtraceSimulManager.h"
14   #include "view.h"
15   #include "depthcodec.h"
16 – #include "abitmap.h"
16  
17   /// Data type flags for pixel access and output
18   enum RenderDataType {
# Line 27 | Line 26 | enum RenderDataType {
26   #define RDTcolorT(f)    RenderDataType((f) & RDTcolorM)
27   #define RDTdepthT(f)    RenderDataType((f) & RDTdepthM)
28   #define RDTcommonE(f)   (RDTcolorT(f) >= RDTscolr)
29 < #define RDTnewCT(f,c)   RenderDataType((f) & ~RDTcolorM | (c))
30 < #define RDTnewDT(f,d)   RenderDataType((f) & ~RDTdepthM | (d))
29 > #define RDTnewCT(f,c)   RenderDataType((f) & ~RDTcolorM | (c) & RDTcolorM)
30 > #define RDTnewDT(f,d)   RenderDataType((f) & ~RDTdepthM | (d) & RDTdepthM)
31  
32   /// Pixel accessor (read/write to caller's buffer with possible conversion)
33   class PixelAccess {
# Line 43 | Line 42 | class PixelAccess {
42          long            rowStride;      // # values to next y position
43          int             dtyp;           // data type flags
44          RGBPRIMP        primp;          // color primaries if tristimulus
45 <        COLORMAT        xyz2myrgbmat;   // custom color conversion matrix
45 >        bool            swap2d;         // need to swap 16-bit depths?
46 >        const COLORV *  CF3(int x, int y) const {
47 >                                return pbase.f + (rowStride*y + x)*3;
48 >                        }
49          COLORV *        CF3(int x, int y) {
50                                  return pbase.f + (rowStride*y + x)*3;
51                          }
52 <        COLORV *        GetCF3(int x, int y) const {
53 <                                return const_cast<COLORV *>(pbase.f + (rowStride*y + x)*3);
52 >        const COLRV *   CB3(int x, int y) const {
53 >                                return pbase.b + (rowStride*y + x)*4;
54                          }
53 –        COLORV *        SCF(int x, int y) {
54 –                                return pbase.f + (rowStride*y + x)*NCSAMP;
55 –                        }
56 –        COLORV *        GetSCF(int x, int y) const {
57 –                                return const_cast<COLORV *>(pbase.f + (rowStride*y + x)*NCSAMP);
58 –                        }
55          COLRV *         CB3(int x, int y) {
56                                  return pbase.b + (rowStride*y + x)*4;
57                          }
58 <        COLRV *         GetCB3(int x, int y) const {
59 <                                return const_cast<COLRV *>(pbase.b + (rowStride*y + x)*4);
58 >        const COLORV *  SCF(int x, int y) const {
59 >                                return pbase.f + (rowStride*y + x)*NCSAMP;
60                          }
61 +        COLORV *        SCF(int x, int y) {
62 +                                return pbase.f + (rowStride*y + x)*NCSAMP;
63 +                        }
64 +        const COLRV *   SCB(int x, int y) const {
65 +                                return pbase.b + (rowStride*y + x)*(NCSAMP+1);
66 +                        }
67          COLRV *         SCB(int x, int y) {
68                                  return pbase.b + (rowStride*y + x)*(NCSAMP+1);
69                          }
70 <        COLRV *         GetSCB(int x, int y) const {
71 <                                return const_cast<COLRV *>(pbase.b + (rowStride*y + x)*(NCSAMP+1));
70 >        void            EncodeDepth16(int x, int y, float z) {
71 >                                short * sp = dbase.s + rowStride*y + x;
72 >                                *sp = depth2code(z, refDepth);
73 >                                if (swap2d) swap16((char *)sp, 1);
74                          }
75 +        float           DecodeDepth16(int x, int y) const {
76 +                                short   sv = dbase.s[rowStride*y + x];
77 +                                if (swap2d) swap16((char *)&sv, 1);
78 +                                return code2depth(sv, refDepth);
79 +                        }
80   public:
81          double          refDepth;       // reference depth
82                          PixelAccess() {
83                                  refDepth = 1.;
84 +                                swap2d = !nativebigendian();
85                                  Init();
86                          }
87                          PixelAccess(COLORV *rp, int ystride, float *zp=NULL) {
88                                  refDepth = 1.;
89 +                                swap2d = !nativebigendian();
90                                  Init(rp, ystride, zp);
91                          }
92                          PixelAccess(COLRV *bp, int ystride, float *zp=NULL) {
93                                  refDepth = 1.;
94 +                                swap2d = !nativebigendian();
95                                  Init(bp, ystride, zp);
96                          }
97                          PixelAccess(COLRV *bp, int ystride, short *dp) {
98                                  refDepth = 1.;
99 +                                swap2d = !nativebigendian();
100                                  Init(bp, ystride, dp);
101                          }
102 +                        PixelAccess(COLORV *rp, int ystride, short *dp) {
103 +                                refDepth = 1.;
104 +                                swap2d = !nativebigendian();
105 +                                Init(rp, ystride, dp);
106 +                        }
107          void            Init() {
108                                  pbase.f = NULL; dbase.f = NULL;
109                                  rowStride = 0;
# Line 123 | Line 141 | class PixelAccess {
141                                  }
142                                  if (dp) dtyp |= RDTdshort;
143                          }
144 +        void            Init(COLORV *rp, int ystride, short *dp) {
145 +                                pbase.f = rp; dbase.s = dp;
146 +                                rowStride = ystride;
147 +                                if (NCSAMP > 3) {
148 +                                        dtyp = RDTscolor; primp = NULL;
149 +                                } else {
150 +                                        dtyp = RDTrgb; primp = stdprims;
151 +                                }
152 +                                if (dp) dtyp |= RDTdshort;
153 +                        }
154                          /// Set color space after non-empty initialization
155          bool            SetColorSpace(RenderDataType cs, RGBPRIMP pr=NULL);
156                          /// Get color space
# Line 166 | Line 194 | class PixelAccess {
194                                          scolor_scolr(SCB(x,y), pv);
195                                  else
196                                          copyscolor(SCF(x,y), pv);
197 <                                if (RDTdepthT(dtyp) == RDTdfloat)
197 >                                if (DepthType() == RDTdfloat)
198                                          dbase.f[rowStride*y + x] = z;
199 <                                else if (RDTdepthT(dtyp) == RDTdshort)
200 <                                        dbase.s[rowStride*y + x] = depth2code(z, refDepth);
199 >                                else if (DepthType() == RDTdshort)
200 >                                        EncodeDepth16(x, y, z);
201                                  return true;
202                          }
203                          /// Retrieve pixel color (& depth) -- may convert either/both
204          bool            GetPixel(int x, int y, COLORV *pv, float *zp=NULL) const {
205                                  if (NC() == 3) {
206                                          if (RDTcommonE(dtyp))
207 <                                                colr_color(pv, GetCB3(x,y));
207 >                                                colr_color(pv, CB3(x,y));
208                                          else
209 <                                                copycolor(pv, GetCF3(x,y));
209 >                                                copycolor(pv, CF3(x,y));
210                                  } else if (RDTcommonE(dtyp))
211 <                                        scolr_scolor(pv, GetSCB(x,y));
211 >                                        scolr_scolor(pv, SCB(x,y));
212                                  else
213 <                                        copyscolor(pv, GetSCF(x,y));
213 >                                        copyscolor(pv, SCF(x,y));
214                                  if (!zp) return true;
215 <                                if (RDTdepthT(dtyp) == RDTdfloat)
215 >                                if (DepthType() == RDTdfloat)
216                                          *zp = dbase.f[rowStride*y + x];
217 <                                else if (RDTdepthT(dtyp) == RDTdshort)
218 <                                        *zp = code2depth(dbase.s[rowStride*y + x], refDepth);
217 >                                else if (DepthType() == RDTdshort)
218 >                                        *zp = DecodeDepth16(x, y);
219                                  else
220                                          *zp = .0f;
221                                  return true;
# Line 198 | Line 226 | class PixelAccess {
226                                  const int       nc = NC();
227                                  if (nc == 3) {
228                                          if (RDTcommonE(dtyp))
229 <                                                copycolr(CB3(dx,dy), GetCB3(sx,sy));
229 >                                                copycolr(CB3(dx,dy), CB3(sx,sy));
230                                          else
231 <                                                copycolor(CF3(dx,dy), GetCF3(sx,sy));
231 >                                                copycolor(CF3(dx,dy), CF3(sx,sy));
232                                  } else if (RDTcommonE(dtyp))
233 <                                        copyscolr(SCB(dx,dy), GetSCB(sx,sy));
233 >                                        copyscolr(SCB(dx,dy), SCB(sx,sy));
234                                  else
235 <                                        copyscolor(SCF(dx,dy), GetSCF(sx,sy));
236 <                                switch (RDTdepthT(dtyp)) {
235 >                                        copyscolor(SCF(dx,dy), SCF(sx,sy));
236 >                                switch (DepthType()) {
237                                  case RDTdfloat:
238                                          dbase.f[rowStride*dy + dx] =
239                                                          dbase.f[rowStride*sy + sx];
# Line 238 | Line 266 | class RpictSimulManager : protected RtraceSimulManager
266          COLORV *                barPix;                 // current render bar pixels
267          float *                 barDepth;               // current render bar depths
268          bool                    SetTile(const int ti[2]);
269 <        bool                    RenderRect();
269 >        bool                    RenderRect(const int x0 = 0, const int y0 = 0);
270          bool                    ComputePixel(int x, int y);
271 <        bool                    BelowSampThresh(int x, int y, const int noff[4][2]) const;
272 <        void                    FillSquare(int x, int y, const int noff[4][2]);
271 >        bool                    BelowSampThresh(const int x, const int y,
272 >                                                        const int noff[4][2]) const;
273 >        void                    FillSquare(const int x, const int y, const int noff[4][2]);
274          void                    NewBar(int ht = 0);
275 <        bool                    LowerBar(int v);
275 >        bool                    LowerBar(int v, int ytop);
276          bool                    RenderBelow(int ytop, const int vstep, FILE *pfp,
277                                                          const int dt, FILE *dfp=NULL);
278   public:
# Line 262 | Line 291 | class RpictSimulManager : protected RtraceSimulManager
291                                          frameNo = 0;
292                                  }
293                                  ~RpictSimulManager() {
294 <                                        NewBar();
294 >                                        delete [] barPix; delete [] barDepth;
295                                  }
296                                  /// Load octree and prepare renderer
297          bool                    LoadOctree(const char *octn) {
# Line 281 | Line 310 | class RpictSimulManager : protected RtraceSimulManager
310                                          return RtraceSimulManager::AddHeader(ac, av);
311                                  }
312                                  /// Get header lines if any
313 <        const char *            GetHeader() const {
314 <                                        return RtraceSimulManager::GetHeader();
313 >        const char *            GetHeadStr() const {
314 >                                        return RtraceSimulManager::GetHeadStr();
315                                  }
316 +                                /// Look for specific header keyword, return value
317 +        const char *            GetHeadStr(const char *key, bool inOK = false) const {
318 +                                        return RtraceSimulManager::GetHeadStr(key, inOK);
319 +                                }
320                                  /// Set number of computation threads (0 => #cores)
321          int                     SetThreadCount(int nt = 0) {
322                                          return RtraceSimulManager::SetThreadCount(nt);
# Line 326 | Line 359 | class RpictSimulManager : protected RtraceSimulManager
359                                  /// Increments frameNo if >0
360          bool                    NewFrame(const VIEW &v, int xydim[2], double *ap=NULL,
361                                                  const int *tgrid=NULL);
362 +                                /// Get current view if set
363 +        const VIEW *            GetView() const {
364 +                                        if (!vw.type) return NULL;
365 +                                        return &vw;
366 +                                }
367 +                                /// Writeable previous view (for motion blur)
368 +        VIEW &                  PreView() {
369 +                                        return pvw;
370 +                                }
371                                  /// Get current picture width
372          int                     GetWidth() const {
373                                          return hvres[0];
# Line 354 | Line 396 | class RpictSimulManager : protected RtraceSimulManager
396                                  /// Same but also use 16-bit encoded depth buffer
397          bool                    RenderTile(COLRV *bp, int ystride, short *dp,
398                                                  const int *tile=NULL);
399 +                                /// Back to float color with 16-bit depth
400 +        bool                    RenderTile(COLORV *rp, int ystride, short *dp,
401 +                                                const int *tile=NULL);
402                                  /// Render and write a frame to the named file
403                                  /// Include any header lines set prior to call
404 <                                /// Picture file must not already exist
405 <                                /// Picture to stdout if pfname==NULL
406 <                                /// Depth written to a command if dfname[0]=='!'
404 >                                /// Picture file must not exist
405 >                                /// Write pixels to stdout if !pfname
406 >                                /// Write depth to a command if dfname[0]=='!'
407          RenderDataType          RenderFrame(const char *pfname,
408                                                  RenderDataType dt=RDTrgbe,
409                                                  const char *dfname=NULL);
410                                  /// Resume partially finished rendering
411                                  /// Picture file must exist with valid header
412          RenderDataType          ResumeFrame(const char *pfname,
413 +                                                const char *dfname=NULL);
414 +                                /// Prepare new picture (and depth) output
415 +                                /// Called by RenderFrame() after NewFrame()
416 +        RenderDataType          NewOutput(FILE *pdfp[2], const char *pfname,
417 +                                                RenderDataType dt=RDTrgbe,
418 +                                                const char *dfname=NULL);
419 +                                /// Reopen existing picture (and depth) file
420 +                                /// Called by ResumeFrame()
421 +                                /// File pointers @ end of header (before res.)
422 +        RenderDataType          ReopenOutput(FILE *pdfp[2], const char *pfname,
423                                                  const char *dfname=NULL);
424                                  /// Close octree, free data, return status
425          int                     Cleanup(bool everything = false) {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines