// --- Simple file header ---
char fileType[8] = "MEMFRAG!";
uint32_t version;
 
// --- Assets section starts here ---
char assetsSection[4] = "ASTS";
uint32_t assetCount;
struct {
    char assetName[128]; // Name of asset in UTF-8
    uint32_t offset; // File offset to asset
} assetTOC[assetCount];
 
// --- Assets will follow this pattern. ---
char assetSection[4] = "ASET";
char assetType[4] = "<asset type goes here>";
uint32_t version;
uint8_t assetData[dataSize];
uint8_t paddingTo32BitBoundary[x];
 
// --- Arbitrary binary data asset ---
char assetSection = "ASET";
char assetType = "DATA";
uint32_t version;
uint32_t size;
uint8_t data[size];
uint8_t paddingTo32BitBoundary[x];
 
// --- Texture asset ---
char assetSection[4] = "ASET";
char assetType[4] = "TXTR";
uint32_t version;
uint32_t format; // PVR (iPhone), PNG or DDS (Mac)
uint32_t size;
uint8_t data[size];
uint8_t paddingTo32BitBoundary[x];
 
// --- Effect asset ---
char assetSection[4] = "ASET";
char fileType[4] = "EFCT";
uint32_t version;
uint32_t lengthOfVertexShader;
char vertexShader[lengthOfVertexShader];
uint32_t lengthOfFragmentShader;
char fragmentShader[lengthOfFragmentShader];
uint32_t attributeCount;
struct {
   uint32_t index;
   uint32_t standardAttributeIndex; // -1 if not standard
} attributes[attributeCount];
 
// --- Sprite asset ---
char assetSection[4] = "ASET";
char fileType[4] = "SPRT";
uint32_t version;
char texture[64]; // Asset name
uint32_t frameCount;
struct {
   uint32_t originX;
   uint32_t originY;
   uint32_t sizeX;
   uint32_t sizeY;
   uint32_t hotspotX;
   uint32_t hotspotY;
} frames[frameCount];
uint32_t animationCount;
struct {
   char key[64];
   uint32_t loopCount;
   float frameDuration;
   uint32_t frameCount;
   uint32_t frames[frameCount];
} animations[animationCount];
 
// --- Sound asset ---
char assetSection[4] = "ASET";
char assetType[4] = "SOND";
uint32_t version;
uint32_t format; // AL_FORMAT_STEREO16 or AL_FORMAT_MONO16
uint32_t sampleRate;
uint32_t size;
uint8_t data[size];
uint8_t paddingTo32BitBoundary[x];
 
// --- Music asset ---
char assetSection[4] = "ASET";
char assetType[4] = "MUSC";
uint32_t version;
char filePath[128]; // Music files stored separately.

#import <Foundation/Foundation.h>
 
 
@interface MemoryMappedFile : NSObject
{
@private
    NSString *path;
    void *baseAddress;
    NSUInteger size;
}
 
// The path of the file to map into memory.
@property (nonatomic, readonly) NSString *path;
 
// The memory address where the file is mapped.
// NULL when the file is not mapped into memory.
@property (nonatomic, readonly) void *baseAddress;
 
// Total size of the file.
@property (nonatomic, readonly) NSUInteger size;
 
// Returns YES when the file is mapped into memory.
@property (nonatomic, readonly) BOOL isMapped;
 
// Prepares to map the specified file, but does not
// actually map the file into memory.
- (id)initWithPath:(NSString *)pathToFile;
 
// Maps the file into memory.
// Returns pointer to start of file or NULL if unsuccessful.
- (void *)map;
 
// Unmaps the file from memory.
// The pointer returned by map is no longer valid.
- (void)unmap;
 
@end

#import "MemoryMappedFile.h"
#import <fcntl.h>
#import <unistd.h>
#import <sys/stat.h>
#import <sys/mman.h>
 
@implementation MemoryMappedFile
 
@synthesize path;
@synthesize baseAddress;
@synthesize size;
 
- (id)initWithPath:(NSString *)pathToFile
{
    if (self = [super init])
    {
        path = [pathToFile copyWithZone:nil];
    }
 
    return self;
}
 
- (void)dealloc
{
    if ([self isMapped])
    {
        [self unmap];
    }
 
    [path release];
    [super dealloc];
}
 
- (void *)map
{
    if ([self isMapped])
    {
        return baseAddress;
    }
 
    // This will be released when "path" is released.
    const char *cPath = [path
            cStringUsingEncoding:NSISOLatin1StringEncoding];
 
    // The file must be opened so we can pass 
    // the file descriptor to mmap().
    int file = open(cPath, O_RDONLY);
    if (file == -1)
    {
        perror("open");
        return NULL;
    }
 
    // Get info about file, we need the file size.
    struct stat buffer;
    if (fstat(file, &buffer) == -1)
    {
        perror("fstat");
        close(file);
        return NULL;
    }
 
    // Map the file as read only pages.
    baseAddress = mmap(NULL, buffer.st_size, PROT_READ,
                        MAP_SHARED, file, 0);
    if (baseAddress == MAP_FAILED)
    {
        perror("mmap");
        close(file);
        return NULL;
    }
 
    // Store the size, we need it when we unmap the file.
    size = (NSUInteger)buffer.st_size;
 
    // It's ok to close() after mmap().
    if (close(file) == -1)
    {
        perror("close");
        [self unmap];
        return NULL;
    }
 
    return baseAddress;
}
 
- (void)unmap
{
    // Only unmap the file if it is actually mapped.
    if ([self isMapped])
    {
        if (munmap(baseAddress, size) == -1)
        {
            perror("munmap");
            // There's not much we can do if munmap() fails.
        }
 
        baseAddress = NULL;
        size = 0;
    }
}
 
- (BOOL)isMapped
{
    return baseAddress != NULL;
}
 
@end

#import <Foundation/Foundation.h>
 
// A GameService is an object that provides a service to other objects.
@protocol GameService
 
// Each service should have a unique name identifying
// the type of service it provides.
@property(nonatomic, readonly) NSString *serviceName;
 
@end

#import <Foundation/Foundation.h>
#import "GameService.h"
 
// A game service broker is a singleton object that keeps track of
// game services and provides access to them. 
@interface GameServiceBroker : NSObject
{
@private
    // Holds the services.
    NSMutableDictionary *services;
}
 
// Get the global instance of the service broker.
+ (GameServiceBroker *)sharedGameServiceBroker;
 
// Gets the object providing the specified type of service.
+ (id)serviceOfType:(NSString *)serviceType;
 
// Adds a service to the set of game services.
- (void)addService:(id<GameService>)service;
 
// Gets the object providing the specified type of service.
- (id)serviceOfType:(NSString *)serviceType;
 
// Removes and destroys the object providing the specified service.
- (void)removeService:(NSString *)serviceType;
 
@end

#import "GameServiceBroker.h"
 
@implementation GameServiceBroker
 
+ (GameServiceBroker *)sharedGameServiceBroker
{
    static GameServiceBroker *sharedInstance = nil;
 
    if (sharedInstance)
    {
        return sharedInstance;
    }
 
    @synchronized(self)
    {
        if (sharedInstance == nil)
        {
            sharedInstance = [[self alloc] init];
        }
    }
 
    return sharedInstance;
}
 
+ (id)serviceOfType:(NSString *)serviceType
{
    return [[GameServiceBroker sharedGameServiceBroker] 
            serviceOfType:serviceType];
}
 
- (id)init
{
    if (self = [super init])
    {
        services = [[NSMutableDictionary alloc] init];
    }
 
    return self;
}
 
- (void)dealloc
{
    [services release];
    [super dealloc];
}
 
- (void)addService:(id <GameService>)service
{
    [services setObject:service forKey:[service serviceName]];
}
 
- (id)serviceOfType:(NSString *)serviceType
{
    return [services objectForKey:serviceType];
}
 
- (void)removeService:(NSString *)serviceType
{
    [services removeObjectForKey:serviceType];
}
 
@end

#import <Foundation/Foundation.h>
 
@interface NSString (UUID)
 
+ (NSString *)stringWithUUID;
 
@end

#import "UUID.h"
 
@implementation NSString (UUID)
 
+ (NSString *)stringWithUUID
{
    CFUUIDRef uuidObject = CFUUIDCreate(nil);
    NSString *uuidString = (NSString *)CFUUIDCreateString(nil, uuidObject);
    CFRelease(uuidObject);
    return [uuidString autorelease];
}
 
@end

#include "GLGXMath.h"
 
#define MAX_MATRIX_STACK_LEVELS 32
 
class MatrixStack
{
private:
    GLGXMATRIX stack[MAX_MATRIX_STACK_LEVELS];
    int currentLevel;
 
public:
    MatrixStack();
 
    void clear();
 
    const GLGXMATRIX *getTop() const;
 
    void loadIdentity();
 
    void loadMatrix(GLGXMATRIX *matrix);
 
    void multMatrix(GLGXMATRIX *matrix);    
    void multMatrixLocal(GLGXMATRIX *matrix);
 
    void pop();
    void push();
 
    void rotateAxis(GLGXVECTOR3 *vector, float angle);  
    void rotateAxisLocal(GLGXVECTOR3 *vector, float angle);
 
    void rotateYawPitchRoll(float yaw, float pitch, float roll);
    void rotateYawPitchRollLocal(float yaw, float pitch, float roll);
 
    void scale(float x, float y, float z);
    void scaleLocal(float x, float y, float z);
 
    void translate(float x, float y, float z);
    void translateLocal(float x, float y, float z); 
};

#import <assert.h>
#import "MatrixStack.cpp"
 
// Constructs the matrix and loads the identity matrix.
MatrixStack::MatrixStack()
{
    clear();
}
 
// Clears the stack and pops all matrices.
void MatrixStack::clear()
{
    currentLevel = 0;
    this->loadIdentity();
}
 
// Retrieves the current matrix at the top of the stack.
const GLGXMATRIX *MatrixStack::getTop() const
{
    return &stack[currentLevel];
}
 
// Loads identity in the current matrix.
void MatrixStack::loadIdentity()
{   
    GLGXMatrixIdentity(&stack[currentLevel]);
}
 
// Loads the specified matrix in the current matrix.
void MatrixStack::loadMatrix(const GLGXMATRIX *matrix)
{
    stack[currentLevel] = *matrix;
}
 
// Multiplies the current matrix with the specified matrix.
void MatrixStack::multMatrix(const GLGXMATRIX *matrix)
{
    stack[currentLevel] = stack[currentLevel] * (*matrix);
}
 
// Multiplies the specified matrix with the current matrix.
void MatrixStack::multMatrixLocal(const GLGXMATRIX *matrix)
{
    stack[currentLevel] = (*(GLGXMATRIX *)matrix) * stack[currentLevel];
}
 
// Removes the current matrix from the top of the stack.
void MatrixStack::pop()
{   
    if (currentLevel > 0)
    {
        currentLevel--;
    }
}
 
// Adds a matrix level to the stack, by duplicating the current matrix.
void MatrixStack::push()
{
    assert(currentLevel + 1 < MAX_MATRIX_STACK_LEVELS);
 
    stack[currentLevel + 1] = stack[currentLevel];
    currentLevel++;
}
 
// Rotates around an arbitrary vector axis. (world space)
void MatrixStack::rotateAxis(const GLGXVECTOR3 *vector, float angle)
{
    GLGXMATRIX tmp;
    GLGXMatrixRotationAxis(&tmp, (GLGXVECTOR3 *)vector, angle);
    stack[currentLevel] = stack[currentLevel] * tmp;
}
 
// Rotates around an arbitrary vector axis. (local space)
void MatrixStack::rotateAxisLocal(const GLGXVECTOR3 *vector, float angle)
{
    GLGXMATRIX tmp;
    GLGXMatrixRotationAxis(&tmp, (GLGXVECTOR3 *)vector, angle);
    stack[currentLevel] = tmp * stack[currentLevel];
}
 
// Rotates around an arbitrary axis. (world space)
void MatrixStack::rotateYawPitchRoll(float yaw, float pitch, float roll)
{
    GLGXMATRIX tmp;
    GLGXQUATERNION quaternion;
    GLGXQuaternionRotationYawPitchRoll(&quaternion, yaw, pitch, roll);
    GLGXMatrixRotationQuaternion(&tmp, &quaternion);
    stack[currentLevel] = stack[currentLevel] * tmp;
}
 
// Rotates around an arbitrary axis. (local space)
void MatrixStack::rotateYawPitchRollLocal(float yaw, float pitch, float roll)
{
    GLGXMATRIX tmp;
    GLGXQUATERNION quaternion;
    GLGXQuaternionRotationYawPitchRoll(&quaternion, yaw, pitch, roll);
    GLGXMatrixRotationQuaternion(&tmp, &quaternion);
    stack[currentLevel] = tmp * stack[currentLevel];
}
 
// Scale the current matrix. (world origin)
void MatrixStack::scale(float x, float y, float z)
{
    GLGXMATRIX tmp;
    GLGXMatrixScaling(&tmp, x, y, z);
    stack[currentLevel] = stack[currentLevel] * tmp;     
}
 
// Scale the current matrix. (local origin)
void MatrixStack::scaleLocal(float x, float y, float z)
{
    GLGXMATRIX tmp;
    GLGXMatrixScaling(&tmp, x, y, z);
    stack[currentLevel] = tmp * stack[currentLevel];     
}
 
// Translate the current matrix. (world origin)
void MatrixStack::translate(float x, float y, float z)
{
    GLGXMATRIX tmp;
    GLGXMatrixTranslation(&tmp, x, y, z);
    stack[currentLevel] = stack[currentLevel] * tmp;
}
 
// Translate the current matrix. (local origin)
void MatrixStack::translateLocal(float x, float y, float z)
{
    GLGXMATRIX tmp;
    GLGXMatrixTranslation(&tmp, x, y, z);
    stack[currentLevel] = tmp * stack[currentLevel];
}