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.16 by greg, Wed Oct 23 23:40:41 2024 UTC vs.
Revision 2.22 by greg, Thu Jan 9 17:25:37 2025 UTC

# Line 27 | Line 27 | 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() {
39 <                                        Cleanup();
39 >                                        // Cleanup();
40 >                                        if (ray_pnprocs > 0) ray_pclose(0);
41                                  }
42                                  /// Load octree and prepare renderer
43          bool                    LoadOctree(const char *octn);
# Line 65 | Line 67 | class RadSimulManager {
67                                          return ray_pnprocs + !ray_pnprocs;
68                                  }
69                                  /// How many threads are currently unoccupied?
70 <        int                     ThreadsAvailable() const;
70 >        int                     ThreadsAvailable() const {
71 >                                        return ray_pnprocs ? ray_pnidle : 1;
72 >                                }
73                                  /// Are we ready?
74          bool                    Ready() const {
75                                          return (octname && nobjects > 0);
76                                  }
77                                  /// Process a ray (in subthread), optional result
78 <        bool                    ProcessRay(RAY *r);
78 >        int                     ProcessRay(RAY *r);
79                                  /// Wait for next result (or fail)
80          bool                    WaitResult(RAY *r);
81                                  /// Close octree, free data, return status
# Line 93 | Line 97 | class RtraceSimulManager : public RadSimulManager {
97          static void             RTracer(RAY *r);
98                                  // Call-back for FIFO
99          static int              Rfifout(RAY *r);
100 + protected:
101                                  // Check for changes to render flags, etc.
102          bool                    UpdateMode();
98 – protected:
103          RNUMBER                 lastRayID;      // last ray ID assigned
104   public:
105          int                     rtFlags;        // operation (RT*) flags
# Line 109 | Line 113 | class RtraceSimulManager : public RadSimulManager {
113                                  ~RtraceSimulManager() {
114                                          FlushQueue();
115                                  }
116 +                                /// Load octree and prepare renderer
117 +        bool                    LoadOctree(const char *octn) {
118 +                                        if ((octn != NULL) & (octname != NULL) &&
119 +                                                        !strcmp(octn, octname))
120 +                                                return true;
121 +                                        srcFollowed.NewBitMap(0);
122 +                                        curFlags &= ~RTtraceSources;
123 +                                        return RadSimulManager::LoadOctree(octn);
124 +                                }
125                                  /// Set number of computation threads (0 => #cores)
126          int                     SetThreadCount(int nt = 0) {
127                                          if (nt <= 0) nt = castonly ? 1 : GetNCores();
# Line 120 | Line 133 | class RtraceSimulManager : public RadSimulManager {
133          int                     EnqueueBundle(const FVECT orig_direc[], int n,
134                                                  RNUMBER rID0 = 0);
135                                  /// Enqueue a single ray w/ optional ray ID
136 <        bool                    EnqueueRay(const FVECT org, const FVECT dir,
136 >        int                     EnqueueRay(const FVECT org, const FVECT dir,
137                                                  RNUMBER rID = 0) {
138                                          if (dir == org+1)
139                                                  return(EnqueueBundle((const FVECT *)org, 1, rID) > 0);
140                                          FVECT   orgdir[2];
141                                          VCOPY(orgdir[0], org); VCOPY(orgdir[1], dir);
142 <                                        return(EnqueueBundle(orgdir, 1, rID) > 0);
142 >                                        return EnqueueBundle(orgdir, 1, rID);
143                                  }
144                                  /// Set/change cooked ray callback
145          void                    SetCookedCall(RayReportCall *cb, void *cd = NULL) {
# Line 135 | Line 148 | class RtraceSimulManager : public RadSimulManager {
148                                          cookedCall = cb;
149                                          ccData = cb ? cd : NULL;
150                                  }
151 <                                /// Set/change trace callback (before threading)
151 >                                /// Set/change trace callback
152          void                    SetTraceCall(RayReportCall *cb, void *cd = NULL) {
153 +                                        if ((cb == traceCall) & (cd == tcData)) return;
154 +                                        int     nt = NThreads();
155 +                                        if (nt > 1) SetThreadCount(1);
156                                          traceCall = cb;
157                                          tcData = cb ? cd : NULL;
158 +                                        UpdateMode();
159 +                                        if (nt > 1) SetThreadCount(nt);
160                                  }
143 –                                /// Are we ready?
144 –        bool                    Ready() const {
145 –                                        return (cookedCall != NULL) | (traceCall != NULL) &&
146 –                                                RadSimulManager::Ready();
147 –                                }
161                                  /// Finish pending rays and complete callbacks (return #sent)
162          int                     FlushQueue();
163                                  /// Close octree, free data, return status
164          int                     Cleanup(bool everything = false) {
165 <                                        SetCookedCall(NULL);
166 <                                        SetTraceCall(NULL);
167 <                                        rtFlags = 0;
165 >                                        int     st = RadSimulManager::Cleanup(everything);
166 >                                        srcFollowed.NewBitMap(0);
167 >                                        curFlags &= ~RTtraceSources;
168 >                                        if (everything) {
169 >                                                SetCookedCall(NULL);
170 >                                                SetTraceCall(NULL);
171 >                                                rtFlags &= ~RTmask;
172 >                                        }
173                                          UpdateMode();
174                                          lastRayID = 0;
175 <                                        return RadSimulManager::Cleanup(everything);
175 >                                        return st;
176                                  }
177   };
178  

Diff Legend

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