ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/RtraceSimulManager.h

Comparing ray/src/rt/RtraceSimulManager.h (file contents):
Revision 2.4 by greg, Wed Aug 2 00:04:31 2023 UTC vs.
Revision 2.11 by greg, Sat Aug 3 21:33:15 2024 UTC

#	Line 16 | Line 16
16
17		extern char *   octname;        // global octree name
18
19	<	/// Ray reporting callback method
20	<	typedef void    RayReportCall(RAY *r, void *cd);
19	>	extern int      castonly;       // doing ray-casting only?
20
21	+	/// Ray reporting callback method -- returns # successfully reported, -1 to abort
22	+	typedef int     RayReportCall(RAY *r, void *cd);
23	+
24		/// Multi-threaded simulation manager base class
25		class RadSimulManager {
26	<	int                     nThreads;       // number of active threads
26	>	char *                  header;                 // header (less intro and format)
27	>	int                     hlen;                   // header string length
28		protected:
29		// Assign ray to subthread (fails if NThreads()<2)
30		bool                    SplitRay(RAY *r);
31		public:
32		RadSimulManager(const char *octn = NULL) {
33	+	header = NULL; hlen = 0;
34		LoadOctree(octn);
31	–	nThreads = 1;
35		}
36		~RadSimulManager() {
37		Cleanup();
38		}
39		/// Load octree and prepare renderer
40		bool                    LoadOctree(const char *octn);
41	<	/// How many cores are there?
41	>	/// Prepare header from previous input (or clear)
42	>	/// Normally called during octree load
43	>	bool                    NewHeader(const char *inspec=NULL);
44	>	/// Add a line to header (adds newline if none)
45	>	bool                    AddHeader(const char *str);
46	>	/// Append program line to header
47	>	bool                    AddHeader(int ac, const char *av[]);
48	>	/// Get header lines or empty string
49	>	const char *            GetHeader() const {
50	>	return hlen ? header : "";
51	>	}
52	>	/// How many cores are available?
53		static int              GetNCores();
54		/// Set number of computation threads (0 => #cores)
55		int                     SetThreadCount(int nt = 0);
56		/// Check thread count (1 means no multi-threading)
57		int                     NThreads() const {
58	<	return nThreads;
58	>	return ray_pnprocs + !ray_pnprocs;
59		}
60		/// How many threads are currently unoccupied?
61		int                     ThreadsAvailable() const;
62		/// Are we ready?
63		bool                    Ready() const {
64	<	return (octname && nsceneobjs > 0);
64	>	return (octname && nobjects > 0);
65		}
66		/// Process a ray (in subthread), optional result
67		bool                    ProcessRay(RAY *r);
#	Line 69 | Line 83 | class RtraceSimulManager : public RadSimulManager {
83		int                     curFlags;       // current operating flags
84		// Call-back for global ray-tracing context
85		static void             RTracer(RAY *r);
86	+	// Call-back for FIFO
87	+	static int              Rfifout(RAY *r);
88		// Check for changes to render flags, etc.
89		bool                    UpdateMode();
90		protected:
75	–	// Add a ray result to FIFO, flushing what we can
76	–	int                     QueueResult(const RAY &ra);
91		RNUMBER                 lastRayID;      // last ray ID assigned
92		public:
93		int                     rtFlags;        // operation (RT*) flags
#	Line 89 | Line 103 | class RtraceSimulManager : public RadSimulManager {
103		}
104		/// Set number of computation threads (0 => #cores)
105		int                     SetThreadCount(int nt = 0) {
106	<	if (nt <= 0) nt = GetNCores();
106	>	if (nt <= 0) nt = castonly ? 1 : GetNCores();
107		if (nt == NThreads()) return nt;
108	<	FlushQueue();
108	>	if (FlushQueue() < 0) return 0;
109		return RadSimulManager::SetThreadCount(nt);
110		}
111		/// Add ray bundle to queue w/ optional 1st ray ID
#	Line 106 | Line 120 | class RtraceSimulManager : public RadSimulManager {
120		VCOPY(orgdir[0], org); VCOPY(orgdir[1], dir);
121		return(EnqueueBundle(orgdir, 1, rID) > 0);
122		}
123	<	/// Set/change cooked ray callback & FIFO flag
123	>	/// Set/change cooked ray callback
124		void                    SetCookedCall(RayReportCall *cb, void *cd = NULL) {
125		if (cookedCall && (cookedCall != cb) | (ccData != cd))
126		FlushQueue();
127		cookedCall = cb;
128	<	ccData = cd;
128	>	ccData = cb ? cd : NULL;
129		}
130		/// Set/change trace callback
131		void                    SetTraceCall(RayReportCall *cb, void *cd = NULL) {
132		traceCall = cb;
133	<	tcData = cd;
133	>	tcData = cb ? cd : NULL;
134		}
135		/// Are we ready?
136		bool                    Ready() const {

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)