G3D::BinaryOutput Class Reference

#include <BinaryOutput.h>

Public Member Functions
	BinaryOutput ()
	BinaryOutput (const std::string &filename, G3DEndian fileEndian)
	~BinaryOutput ()
void	compress (int level=9)
bool	ok () const
const uint8 *	getCArray () const
void	setEndian (G3DEndian fileEndian)
G3DEndian	endian () const
std::string	getFilename () const
void	commit (bool flush=true)
void	commit (uint8 *)
void	reset ()
int64	length () const
int64	size () const
void	setLength (int64 n)
int64	position () const
void	setPosition (int64 p)
void	writeBytes (const void *b, size_t count)
void	writeInt8 (int8 i)
void	writeBool8 (bool b)
void	writeUInt8 (uint8 i)
void	writeUNorm8 (unorm8 i)
void	writeUInt16 (uint16 u)
void	writeInt16 (int16 i)
void	writeUInt32 (uint32 u)
void	writeInt32 (int32 i)
void	writeUInt64 (uint64 u)
void	writeInt64 (int64 i)
void	writeFloat32 (float32 f)
void	writeFloat64 (float64 f)
void	writeString (const std::string &s)
void	writeString (const std::string &s, int len)
void	writeString (const char *s)
void	writeStringEven (const std::string &s)
void	writeStringEven (const char *s)
void	writeString32 (const char *s)
void	writeString32 (const std::string &s)
void	writeVector4 (const Vector4 &v)
void	writeVector3 (const Vector3 &v)
void	writeVector2 (const Vector2 &v)
void	writeColor4 (const Color4 &v)
void	writeColor3 (const Color3 &v)
void	skip (int n)
void	beginBits ()
void	writeBits (uint32 bitString, int numBits)
void	endBits ()

Private Member Functions
void	reserveBytesWhenOutOfMemory (size_t bytes)
void	reallocBuffer (size_t bytes, size_t oldBufferLen)
void	reserveBytes (size_t bytes)
	BinaryOutput (const BinaryOutput &)
BinaryOutput &	operator= (const BinaryOutput &)
bool	operator== (const BinaryOutput &)

Private Attributes
std::string	m_filename
bool	m_committed
int	m_beginEndBits
int8	m_bitString
int	m_bitPos
bool	m_swapBytes
G3DEndian	m_fileEndian
uint8 *	m_buffer
size_t	m_bufferLen
size_t	m_maxBufferLen
int64	m_pos
bool	m_init
int64	m_alreadyWritten
bool	m_ok

Detailed Description

Sequential or random access byte-order independent binary file access.

The compress() call can be used to compress with zlib.

Any method call can trigger an out of memory error (thrown as char*) when writing to "<memory>" instead of a file.

Compressed writing and seeking backwards is not supported for huge files (i.e., BinaryOutput may have to dump the contents to disk if they exceed available RAM).

Constructor & Destructor Documentation

G3D::BinaryOutput::BinaryOutput ( const BinaryOutput &  )

private

G3D::BinaryOutput::BinaryOutput

(

)

You must call setEndian() if you use this (memory) constructor.

 {
 m_alreadyWritten = 0;
 m_swapBytes = false;
 m_pos = 0;
 m_filename = "<memory>";
 m_buffer = NULL;
 m_bufferLen = 0;
 m_maxBufferLen = 0;
 m_beginEndBits = 0;
 m_bitString = 0;
 m_bitPos = 0;
 m_ok = true;
 m_committed = false;
}

G3D::BinaryOutput::BinaryOutput	(	const std::string &	filename,
		G3DEndian	fileEndian
	)

Doesn't actually open the file; commit() does that. Use "<memory>" as the filename if you're going to commit to memory.

Verify ability to write to disk

 {

 m_pos = 0;
 m_alreadyWritten = 0;
 setEndian(fileEndian);
 m_filename = filename;
 m_buffer = NULL;
 m_bufferLen = 0;
 m_maxBufferLen = 0;
 m_beginEndBits = 0;
 m_bitString = 0;
 m_bitPos = 0;
 m_committed = false;

 m_ok = true; 
 commit(false);
 m_committed = false;
}

Here is the call graph for this function:

G3D::BinaryOutput::~BinaryOutput

(

)

 {
 debugAssert((m_buffer == NULL) || isValidHeapPointer(m_buffer));
 System::free(m_buffer);
 m_buffer = NULL;
 m_bufferLen = 0;
 m_maxBufferLen = 0;
}

Here is the call graph for this function:

Member Function Documentation

void G3D::BinaryOutput::beginBits

(

)

Call before a series of BinaryOutput::writeBits calls. Only writeBits can be called between beginBits and endBits without corrupting the stream.

 {
 debugAssertM(m_beginEndBits == 0, "Already in beginBits...endBits");
 m_bitString = 0x00;
 m_bitPos = 0;
 m_beginEndBits = 1;
}

void G3D::BinaryOutput::commit

(

bool

flush = true

)

Write the bytes to disk. It is ok to call this multiple times; it will just overwrite the previous file.

Parent directories are created as needed if they do not exist.

Not called from the destructor; you must call it yourself.

Parameters

flush

If true (default) the file is ready for reading when the method returns, otherwise the method returns immediately and writes the file in the background.

 {
 debugAssertM(! m_committed, "Cannot commit twice");
 m_committed = true;
 debugAssertM(m_beginEndBits == 0, "Missing endBits before commit");

 if (m_filename == "<memory>") {
 return;
 }

 // Make sure the directory exists.
 std::string root, base, ext, path;
 Array<std::string> pathArray;
 parseFilename(m_filename, root, pathArray, base, ext); 

 path = root + stringJoin(pathArray, '/');
 if (! FileSystem::exists(path, false)) {
 FileSystem::createDirectory(path);
 }

 const char* mode = (m_alreadyWritten > 0) ? "ab" : "wb";

 alwaysAssertM(m_filename != "<memory>", "Writing to memory file");
 FILE* file = FileSystem::fopen(m_filename.c_str(), mode);

 if (! file) {
 logPrintf("Error %d while trying to open \"%s\"\n", errno, m_filename.c_str());
 }
 m_ok = (file != NULL) && m_ok;

 if (m_ok) {
 debugAssertM(file, std::string("Could not open '") + m_filename + "'");

 if (m_buffer != NULL) {
 m_alreadyWritten += m_bufferLen;

 size_t success = fwrite(m_buffer, m_bufferLen, 1, file);
 (void)success;
 debugAssertM(success == 1, std::string("Could not write to '") + m_filename + "'");
 }
 if (flush) {
 fflush(file);
 }
 FileSystem::fclose(file);
 file = NULL;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::commit

(

uint8 *

out

)

Write the bytes to memory (which must be of at least size() bytes).

 {
 debugAssertM(! m_committed, "Cannot commit twice");
 m_committed = true;

 System::memcpy(out, m_buffer, m_bufferLen);
}

Here is the call graph for this function:

void G3D::BinaryOutput::compress

(

int

level = 9

)

Compresses the data in the buffer in place, preceeding it with a little-endian uint32 indicating the uncompressed size.

Call immediately before commit().

Cannot be used for huge files (ones where the data was already written to disk)– will throw char*.

Parameters

level

Compression level. 0 = fast, low compression; 9 = slow, high compression

 {
 if (m_alreadyWritten > 0) {
 throw "Cannot compress huge files (part of this file has already been written to disk).";
 }
 debugAssertM(! m_committed, "Cannot compress after committing.");
 alwaysAssertM(m_bufferLen < 0xFFFFFFFF, "Compress only works for 32-bit files.");

 // This is the worst-case size, as mandated by zlib
 unsigned long compressedSize = iCeil(m_bufferLen * 1.001) + 12;

 // Save the old buffer and reallocate to the worst-case size
 const uint8* src = m_buffer;
 const uint32 srcSize = (uint32)m_bufferLen;

 // add space for the 4-byte header
 m_maxBufferLen = compressedSize + 4;
 m_buffer = (uint8*)System::malloc(m_maxBufferLen);
 
 // Write the header containing the old buffer size, which is needed for decompression
 {
 const uint8* convert = (const uint8*)&srcSize;
 if (m_swapBytes) {
 m_buffer[0] = convert[3];
 m_buffer[1] = convert[2];
 m_buffer[2] = convert[1];
 m_buffer[3] = convert[0];
 } else {
 m_buffer[0] = convert[0];
 m_buffer[1] = convert[1];
 m_buffer[2] = convert[2];
 m_buffer[3] = convert[3];
 }
 }

 // Compress and write after the header
 int result = compress2(m_buffer + 4, &compressedSize, src, srcSize, iClamp(level, 0, 9));

 debugAssert(result == Z_OK); (void)result;
 m_bufferLen = compressedSize + 4;
 m_pos = m_bufferLen;

 // Free the old data
 System::free((void*)src);
}

Here is the call graph for this function:

void G3D::BinaryOutput::endBits

(

)

Call after a series of BinaryOutput::writeBits calls. This will finish out with zeros the last byte into which bits were written.

 {
 debugAssertM(m_beginEndBits == 1, "Not in beginBits...endBits");
 if (m_bitPos > 0) {
 writeUInt8(m_bitString);
 }
 m_bitString = 0;
 m_bitPos = 0;
 m_beginEndBits = 0;
}

Here is the call graph for this function:

G3DEndian G3D::BinaryOutput::endian ( ) const

inline

 {
 return m_fileEndian;
 }

const uint8* G3D::BinaryOutput::getCArray ( ) const

inline

Returns a pointer to the internal memory buffer.

 {
 return m_buffer;
 }

Here is the caller graph for this function:

std::string G3D::BinaryOutput::getFilename ( ) const

inline

 {
 return m_filename;
 }

int64 G3D::BinaryOutput::length ( ) const

inline

 {
 return m_bufferLen + m_alreadyWritten;
 }

Here is the caller graph for this function:

bool G3D::BinaryOutput::ok

(

)

const

True if no errors have been encountered.

 {
 return m_ok;
}

BinaryOutput& G3D::BinaryOutput::operator= ( const BinaryOutput &  )

private

bool G3D::BinaryOutput::operator== ( const BinaryOutput &  )

private

int64 G3D::BinaryOutput::position ( ) const

inline

Returns the current byte position in the file, where 0 is the beginning and getLength() - 1 is the end.

 {
 return m_pos + m_alreadyWritten;
 }

void G3D::BinaryOutput::reallocBuffer ( size_t  bytes, size_t  oldBufferLen  )

private

 {
 //debugPrintf("reallocBuffer(%d, %d)\n", bytes, oldBufferLen);

 size_t newBufferLen = (int)(m_bufferLen * 1.5) + 100;
 uint8* newBuffer = NULL;

 if ((m_filename == "<memory>") || (newBufferLen < MAX_BINARYOUTPUT_BUFFER_SIZE)) {
 // We're either writing to memory (in which case we *have* to
 // try and allocate) or we've been asked to allocate a
 // reasonable size buffer.

 // debugPrintf(" realloc(%d)\n", newBufferLen); 
 newBuffer = (uint8*)System::realloc(m_buffer, newBufferLen);
 if (newBuffer != NULL) {
 m_maxBufferLen = newBufferLen;
 }
 }

 if ((newBuffer == NULL) && (bytes > 0)) {
 // Realloc failed; we're probably out of memory. Back out
 // the entire call and try to dump some data to disk.
 alwaysAssertM(m_filename != "<memory>", "Realloc failed while writing to memory.");
 m_bufferLen = oldBufferLen;
 reserveBytesWhenOutOfMemory(bytes);
 } else {
 // Realloc succeeded
 m_buffer = newBuffer;
 debugAssert(isValidHeapPointer(m_buffer));
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::reserveBytes ( size_t  bytes )

inlineprivate

Make sure at least bytes can be written, resizing if necessary.

 {
 debugAssert(bytes > 0);
 size_t oldBufferLen = m_bufferLen;

 m_bufferLen = max(m_bufferLen, (size_t)(m_pos + bytes));
 if (m_bufferLen > m_maxBufferLen) {
 reallocBuffer(bytes, oldBufferLen);
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::reserveBytesWhenOutOfMemory ( size_t  bytes )

private

 {
 if (m_filename == "<memory>") {
 throw "Out of memory while writing to memory in BinaryOutput (no RAM left).";
 } else if ((int)bytes > (int)m_maxBufferLen) {
 throw "Out of memory while writing to disk in BinaryOutput (could not create a large enough buffer).";
 } else {

 // Dump the contents to disk. In order to enable seeking backwards, 
 // we keep the last 10 MB in memory.
 size_t writeBytes = m_bufferLen - 10 * 1024 * 1024;

 if (writeBytes < m_bufferLen / 3) {
 // We're going to write less than 1/3 of the file;
 // give up and just write the whole thing.
 writeBytes = m_bufferLen;
 }
 debugAssert(writeBytes > 0);

 //debugPrintf("Writing %d bytes to disk\n", writeBytes);

 const char* mode = (m_alreadyWritten > 0) ? "ab" : "wb";
 alwaysAssertM(m_filename != "<memory>", "Writing memory file");
 FILE* file = FileSystem::fopen(m_filename.c_str(), mode);
 debugAssert(file);

 size_t count = fwrite(m_buffer, 1, writeBytes, file);
 debugAssert(count == writeBytes); (void)count;

 fclose(file);
 file = NULL;

 // Record that we saved this data.
 m_alreadyWritten += writeBytes;
 m_bufferLen -= writeBytes;
 m_pos -= writeBytes;

 debugAssert(m_bufferLen < m_maxBufferLen);
 debugAssert(m_bufferLen >= 0);
 debugAssert(m_pos >= 0);
 debugAssert(m_pos <= (int64)m_bufferLen);

 // Shift the unwritten data back appropriately in the buffer.
 debugAssert(isValidHeapPointer(m_buffer));
 System::memcpy(m_buffer, m_buffer + writeBytes, m_bufferLen);
 debugAssert(isValidHeapPointer(m_buffer));

 // *now* we allocate bytes (there should presumably be enough 
 // space in the buffer; if not, we'll come back through this 
 // code and dump the last 10MB to disk as well. Note that the 
 // bytes > maxBufferLen case above would already have triggered
 // if this call couldn't succeed. 
 reserveBytes(bytes);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::reset

(

)

A memory BinaryOutput may be reset so that it can be written to again without allocating new memory. The underlying array will not be deallocated, but the reset structure will act like a newly intialized one.

 {
 debugAssert(m_beginEndBits == 0);
 alwaysAssertM(m_filename == "<memory>", 
 "Can only reset a BinaryOutput that writes to memory.");

 // Do not reallocate, just clear the size of the buffer.
 m_pos = 0;
 m_alreadyWritten = 0;
 m_bufferLen = 0;
 m_beginEndBits = 0;
 m_bitString = 0;
 m_bitPos = 0;
 m_committed = false;
}

Here is the caller graph for this function:

void G3D::BinaryOutput::setEndian

(

G3DEndian

fileEndian

)

 {
 m_fileEndian = fileEndian;
 m_swapBytes = (fileEndian != System::machineEndian());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::setLength ( int64  n )

inline

Sets the length of the file to n, padding with 0's past the current end. Does not change the position of the next byte to be written unless n < size().

Throws char* when resetting a huge file to be shorter than its current length.

 {
 n = n - m_alreadyWritten;

 if (n < 0) {
 throw "Cannot resize huge files to be shorter.";
 }

 if (n < (int64)m_bufferLen) {
 m_pos = n;
 }
 if (n > (int64)m_bufferLen) {
 reserveBytes((size_t)(n - m_bufferLen));
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::setPosition ( int64  p )

inline

Sets the position. Can set past length, in which case the file is padded with zeros up to one byte before the next to be written.

May throw a char* exception when seeking backwards on a huge file.

 {
 p = p - m_alreadyWritten;

 if (p > (int64)m_bufferLen) {
 setLength((int)(p + (int64)m_alreadyWritten));
 }

 if (p < 0) {
 throw "Cannot seek more than 10 MB backwards on huge files.";
 }

 m_pos = (int)p;
 }

Here is the call graph for this function:

int64 G3D::BinaryOutput::size ( ) const

inline

 {
 return length();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::skip ( int  n )

inline

Skips ahead n bytes.

 {
 if (m_pos + n > (int64)m_bufferLen) {
 setLength(m_pos + m_alreadyWritten + n);
 }
 m_pos += n;
 }

Here is the call graph for this function:

void G3D::BinaryOutput::writeBits	(	uint32	bitString,
		int	numBits
	)

Write numBits from bitString to the output stream. Bits are numbered from low to high.

Can only be called between beginBits and endBits. Bits written are semantically little-endian, regardless of the actual endian-ness of the system. That is, writeBits(0xABCD, 16) writes 0xCD to the first byte and 0xAB to the second byte. However, if used with BinaryInput::readBits, the ordering is transparent to the caller.

 {

 while (numBits > 0) {
 // Extract the current bit of value and
 // insert it into the current byte
 m_bitString |= (value & 1) << m_bitPos;
 ++m_bitPos;
 value = value >> 1;
 --numBits;

 if (m_bitPos > 7) {
 // We've reached the end of this byte
 writeUInt8(m_bitString);
 m_bitString = 0x00;
 m_bitPos = 0;
 }
 }
}

Here is the call graph for this function:

void G3D::BinaryOutput::writeBool8 ( bool  b )

inline

 {
 writeInt8(b ? 1 : 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeBytes ( const void *  b, size_t  count  )

inline

 {

 reserveBytes(count);
 debugAssert(m_pos >= 0);
 debugAssert(m_bufferLen >= count);
 System::memcpy(m_buffer + m_pos, b, count);
 m_pos += count;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeColor3

(

const Color3 &

v

)

                                              {
    writeFloat32(v.r);
    writeFloat32(v.g);
    writeFloat32(v.b);
}

Here is the call graph for this function:

void G3D::BinaryOutput::writeColor4

(

const Color4 &

v

)

                                              {
    writeFloat32(v.r);
    writeFloat32(v.g);
    writeFloat32(v.b);
    writeFloat32(v.a);
}

Here is the call graph for this function:

void G3D::BinaryOutput::writeFloat32 ( float32  f )

inline

                                        {
        debugAssert(m_beginEndBits == 0);
        union {
            float32 a;
            uint32 b;
        };
        a = f;
        writeUInt32(b);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeFloat64 ( float64  f )

inline

                                        {
        union {
            float64 a;
            uint64 b;
        };
        a = f;
        writeUInt64(b);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeInt16 ( int16  i )

inline

                                    {
        writeUInt16(*(uint16*)&i);
    }

Here is the call graph for this function:

void G3D::BinaryOutput::writeInt32 ( int32  i )

inline

                                    {
        debugAssert(m_beginEndBits == 0);
        writeUInt32(*(uint32*)&i);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeInt64 ( int64  i )

inline

                                    {
        writeUInt64(*(uint64*)&i);
    }

Here is the call graph for this function:

void G3D::BinaryOutput::writeInt8 ( int8  i )

inline

Writes a signed 8-bit integer to the current position.

                                  {
        reserveBytes(1);
        m_buffer[m_pos] = *(uint8*)&i;
        ++m_pos;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeString ( const std::string &  s )

inline

Write a string with NULL termination.

                                                {
        writeString(s.c_str());
    }

Here is the caller graph for this function:

void G3D::BinaryOutput::writeString ( const std::string &  s, int  len  )

inline

Write a string that always consumes len bytes, truncating or padding as necessary

                                                         {
        const int pad = len - ((int)s.length() + 1);
        if (pad >= 0) {
            writeString(s.c_str());
            for (int i = 0; i < pad; ++i) {
                writeUInt8(0);
            }
        } else {
            // Truncate
            writeBytes(s.c_str(), len);
        }
    }

Here is the call graph for this function:

void G3D::BinaryOutput::writeString

(

const char *

s

)

                                            {
    // +1 is because strlen doesn't count the null
    size_t len = strlen(s) + 1;

    debugAssert(m_beginEndBits == 0);
    reserveBytes(len);
    System::memcpy(m_buffer + m_pos, s, len);
    m_pos += len;
}

Here is the call graph for this function:

void G3D::BinaryOutput::writeString32

(

const char *

s

)

                                              {
    // Write the NULL and count it
    size_t len = strlen(s) + 1;
    writeUInt32((uint32)len);

    debugAssert(m_beginEndBits == 0);
    reserveBytes(len);
    System::memcpy(m_buffer + m_pos, s, len);
    m_pos += len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeString32 ( const std::string &  s )

inline

Write a NULL-terminated string with a 32-bit length field in front of it. The NULL character is included in the length count.

                                           {
        writeString32(s.c_str());
    }

Here is the call graph for this function:

void G3D::BinaryOutput::writeStringEven ( const std::string &  s )

inline

Write a string, ensuring that the total length including NULL is even.

                                             {
        writeStringEven(s.c_str());
    }

void G3D::BinaryOutput::writeStringEven

(

const char *

s

)

                                                {
    // +1 is because strlen doesn't count the null
    size_t len = strlen(s) + 1;

    reserveBytes(len);
    System::memcpy(m_buffer + m_pos, s, len);
    m_pos += len;

    // Pad with another NULL
    if ((len % 2) == 1) {
        writeUInt8(0);
    }
}

Here is the call graph for this function:

void G3D::BinaryOutput::writeUInt16

(

uint16

u

)

                                       {
    reserveBytes(2);

    uint8* convert = (uint8*)&u;

    if (m_swapBytes) {
        m_buffer[m_pos]     = convert[1];
        m_buffer[m_pos + 1] = convert[0];
    } else {
        *(uint16*)(m_buffer + m_pos) = u;
    }

    m_pos += 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeUInt32

(

uint32

u

)

                                       {
    reserveBytes(4);

    uint8* convert = (uint8*)&u;

    debugAssert(m_beginEndBits == 0);

    if (m_swapBytes) {
        m_buffer[m_pos]     = convert[3];
        m_buffer[m_pos + 1] = convert[2];
        m_buffer[m_pos + 2] = convert[1];
        m_buffer[m_pos + 3] = convert[0];
    } else {
        *(uint32*)(m_buffer + m_pos) = u;
    }

    m_pos += 4;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeUInt64

(

uint64

u

)

                                       {
    reserveBytes(8);

    uint8* convert = (uint8*)&u;

    if (m_swapBytes) {
        m_buffer[m_pos]     = convert[7];
        m_buffer[m_pos + 1] = convert[6];
        m_buffer[m_pos + 2] = convert[5];
        m_buffer[m_pos + 3] = convert[4];
        m_buffer[m_pos + 4] = convert[3];
        m_buffer[m_pos + 5] = convert[2];
        m_buffer[m_pos + 6] = convert[1];
        m_buffer[m_pos + 7] = convert[0];
    } else {
        *(uint64*)(m_buffer + m_pos) = u;
    }

    m_pos += 8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeUInt8 ( uint8  i )

inline

                                    {
        reserveBytes(1);
        m_buffer[m_pos] = i;
        ++m_pos;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeUNorm8 ( unorm8  i )

inline

                                      {
        writeUInt8(i.bits());
    }

Here is the call graph for this function:

void G3D::BinaryOutput::writeVector2

(

const Vector2 &

v

)

                                                {
    writeFloat32(v.x);
    writeFloat32(v.y);
}

Here is the call graph for this function:

void G3D::BinaryOutput::writeVector3

(

const Vector3 &

v

)

                                                {
    writeFloat32(v.x);
    writeFloat32(v.y);
    writeFloat32(v.z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryOutput::writeVector4

(

const Vector4 &

v

)

                                                {
    writeFloat32(v.x);
    writeFloat32(v.y);
    writeFloat32(v.z);
    writeFloat32(v.w);
}

Here is the call graph for this function:

Member Data Documentation

int64 G3D::BinaryOutput::m_alreadyWritten

private

Number of bytes already written to the file. Even on 32-bit OS, this can be 64-bits

int G3D::BinaryOutput::m_beginEndBits

private

0 outside of beginBits...endBits, 1 inside

int G3D::BinaryOutput::m_bitPos

private

Position (from the lowest bit) currently used in bitString.

int8 G3D::BinaryOutput::m_bitString

private

The current string of bits being built up by beginBits...endBits. This string is treated semantically, as if the lowest bit was on the left and the highest was on the right.

uint8* G3D::BinaryOutput::m_buffer

private

size_t G3D::BinaryOutput::m_bufferLen

private

Size of the elements used

bool G3D::BinaryOutput::m_committed

private

G3DEndian G3D::BinaryOutput::m_fileEndian

private

std::string G3D::BinaryOutput::m_filename

private

bool G3D::BinaryOutput::m_init

private

is this initialized?

size_t G3D::BinaryOutput::m_maxBufferLen

private

Underlying size of memory allocaded

bool G3D::BinaryOutput::m_ok

private

int64 G3D::BinaryOutput::m_pos

private

Next byte in file

bool G3D::BinaryOutput::m_swapBytes

private

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/BinaryOutput.h
• dep/g3dlite/source/BinaryOutput.cpp