OOMeshToOctreeConverter.m File Reference

import "OOMeshToOctreeConverter.h"
import "OOMaths.h"
import "Octree.h"
import "OOLogging.h"

Include dependency graph for OOMeshToOctreeConverter.m:

Go to the source code of this file.

Macros
#define	DECL_GEOMETRY(NAME, CAP)

Typedefs
typedef struct OOMeshToOctreeConverterInternalData	GeometryData

Functions
OOINLINE void	InitGeometryData (GeometryData *data, uint_fast32_t capacity)
OOINLINE void	DestroyGeometryData (GeometryData *data)
OOINLINE void	AddTriangle (GeometryData *data, Triangle tri)
static NO_INLINE_FUNC void	AddTriangle_slow (GeometryData *data, Triangle tri)
static OOScalar	MaxDimensionFromOrigin (GeometryData *data)
void	BuildSubOctree (GeometryData *data, OOOctreeBuilder *builder, OOScalar halfWidth, NSUInteger depth)
static void	SplitGeometryX (GeometryData *data, GeometryData *dPlus, GeometryData *dMinus, OOScalar x)
static void	SplitGeometryY (GeometryData *data, GeometryData *dPlus, GeometryData *dMinus, OOScalar y)
static void	SplitGeometryZ (GeometryData *data, GeometryData *dPlus, GeometryData *dMinus, OOScalar z)
static void	TranslateGeometryX (GeometryData *data, OOScalar offset)
static void	TranslateGeometryY (GeometryData *data, OOScalar offset)
static void	TranslateGeometryZ (GeometryData *data, OOScalar offset)

Macro Definition Documentation

DECL_GEOMETRY

#define DECL_GEOMETRY	(		NAME,
			CAP )

Value:

GeometryData NAME; InitGeometryData(&NAME, CAP);

Referenced by BuildSubOctree().

Typedef Documentation

GeometryData

typedef struct OOMeshToOctreeConverterInternalData GeometryData

Definition at line 111 of file OOMeshToOctreeConverter.m.

Function Documentation

AddTriangle()

OOINLINE void AddTriangle	(	GeometryData *	data,
		Triangle	tri )

Definition at line 217 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    if (data->count < data->capacity)
    {
        data->triangles[data->count++] = tri;
    }
    else
    {
        AddTriangle_slow(data, tri);
    }
}

References AddTriangle_slow().

Referenced by SplitGeometryX(), SplitGeometryY(), and SplitGeometryZ().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTriangle_slow()

static NO_INLINE_FUNC void AddTriangle_slow ( GeometryData * data, Triangle tri )

static

Definition at line 903 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    NSCParameterAssert(data->count == data->capacity);
    
    if (data->capacity == kOOMeshToOctreeConverterSmallDataCapacity)
    {
        data->capacity = MAX(data->pendingCapacity, (uint_fast32_t)kOOMeshToOctreeConverterSmallDataCapacity * 2);
        data->triangles = malloc(data->capacity * sizeof(Triangle));
        memcpy(data->triangles, data->smallData, sizeof data->smallData);
    }
    else
    {
        // create more space by doubling the capacity of this geometry.
        data->capacity = 1 + data->capacity * 2;
        data->triangles = realloc(data->triangles, data->capacity * sizeof(Triangle));
        
        // N.b.: we leak here if realloc() failed, but we're about to abort anyway.
    }
    
    if (EXPECT_NOT(data->triangles == NULL))
    {
        OOLog(kOOLogAllocationFailure, @"%@", @"!!!!! Ran out of memory to allocate more geometry!");
        exit(EXIT_FAILURE);
    }
    
    data->triangles[data->count++] = tri;
}

Referenced by AddTriangle().

Here is the caller graph for this function:

BuildSubOctree()

void BuildSubOctree	(	GeometryData *	data,
		OOOctreeBuilder *	builder,
		OOScalar	halfWidth,
		NSUInteger	depth )

Definition at line 308 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    OOScalar subHalfWidth = 0.5f * halfWidth;
    
    if (data->count == 0)
    {
        // No geometry here.
        [builder writeEmpty];
        return;
    }
    
    if (halfWidth <= OCTREE_MIN_HALF_WIDTH || depth <= 0)
    {
        // Maximum resolution reached and not full.
        [builder writeSolid];
        return;
    }
 
    /*
        To avoid reallocations, we want a reasonably pessimistic estimate of
        sub-data size.
        
        This table shows observed performance for several heuristics using
        vanilla Oolite r5352 (plus instrumentation). Values aren't precisely
        reproducible, but are reasonably stable.
        
        Heuristic: expression used to initialize subCapacity.
        
        PER: number of geometries per reallocation; in other words, a realloc
             is needed one time per PER geometries.
        
        MEM: high water mark for total memory consumption (triangles arrays
             only) across all live Geometries.
        
        Heuristic                   PER         MEM
        n_triangles                 3-4         71856
        n_triangles * 2             100         111384
        MAX(n_triangles * 2, 16)    300         111384
        MAX(n_triangles * 2, 21)    500         148512
        n_triangles * 3             500         165744
        MAX(n_triangles * 3, 16)    12000       165744
        MAX(n_triangles * 3, 21)    20000       165744
        
        The value 21 was chosen for reasons which, on reflection, were entirely
        wrong. Performance profiling shows no discernible difference between
        2,16 and 3,21.
        
        As of r5374, up to 16 entries are stored on the stack and there is no
        benefit to specifying a minimum here any longer.
    */
    enum
    {
        kFactor = 2
    };
    uint_fast32_t subCapacity = data->count * kFactor;
    
#define DECL_GEOMETRY(NAME, CAP) GeometryData NAME; InitGeometryData(&NAME, CAP);
    
    DECL_GEOMETRY(g_000, subCapacity);
    DECL_GEOMETRY(g_001, subCapacity);
    DECL_GEOMETRY(g_010, subCapacity);
    DECL_GEOMETRY(g_011, subCapacity);
    DECL_GEOMETRY(g_100, subCapacity);
    DECL_GEOMETRY(g_101, subCapacity);
    DECL_GEOMETRY(g_110, subCapacity);
    DECL_GEOMETRY(g_111, subCapacity);
    
    DECL_GEOMETRY(g_xx1, subCapacity);
    DECL_GEOMETRY(g_xx0, subCapacity);
    
    SplitGeometryZ(data, &g_xx1, &g_xx0, subHalfWidth);
    if (g_xx0.count != 0)
    {
        DECL_GEOMETRY(g_x00, subCapacity);
        DECL_GEOMETRY(g_x10, subCapacity);
        
        SplitGeometryY(&g_xx0, &g_x10, &g_x00, subHalfWidth);
        if (g_x00.count != 0)
        {
            SplitGeometryX(&g_x00, &g_100, &g_000, subHalfWidth);
        }
        if (g_x10.count != 0)
        {
            SplitGeometryX(&g_x10, &g_110, &g_010, subHalfWidth);
        }
        DestroyGeometryData(&g_x00);
        DestroyGeometryData(&g_x10);
    }
    if (g_xx1.count != 0)
    {
        DECL_GEOMETRY(g_x01, subCapacity);
        DECL_GEOMETRY(g_x11, subCapacity);
        
        SplitGeometryY(&g_xx1, &g_x11, &g_x01, subHalfWidth);
        if (g_x01.count != 0)
        {
            SplitGeometryX(&g_x01, &g_101, &g_001, subHalfWidth);
        }
        if (g_x11.count != 0)
        {
            SplitGeometryX(&g_x11, &g_111, &g_011, subHalfWidth);
        }
        DestroyGeometryData(&g_x01);
        DestroyGeometryData(&g_x11);
    }
    DestroyGeometryData(&g_xx0);
    DestroyGeometryData(&g_xx1);
    
    [builder beginInnerNode];
    depth--;
    BuildSubOctree(&g_000, builder, subHalfWidth, depth);
    BuildSubOctree(&g_001, builder, subHalfWidth, depth);
    BuildSubOctree(&g_010, builder, subHalfWidth, depth);
    BuildSubOctree(&g_011, builder, subHalfWidth, depth);
    BuildSubOctree(&g_100, builder, subHalfWidth, depth);
    BuildSubOctree(&g_101, builder, subHalfWidth, depth);
    BuildSubOctree(&g_110, builder, subHalfWidth, depth);
    BuildSubOctree(&g_111, builder, subHalfWidth, depth);
    [builder endInnerNode];
    
    DestroyGeometryData(&g_000);
    DestroyGeometryData(&g_001);
    DestroyGeometryData(&g_010);
    DestroyGeometryData(&g_011);
    DestroyGeometryData(&g_100);
    DestroyGeometryData(&g_101);
    DestroyGeometryData(&g_110);
    DestroyGeometryData(&g_111);
}

References OOOctreeBuilder::beginInnerNode, BuildSubOctree(), DECL_GEOMETRY, DestroyGeometryData(), OOOctreeBuilder::endInnerNode, OCTREE_MIN_HALF_WIDTH, SplitGeometryX(), SplitGeometryY(), SplitGeometryZ(), OOOctreeBuilder::writeEmpty, and OOOctreeBuilder::writeSolid.

Referenced by BuildSubOctree().

Here is the call graph for this function:

Here is the caller graph for this function:

DestroyGeometryData()

OOINLINE void DestroyGeometryData

(

GeometryData *

data

)

Definition at line 196 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != 0 && data->capacity >= kOOMeshToOctreeConverterSmallDataCapacity);
    
#if OO_DEBUG
    Triangle * const kScribbleValue = (Triangle *)-1L;
    NSCAssert(data->triangles != kScribbleValue, @"Attempt to destroy a GeometryData twice.");
#endif
    
    if (data->capacity != kOOMeshToOctreeConverterSmallDataCapacity)
    {
        // If capacity is kOOMeshToOctreeConverterSmallDataCapacity, triangles points to smallData.
        free(data->triangles);
    }
    
#if OO_DEBUG
    data->triangles = kScribbleValue;
#endif
}

References kOOMeshToOctreeConverterSmallDataCapacity.

Referenced by BuildSubOctree().

Here is the caller graph for this function:

InitGeometryData()

void InitGeometryData	(	GeometryData *	data,
		uint_fast32_t	capacity )

Definition at line 185 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    data->count = 0;
    data->capacity = kOOMeshToOctreeConverterSmallDataCapacity;
    data->pendingCapacity = capacity;
    data->triangles = data->smallData;
}

References kOOMeshToOctreeConverterSmallDataCapacity.

MaxDimensionFromOrigin()

static OOScalar MaxDimensionFromOrigin ( GeometryData * data )

static

Definition at line 290 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    OOScalar        result = 0.0f;
    uint_fast32_t   i, j;
    for (i = 0; i < data->count; i++) for (j = 0; j < 3; j++)
    {
        Vector v = data->triangles[i].v[j];
        
        result = fmax(result, fabs(v.x));
        result = fmax(result, fabs(v.y));
        result = fmax(result, fabs(v.z));
    }
    return result;
}

SplitGeometryX()

static void SplitGeometryX ( GeometryData * data, GeometryData * dPlus, GeometryData * dMinus, OOScalar x )

static

Definition at line 489 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL && dPlus != NULL && dMinus != NULL);
    
    // test each triangle splitting against x == 0.0
    uint_fast32_t   i, count = data->count;
    for (i = 0; i < count; i++)
    {
        bool done_tri = false;
        Vector v0 = data->triangles[i].v[0];
        Vector v1 = data->triangles[i].v[1];
        Vector v2 = data->triangles[i].v[2];
        
        if (v0.x >= 0.0f && v1.x >= 0.0f && v2.x >= 0.0f)
        {
            AddTriangle(dPlus, data->triangles[i]);
            done_tri = true;
        }
        else if (v0.x <= 0.0f && v1.x <= 0.0f && v2.x <= 0.0f)
        {
            AddTriangle(dMinus, data->triangles[i]);
            done_tri = true;
        }
        if (!done_tri)  // triangle must cross x == 0.0
        {
            OOScalar i01, i12, i20;
            if (v0.x == v1.x)
                i01 = -1.0f;
            else
                i01 = v0.x / (v0.x - v1.x);
            if (v1.x == v2.x)
                i12 = -1.0f;
            else
                i12 = v1.x / (v1.x - v2.x);
            if (v2.x == v0.x)
                i20 = -1.0f;
            else
                i20 = v2.x / (v2.x - v0.x);
            
            Vector v01 = make_vector(0.0f, i01 * (v1.y - v0.y) + v0.y, i01 * (v1.z - v0.z) + v0.z);
            Vector v12 = make_vector(0.0f, i12 * (v2.y - v1.y) + v1.y, i12 * (v2.z - v1.z) + v1.z);
            Vector v20 = make_vector(0.0f, i20 * (v0.y - v2.y) + v2.y, i20 * (v0.z - v2.z) + v2.z);
        
            // cases where a vertex is on the split.
            if (v0.x == 0.0f)
            {
                if (v1.x > 0)
                {
                    AddTriangle(dPlus, make_triangle(v0, v1, v12));
                    AddTriangle(dMinus, make_triangle(v0, v12, v2));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v0, v1, v12));
                    AddTriangle(dPlus, make_triangle(v0, v12, v2));
                }
            }
            if (v1.x == 0.0f)
            {
                if (v2.x > 0)
                {
                    AddTriangle(dPlus, make_triangle(v1, v2, v20));
                    AddTriangle(dMinus, make_triangle(v1, v20, v0));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v1, v2, v20));
                    AddTriangle(dPlus, make_triangle(v1, v20, v0));
                }
            }
            if (v2.x == 0.0f)
            {
                if (v0.x > 0)
                {
                    AddTriangle(dPlus, make_triangle(v2, v0, v01));
                    AddTriangle(dMinus, make_triangle(v2, v01, v1));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v2, v0, v01));
                    AddTriangle(dPlus, make_triangle(v2, v01, v1));
                }
            }
            
            if (v0.x > 0.0f && v1.x > 0.0f && v2.x < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v0, v12, v20));
                AddTriangle(dPlus, make_triangle(v0, v1, v12));
                AddTriangle(dMinus, make_triangle(v20, v12, v2));
            }
            
            if (v0.x > 0.0f && v1.x < 0.0f && v2.x > 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v2, v01, v12));
                AddTriangle(dPlus, make_triangle(v2, v0, v01));
                AddTriangle(dMinus, make_triangle(v12, v01, v1));
            }
            
            if (v0.x > 0.0f && v1.x < 0.0f && v2.x < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v20, v0, v01));
                AddTriangle(dMinus, make_triangle(v2, v20, v1));
                AddTriangle(dMinus, make_triangle(v20, v01, v1));
            }
            
            if (v0.x < 0.0f && v1.x > 0.0f && v2.x > 0.0f)
            {
                AddTriangle(dMinus, make_triangle(v01, v20, v0));
                AddTriangle(dPlus, make_triangle(v1, v20, v01));
                AddTriangle(dPlus, make_triangle(v1, v2, v20));
            }
            
            if (v0.x < 0.0f && v1.x > 0.0f && v2.x < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v01, v1, v12));
                AddTriangle(dMinus, make_triangle(v0, v01, v2));
                AddTriangle(dMinus, make_triangle(v01, v12, v2));
            }
            
            if (v0.x < 0.0f && v1.x < 0.0f && v2.x > 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v12, v2, v20));
                AddTriangle(dMinus, make_triangle(v1, v12, v0));
                AddTriangle(dMinus, make_triangle(v12, v20, v0));
            }
        }
    }
    TranslateGeometryX(dPlus, -x);
    TranslateGeometryX(dMinus, x);
}

References AddTriangle(), count, TranslateGeometryX(), and x.

Referenced by BuildSubOctree().

Here is the call graph for this function:

Here is the caller graph for this function:

SplitGeometryY()

static void SplitGeometryY ( GeometryData * data, GeometryData * dPlus, GeometryData * dMinus, OOScalar y )

static

Definition at line 621 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL && dPlus != NULL && dMinus != NULL);
    
    // test each triangle splitting against y == 0.0
    uint_fast32_t   i, count = data->count;
    for (i = 0; i < count; i++)
    {
        bool done_tri = false;
        Vector v0 = data->triangles[i].v[0];
        Vector v1 = data->triangles[i].v[1];
        Vector v2 = data->triangles[i].v[2];
 
        if (v0.y >= 0.0f && v1.y >= 0.0f && v2.y >= 0.0f)
        {
            AddTriangle(dPlus, data->triangles[i]);
            done_tri = true;
        }
        if (v0.y <= 0.0f && v1.y <= 0.0f && v2.y <= 0.0f)
        {
            AddTriangle(dMinus, data->triangles[i]);
            done_tri = true;
        }
        if (!done_tri)  // triangle must cross y == 0.0
        {
            OOScalar i01, i12, i20;
            
            if (v0.y == v1.y)
                i01 = -1.0f;
            else
                i01 = v0.y / (v0.y - v1.y);
            if (v1.y == v2.y)
                i12 = -1.0f;
            else
                i12 = v1.y / (v1.y - v2.y);
            if (v2.y == v0.y)
                i20 = -1.0f;
            else
                i20 = v2.y / (v2.y - v0.y);
            
            Vector v01 = make_vector(i01 * (v1.x - v0.x) + v0.x, 0.0f, i01 * (v1.z - v0.z) + v0.z);
            Vector v12 = make_vector(i12 * (v2.x - v1.x) + v1.x, 0.0f, i12 * (v2.z - v1.z) + v1.z);
            Vector v20 = make_vector(i20 * (v0.x - v2.x) + v2.x, 0.0f, i20 * (v0.z - v2.z) + v2.z);
            
            // cases where a vertex is on the split.
            if (v0.y == 0.0f)
            {
                if (v1.y > 0)
                {
                    AddTriangle(dPlus, make_triangle(v0, v1, v12));
                    AddTriangle(dMinus, make_triangle(v0, v12, v2));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v0, v1, v12));
                    AddTriangle(dPlus, make_triangle(v0, v12, v2));
                }
            }
            if (v1.y == 0.0f)
            {
                if (v2.y > 0)
                {
                    AddTriangle(dPlus, make_triangle(v1, v2, v20));
                    AddTriangle(dMinus, make_triangle(v1, v20, v0));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v1, v2, v20));
                    AddTriangle(dPlus, make_triangle(v1, v20, v0));
                }
            }
            if (v2.y == 0.0f)
            {
                if (v0.y > 0)
                {
                    AddTriangle(dPlus, make_triangle(v2, v0, v01));
                    AddTriangle(dMinus, make_triangle(v2, v01, v1));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v2, v0, v01));
                    AddTriangle(dPlus, make_triangle(v2, v01, v1));
                }
            }
            
            if (v0.y > 0.0f && v1.y > 0.0f && v2.y < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v0, v12, v20));
                AddTriangle(dPlus, make_triangle(v0, v1, v12));
                AddTriangle(dMinus, make_triangle(v20, v12, v2));
            }
            
            if (v0.y > 0.0f && v1.y < 0.0f && v2.y > 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v2, v01, v12));
                AddTriangle(dPlus, make_triangle(v2, v0, v01));
                AddTriangle(dMinus, make_triangle(v12, v01, v1));
            }
            
            if (v0.y > 0.0f && v1.y < 0.0f && v2.y < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v20, v0, v01));
                AddTriangle(dMinus, make_triangle(v2, v20, v1));
                AddTriangle(dMinus, make_triangle(v20, v01, v1));
            }
            
            if (v0.y < 0.0f && v1.y > 0.0f && v2.y > 0.0f)
            {
                AddTriangle(dMinus, make_triangle(v01, v20, v0));
                AddTriangle(dPlus, make_triangle(v1, v20, v01));
                AddTriangle(dPlus, make_triangle(v1, v2, v20));
            }
            
            if (v0.y < 0.0f && v1.y > 0.0f && v2.y < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v01, v1, v12));
                AddTriangle(dMinus, make_triangle(v0, v01, v2));
                AddTriangle(dMinus, make_triangle(v01, v12, v2));
            }
            
            if (v0.y < 0.0f && v1.y < 0.0f && v2.y > 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v12, v2, v20));
                AddTriangle(dMinus, make_triangle(v1, v12, v0));
                AddTriangle(dMinus, make_triangle(v12, v20, v0));
            }           
        }
    }
    TranslateGeometryY(dPlus, -y);
    TranslateGeometryY(dMinus, y);
}

References AddTriangle(), count, TranslateGeometryY(), and y.

Referenced by BuildSubOctree().

Here is the call graph for this function:

Here is the caller graph for this function:

SplitGeometryZ()

static void SplitGeometryZ ( GeometryData * data, GeometryData * dPlus, GeometryData * dMinus, OOScalar z )

static

Definition at line 754 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL && dPlus != NULL && dMinus != NULL);
    
    // test each triangle splitting against z == 0.0
    uint_fast32_t   i, count = data->count;
    for (i = 0; i < count; i++)
    {
        bool done_tri = false;
        Vector v0 = data->triangles[i].v[0];
        Vector v1 = data->triangles[i].v[1];
        Vector v2 = data->triangles[i].v[2];
        
        if (v0.z >= 0.0f && v1.z >= 0.0f && v2.z >= 0.0f)
        {
            AddTriangle(dPlus, data->triangles[i]);
            done_tri = true;
        }
        else if (v0.z <= 0.0f && v1.z <= 0.0f && v2.z <= 0.0f)
        {
            AddTriangle(dMinus, data->triangles[i]);
            done_tri = true;
        }
        if (!done_tri)  // triangle must cross z == 0.0
        {
            OOScalar i01, i12, i20;
            
            if (v0.z == v1.z)
                i01 = -1.0f;
            else
                i01 = v0.z / (v0.z - v1.z);
            if (v1.z == v2.z)
                i12 = -1.0f;
            else
                i12 = v1.z / (v1.z - v2.z);
            if (v2.z == v0.z)
                i20 = -1.0f;
            else
                i20 = v2.z / (v2.z - v0.z);
            
            Vector v01 = make_vector(i01 * (v1.x - v0.x) + v0.x, i01 * (v1.y - v0.y) + v0.y, 0.0f);
            Vector v12 = make_vector(i12 * (v2.x - v1.x) + v1.x, i12 * (v2.y - v1.y) + v1.y, 0.0f);
            Vector v20 = make_vector(i20 * (v0.x - v2.x) + v2.x, i20 * (v0.y - v2.y) + v2.y, 0.0f);
        
            // cases where a vertex is on the split.
            if (v0.z == 0.0f)
            {
                if (v1.z > 0)
                {
                    AddTriangle(dPlus, make_triangle(v0, v1, v12));
                    AddTriangle(dMinus, make_triangle(v0, v12, v2));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v0, v1, v12));
                    AddTriangle(dPlus, make_triangle(v0, v12, v2));
                }
            }
            if (v1.z == 0.0f)
            {
                if (v2.z > 0)
                {
                    AddTriangle(dPlus, make_triangle(v1, v2, v20));
                    AddTriangle(dMinus, make_triangle(v1, v20, v0));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v1, v2, v20));
                    AddTriangle(dPlus, make_triangle(v1, v20, v0));
                }
            }
            if (v2.z == 0.0f)
            {
                if (v0.z > 0)
                {
                    AddTriangle(dPlus, make_triangle(v2, v0, v01));
                    AddTriangle(dMinus, make_triangle(v2, v01, v1));
                }
                else
                {
                    AddTriangle(dMinus, make_triangle(v2, v0, v01));
                    AddTriangle(dPlus, make_triangle(v2, v01, v1));
                }
            }
            
            if (v0.z > 0.0f && v1.z > 0.0f && v2.z < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v0, v12, v20));
                AddTriangle(dPlus, make_triangle(v0, v1, v12));
                AddTriangle(dMinus, make_triangle(v20, v12, v2));
            }
            
            if (v0.z > 0.0f && v1.z < 0.0f && v2.z > 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v2, v01, v12));
                AddTriangle(dPlus, make_triangle(v2, v0, v01));
                AddTriangle(dMinus, make_triangle(v12, v01, v1));
            }
            
            if (v0.z > 0.0f && v1.z < 0.0f && v2.z < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v20, v0, v01));
                AddTriangle(dMinus, make_triangle(v2, v20, v1));
                AddTriangle(dMinus, make_triangle(v20, v01, v1));
            }
            
            if (v0.z < 0.0f && v1.z > 0.0f && v2.z > 0.0f)
            {
                AddTriangle(dMinus, make_triangle(v01, v20, v0));
                AddTriangle(dPlus, make_triangle(v1, v20, v01));
                AddTriangle(dPlus, make_triangle(v1, v2, v20));
            }
            
            if (v0.z < 0.0f && v1.z > 0.0f && v2.z < 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v01, v1, v12));
                AddTriangle(dMinus, make_triangle(v0, v01, v2));
                AddTriangle(dMinus, make_triangle(v01, v12, v2));
            }
            
            if (v0.z < 0.0f && v1.z < 0.0f && v2.z > 0.0f)
            {
                AddTriangle(dPlus, make_triangle(v12, v2, v20));
                AddTriangle(dMinus, make_triangle(v1, v12, v0));
                AddTriangle(dMinus, make_triangle(v12, v20, v0));
            }
        }
    }
    TranslateGeometryZ(dPlus, -z);
    TranslateGeometryZ(dMinus, z);
}

References AddTriangle(), count, and TranslateGeometryZ().

Referenced by BuildSubOctree().

Here is the call graph for this function:

Here is the caller graph for this function:

TranslateGeometryX()

static void TranslateGeometryX ( GeometryData * data, OOScalar offset )

static

Definition at line 441 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    // Optimization note: offset is never zero, so no early return.
    
    uint_fast32_t i, count = data->count;
    for (i = 0; i < count; i++)
    {
        data->triangles[i].v[0].x += offset;
        data->triangles[i].v[1].x += offset;
        data->triangles[i].v[2].x += offset;
    }
}

References count.

Referenced by SplitGeometryX().

Here is the caller graph for this function:

TranslateGeometryY()

static void TranslateGeometryY ( GeometryData * data, OOScalar offset )

static

Definition at line 457 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    // Optimization note: offset is never zero, so no early return.
    
    uint_fast32_t i, count = data->count;
    for (i = 0; i < count; i++)
    {
        data->triangles[i].v[0].y += offset;
        data->triangles[i].v[1].y += offset;
        data->triangles[i].v[2].y += offset;
    }
}

References count.

Referenced by SplitGeometryY().

Here is the caller graph for this function:

TranslateGeometryZ()

static void TranslateGeometryZ ( GeometryData * data, OOScalar offset )

static

Definition at line 473 of file OOMeshToOctreeConverter.m.

{
    NSCParameterAssert(data != NULL);
    
    // Optimization note: offset is never zero, so no early return.
    
    uint_fast32_t i, count = data->count;
    for (i = 0; i < count; i++)
    {
        data->triangles[i].v[0].z += offset;
        data->triangles[i].v[1].z += offset;
        data->triangles[i].v[2].z += offset;
    }
}

References count.

Referenced by SplitGeometryZ().

Here is the caller graph for this function: