OOMesh(Private) Category Reference

Inheritance diagram for OOMesh(Private):

Collaboration diagram for OOMesh(Private):

Instance Methods
(id)	- initWithName:cacheKey:materialDictionary:shadersDictionary:smooth:shaderMacros:shaderBindingTarget:scaleFactor:cacheWriteable:
(BOOL)	- loadData:scaleFactor:
(void)	- checkNormalsAndAdjustWinding
(void)	- generateFaceTangents
(void)	- calculateVertexNormalsAndTangentsWithFaceRefs:
(void)	- calculateVertexTangentsWithFaceRefs:
(void)	- deleteDisplayLists
(NSDictionary *)	- modelData
(BOOL)	- setModelFromModelData:name:
(void)	- getNormal:andTangent:forVertex:inSmoothGroup:
(BOOL)	- setUpVertexArrays
(void)	- calculateBoundingVolumes
(void)	- rescaleByFactor:
(void)	- debugDrawNormals
(void)	- setRetainedObject:forKey:
(void *)	- allocateBytesWithSize:count:key:
(BOOL)	- allocateVertexBuffersWithCount:
(BOOL)	- allocateNormalBuffersWithCount:
(BOOL)	- allocateFaceBuffersWithCount:
(BOOL)	- allocateVertexArrayBuffersWithCount:
(void)	- renameTexturesFrom:to:
(id)	- mutableCopyWithZone: [implementation]
(void)	- resetGraphicsState [implementation]
(BoundingBox)	- boundingBox [implementation]

Class Methods
(static float)	+ FaceArea [implementation]
(static float)	+ FaceAreaCorrect [implementation]

Detailed Description

Definition at line 130 of file OOMesh.m.

Method Documentation

allocateBytesWithSize:count:key:

- (void *) allocateBytesWithSize:		(size_t)	size
count:		(NSUInteger)	count
key:		(NSString *)	key

Extends class OOMesh.

Definition at line 2141 of file OOMesh.m.

                                :(size_t)size count:(NSUInteger)count key:(NSString *)key
{
    if (count == 0) { count=1; }
    size *= count;
    void *bytes = malloc(size);
    if (bytes != NULL)
    {
        Scribble(bytes, size);
        NSData *holder = [NSData dataWithBytesNoCopy:bytes length:size freeWhenDone:YES];
        [self setRetainedObject:holder forKey:key];
    }
    return bytes;
}

References count, Scribble, and OOMesh::setRetainedObject:forKey:.

Here is the call graph for this function:

allocateFaceBuffersWithCount:

- (BOOL) allocateFaceBuffersWithCount:

(NSUInteger)

count

Extends class OOMesh.

Definition at line 2171 of file OOMesh.m.

                                     :(NSUInteger)count
{
    _faces = [self allocateBytesWithSize:sizeof *_faces count:faceCount key:@"faces"];
    return  _faces != NULL;
}

References OOMesh::allocateBytesWithSize:count:key:.

Here is the call graph for this function:

allocateNormalBuffersWithCount:

- (BOOL) allocateNormalBuffersWithCount:

(NSUInteger)

count

Extends class OOMesh.

Definition at line 2163 of file OOMesh.m.

                                       :(NSUInteger)count
{
    _normals = [self allocateBytesWithSize:sizeof *_normals count:vertexCount key:@"normals"];
    _tangents = [self allocateBytesWithSize:sizeof *_tangents count:vertexCount key:@"tangents"];
    return _normals != NULL && _tangents != NULL;
}

References OOMesh::allocateBytesWithSize:count:key:.

Here is the call graph for this function:

allocateVertexArrayBuffersWithCount:

- (BOOL) allocateVertexArrayBuffersWithCount:

(NSUInteger)

count

Extends class OOMesh.

Definition at line 2178 of file OOMesh.m.

                                            :(NSUInteger)count
{
    _displayLists.indexArray = [self allocateBytesWithSize:sizeof *_displayLists.indexArray count:count * 3 key:@"indexArray"];
    _displayLists.textureUVArray = [self allocateBytesWithSize:sizeof *_displayLists.textureUVArray count:count * 6 key:@"textureUVArray"];
    _displayLists.vertexArray = [self allocateBytesWithSize:sizeof *_displayLists.vertexArray count:count * 3 key:@"vertexArray"];
    _displayLists.normalArray = [self allocateBytesWithSize:sizeof *_displayLists.normalArray count:count * 3 key:@"normalArray"];
    _displayLists.tangentArray = [self allocateBytesWithSize:sizeof *_displayLists.tangentArray count:count * 3 key:@"tangentArray"];
    
    return  _faces != NULL &&
            _displayLists.indexArray != NULL &&
            _displayLists.textureUVArray != NULL &&
            _displayLists.vertexArray != NULL &&
            _displayLists.normalArray != NULL &&
            _displayLists.tangentArray != NULL;
}

References OOMesh::allocateBytesWithSize:count:key:.

Here is the call graph for this function:

allocateVertexBuffersWithCount:

- (BOOL) allocateVertexBuffersWithCount:

(NSUInteger)

count

Extends class OOMesh.

Definition at line 2156 of file OOMesh.m.

                                       :(NSUInteger)count
{
    _vertices = [self allocateBytesWithSize:sizeof *_vertices count:vertexCount key:@"vertices"];
    return _vertices != NULL;
}

References OOMesh::allocateBytesWithSize:count:key:.

Here is the call graph for this function:

boundingBox

- (BoundingBox) boundingBox

implementation

Extends class OOMesh.

Definition at line 2048 of file OOMesh.m.

{
    return boundingBox;
}

References boundingBox.

Referenced by boundingBox, calculateBoundingVolumes, OOMesh::octreeDepth, and OOMesh::suppressClangStuff.

Here is the call graph for this function:

Here is the caller graph for this function:

calculateBoundingVolumes

- (void) calculateBoundingVolumes

Extends class OOMesh.

Definition at line 1982 of file OOMesh.m.

{
    OOJS_PROFILE_ENTER
    
    OOMeshVertexCount  i;
    float               d_squared, length_longest_axis, length_shortest_axis;
    GLfloat             result;
    
    result = 0.0f;
    if (vertexCount)  bounding_box_reset_to_vector(&boundingBox, _vertices[0]);
    else  bounding_box_reset(&boundingBox);
 
    for (i = 0; i < vertexCount; i++)
    {
        d_squared = magnitude2(_vertices[i]);
        if (d_squared > result)  result = d_squared;
        bounding_box_add_vector(&boundingBox, _vertices[i]);
    }
 
    length_longest_axis = boundingBox.max.x - boundingBox.min.x;
    if (boundingBox.max.y - boundingBox.min.y > length_longest_axis)
        length_longest_axis = boundingBox.max.y - boundingBox.min.y;
    if (boundingBox.max.z - boundingBox.min.z > length_longest_axis)
        length_longest_axis = boundingBox.max.z - boundingBox.min.z;
 
    length_shortest_axis = boundingBox.max.x - boundingBox.min.x;
    if (boundingBox.max.y - boundingBox.min.y < length_shortest_axis)
        length_shortest_axis = boundingBox.max.y - boundingBox.min.y;
    if (boundingBox.max.z - boundingBox.min.z < length_shortest_axis)
        length_shortest_axis = boundingBox.max.z - boundingBox.min.z;
 
    d_squared = (length_longest_axis + length_shortest_axis) * (length_longest_axis + length_shortest_axis) * 0.25; // square of average length
    maxDrawDistance = d_squared * NO_DRAW_DISTANCE_FACTOR * NO_DRAW_DISTANCE_FACTOR;  // no longer based on the collision radius
    
    collisionRadius = sqrtf(result);
    
    OOJS_PROFILE_EXIT_VOID
}

References boundingBox, calculateBoundingVolumes, NO_DRAW_DISTANCE_FACTOR, OOJS_PROFILE_ENTER, and OOJS_PROFILE_EXIT_VOID.

Referenced by calculateBoundingVolumes.

Here is the call graph for this function:

Here is the caller graph for this function:

calculateVertexNormalsAndTangentsWithFaceRefs:

- (void) calculateVertexNormalsAndTangentsWithFaceRefs:

(VertexFaceRef *)

faceRefs

Extends class OOMesh.

Definition at line 1749 of file OOMesh.m.

                                                      :(VertexFaceRef *)faceRefs
{
    OOJS_PROFILE_ENTER
    
    NSParameterAssert(faceRefs != NULL);
    
    NSUInteger  i,j;
    float       triangle_area[faceCount];
    
    NSAssert1(_normals != NULL && _tangents != NULL, @"Normal/tangent buffers not allocated in %s", __PRETTY_FUNCTION__);
    
    for (i = 0 ; i < faceCount; i++)
    {
        triangle_area[i] = FaceArea(_faces[i].vertex, _vertices);
    }
    for (i = 0; i < vertexCount; i++)
    {
        Vector normal_sum = kZeroVector;
        Vector tangent_sum = kZeroVector;
        
        VertexFaceRef *vfr = &faceRefs[i];
        NSUInteger fIter, fCount = VFRGetCount(vfr);
        for (fIter = 0; fIter < fCount; fIter++)
        {
            j = VFRGetFaceAtIndex(vfr, fIter);
            
            float t = triangle_area[j]; // weight sum by area
            normal_sum = vector_add(normal_sum, vector_multiply_scalar(_faces[j].normal, t));
            tangent_sum = vector_add(tangent_sum, vector_multiply_scalar(_faces[j].tangent, t));
        }
        
        normal_sum = vector_normal_or_fallback(normal_sum, kBasisZVector);
        tangent_sum = vector_subtract(tangent_sum, vector_multiply_scalar(normal_sum, dot_product(tangent_sum, normal_sum)));
        tangent_sum = vector_normal_or_fallback(tangent_sum, kBasisXVector);
        
        _normals[i] = normal_sum;
        _tangents[i] = tangent_sum;
    }
    
    OOJS_PROFILE_EXIT_VOID
}

References FaceArea, kBasisXVector, kBasisZVector, kZeroVector, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT_VOID, VFRGetCount(), and VFRGetFaceAtIndex().

Here is the call graph for this function:

calculateVertexTangentsWithFaceRefs:

- (void) calculateVertexTangentsWithFaceRefs:

(VertexFaceRef *)

faceRefs

Extends class OOMesh.

Definition at line 1808 of file OOMesh.m.

                                            :(VertexFaceRef *)faceRefs
{
    OOJS_PROFILE_ENTER
    
    NSParameterAssert(faceRefs != NULL);
    
    /*  This is conceptually broken.
        At the moment, it's calculating one tangent per "input" vertex. It should
        be calculating one tangent per "real" vertex, where a "real" vertex is
        defined as a combination of position, normal, material and texture
        coordinates.
        Currently, we don't have a format with unique "real" vertices.
        This basically means explicit-normal models without explicit tangents
        can't usefully be normal mapped.
        I don't intend to do anything about this pre-MSNR, although it might be
        possible to fix it by moving tangent generation to the same stage as
        smooth-grouped normal generation.
        -- Ahruman 2010-05-22
    */
    NSUInteger  i,j;
    float   triangle_area[faceCount];
    for (i = 0 ; i < faceCount; i++)
    {
        triangle_area[i] = FaceAreaCorrect(_faces[i].vertex, _vertices);
    }
    for (i = 0; i < vertexCount; i++)
    {
        Vector tangent_sum = kZeroVector;
        
        VertexFaceRef *vfr = &faceRefs[i];
        NSUInteger fIter, fCount = VFRGetCount(vfr);
        for (fIter = 0; fIter < fCount; fIter++)
        {
            j = VFRGetFaceAtIndex(vfr, fIter);
            
            float t = triangle_area[j]; // weight sum by area
            tangent_sum = vector_add(tangent_sum, vector_multiply_scalar(_faces[j].tangent, t));
        }
        
        tangent_sum = vector_subtract(tangent_sum, vector_multiply_scalar(_normals[i], dot_product(_normals[i], tangent_sum)));
        tangent_sum = vector_normal_or_fallback(tangent_sum, kBasisXVector);
        
        _tangents[i] = tangent_sum;
    }
    
    OOJS_PROFILE_EXIT_VOID
}

References FaceAreaCorrect, kBasisXVector, kZeroVector, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT_VOID, VFRGetCount(), and VFRGetFaceAtIndex().

Here is the call graph for this function:

checkNormalsAndAdjustWinding

- (void) checkNormalsAndAdjustWinding

Extends class OOMesh.

Definition at line 1647 of file OOMesh.m.

{
    OOJS_PROFILE_ENTER
    
    Vector              calculatedNormal;
    OOMeshFaceCount      i;
    
    NSParameterAssert(_normalMode != kNormalModeExplicit);
    
    for (i = 0; i < faceCount; i++)
    {
        Vector v0, v1, v2, norm;
        v0 = _vertices[_faces[i].vertex[0]];
        v1 = _vertices[_faces[i].vertex[1]];
        v2 = _vertices[_faces[i].vertex[2]];
        norm = _faces[i].normal;
        
        calculatedNormal = normal_to_surface(v2, v1, v0);
        if (vector_equal(norm, kZeroVector))
        {
            norm = vector_flip(calculatedNormal);
            _faces[i].normal = norm;
        }
        
        /*  FIXME: for 2.0, either require explicit normals for every model
            or change to: if (dot_product(norm, calculatedNormal) < 0.0f)
            -- Ahruman 2010-01-23
        */
        if (norm.x * calculatedNormal.x < 0 || norm.y * calculatedNormal.y < 0 || norm.z * calculatedNormal.z < 0)
        {
            // normal lies in the WRONG direction!
            // reverse the winding
            int v0 = _faces[i].vertex[0];
            _faces[i].vertex[0] = _faces[i].vertex[2];
            _faces[i].vertex[2] = v0;
            
            GLfloat f0 = _faces[i].s[0];
            _faces[i].s[0] = _faces[i].s[2];
            _faces[i].s[2] = f0;
            
            f0 = _faces[i].t[0];
            _faces[i].t[0] = _faces[i].t[2];
            _faces[i].t[2] = f0;
        }
    }
    
    OOJS_PROFILE_EXIT_VOID
}

References checkNormalsAndAdjustWinding, kNormalModeExplicit, kZeroVector, OOJS_PROFILE_ENTER, and OOJS_PROFILE_EXIT_VOID.

Referenced by checkNormalsAndAdjustWinding.

Here is the call graph for this function:

Here is the caller graph for this function:

debugDrawNormals

- (void) debugDrawNormals

Extends class OOMesh.

Definition at line 2055 of file OOMesh.m.

{
    GLuint              i;
    Vector              v, n, t, b;
    float               length, blend;
    GLfloat             color[3];
    OODebugWFState      state;
    
    OO_ENTER_OPENGL();
    
    state = OODebugBeginWireframe(NO);
    
    // Draw
    OOGLBEGIN(GL_LINES);
    for (i = 0; i < _displayLists.count; ++i)
    {
        v = _displayLists.vertexArray[i];
        n = _displayLists.normalArray[i];
        t = _displayLists.tangentArray[i];
        b = true_cross_product(n, t);
        
        // Draw normal
        length = magnitude2(n);
        blend = fabs(length - 1) * 5.0;
        color[0] = MIN(blend, 1.0f);
        color[1] = 1.0f - color[0];
        color[2] = color[1];
        glColor3fv(color);
        
        glVertex3f(v.x, v.y, v.z);
        scale_vector(&n, 5.0f);
        n = vector_add(n, v);
        glVertex3f(n.x, n.y, n.z);
        
        // Draw tangent
        glColor3f(1.0f, 1.0f, 0.0f);
        t = vector_add(v, vector_multiply_scalar(t, 3.0f));
        glVertex3f(v.x, v.y, v.z);
        glVertex3f(t.x, t.y, t.z);
        
        // Draw bitangent
        glColor3f(0.0f, 1.0f, 0.0f);
        b = vector_add(v, vector_multiply_scalar(b, 3.0f));
        glVertex3f(v.x, v.y, v.z);
        glVertex3f(b.x, b.y, b.z);
    }
    OOGLEND();
    
    OODebugEndWireframe(state);
}

References debugDrawNormals, MIN, OO_ENTER_OPENGL, OODebugBeginWireframe(), OODebugEndWireframe(), OOGLBEGIN, and OOGLEND.

Referenced by debugDrawNormals.

Here is the call graph for this function:

Here is the caller graph for this function:

deleteDisplayLists

- (void) deleteDisplayLists

Extends class OOMesh.

Definition at line 976 of file OOMesh.m.

{
    if (listsReady)
    {
        OO_ENTER_OPENGL();
        
        OOGL(glDeleteLists(displayList0, materialCount));
        listsReady = NO;
    }
}

References deleteDisplayLists, OO_ENTER_OPENGL, and OOGL.

Referenced by deleteDisplayLists.

Here is the call graph for this function:

Here is the caller graph for this function:

FaceArea

+ (static float) FaceArea (GLuint *) vertIndices (Vector *) vertices

implementation

Extends class OOMesh.

Definition at line 1739 of file OOMesh.m.

{
    /*  Calculate areas using Heron's formula.  */
    float   a2 = distance2(vertices[vertIndices[0]], vertices[vertIndices[1]]);
    float   b2 = distance2(vertices[vertIndices[1]], vertices[vertIndices[2]]);
    float   c2 = distance2(vertices[vertIndices[2]], vertices[vertIndices[0]]);
    return sqrt((2.0f * (a2 * b2 + b2 * c2 + c2 * a2) - (a2 * a2 + b2 * b2 +c2 * c2)) * 0.0625f);
}

Referenced by calculateVertexNormalsAndTangentsWithFaceRefs:, and getNormal:andTangent:forVertex:inSmoothGroup:.

Here is the caller graph for this function:

FaceAreaCorrect

+ (static float) FaceAreaCorrect (GLuint *) vertIndices (Vector *) vertices

implementation

Extends class OOMesh.

Definition at line 1792 of file OOMesh.m.

{
    /*  Calculate area of triangle.
        The magnitude of the cross product of two vectors is the area of
        the parallelogram they span. The area of a triangle is half the
        area of a parallelogram sharing two of its sides.
        Since we only use the area of the triangle as a weight factor,
        constant terms are irrelevant, so we don't bother halving the
        value.
    */
    Vector AB = vector_subtract(vertices[vertIndices[1]], vertices[vertIndices[0]]);
    Vector AC = vector_subtract(vertices[vertIndices[2]], vertices[vertIndices[0]]);
    return magnitude(true_cross_product(AB, AC));
}

Referenced by calculateVertexTangentsWithFaceRefs:.

Here is the caller graph for this function:

generateFaceTangents

- (void) generateFaceTangents

Extends class OOMesh.

Definition at line 1697 of file OOMesh.m.

{
    OOJS_PROFILE_ENTER
    
    OOMeshFaceCount  i;
    for (i = 0; i < faceCount; i++)
    {
        OOMeshFace *face = _faces + i;
        
        /*  Generate tangents, i.e. vectors that run in the direction of the s
            texture coordinate. Based on code I found in a forum somewhere and
            then lost track of. Sorry to whomever I should be crediting.
            -- Ahruman 2008-11-23
        */
        Vector vAB = vector_subtract(_vertices[face->vertex[1]], _vertices[face->vertex[0]]);
        Vector vAC = vector_subtract(_vertices[face->vertex[2]], _vertices[face->vertex[0]]);
        Vector nA = face->normal;
        
        // projAB = aB - (nA . vAB) * nA
        Vector vProjAB = vector_subtract(vAB, vector_multiply_scalar(nA, dot_product(nA, vAB)));
        Vector vProjAC = vector_subtract(vAC, vector_multiply_scalar(nA, dot_product(nA, vAC)));
        
        // delta s/t
        GLfloat dsAB = face->s[1] - face->s[0];
        GLfloat dsAC = face->s[2] - face->s[0];
        GLfloat dtAB = face->t[1] - face->t[0];
        GLfloat dtAC = face->t[2] - face->t[0];
        
        if (dsAC * dtAB > dsAB * dtAC)
        {
            face->tangent = vector_normal(vector_subtract(vector_multiply_scalar(vProjAC, dtAB), vector_multiply_scalar(vProjAB, dtAC)));
        }
        else
        {
            face->tangent = vector_normal(vector_subtract(vector_multiply_scalar(vProjAB, dtAC), vector_multiply_scalar(vProjAC, dtAB)));
        }           
    }
    
    OOJS_PROFILE_EXIT_VOID
}

References generateFaceTangents, OOMeshFace::normal, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT_VOID, OOMeshFace::s, OOMeshFace::t, OOMeshFace::tangent, and OOMeshFace::vertex.

Referenced by generateFaceTangents.

Here is the call graph for this function:

Here is the caller graph for this function:

getNormal:andTangent:forVertex:inSmoothGroup:

- (void) getNormal:		(Vector *)	outNormal
andTangent:		(Vector *)	outTangent
forVertex:		(OOMeshVertexCount)	v_index
inSmoothGroup:		(OOMeshSmoothGroup)	smoothGroup

Extends class OOMesh.

Definition at line 1858 of file OOMesh.m.

                  :(Vector *)outNormal andTangent:(Vector *)outTangent forVertex:(OOMeshVertexCount)v_index inSmoothGroup:(OOMeshSmoothGroup)smoothGroup
{
    OOJS_PROFILE_ENTER
    
    assert(outNormal != NULL && outTangent != NULL);
    
    NSUInteger j;
    Vector normal_sum = kZeroVector;
    Vector tangent_sum = kZeroVector;
    for (j = 0; j < faceCount; j++)
    {
        if (_faces[j].smoothGroup == smoothGroup)
        {
            if ((_faces[j].vertex[0] == v_index)||(_faces[j].vertex[1] == v_index)||(_faces[j].vertex[2] == v_index))
            {
                float area = FaceArea(_faces[j].vertex, _vertices);
                normal_sum = vector_add(normal_sum, vector_multiply_scalar(_faces[j].normal, area));
                tangent_sum = vector_add(tangent_sum, vector_multiply_scalar(_faces[j].tangent, area));
            }
        }
    }
    
    *outNormal = vector_normal_or_fallback(normal_sum, kBasisZVector);
    *outTangent = vector_normal_or_fallback(tangent_sum, kBasisXVector);
    
    OOJS_PROFILE_EXIT_VOID
}

References FaceArea, kBasisXVector, kBasisZVector, kZeroVector, OOJS_PROFILE_ENTER, and OOJS_PROFILE_EXIT_VOID.

Here is the call graph for this function:

initWithName:cacheKey:materialDictionary:shadersDictionary:smooth:shaderMacros:shaderBindingTarget:scaleFactor:cacheWriteable:

- (id) initWithName:		(NSString *)	name
cacheKey:		(NSString *)	cacheKey
materialDictionary:		(NSDictionary *)	materialDict
shadersDictionary:		(NSDictionary *)	shadersDict
smooth:		(BOOL)	smooth
shaderMacros:		(NSDictionary *)	macros
shaderBindingTarget:		(id<OOWeakReferenceSupport>)	object
scaleFactor:		(float)	scale
cacheWriteable:		(BOOL)	cacheWriteable

Extends class OOMesh.

Definition at line 873 of file OOMesh.m.

                  :(NSString *)name
          cacheKey:(NSString *)cacheKey
materialDictionary:(NSDictionary *)materialDict
 shadersDictionary:(NSDictionary *)shadersDict
            smooth:(BOOL)smooth
      shaderMacros:(NSDictionary *)macros
shaderBindingTarget:(id<OOWeakReferenceSupport>)target
       scaleFactor:(float)scale
    cacheWriteable:(BOOL)cacheWriteable
{
    OOJS_PROFILE_ENTER
    
    self = [super init];
    if (self == nil)  return nil;
    
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
    _normalMode = smooth ? kNormalModeSmooth : kNormalModePerFace;
    _cacheWriteable = cacheWriteable;
    
#if OOMESH_PROFILE
    _stopwatch = [[OOProfilingStopwatch alloc] init];
#endif
    
    if ([self loadData:name scaleFactor:scale])
    {
        [self calculateBoundingVolumes];
        PROFILE(@"finished calculateBoundingVolumes (again\?\?)");
        
        baseFile = [name copy];
        baseFileOctreeCacheRef = [[NSString stringWithFormat:@"%@-%.3f", baseFile, scale] copy];
        
        /*  New in r3033: save the material-defining parameters here so we
            can rebind the materials at any time.
            -- Ahruman 2010-02-17
        */
        _materialDict = [materialDict copy];
        _shadersDict = [shadersDict copy];
        _cacheKey = [cacheKey copy];
        _shaderMacros = [macros copy];
        _shaderBindingTarget = [target weakRetain];
        
        [self rebindMaterials];
        PROFILE(@"finished material setup");
        
        [[OOGraphicsResetManager sharedManager] registerClient:self];
    }
    else
    {
        [self release];
        self = nil;
    }
#if OOMESH_PROFILE
    DESTROY(_stopwatch);
#endif
#if OO_MULTITEXTURE
    if (EXPECT(self != nil))
    {
        _textureUnitCount = NSNotFound;
    }
#endif
    
    [pool release];
    return self;
    
    OOJS_PROFILE_EXIT
}

References OOMesh::calculateBoundingVolumes, DESTROY, EXPECT, kNormalModePerFace, kNormalModeSmooth, nil, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT, PROFILE, OOMesh::rebindMaterials, OOGraphicsResetManager::registerClient:, and OOGraphicsResetManager::sharedManager.

Here is the call graph for this function:

loadData:scaleFactor:

- (BOOL) loadData:		(NSString *)	filename
scaleFactor:		(float)	scale

Extends class OOMesh.

Definition at line 1162 of file OOMesh.m.

                :(NSString *)filename scaleFactor:(float)scale
{
    OOJS_PROFILE_ENTER
    
    NSScanner           *scanner;
    NSDictionary        *cacheData = nil;
    BOOL                failFlag = NO;
    NSString            *failString = @"***** ";
    unsigned            i, j;
    NSMutableDictionary *texFileName2Idx = nil;
    NSString            *cacheKey = nil;
    BOOL                using_preloaded = NO;
    
    cacheKey = [NSString stringWithFormat:@"%@:%u:%.3f", filename, _normalMode, scale];
    cacheData = [OOCacheManager meshDataForName:cacheKey];
    if (cacheData != nil)
    {
        if ([self setModelFromModelData:cacheData name:filename])
        {
            using_preloaded = YES;
            PROFILE(@"loaded from cache");
            OOLog(@"mesh.load.cached", @"Retrieved mesh \"%@\" from cache.", filename);
        }
    }
    
    if (!using_preloaded)
    {
        OOLog(@"mesh.load.uncached", @"Mesh \"%@\" is not in cache, loading.", cacheKey);
        
        NSCharacterSet  *whitespaceCharSet = [NSCharacterSet whitespaceCharacterSet];
        NSCharacterSet  *whitespaceAndNewlineCharSet = [NSCharacterSet whitespaceAndNewlineCharacterSet];
#if OOLITE_MAC_OS_X
        NSCharacterSet  *newlineCharSet = [NSCharacterSet newlineCharacterSet];
#else
        static NSCharacterSet *newlineCharSet = nil;
        if (newlineCharSet == nil)
        {
            NSMutableCharacterSet *temp = [[whitespaceAndNewlineCharSet mutableCopy] autorelease];
            [temp formIntersectionWithCharacterSet:[whitespaceCharSet invertedSet]];
            newlineCharSet = [temp copy];
        }
#endif
        
        texFileName2Idx = [NSMutableDictionary dictionary];
        
        {
            NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
            NSString *data = [ResourceManager stringFromFilesNamed:filename inFolder:@"Models" cache:NO];
            if (data == nil)
            {
                // Model not found
                OOLog(kOOLogMeshDataNotFound, @"***** ERROR: could not find %@", filename);
                OOStandardsError(@"Model file not found");
                return NO;
            }
            
            // strip out comments and commas between values
            NSMutableArray *lines = [NSMutableArray arrayWithArray:[data componentsSeparatedByString:@"\n"]];
            for (i = 0; i < [lines count]; i++)
            {
                NSString *line = [lines objectAtIndex:i];
                NSArray *parts;
                //
                // comments
                //
                parts = [line componentsSeparatedByString:@"#"];
                line = [parts objectAtIndex:0];
                parts = [line componentsSeparatedByString:@"//"];
                line = [parts objectAtIndex:0];
                //
                // commas
                //
                line = [[line componentsSeparatedByString:@","] componentsJoinedByString:@" "];
                //
                [lines replaceObjectAtIndex:i withObject:line];
            }
            
            data = [lines componentsJoinedByString:@"\n"];
            scanner = [NSScanner scannerWithString:data];
            
            [scanner retain];
            [pool release];
            [scanner autorelease];
        }
        
        PROFILE(@"finished preprocessing");
 
        // get number of vertices
        //
        [scanner setScanLocation:0];    //reset
        if ([scanner scanString:@"NVERTS" intoString:NULL])
        {
            int n_v;
            if ([scanner scanInt:&n_v])
                vertexCount = n_v;
            else
            {
                failFlag = YES;
                failString = [NSString stringWithFormat:@"%@Failed to read value of NVERTS\n",failString];
            }
        }
        else
        {
            failFlag = YES;
            failString = [NSString stringWithFormat:@"%@Failed to read NVERTS\n",failString];
        }
        
        if (![self allocateVertexBuffersWithCount:vertexCount])
        {
            OOLog(kOOLogAllocationFailure, @"***** ERROR: failed to allocate memory for model %@ (%u vertices).", filename, vertexCount);
            return NO;
        }
        
        // get number of faces
        if ([scanner scanString:@"NFACES" intoString:NULL])
        {
            int n_f;
            if ([scanner scanInt:&n_f])
            {
                faceCount = n_f;
            }
            else
            {
                failFlag = YES;
                failString = [NSString stringWithFormat:@"%@Failed to read value of NFACES\n",failString];
            }
        }
        else
        {
            failFlag = YES;
            failString = [NSString stringWithFormat:@"%@Failed to read NFACES\n",failString];
        }
        
        // Allocate face->vertex table.
        size_t faceRefSize = sizeof (VertexFaceRef) * vertexCount;
        VertexFaceRef *faceRefs = calloc(1, faceRefSize);
        if (faceRefs != NULL)
        {
            // use an NSData to effectively autorelease it.
            NSData *faceRefHolder = [NSData dataWithBytesNoCopy:faceRefs length:faceRefSize freeWhenDone:YES];
            if (faceRefHolder == nil)
            {
                free(faceRefs);
                faceRefs = NULL;
            }
        }
        
        if (faceRefs == NULL || ![self allocateFaceBuffersWithCount:faceCount])
        {
            OOLog(kOOLogAllocationFailure, @"***** ERROR: failed to allocate memory for model %@ (%u vertices, %u faces).", filename, vertexCount, faceCount);
            return NO;
        }
        
        // get vertex data
        if ([scanner scanString:@"VERTEX" intoString:NULL])
        {
            for (j = 0; j < vertexCount; j++)
            {
                float x, y, z;
                if (!failFlag)
                {
                    if (![scanner scanFloat:&x])  failFlag = YES;
                    if (![scanner scanFloat:&y])  failFlag = YES;
                    if (![scanner scanFloat:&z])  failFlag = YES;
                    if (!failFlag)
                    {
                        _vertices[j] = make_vector(x*scale, y*scale, z*scale);
                    }
                    else
                    {
                        failString = [NSString stringWithFormat:@"%@Failed to read a value for vertex[%d] in %@\n", failString, j, @"VERTEX"];
                    }
                }
            }
        }
        else
        {
            failFlag = YES;
            failString = [NSString stringWithFormat:@"%@Failed to find VERTEX data\n",failString];
        }
 
        // get face data
        if ([scanner scanString:@"FACES" intoString:NULL])
        {
            for (j = 0; j < faceCount; j++)
            {
                int r, g, b;
                float nx, ny, nz;
                int n_v;
                if (!failFlag)
                {
                    // colors
                    if (![scanner scanInt:&r])  failFlag = YES;
                    if (![scanner scanInt:&g])  failFlag = YES;
                    if (![scanner scanInt:&b])  failFlag = YES;
                    if (!failFlag)
                    {
                        _faces[j].smoothGroup = r;
                    }
                    else
                    {
                        failString = [NSString stringWithFormat:@"%@Failed to read a color for face[%d] in FACES\n", failString, j];
                    }
                    
                    // normal
                    if (![scanner scanFloat:&nx])  failFlag = YES;
                    if (![scanner scanFloat:&ny])  failFlag = YES;
                    if (![scanner scanFloat:&nz])  failFlag = YES;
                    if (!failFlag)
                    {
                        _faces[j].normal = vector_normal(make_vector(nx, ny, nz));
                    }
                    else
                    {
                        failString = [NSString stringWithFormat:@"%@Failed to read a normal for face[%d] in FACES\n", failString, j];
                    }
                    
                    // vertices
                    if ([scanner scanInt:&n_v])
                    {
                        if (n_v < 3)
                        {
                            failFlag = YES;
                            failString = [NSString stringWithFormat:@"%@Face[%u] has fewer than three vertices.\n", failString, j];
                        }
                        else if (n_v > 3)
                        {
                            OOLogWARN(@"mesh.load.warning.nonTriangular", @"Face[%u] of %@ has %u vertices specified. Only the first three will be used.", j, baseFile, n_v);
                            n_v = 3;
                        }
                    }
                    else
                    {
                        failFlag = YES;
                        failString = [NSString stringWithFormat:@"%@Failed to read number of vertices for face[%d] in FACES\n", failString, j];
                    }
                    
                    if (!failFlag)
                    {
                        int vi;
                        for (i = 0; (int)i < n_v; i++)
                        {
                            if ([scanner scanInt:&vi])
                            {
                                _faces[j].vertex[i] = vi;
                                if (faceRefs != NULL)  VFRAddFace(&faceRefs[vi], j);
                            }
                            else
                            {
                                failFlag = YES;
                                failString = [NSString stringWithFormat:@"%@Failed to read vertex[%d] for face[%d] in FACES\n", failString, i, j];
                            }
                        }
                    }
                }
            }
        }
        else
        {
            failFlag = YES;
            failString = [NSString stringWithFormat:@"%@Failed to find FACES data\n",failString];
        }
 
        // Get textures data.
        if ([scanner scanString:@"TEXTURES" intoString:NULL])
        {
            for (j = 0; j < faceCount; j++)
            {
                NSString    *materialKey;
                float   max_x, max_y;
                float   s, t;
                if (!failFlag)
                {
                    // materialKey
                    //
                    [scanner scanCharactersFromSet:whitespaceAndNewlineCharSet intoString:NULL];
                    if (![scanner scanUpToCharactersFromSet:whitespaceCharSet intoString:&materialKey])
                    {
                        failFlag = YES;
                        failString = [NSString stringWithFormat:@"%@Failed to read texture filename for face[%d] in TEXTURES\n", failString, j];
                    }
                    else
                    {
                        NSNumber *index = [texFileName2Idx objectForKey:materialKey];
                        if (index != nil)
                        {
                            _faces[j].materialIndex = [index unsignedIntValue];
                        }
                        else
                        {
                            if (materialCount == kOOMeshMaxMaterials)
                            {
                                OOLog(kOOLogMeshTooManyMaterials, @"***** ERROR: model %@ has too many materials (maximum is %d)", filename, kOOMeshMaxMaterials);
                                return NO;
                            }
                            _faces[j].materialIndex = materialCount;
                            materialKeys[materialCount] = [materialKey retain];
                            index = [NSNumber numberWithUnsignedInt:materialCount];
                            [texFileName2Idx setObject:index forKey:materialKey];
                            ++materialCount;
                        }
                    }
 
                    // texture size
                    //
                   if (!failFlag)
                    {
                        if (![scanner scanFloat:&max_x])  failFlag = YES;
                        if (![scanner scanFloat:&max_y])  failFlag = YES;
                        if (failFlag)
                            failString = [NSString stringWithFormat:@"%@Failed to read texture size for max_x and max_y in face[%d] in TEXTURES\n", failString, j];
                    }
 
                    // vertices
                    //
                    if (!failFlag)
                    {
                        for (i = 0; i < 3; i++)
                        {
                            if (![scanner scanFloat:&s])  failFlag = YES;
                            if (![scanner scanFloat:&t])  failFlag = YES;
                            if (!failFlag)
                            {
                                _faces[j].s[i] = s / max_x;
                                _faces[j].t[i] = t / max_y;
                            }
                            else
                                failString = [NSString stringWithFormat:@"%@Failed to read s t coordinates for vertex[%d] in face[%d] in TEXTURES\n", failString, i, j];
                        }
                    }
                }
            }
        }
        else
        {
            failFlag = YES;
            failString = [failString stringByAppendingString:@"Failed to find TEXTURES data (will use placeholder material)\n"];
            materialKeys[0] = @"_oo_placeholder_material";
            materialCount = 1;
            
            for (j = 0; j < faceCount; j++)
            {
                _faces[j].materialIndex = 0;
            }
        }
        
        if ([scanner scanString:@"NAMES" intoString:NULL])
        {
            unsigned int count;
            if (![scanner scanInt:(int *)&count])
            {   
                failFlag = YES;
                failString = [failString stringByAppendingString:@"Expected count after NAMES\n"];
            }
            else
            {
                for (j = 0; j < count; j++)
                {
                    NSString *name = nil;
                    [scanner scanCharactersFromSet:whitespaceAndNewlineCharSet intoString:NULL];
                    if (![scanner scanUpToCharactersFromSet:newlineCharSet intoString:&name])
                    {
                        failFlag = YES;
                        failString = [failString stringByAppendingString:@"Expected file name\n"];
                    }
                    else
                    {
                        [self renameTexturesFrom:[NSString stringWithFormat:@"%u", j] to:name];
                    }
                }
            }
        }
        
        BOOL explicitTangents = NO;
        
        // Get explicit normals.
        if ([scanner scanString:@"NORMALS" intoString:NULL])
        {
            _normalMode = kNormalModeExplicit;
            if (![self allocateNormalBuffersWithCount:vertexCount])
            {
                OOLog(kOOLogAllocationFailure, @"***** ERROR: failed to allocate memory for model %@ (%u vertices).", filename, vertexCount);
                return NO;
            }
            
            for (j = 0; j < vertexCount; j++)
            {
                float x, y, z;
                if (!failFlag)
                {
                    if (![scanner scanFloat:&x])  failFlag = YES;
                    if (![scanner scanFloat:&y])  failFlag = YES;
                    if (![scanner scanFloat:&z])  failFlag = YES;
                    if (!failFlag)
                    {
                        _normals[j] = vector_normal(make_vector(x, y, z));
                    }
                    else
                    {
                        failString = [NSString stringWithFormat:@"%@Failed to read a value for vertex[%d] in %@\n", failString, j, @"NORMALS"];
                    }
                }
            }
            
            // Get explicit tangents (only together with vertices).
            if ([scanner scanString:@"TANGENTS" intoString:NULL])
            {
                for (j = 0; j < vertexCount; j++)
                {
                    float x, y, z;
                    if (!failFlag)
                    {
                        if (![scanner scanFloat:&x])  failFlag = YES;
                        if (![scanner scanFloat:&y])  failFlag = YES;
                        if (![scanner scanFloat:&z])  failFlag = YES;
                        if (!failFlag)
                        {
                            _tangents[j] = vector_normal(make_vector(x, y, z));
                        }
                        else
                        {
                            failString = [NSString stringWithFormat:@"%@Failed to read a value for vertex[%d] in %@\n", failString, j, @"TANGENTS"];
                        }
                    }
                }
            }
        }
        
        PROFILE(@"finished parsing");
        
        if (IsLegacyNormalMode(_normalMode))
        {
            [self checkNormalsAndAdjustWinding];
            PROFILE(@"finished checkNormalsAndAdjustWinding");
        }
        if (!explicitTangents)
        {
            [self generateFaceTangents];
            PROFILE(@"finished generateFaceTangents");
        }
        
        // check for smooth shading and recalculate normals
        if (_normalMode == kNormalModeSmooth)
        {
            if (![self allocateNormalBuffersWithCount:vertexCount])
            {
                OOLog(kOOLogAllocationFailure, @"***** ERROR: failed to allocate memory for model %@ (%u vertices).", filename, vertexCount);
                return NO;
            }
            [self calculateVertexNormalsAndTangentsWithFaceRefs:faceRefs];
            PROFILE(@"finished calculateVertexNormalsAndTangents");
            
        }
        else if (IsPerVertexNormalMode(_normalMode) && !explicitTangents)
        {
            [self calculateVertexTangentsWithFaceRefs:faceRefs];
            PROFILE(@"finished calculateVertexTangents");
        }
        
        // save the resulting data for possible reuse
        if (EXPECT(_cacheWriteable))
        {
            [OOCacheManager setMeshData:[self modelData] forName:cacheKey];
            PROFILE(@"saved to cache");
        }
        
        if (failFlag)
        {
            OOLog(@"mesh.error", @"%@ ..... from %@ %@", failString, filename, (using_preloaded)? @"(from preloaded data)" :@"(from file)");
        }
    }
    
    [self calculateBoundingVolumes];
    PROFILE(@"finished calculateBoundingVolumes");
    
    // set up vertex arrays for drawing
    if (![self setUpVertexArrays])  return NO;
    PROFILE(@"finished setUpVertexArrays");
    
    return YES;
    
    OOJS_PROFILE_EXIT
}

References OOMesh::calculateBoundingVolumes, OOMesh::calculateVertexNormalsAndTangentsWithFaceRefs:, OOMesh::calculateVertexTangentsWithFaceRefs:, OOMesh::checkNormalsAndAdjustWinding, count, EXPECT, OOMesh::generateFaceTangents, int(), IsLegacyNormalMode(), IsPerVertexNormalMode(), kNormalModeExplicit, kNormalModeSmooth, kOOLogAllocationFailure, kOOLogMeshDataNotFound, kOOLogMeshTooManyMaterials, kOOMeshMaxMaterials, OOCacheManager::meshDataForName:, OOMesh::modelData, nil, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT, OOLog, OOLogWARN, OOStandardsError(), PROFILE, OOMesh::renameTexturesFrom:to:, OOCacheManager::setMeshData:forName:, setUpVertexArrays, ResourceManager::stringFromFilesNamed:inFolder:cache:, VFRAddFace(), x, and y.

Here is the call graph for this function:

modelData

- (NSDictionary *) modelData

Extends class OOMesh.

Definition at line 996 of file OOMesh.m.

{
    OOJS_PROFILE_ENTER
    
    NSNumber            *vertCnt = nil,
                        *faceCnt = nil;
    NSData              *vertData = nil,
                        *normData = nil,
                        *tanData = nil,
                        *faceData = nil;
    NSArray             *mtlKeys = nil;
    NSNumber            *normMode = nil;
    
    BOOL includeNormals = IsPerVertexNormalMode(_normalMode);
    
    // Prepare cache data elements.
    vertCnt = [NSNumber numberWithUnsignedInt:vertexCount];
    faceCnt = [NSNumber numberWithUnsignedInt:faceCount];
    
    vertData = [_retainedObjects objectForKey:@"vertices"];
    faceData = [_retainedObjects objectForKey:@"faces"];
    if (includeNormals)
    {
        normData = [_retainedObjects objectForKey:@"normals"];
        tanData = [_retainedObjects objectForKey:@"tangents"];
    }
    
    if (materialCount != 0)
    {
        mtlKeys = [NSArray arrayWithObjects:materialKeys count:materialCount];
    }
    else
    {
        mtlKeys = [NSArray array];
    }
    normMode = [NSNumber numberWithUnsignedChar:_normalMode];
    
    // Ensure we have all the required data elements.
    if (vertCnt == nil ||
        faceCnt == nil ||
        vertData == nil ||
        faceData == nil ||
        mtlKeys == nil ||
        normMode == nil)
    {
        return nil;
    }
    
    if (includeNormals)
    {
        if (normData == nil || tanData == nil)  return nil;
    }
    
    // All OK; stick 'em in a dictionary.
    return [NSDictionary dictionaryWithObjectsAndKeys:
                        vertCnt, @"vertex count",
                        vertData, @"vertex data",
                        faceCnt, @"face count",
                        faceData, @"face data",
                        mtlKeys, @"material keys",
                        normMode, @"normal mode",
                        /*  NOTE: order matters. Since normData and tanData
                            are last, if they're nil the dictionary will be
                            built without them, which is desired behaviour.
                        */
                        normData, @"normal data",
                        tanData, @"tangent data",
                        nil];
    
    OOJS_PROFILE_EXIT
}

References IsPerVertexNormalMode(), modelData, nil, OOJS_PROFILE_ENTER, and OOJS_PROFILE_EXIT.

Referenced by modelData.

Here is the call graph for this function:

Here is the caller graph for this function:

mutableCopyWithZone:

- (id) mutableCopyWithZone: (NSZone *) zone

implementation

Extends class OOMesh.

Definition at line 941 of file OOMesh.m.

                         :(NSZone *)zone
{
    OOMesh              *result = nil;
    OOMeshMaterialCount  i;
    
    result = (OOMesh *)NSCopyObject(self, 0, zone);
    
    if (result != nil)
    {
        [result->baseFile retain];
        [result->baseFileOctreeCacheRef retain];
        [result->octree retain];
        [result->_retainedObjects retain];
        [result->_materialDict retain];
        [result->_shadersDict retain];
        [result->_cacheKey retain];
        [result->_shaderMacros retain];
        [result->_shaderBindingTarget retain];
        
        for (i = 0; i != kOOMeshMaxMaterials; ++i)
        {
            [result->materialKeys[i] retain];
            [result->materials[i] retain];
        }
        
        // Reset unsharable GL state
        result->listsReady = NO;
        
        [[OOGraphicsResetManager sharedManager] registerClient:result];
    }
    
    return result;
}

References kOOMeshMaxMaterials, OOMesh::listsReady, nil, OOGraphicsResetManager::registerClient:, and OOGraphicsResetManager::sharedManager.

Here is the call graph for this function:

renameTexturesFrom:to:

- (void) renameTexturesFrom:		(NSString *)	from
to:		(NSString *)	to

Extends class OOMesh.

Definition at line 2195 of file OOMesh.m.

                           :(NSString *)from to:(NSString *)to
{
    /*  IMPORTANT: this has to be called before setUpMaterials..., so it can
        only be used during loading.
    */
    OOMeshMaterialCount i;
    for (i = 0; i != materialCount; i++)
    {
        if ([materialKeys[i] isEqualToString:from])
        {
            [materialKeys[i] release];
            materialKeys[i] = [to copy];
        }
    }
}

rescaleByFactor:

- (void) rescaleByFactor:

(GLfloat)

factor

Extends class OOMesh.

Definition at line 2022 of file OOMesh.m.

                        :(GLfloat)factor
{
    // Rescale base vertices used for geometry calculations.
    OOMeshVertexCount  i;
    Vector              *vertex = NULL;
    
    for (i = 0; i < vertexCount; i++)
    {
        vertex = &_vertices[i];
        *vertex = vector_multiply_scalar(*vertex, factor);
    }
    
    // Rescale actual display vertices.
    for (i = 0; i < _displayLists.count; i++)
    {
        vertex = &_displayLists.vertexArray[i];
        *vertex = vector_multiply_scalar(*vertex, factor);
    }
    
    [self calculateBoundingVolumes];
    DESTROY(octree);
    DESTROY(baseFile);   // Avoid octree cache.
    DESTROY(baseFileOctreeCacheRef);
}

References OOMesh::calculateBoundingVolumes, and DESTROY.

Here is the call graph for this function:

resetGraphicsState

- (void) resetGraphicsState

implementation

Reimplemented from <OOGraphicsResetClient>.

Extends class OOMesh.

Definition at line 988 of file OOMesh.m.

{
    [self deleteDisplayLists];
    [self rebindMaterials];
    _textureUnitCount = NSNotFound;
}

References OOMesh::deleteDisplayLists, OOMesh::rebindMaterials, and resetGraphicsState.

Referenced by resetGraphicsState.

Here is the call graph for this function:

Here is the caller graph for this function:

setModelFromModelData:name:

- (BOOL) setModelFromModelData:		(NSDictionary*)	dict
name:		(NSString *)	fileName

Extends class OOMesh.

Definition at line 1069 of file OOMesh.m.

                             :(NSDictionary *)dict name:(NSString *)fileName
{
    OOJS_PROFILE_ENTER
    
    NSData              *vertData = nil,
                        *normData = nil,
                        *tanData = nil,
                        *faceData = nil;
    NSArray             *mtlKeys = nil;
    NSString            *key = nil;
    unsigned            i;
    
    if (dict == nil || ![dict isKindOfClass:[NSDictionary class]])  return NO;
    
    vertexCount = [dict oo_unsignedIntForKey:@"vertex count"];
    faceCount = [dict oo_unsignedIntForKey:@"face count"];
    
    if (vertexCount == 0 || faceCount == 0)  return NO;
    
    // Read data elements from dictionary.
    vertData = [dict oo_dataForKey:@"vertex data"];
    faceData = [dict oo_dataForKey:@"face data"];
    
    mtlKeys = [dict oo_arrayForKey:@"material keys"];
    _normalMode = [dict oo_unsignedCharForKey:@"normal mode"];
    BOOL includeNormals = IsPerVertexNormalMode(_normalMode);
    
    // Ensure we have all the required data elements.
    if (vertData == nil ||
        faceData == nil ||
        mtlKeys == nil)
    {
        OOLog(@"mesh.load.error.badCacheData", @"Ignoring bad cache data for mesh \"%@\".", fileName);
        return NO;
    }
    
    if (includeNormals)
    {
        normData = [dict oo_dataForKey:@"normal data"];
        tanData = [dict oo_dataForKey:@"tangent data"];
        if (normData == nil || tanData == nil)
        {
            OOLog(@"mesh.load.error.badCacheData", @"Ignoring bad normal/tangent cache data for mesh \"%@\".", fileName);
            return NO;
        }
    }
    
    // Ensure data objects are of correct size.
    if ([vertData length] != sizeof *_vertices * vertexCount)  return NO;
    if ([faceData length] != sizeof *_faces * faceCount)  return NO;
    if (includeNormals)
    {
        if ([normData length] != sizeof *_normals * vertexCount)  return NO;
        if ([tanData length] != sizeof *_tangents * vertexCount)  return NO;
    }
    
    // Retain data.
    _vertices = (Vector *)[vertData bytes];
    [self setRetainedObject:vertData forKey:@"vertices"];
    _faces = (OOMeshFace *)[faceData bytes];
    [self setRetainedObject:faceData forKey:@"faces"];
    if (includeNormals)
    {
        _normals = (Vector *)[normData bytes];
        [self setRetainedObject:normData forKey:@"normals"];
        _tangents = (Vector *)[tanData bytes];
        [self setRetainedObject:tanData forKey:@"tangents"];
    }
    else
    {
        _normals = NULL;
        _tangents = NULL;
    }
    
    // Copy material keys.
    materialCount = [mtlKeys count];
    for (i = 0; i != materialCount; ++i)
    {
        key = [mtlKeys oo_stringAtIndex:i];
        if (key != nil)  materialKeys[i] = [key copy];
        else
        {
            OOLog(@"mesh.load.error.badCacheData", @"Ignoring bad cache data for mesh \"%@\".", fileName);
            return NO;
        }
    }
    
    return YES;
    
    OOJS_PROFILE_EXIT
}

References IsPerVertexNormalMode(), nil, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT, OOLog, and OOMesh::setRetainedObject:forKey:.

Here is the call graph for this function:

setRetainedObject:forKey:

- (void) setRetainedObject:		(id)	object
forKey:		(NSString *)	key

Extends class OOMesh.

Definition at line 2108 of file OOMesh.m.

                          :(id)object forKey:(NSString *)key
{
    assert(key != nil);
    
    if (object != nil)
    {
        if (_retainedObjects == nil)  _retainedObjects = [[NSMutableDictionary alloc] init];
        [_retainedObjects setObject:object forKey:key];
    }
}

References nil.

setUpVertexArrays

- (BOOL) setUpVertexArrays

Extends class OOMesh.

Definition at line 1887 of file OOMesh.m.

{
    OOJS_PROFILE_ENTER
    
    NSUInteger  fi, vi, mi;
    
    if (![self allocateVertexArrayBuffersWithCount:faceCount])  return NO;
    
    // if smoothed, find any vertices that are between faces of different
    // smoothing groups and mark them as being on an edge and therefore NOT
    // smooth shaded
    BOOL is_edge_vertex[vertexCount];
    GLfloat smoothGroup[vertexCount];
    for (vi = 0; vi < vertexCount; vi++)
    {
        is_edge_vertex[vi] = NO;
        smoothGroup[vi] = -1;
    }
    if (_normalMode == kNormalModeSmooth)
    {
        for (fi = 0; fi < faceCount; fi++)
        {
            GLfloat rv = _faces[fi].smoothGroup;
            int i;
            for (i = 0; i < 3; i++)
            {
                vi = _faces[fi].vertex[i];
                if (smoothGroup[vi] < 0.0)  // unassigned
                    smoothGroup[vi] = rv;
                else if (smoothGroup[vi] != rv) // a different colour
                    is_edge_vertex[vi] = YES;
            }
        }
    }
 
 
    // base model, flat or smooth shaded, all triangles
    int tri_index = 0;
    int uv_index = 0;
    int vertex_index = 0;
    
    // Iterate over material names
    for (mi = 0; mi != materialCount; ++mi)
    {
        triangle_range[mi].location = tri_index;
        
        for (fi = 0; fi < faceCount; fi++)
        {
            Vector normal, tangent;
            
            if (_faces[fi].materialIndex == mi)
            {
                for (vi = 0; vi < 3; vi++)
                {
                    int v = _faces[fi].vertex[vi];
                    if (IsPerVertexNormalMode(_normalMode))
                    {
                        if (is_edge_vertex[v])
                        {
                            [self getNormal:&normal andTangent:&tangent forVertex:v inSmoothGroup:_faces[fi].smoothGroup];
                        }
                        else
                        {
                            NSAssert1(_normals != NULL && _tangents != NULL, @"Normal/tangent buffers not allocated in %s", __PRETTY_FUNCTION__);
                            
                            normal = _normals[v];
                            tangent = _tangents[v];
                        }
                    }
                    else
                    {
                        normal = _faces[fi].normal;
                        tangent = _faces[fi].tangent;
                    }
                    
                    // FIXME: avoid redundant vertices so index array is actually useful.
                    _displayLists.indexArray[tri_index++] = vertex_index;
                    _displayLists.normalArray[vertex_index] = normal;
                    _displayLists.tangentArray[vertex_index] = tangent;
                    _displayLists.vertexArray[vertex_index++] = _vertices[v];
                    _displayLists.textureUVArray[uv_index++] = _faces[fi].s[vi];
                    _displayLists.textureUVArray[uv_index++] = _faces[fi].t[vi];
                }
            }
        }
        triangle_range[mi].length = tri_index - triangle_range[mi].location;
    }
    
    _displayLists.count = tri_index;    // total number of triangle vertices
    return YES;
    
    OOJS_PROFILE_EXIT
}

References OOMesh::getNormal:andTangent:forVertex:inSmoothGroup:, IsPerVertexNormalMode(), kNormalModeSmooth, OOJS_PROFILE_ENTER, OOJS_PROFILE_EXIT, and setUpVertexArrays.

Referenced by loadData:scaleFactor:, and setUpVertexArrays.

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this category was generated from the following file:

• src/Core/OOMesh.m