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

Comparing ray/src/rt/RtraceSimulManager.h (file contents):
Revision 2.7 by greg, Wed May 1 22:06:09 2024 UTC vs.
Revision 2.20 by greg, Mon Dec 16 20:18:36 2024 UTC

# Line 13 | Line 13
13   #define RtraceSimulManager_h
14  
15   #include "ray.h"
16 + #include "abitmap.h"
17  
18   extern char *   octname;        // global octree name
19  
# Line 23 | Line 24 | typedef int    RayReportCall(RAY *r, void *cd);
24  
25   /// Multi-threaded simulation manager base class
26   class RadSimulManager {
27 +        char *                  header;                 // header (less intro and format)
28 +        int                     hlen;                   // header string length
29   protected:
30 <                                // Assign ray to subthread (fails if NThreads()<2)
31 <        bool                    SplitRay(RAY *r);
30 >        bool                    SplitRay(RAY *r) {
31 >                                        return (ray_pnprocs && ray_psend(r) > 0);
32 >                                }
33   public:
34                                  RadSimulManager(const char *octn = NULL) {
35 +                                        header = NULL; hlen = 0;
36                                          LoadOctree(octn);
37                                  }
38                                  ~RadSimulManager() {
# Line 35 | Line 40 | class RadSimulManager { (public)
40                                  }
41                                  /// Load octree and prepare renderer
42          bool                    LoadOctree(const char *octn);
43 +                                /// Prepare header from previous input (or clear)
44 +                                /// Normally called during octree load
45 +        bool                    NewHeader(const char *inspec = NULL);
46 +                                /// Add a line to header (adds newline if none)
47 +        bool                    AddHeader(const char *str);
48 +                                /// Append program line to header
49 +        bool                    AddHeader(int ac, char *av[]);
50 +                                /// Get current header length in bytes
51 +        int                     GetHeadLen() const {
52 +                                        return hlen;
53 +                                }
54 +                                /// Get header lines or empty string
55 +        const char *            GetHeadStr() const {
56 +                                        return hlen ? header : "";
57 +                                }
58 +                                /// Look for specific header keyword, return value
59 +        const char *            GetHeadStr(const char *key, bool inOK = false) const;
60                                  /// How many cores are available?
61          static int              GetNCores();
62                                  /// Set number of computation threads (0 => #cores)
# Line 44 | Line 66 | class RadSimulManager { (public)
66                                          return ray_pnprocs + !ray_pnprocs;
67                                  }
68                                  /// How many threads are currently unoccupied?
69 <        int                     ThreadsAvailable() const;
69 >        int                     ThreadsAvailable() const {
70 >                                        return ray_pnprocs ? ray_pnidle : 1;
71 >                                }
72                                  /// Are we ready?
73          bool                    Ready() const {
74                                          return (octname && nobjects > 0);
75                                  }
76                                  /// Process a ray (in subthread), optional result
77 <        bool                    ProcessRay(RAY *r);
77 >        int                     ProcessRay(RAY *r);
78                                  /// Wait for next result (or fail)
79          bool                    WaitResult(RAY *r);
80                                  /// Close octree, free data, return status
# Line 67 | Line 91 | class RtraceSimulManager : public RadSimulManager {
91          RayReportCall *         traceCall;      // call for every ray in tree
92          void *                  tcData;         // client data for traced rays
93          int                     curFlags;       // current operating flags
94 +        ABitMap                 srcFollowed;    // source flags changed
95                                  // Call-back for global ray-tracing context
96          static void             RTracer(RAY *r);
97                                  // Call-back for FIFO
# Line 91 | Line 116 | class RtraceSimulManager : public RadSimulManager {
116          int                     SetThreadCount(int nt = 0) {
117                                          if (nt <= 0) nt = castonly ? 1 : GetNCores();
118                                          if (nt == NThreads()) return nt;
119 <                                        if (FlushQueue() < 0) return 0;
119 >                                        if (nt < NThreads() && FlushQueue() < 0) return 0;
120                                          return RadSimulManager::SetThreadCount(nt);
121                                  }
122                                  /// Add ray bundle to queue w/ optional 1st ray ID
123          int                     EnqueueBundle(const FVECT orig_direc[], int n,
124                                                  RNUMBER rID0 = 0);
125                                  /// Enqueue a single ray w/ optional ray ID
126 <        bool                    EnqueueRay(const FVECT org, const FVECT dir,
126 >        int                     EnqueueRay(const FVECT org, const FVECT dir,
127                                                  RNUMBER rID = 0) {
128                                          if (dir == org+1)
129                                                  return(EnqueueBundle((const FVECT *)org, 1, rID) > 0);
130                                          FVECT   orgdir[2];
131                                          VCOPY(orgdir[0], org); VCOPY(orgdir[1], dir);
132 <                                        return(EnqueueBundle(orgdir, 1, rID) > 0);
132 >                                        return EnqueueBundle(orgdir, 1, rID);
133                                  }
134                                  /// Set/change cooked ray callback
135          void                    SetCookedCall(RayReportCall *cb, void *cd = NULL) {
# Line 115 | Line 140 | class RtraceSimulManager : public RadSimulManager {
140                                  }
141                                  /// Set/change trace callback
142          void                    SetTraceCall(RayReportCall *cb, void *cd = NULL) {
143 +                                        if ((cb == traceCall) & (cd == tcData)) return;
144 +                                        int     nt = NThreads();
145 +                                        if (nt > 1) SetThreadCount(1);
146                                          traceCall = cb;
147                                          tcData = cb ? cd : NULL;
148 +                                        UpdateMode();
149 +                                        if (nt > 1) SetThreadCount(nt);
150                                  }
121 –                                /// Are we ready?
122 –        bool                    Ready() const {
123 –                                        return (cookedCall != NULL) | (traceCall != NULL) &&
124 –                                                RadSimulManager::Ready();
125 –                                }
151                                  /// Finish pending rays and complete callbacks (return #sent)
152          int                     FlushQueue();
153                                  /// Close octree, free data, return status
154          int                     Cleanup(bool everything = false) {
130 –                                        FlushQueue();
155                                          SetCookedCall(NULL);
156                                          SetTraceCall(NULL);
157                                          rtFlags = 0;

Diff Legend

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