copy of docs from 2.4x for python modules that have been kept
[blender-staging.git] / source / blender / render / intern / include / rayobject.h
index 19608fba262432a7feb88d57efa14fa01d04045f..309048d8efbb928e396743d826c1131d0bb91174 100644 (file)
@@ -35,6 +35,7 @@ extern "C" {
 
 #include "RE_raytrace.h"
 #include "render_types.h"
+#include <stdio.h>
 #include <float.h>
 
 
@@ -57,17 +58,18 @@ extern "C" {
        
        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 0x02) to define the
+       2 least significant bits (with the mask 0x03) to define the
        type of RayObject.
        
-       This leads to 4 possible types of RayObject, but at the moment
-       only 2 are used:
+       This leads to 4 possible types of RayObject:
 
-        addr&2  - type of object
+        addr&3  - type of object
                0               Self (reserved for each structure)
-               1       RayFace
+               1       RayFace (tri/quad primitive)
                2               RayObject (generic with API callbacks)
-               3               RayObject_Vlak
+               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
@@ -83,43 +85,29 @@ extern "C" {
 /* 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_unalignRayVlak(o)         ((RayObject*)(((intptr_t)o)|3))
+#define RE_rayobject_unalignVlakPrimitive(o)   ((RayObject*)(((intptr_t)o)|3))
 
 /* 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_isRayVlak(o)      ((((intptr_t)o)&3) == 3)
+#define RE_rayobject_isVlakPrimitive(o)        ((((intptr_t)o)&3) == 3)
 
 
-/*
- * This ray object represents faces directly from a given VlakRen structure.
- * Thus allowing to save memory, but making code dependant on render structures
-typedef struct RayVlak
-{
-       struct ObjectInstanceRen *ob;
-       struct VlakRen *face;
-} RayVlak;
- */
 
 /*
- * This ray object represents a triangle or a quad face.
- * All data needed to realize intersection is "localy" available.
- */
-typedef struct RayFace
+ * 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 RayObjectControl;
+struct RayObjectControl
 {
-       float v1[4], v2[4], v3[4], v4[3];
-       int quad;
-       void *ob;
-       void *face;
-       
-} RayFace;
-
-#define RE_rayface_isQuad(a) ((a)->quad)
-/* Loads a VlakRen on a RayFace */
-void RE_rayface_from_vlak(RayFace *face, ObjectInstanceRen *obi, VlakRen *vlr);
-
-
+       void *data;
+       RE_rayobjectcontrol_test_break_callback test_break;     
+};
 
 /*
  * This rayobject represents a generic object. With it's own callbacks for raytrace operations.
@@ -128,9 +116,13 @@ void RE_rayface_from_vlak(RayFace *face, ObjectInstanceRen *obi, VlakRen *vlr);
 struct RayObject
 {
        struct RayObjectAPI *api;
+
+       struct RayObjectControl control;
 };
 
 
+
+
 typedef int  (*RE_rayobject_raycast_callback)(RayObject *, Isect *);
 typedef void (*RE_rayobject_add_callback)(RayObject *raytree, RayObject *rayobject);
 typedef void (*RE_rayobject_done_callback)(RayObject *);
@@ -172,20 +164,24 @@ int RE_rayobject_bb_intersect_test(const Isect *i, const float *bb); /* same as
 float RE_rayobject_cost(RayObject *r);
 
 
+/*
+ * 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);
 
 
 #define ISECT_EPSILON ((float)FLT_EPSILON)
 
 
 
-#if !defined(_WIN32)
+#if !defined(_WIN32) && !defined(_WIN64)
 
 #include <sys/time.h>
 #include <time.h>
-#include <stdio.h>
 
 #define BENCH(a,name)  \
-       do {                    \
+       {                       \
                double _t1, _t2;                                \
                struct timeval _tstart, _tend;  \
                clock_t _clock_init = clock();  \
@@ -195,10 +191,10 @@ float RE_rayobject_cost(RayObject *r);
                _t1 = ( double ) _tstart.tv_sec + ( double ) _tstart.tv_usec/ ( 1000*1000 );    \
                _t2 = ( double )   _tend.tv_sec + ( double )   _tend.tv_usec/ ( 1000*1000 );    \
                printf("BENCH:%s: %fs (real) %fs (cpu)\n", #name, _t2-_t1, (float)(clock()-_clock_init)/CLOCKS_PER_SEC);\
-       } while(0)
+       }
 #else
 
-#define BENCH(a)       (a)
+#define BENCH(a,name)  (a)
 
 #endif