1 files changed, 128 insertions, 0 deletions

diff --git a/source/blender/render/intern/raytrace/rayobject_internal.h b/source/blender/render/intern/raytrace/rayobject_internal.h
new file mode 100644
index 00000000000..6067be07c50
--- /dev/null
+++ b/source/blender/render/intern/raytrace/rayobject_internal.h
@@ -0,0 +1,128 @@
+
+#ifndef RE_RAYOBJECT_INTERNAL_H
+#define RE_RAYOBJECT_INTERNAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RayObjectControl
+ *
+ * This class is intended as a place holder for control, configuration of the
+ * rayobject like:
+ *	- stop building (TODO maybe when porting build to threads this could be
+ *    implemented with some thread_cancel function)
+ *  - max number of threads and threads callback to use during build
+ *	...
+ */	
+
+typedef int  (*RE_rayobjectcontrol_test_break_callback)(void *data);
+
+typedef struct RayObjectControl {
+	void *data;
+	RE_rayobjectcontrol_test_break_callback test_break;	
+} RayObjectControl;
+
+/* Returns true if for some reason a heavy processing function should stop
+ * (eg.: user asked to stop during a tree a build)
+ */
+
+int RE_rayobjectcontrol_test_break(RayObjectControl *c);
+
+/* RayObject
+	
+	A ray object is everything where we can cast rays like:
+		* a face/triangle
+		* an octree
+		* a bvh tree
+		* an octree of bvh's
+		* a bvh of bvh's
+	
+		
+	All types of RayObjects can be created by implementing the
+	callbacks of the RayObject.
+
+	Due to high computing time evolved with casting on faces
+	there is a special type of RayObject (named RayFace)
+	which won't use callbacks like other generic nodes.
+	
+	In order to allow a mixture of RayFace+RayObjects,
+	all RayObjects must be 4byte aligned, allowing us to use the
+	2 least significant bits (with the mask 0x03) to define the
+	type of RayObject.
+	
+	This leads to 4 possible types of RayObject:
+
+	 addr&3  - type of object
+		0		Self (reserved for each structure)
+		1     	RayFace (tri/quad primitive)
+		2		RayObject (generic with API callbacks)
+		3		VlakPrimitive
+				(vlak primitive - to be used when we have a vlak describing the data
+				 eg.: on render code)
+
+	0 means it's reserved and has it own meaning inside each ray acceleration structure
+	(this way each structure can use the allign offset to determine if a node represents a
+	 RayObject primitive, which can be used to save memory)
+ */
+
+/* used to test the type of ray object */
+#define RE_rayobject_isAligned(o)		((((intptr_t)o)&3) == 0)
+#define RE_rayobject_isRayFace(o)		((((intptr_t)o)&3) == 1)
+#define RE_rayobject_isRayAPI(o)		((((intptr_t)o)&3) == 2)
+#define RE_rayobject_isVlakPrimitive(o)	((((intptr_t)o)&3) == 3)
+
+/* used to align a given ray object */
+#define RE_rayobject_align(o)					((RayObject*)(((intptr_t)o)&(~3)))
+
+/* used to unalign a given ray object */
+#define RE_rayobject_unalignRayFace(o)			((RayObject*)(((intptr_t)o)|1))
+#define RE_rayobject_unalignRayAPI(o)			((RayObject*)(((intptr_t)o)|2))
+#define RE_rayobject_unalignVlakPrimitive(o)	((RayObject*)(((intptr_t)o)|3))
+
+/*
+ * This rayobject represents a generic object. With it's own callbacks for raytrace operations.
+ * It's suitable to implement things like LOD.
+ */
+
+struct RayObject {
+	struct RayObjectAPI *api;
+	struct RayObjectControl control;
+};
+
+typedef int  (*RE_rayobject_raycast_callback)(RayObject *, struct Isect *);
+typedef void (*RE_rayobject_add_callback)(RayObject *raytree, RayObject *rayobject);
+typedef void (*RE_rayobject_done_callback)(RayObject *);
+typedef void (*RE_rayobject_free_callback)(RayObject *);
+typedef void (*RE_rayobject_merge_bb_callback)(RayObject *, float *min, float *max);
+typedef float (*RE_rayobject_cost_callback)(RayObject *);
+typedef void (*RE_rayobject_hint_bb_callback)(RayObject *, struct RayHint *, float *, float *);
+
+typedef struct RayObjectAPI {
+	RE_rayobject_raycast_callback	raycast;
+	RE_rayobject_add_callback		add;
+	RE_rayobject_done_callback		done;
+	RE_rayobject_free_callback		free;
+	RE_rayobject_merge_bb_callback	bb;
+	RE_rayobject_cost_callback		cost;
+	RE_rayobject_hint_bb_callback	hint_bb;
+} RayObjectAPI;
+
+/*
+ * Returns the expected cost of raycast on this node, primitives have a cost of 1
+ */
+float RE_rayobject_cost(RayObject *r);
+
+/*
+ * This function differs from RE_rayobject_raycast
+ * RE_rayobject_intersect does NOT perform last-hit optimization
+ * So this is probably a function to call inside raytrace structures
+ */
+int RE_rayobject_intersect(RayObject *r, struct Isect *i);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+