mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/4jcraft.git
synced 2026-05-29 18:34:55 +00:00
chore: format Minecraft.World
This commit is contained in:
Tropical
@@ -4,475 +4,442 @@
|
||||
#include "FloatBuffer.h"
|
||||
#include "ByteBuffer.h"
|
||||
|
||||
ByteBuffer::ByteBuffer( unsigned int capacity ) : Buffer( capacity )
|
||||
{
|
||||
hasBackingArray = false;
|
||||
buffer = new uint8_t[capacity];
|
||||
memset( buffer,0,sizeof(uint8_t)*capacity);
|
||||
byteOrder = BIGENDIAN;
|
||||
ByteBuffer::ByteBuffer(unsigned int capacity) : Buffer(capacity) {
|
||||
hasBackingArray = false;
|
||||
buffer = new uint8_t[capacity];
|
||||
memset(buffer, 0, sizeof(uint8_t) * capacity);
|
||||
byteOrder = BIGENDIAN;
|
||||
}
|
||||
|
||||
//Allocates a new direct byte buffer.
|
||||
//The new buffer's position will be zero, its limit will be its capacity, and its mark will be undefined. Whether or not it has a backing array is unspecified.
|
||||
// Allocates a new direct byte buffer.
|
||||
// The new buffer's position will be zero, its limit will be its capacity, and
|
||||
// its mark will be undefined. Whether or not it has a backing array is
|
||||
// unspecified.
|
||||
//
|
||||
//Parameters:
|
||||
//capacity - The new buffer's capacity, in bytes
|
||||
//Returns:
|
||||
//The new byte buffer
|
||||
ByteBuffer *ByteBuffer::allocateDirect(int capacity)
|
||||
{
|
||||
return new ByteBuffer(capacity);
|
||||
// Parameters:
|
||||
// capacity - The new buffer's capacity, in bytes
|
||||
// Returns:
|
||||
// The new byte buffer
|
||||
ByteBuffer* ByteBuffer::allocateDirect(int capacity) {
|
||||
return new ByteBuffer(capacity);
|
||||
}
|
||||
|
||||
|
||||
ByteBuffer::ByteBuffer( unsigned int capacity, uint8_t *backingArray ) : Buffer( capacity )
|
||||
{
|
||||
hasBackingArray = true;
|
||||
buffer = backingArray;
|
||||
ByteBuffer::ByteBuffer(unsigned int capacity, uint8_t* backingArray)
|
||||
: Buffer(capacity) {
|
||||
hasBackingArray = true;
|
||||
buffer = backingArray;
|
||||
}
|
||||
|
||||
ByteBuffer::~ByteBuffer()
|
||||
{
|
||||
if( !hasBackingArray )
|
||||
delete[] buffer;
|
||||
ByteBuffer::~ByteBuffer() {
|
||||
if (!hasBackingArray) delete[] buffer;
|
||||
}
|
||||
|
||||
//Wraps a byte array into a buffer.
|
||||
//The new buffer will be backed by the given uint8_t array; that is, modifications to the buffer will cause the array
|
||||
//to be modified and vice versa. The new buffer's capacity and limit will be array.length, its position will be zero,
|
||||
//and its mark will be undefined. Its backing array will be the given array, and its array offset will be zero.
|
||||
// Wraps a byte array into a buffer.
|
||||
// The new buffer will be backed by the given uint8_t array; that is,
|
||||
// modifications to the buffer will cause the array to be modified and vice
|
||||
// versa. The new buffer's capacity and limit will be array.length, its position
|
||||
// will be zero, and its mark will be undefined. Its backing array will be the
|
||||
// given array, and its array offset will be zero.
|
||||
//
|
||||
//Parameters:
|
||||
//array - The array that will back this buffer
|
||||
//Returns:
|
||||
//The new byte buffer
|
||||
ByteBuffer *ByteBuffer::wrap(byteArray &b)
|
||||
{
|
||||
return new ByteBuffer( b.length, b.data );
|
||||
// Parameters:
|
||||
// array - The array that will back this buffer
|
||||
// Returns:
|
||||
// The new byte buffer
|
||||
ByteBuffer* ByteBuffer::wrap(byteArray& b) {
|
||||
return new ByteBuffer(b.length, b.data);
|
||||
}
|
||||
|
||||
//Allocates a new byte buffer.
|
||||
//The new buffer's position will be zero, its limit will be its capacity, and its mark will be undefined.
|
||||
//It will have a backing array, and its array offset will be zero.
|
||||
// Allocates a new byte buffer.
|
||||
// The new buffer's position will be zero, its limit will be its capacity, and
|
||||
// its mark will be undefined. It will have a backing array, and its array
|
||||
// offset will be zero.
|
||||
//
|
||||
//Parameters:
|
||||
//capacity - The new buffer's capacity, in bytes
|
||||
//Returns:
|
||||
//The new byte buffer
|
||||
ByteBuffer *ByteBuffer::allocate(unsigned int capacity)
|
||||
{
|
||||
return new ByteBuffer( capacity );
|
||||
// Parameters:
|
||||
// capacity - The new buffer's capacity, in bytes
|
||||
// Returns:
|
||||
// The new byte buffer
|
||||
ByteBuffer* ByteBuffer::allocate(unsigned int capacity) {
|
||||
return new ByteBuffer(capacity);
|
||||
}
|
||||
|
||||
//Modifies this buffer's byte order.
|
||||
//Parameters:
|
||||
//bo - The new byte order, either BIGENDIAN or LITTLEENDIAN
|
||||
void ByteBuffer::order(ByteOrder bo)
|
||||
{
|
||||
byteOrder = bo;
|
||||
}
|
||||
// Modifies this buffer's byte order.
|
||||
// Parameters:
|
||||
// bo - The new byte order, either BIGENDIAN or LITTLEENDIAN
|
||||
void ByteBuffer::order(ByteOrder bo) { byteOrder = bo; }
|
||||
|
||||
//Flips this buffer. The limit is set to the current position and then the position is set to zero.
|
||||
//If the mark is defined then it is discarded.
|
||||
// Flips this buffer. The limit is set to the current position and then the
|
||||
// position is set to zero. If the mark is defined then it is discarded.
|
||||
//
|
||||
//Returns:
|
||||
//This buffer
|
||||
ByteBuffer *ByteBuffer::flip()
|
||||
{
|
||||
m_limit = m_position;
|
||||
m_position = 0;
|
||||
return this;
|
||||
// Returns:
|
||||
// This buffer
|
||||
ByteBuffer* ByteBuffer::flip() {
|
||||
m_limit = m_position;
|
||||
m_position = 0;
|
||||
return this;
|
||||
}
|
||||
|
||||
// 4J Added so we can write this to a file
|
||||
uint8_t *ByteBuffer::getBuffer()
|
||||
{
|
||||
return buffer;
|
||||
}
|
||||
uint8_t* ByteBuffer::getBuffer() { return buffer; }
|
||||
|
||||
int ByteBuffer::getSize()
|
||||
{
|
||||
// TODO 4J Stu - Should this be the capcity and not the limit?
|
||||
return m_limit;
|
||||
int ByteBuffer::getSize() {
|
||||
// TODO 4J Stu - Should this be the capcity and not the limit?
|
||||
return m_limit;
|
||||
}
|
||||
// End 4J
|
||||
|
||||
//Absolute get method. Reads the byte at the given index.
|
||||
//Parameters:
|
||||
//index - The index from which the byte will be read
|
||||
//Returns:
|
||||
//The byte at the given index
|
||||
//Throws:
|
||||
//IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
|
||||
uint8_t ByteBuffer::get(int index)
|
||||
{
|
||||
assert( index < m_limit );
|
||||
assert( index >= 0 );
|
||||
// Absolute get method. Reads the byte at the given index.
|
||||
// Parameters:
|
||||
// index - The index from which the byte will be read
|
||||
// Returns:
|
||||
// The byte at the given index
|
||||
// Throws:
|
||||
// IndexOutOfBoundsException - If index is negative or not smaller than the
|
||||
// buffer's limit
|
||||
uint8_t ByteBuffer::get(int index) {
|
||||
assert(index < m_limit);
|
||||
assert(index >= 0);
|
||||
|
||||
return buffer[index];
|
||||
return buffer[index];
|
||||
}
|
||||
|
||||
//Relative get method for reading an int value.
|
||||
//Reads the next four bytes at this buffer's current position, composing them into an int value according to the
|
||||
//current byte order, and then increments the position by four.
|
||||
// Relative get method for reading an int value.
|
||||
// Reads the next four bytes at this buffer's current position, composing them
|
||||
// into an int value according to the current byte order, and then increments
|
||||
// the position by four.
|
||||
//
|
||||
//Returns:
|
||||
//The int value at the buffer's current position
|
||||
int ByteBuffer::getInt()
|
||||
{
|
||||
assert( m_position+3 < m_limit );
|
||||
// Returns:
|
||||
// The int value at the buffer's current position
|
||||
int ByteBuffer::getInt() {
|
||||
assert(m_position + 3 < m_limit);
|
||||
|
||||
int value = 0;
|
||||
int value = 0;
|
||||
|
||||
int b1 = static_cast<int>(buffer[ m_position ]);
|
||||
int b2 = static_cast<int>(buffer[ m_position+1 ]);
|
||||
int b3 = static_cast<int>(buffer[ m_position+2 ]);
|
||||
int b4 = static_cast<int>(buffer[ m_position+3 ]);
|
||||
int b1 = static_cast<int>(buffer[m_position]);
|
||||
int b2 = static_cast<int>(buffer[m_position + 1]);
|
||||
int b3 = static_cast<int>(buffer[m_position + 2]);
|
||||
int b4 = static_cast<int>(buffer[m_position + 3]);
|
||||
|
||||
m_position += 4;
|
||||
m_position += 4;
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
value = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
value = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
|
||||
}
|
||||
return value;
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
value = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
value = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
//Absolute get method for reading an int value.
|
||||
//Reads four bytes at the given index, composing them into a int value according to the current byte order.
|
||||
// Absolute get method for reading an int value.
|
||||
// Reads four bytes at the given index, composing them into a int value
|
||||
// according to the current byte order.
|
||||
//
|
||||
//Parameters:
|
||||
//index - The index from which the bytes will be read
|
||||
//Returns:
|
||||
//The int value at the given index
|
||||
int ByteBuffer::getInt(unsigned int index)
|
||||
{
|
||||
assert( index+3 < m_limit );
|
||||
int value = 0;
|
||||
// Parameters:
|
||||
// index - The index from which the bytes will be read
|
||||
// Returns:
|
||||
// The int value at the given index
|
||||
int ByteBuffer::getInt(unsigned int index) {
|
||||
assert(index + 3 < m_limit);
|
||||
int value = 0;
|
||||
|
||||
int b1 = static_cast<int>(buffer[ index ]);
|
||||
int b2 = static_cast<int>(buffer[ index+1 ]);
|
||||
int b3 = static_cast<int>(buffer[ index+2 ]);
|
||||
int b4 = static_cast<int>(buffer[ index+3 ]);
|
||||
int b1 = static_cast<int>(buffer[index]);
|
||||
int b2 = static_cast<int>(buffer[index + 1]);
|
||||
int b3 = static_cast<int>(buffer[index + 2]);
|
||||
int b4 = static_cast<int>(buffer[index + 3]);
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
value = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
value = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
|
||||
}
|
||||
return value;
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
value = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
value = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
//Relative get method for reading a long value.
|
||||
//Reads the next eight bytes at this buffer's current position, composing them into a long value according to the current byte order,
|
||||
//and then increments the position by eight.
|
||||
// Relative get method for reading a long value.
|
||||
// Reads the next eight bytes at this buffer's current position, composing them
|
||||
// into a long value according to the current byte order, and then increments
|
||||
// the position by eight.
|
||||
//
|
||||
//Returns:
|
||||
//The long value at the buffer's current position
|
||||
__int64 ByteBuffer::getLong()
|
||||
{
|
||||
assert( m_position+8 < m_limit );
|
||||
// Returns:
|
||||
// The long value at the buffer's current position
|
||||
__int64 ByteBuffer::getLong() {
|
||||
assert(m_position + 8 < m_limit);
|
||||
|
||||
__int64 value = 0;
|
||||
__int64 value = 0;
|
||||
|
||||
__int64 b1 = static_cast<__int64>(buffer[ m_position ]);
|
||||
__int64 b2 = static_cast<__int64>(buffer[ m_position+1 ]);
|
||||
__int64 b3 = static_cast<__int64>(buffer[ m_position+2 ]);
|
||||
__int64 b4 = static_cast<__int64>(buffer[ m_position+3 ]);
|
||||
__int64 b5 = static_cast<__int64>(buffer[ m_position+4 ]);
|
||||
__int64 b6 = static_cast<__int64>(buffer[ m_position+5 ]);
|
||||
__int64 b7 = static_cast<__int64>(buffer[ m_position+6 ]);
|
||||
__int64 b8 = static_cast<__int64>(buffer[ m_position+7 ]);
|
||||
__int64 b1 = static_cast<__int64>(buffer[m_position]);
|
||||
__int64 b2 = static_cast<__int64>(buffer[m_position + 1]);
|
||||
__int64 b3 = static_cast<__int64>(buffer[m_position + 2]);
|
||||
__int64 b4 = static_cast<__int64>(buffer[m_position + 3]);
|
||||
__int64 b5 = static_cast<__int64>(buffer[m_position + 4]);
|
||||
__int64 b6 = static_cast<__int64>(buffer[m_position + 5]);
|
||||
__int64 b7 = static_cast<__int64>(buffer[m_position + 6]);
|
||||
__int64 b8 = static_cast<__int64>(buffer[m_position + 7]);
|
||||
|
||||
m_position += 8;
|
||||
m_position += 8;
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
value = (b1 << 56) | (b2 << 48) | (b3 << 40) | (b4 << 32) | (b5 << 24) | (b6 << 16) | (b7 << 8) | b8;
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
value = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24) | (b5 << 32) | (b6 << 40) | (b7 << 48) | (b8 << 56);
|
||||
}
|
||||
return value;
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
value = (b1 << 56) | (b2 << 48) | (b3 << 40) | (b4 << 32) | (b5 << 24) |
|
||||
(b6 << 16) | (b7 << 8) | b8;
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
value = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24) | (b5 << 32) |
|
||||
(b6 << 40) | (b7 << 48) | (b8 << 56);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
//Relative get method for reading a short value.
|
||||
//Reads the next two bytes at this buffer's current position, composing them into a short value according to the current
|
||||
//byte order, and then increments the position by two.
|
||||
// Relative get method for reading a short value.
|
||||
// Reads the next two bytes at this buffer's current position, composing them
|
||||
// into a short value according to the current byte order, and then increments
|
||||
// the position by two.
|
||||
//
|
||||
//Returns:
|
||||
//The short value at the buffer's current position
|
||||
short ByteBuffer::getShort()
|
||||
{
|
||||
assert( m_position+1 < m_limit );
|
||||
// Returns:
|
||||
// The short value at the buffer's current position
|
||||
short ByteBuffer::getShort() {
|
||||
assert(m_position + 1 < m_limit);
|
||||
|
||||
short value = 0;
|
||||
short value = 0;
|
||||
|
||||
short b1 = static_cast<short>(buffer[ m_position ]);
|
||||
short b2 = static_cast<short>(buffer[ m_position+1 ]);
|
||||
short b1 = static_cast<short>(buffer[m_position]);
|
||||
short b2 = static_cast<short>(buffer[m_position + 1]);
|
||||
|
||||
m_position += 2;
|
||||
m_position += 2;
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
value = (b1 << 8) | b2;
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
value = b1 | (b2 << 8);
|
||||
}
|
||||
return value;
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
value = (b1 << 8) | b2;
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
value = b1 | (b2 << 8);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
void ByteBuffer::getShortArray(shortArray &s)
|
||||
{
|
||||
// TODO 4J Stu - Should this function be writing from the start of the buffer, or from position?
|
||||
// And should it update position?
|
||||
assert( s.length >= m_limit/2 );
|
||||
void ByteBuffer::getShortArray(shortArray& s) {
|
||||
// TODO 4J Stu - Should this function be writing from the start of the
|
||||
// buffer, or from position? And should it update position?
|
||||
assert(s.length >= m_limit / 2);
|
||||
|
||||
// 4J Stu - Assumes big endian
|
||||
memcpy( s.data, buffer, (m_limit-m_position) );
|
||||
// 4J Stu - Assumes big endian
|
||||
memcpy(s.data, buffer, (m_limit - m_position));
|
||||
}
|
||||
|
||||
//Absolute put method (optional operation).
|
||||
//Writes the given byte into this buffer at the given index.
|
||||
// Absolute put method (optional operation).
|
||||
// Writes the given byte into this buffer at the given index.
|
||||
//
|
||||
//Parameters:
|
||||
//index - The index at which the byte will be written
|
||||
//b - The byte value to be written
|
||||
//Returns:
|
||||
//This buffer
|
||||
//Throws:
|
||||
//IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
|
||||
//ReadOnlyBufferException - If this buffer is read-only
|
||||
ByteBuffer *ByteBuffer::put(int index, uint8_t b)
|
||||
{
|
||||
assert( index < m_limit );
|
||||
assert( index >= 0 );
|
||||
// Parameters:
|
||||
// index - The index at which the byte will be written
|
||||
// b - The byte value to be written
|
||||
// Returns:
|
||||
// This buffer
|
||||
// Throws:
|
||||
// IndexOutOfBoundsException - If index is negative or not smaller than the
|
||||
// buffer's limit ReadOnlyBufferException - If this buffer is read-only
|
||||
ByteBuffer* ByteBuffer::put(int index, uint8_t b) {
|
||||
assert(index < m_limit);
|
||||
assert(index >= 0);
|
||||
|
||||
buffer[index] = b;
|
||||
return this;
|
||||
buffer[index] = b;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
//Relative put method for writing an int value (optional operation).
|
||||
//Writes four bytes containing the given int value, in the current byte order, into this buffer at the current position,
|
||||
//and then increments the position by four.
|
||||
// Relative put method for writing an int value (optional operation).
|
||||
// Writes four bytes containing the given int value, in the current byte order,
|
||||
// into this buffer at the current position, and then increments the position by
|
||||
// four.
|
||||
//
|
||||
//Parameters:
|
||||
//value - The int value to be written
|
||||
//Returns:
|
||||
//This buffer
|
||||
ByteBuffer *ByteBuffer::putInt(int value)
|
||||
{
|
||||
assert( m_position+3 < m_limit );
|
||||
// Parameters:
|
||||
// value - The int value to be written
|
||||
// Returns:
|
||||
// This buffer
|
||||
ByteBuffer* ByteBuffer::putInt(int value) {
|
||||
assert(m_position + 3 < m_limit);
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
buffer[m_position] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[m_position+1] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position+2] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position+3] = static_cast<uint8_t>(value & 0xFF);
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
buffer[m_position] = static_cast<uint8_t>(value & 0xFF);
|
||||
buffer[m_position+1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position+2] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position+3] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
}
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
buffer[m_position] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[m_position + 1] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position + 2] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position + 3] = static_cast<uint8_t>(value & 0xFF);
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
buffer[m_position] = static_cast<uint8_t>(value & 0xFF);
|
||||
buffer[m_position + 1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position + 2] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position + 3] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
}
|
||||
|
||||
m_position += 4;
|
||||
m_position += 4;
|
||||
|
||||
return this;
|
||||
return this;
|
||||
}
|
||||
|
||||
//Absolute put method for writing an int value (optional operation).
|
||||
//Writes four bytes containing the given int value, in the current byte order, into this buffer at the given index.
|
||||
// Absolute put method for writing an int value (optional operation).
|
||||
// Writes four bytes containing the given int value, in the current byte order,
|
||||
// into this buffer at the given index.
|
||||
//
|
||||
//Parameters:
|
||||
//index - The index at which the bytes will be written
|
||||
//value - The int value to be written
|
||||
//Returns:
|
||||
//This buffer
|
||||
ByteBuffer *ByteBuffer::putInt(unsigned int index, int value)
|
||||
{
|
||||
assert( index+3 < m_limit );
|
||||
// Parameters:
|
||||
// index - The index at which the bytes will be written
|
||||
// value - The int value to be written
|
||||
// Returns:
|
||||
// This buffer
|
||||
ByteBuffer* ByteBuffer::putInt(unsigned int index, int value) {
|
||||
assert(index + 3 < m_limit);
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
buffer[index] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[index+1] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[index+2] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[index+3] = static_cast<uint8_t>(value & 0xFF);
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
buffer[index] = static_cast<uint8_t>(value & 0xFF);
|
||||
buffer[index+1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[index+2] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[index+3] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
}
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
buffer[index] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[index + 1] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[index + 2] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[index + 3] = static_cast<uint8_t>(value & 0xFF);
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
buffer[index] = static_cast<uint8_t>(value & 0xFF);
|
||||
buffer[index + 1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[index + 2] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[index + 3] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
}
|
||||
|
||||
return this;
|
||||
return this;
|
||||
}
|
||||
|
||||
//Relative put method for writing a short value (optional operation).
|
||||
//Writes two bytes containing the given short value, in the current byte order, into this buffer at the current position,
|
||||
//and then increments the position by two.
|
||||
// Relative put method for writing a short value (optional operation).
|
||||
// Writes two bytes containing the given short value, in the current byte order,
|
||||
// into this buffer at the current position, and then increments the position by
|
||||
// two.
|
||||
//
|
||||
//Parameters:
|
||||
//value - The short value to be written
|
||||
//Returns:
|
||||
//This buffer
|
||||
ByteBuffer *ByteBuffer::putShort(short value)
|
||||
{
|
||||
assert( m_position+1 < m_limit );
|
||||
// Parameters:
|
||||
// value - The short value to be written
|
||||
// Returns:
|
||||
// This buffer
|
||||
ByteBuffer* ByteBuffer::putShort(short value) {
|
||||
assert(m_position + 1 < m_limit);
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
buffer[m_position] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position+1] = static_cast<uint8_t>(value & 0xFF);
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
buffer[m_position] = static_cast<uint8_t>(value & 0xFF);
|
||||
buffer[m_position+1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
}
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
buffer[m_position] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position + 1] = static_cast<uint8_t>(value & 0xFF);
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
buffer[m_position] = static_cast<uint8_t>(value & 0xFF);
|
||||
buffer[m_position + 1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
}
|
||||
|
||||
m_position += 2;
|
||||
m_position += 2;
|
||||
|
||||
return this;
|
||||
return this;
|
||||
}
|
||||
|
||||
ByteBuffer *ByteBuffer::putShortArray(shortArray &s)
|
||||
{
|
||||
// TODO 4J Stu - Should this function be writing from the start of the buffer, or from position?
|
||||
// And should it update position?
|
||||
assert( s.length*2 <= m_limit);
|
||||
|
||||
// 4J Stu - Assumes big endian
|
||||
memcpy( buffer, s.data, s.length*2 );
|
||||
ByteBuffer* ByteBuffer::putShortArray(shortArray& s) {
|
||||
// TODO 4J Stu - Should this function be writing from the start of the
|
||||
// buffer, or from position? And should it update position?
|
||||
assert(s.length * 2 <= m_limit);
|
||||
|
||||
return this;
|
||||
// 4J Stu - Assumes big endian
|
||||
memcpy(buffer, s.data, s.length * 2);
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
//Relative put method for writing a long value (optional operation).
|
||||
//Writes eight bytes containing the given long value, in the current byte order, into this buffer at the current position,
|
||||
//and then increments the position by eight.
|
||||
// Relative put method for writing a long value (optional operation).
|
||||
// Writes eight bytes containing the given long value, in the current byte
|
||||
// order, into this buffer at the current position, and then increments the
|
||||
// position by eight.
|
||||
//
|
||||
//Parameters:
|
||||
//value - The long value to be written
|
||||
//Returns:
|
||||
//This buffer
|
||||
ByteBuffer *ByteBuffer::putLong(__int64 value)
|
||||
{
|
||||
assert( m_position+7 < m_limit );
|
||||
// Parameters:
|
||||
// value - The long value to be written
|
||||
// Returns:
|
||||
// This buffer
|
||||
ByteBuffer* ByteBuffer::putLong(__int64 value) {
|
||||
assert(m_position + 7 < m_limit);
|
||||
|
||||
if( byteOrder == BIGENDIAN )
|
||||
{
|
||||
buffer[m_position] = static_cast<uint8_t>((value >> 56) & 0xFF);
|
||||
buffer[m_position+1] = static_cast<uint8_t>((value >> 48) & 0xFF);
|
||||
buffer[m_position+2] = static_cast<uint8_t>((value >> 40) & 0xFF);
|
||||
buffer[m_position+3] = static_cast<uint8_t>((value >> 32) & 0xFF);
|
||||
buffer[m_position+4] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[m_position+5] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position+6] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position+7] = static_cast<uint8_t>(value & 0xFF);
|
||||
}
|
||||
else if( byteOrder == LITTLEENDIAN )
|
||||
{
|
||||
buffer[m_position] = static_cast<uint8_t>((value & 0xFF));
|
||||
buffer[m_position+1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position+2] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position+3] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[m_position+4] = static_cast<uint8_t>((value >> 32) & 0xFF);
|
||||
buffer[m_position+5] = static_cast<uint8_t>((value >> 40) & 0xFF);
|
||||
buffer[m_position+6] = static_cast<uint8_t>((value >> 48) & 0xFF);
|
||||
buffer[m_position+7] = static_cast<uint8_t>((value >> 56) & 0xFF);
|
||||
}
|
||||
if (byteOrder == BIGENDIAN) {
|
||||
buffer[m_position] = static_cast<uint8_t>((value >> 56) & 0xFF);
|
||||
buffer[m_position + 1] = static_cast<uint8_t>((value >> 48) & 0xFF);
|
||||
buffer[m_position + 2] = static_cast<uint8_t>((value >> 40) & 0xFF);
|
||||
buffer[m_position + 3] = static_cast<uint8_t>((value >> 32) & 0xFF);
|
||||
buffer[m_position + 4] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[m_position + 5] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position + 6] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position + 7] = static_cast<uint8_t>(value & 0xFF);
|
||||
} else if (byteOrder == LITTLEENDIAN) {
|
||||
buffer[m_position] = static_cast<uint8_t>((value & 0xFF));
|
||||
buffer[m_position + 1] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
||||
buffer[m_position + 2] = static_cast<uint8_t>((value >> 16) & 0xFF);
|
||||
buffer[m_position + 3] = static_cast<uint8_t>((value >> 24) & 0xFF);
|
||||
buffer[m_position + 4] = static_cast<uint8_t>((value >> 32) & 0xFF);
|
||||
buffer[m_position + 5] = static_cast<uint8_t>((value >> 40) & 0xFF);
|
||||
buffer[m_position + 6] = static_cast<uint8_t>((value >> 48) & 0xFF);
|
||||
buffer[m_position + 7] = static_cast<uint8_t>((value >> 56) & 0xFF);
|
||||
}
|
||||
|
||||
return this;
|
||||
return this;
|
||||
}
|
||||
|
||||
//Relative bulk put method (optional operation).
|
||||
//This method transfers the entire content of the given source byte array into this buffer.
|
||||
//An invocation of this method of the form dst.put(a) behaves in exactly the same way as the invocation
|
||||
// Relative bulk put method (optional operation).
|
||||
// This method transfers the entire content of the given source byte array into
|
||||
// this buffer. An invocation of this method of the form dst.put(a) behaves in
|
||||
// exactly the same way as the invocation
|
||||
//
|
||||
// dst.put(a, 0, a.length)
|
||||
//Returns:
|
||||
//This buffer
|
||||
ByteBuffer *ByteBuffer::put(byteArray inputArray)
|
||||
{
|
||||
if( inputArray.length > remaining() )
|
||||
assert( false ); //TODO 4J Stu - Some kind of exception?
|
||||
// dst.put(a, 0, a.length)
|
||||
// Returns:
|
||||
// This buffer
|
||||
ByteBuffer* ByteBuffer::put(byteArray inputArray) {
|
||||
if (inputArray.length > remaining())
|
||||
assert(false); // TODO 4J Stu - Some kind of exception?
|
||||
|
||||
std::copy( inputArray.data, inputArray.data + inputArray.length, buffer+m_position );
|
||||
std::copy(inputArray.data, inputArray.data + inputArray.length,
|
||||
buffer + m_position);
|
||||
|
||||
m_position += inputArray.length;
|
||||
m_position += inputArray.length;
|
||||
|
||||
return this;
|
||||
return this;
|
||||
}
|
||||
|
||||
byteArray ByteBuffer::array()
|
||||
{
|
||||
return byteArray( buffer, m_capacity );
|
||||
byteArray ByteBuffer::array() { return byteArray(buffer, m_capacity); }
|
||||
|
||||
// Creates a view of this byte buffer as an int buffer.
|
||||
// The content of the new buffer will start at this buffer's current position.
|
||||
// Changes to this buffer's content will be visible in the new buffer, and vice
|
||||
// versa; the two buffers' position, limit, and mark values will be independent.
|
||||
//
|
||||
// The new buffer's position will be zero, its capacity and its limit will be
|
||||
// the number of bytes remaining in this buffer divided by four, and its mark
|
||||
// will be undefined. The new buffer will be direct if, and only if, this buffer
|
||||
// is direct, and it will be read-only if, and only if, this buffer is
|
||||
// read-only.
|
||||
//
|
||||
// Returns:
|
||||
// A new int buffer
|
||||
IntBuffer* ByteBuffer::asIntBuffer() {
|
||||
// TODO 4J Stu - Is it safe to just cast our byte array pointer to another
|
||||
// type?
|
||||
return new IntBuffer((m_limit - m_position) / 4,
|
||||
(int*)(buffer + m_position));
|
||||
}
|
||||
|
||||
//Creates a view of this byte buffer as an int buffer.
|
||||
//The content of the new buffer will start at this buffer's current position. Changes to this buffer's content
|
||||
//will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.
|
||||
// Creates a view of this byte buffer as a float buffer.
|
||||
// The content of the new buffer will start at this buffer's current position.
|
||||
// Changes to this buffer's content will be visible in the new buffer, and vice
|
||||
// versa; the two buffers' position, limit, and mark values will be independent.
|
||||
//
|
||||
//The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer
|
||||
//divided by four, and its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and
|
||||
//it will be read-only if, and only if, this buffer is read-only.
|
||||
// The new buffer's position will be zero, its capacity and its limit will be
|
||||
// the number of bytes remaining in this buffer divided by four, and its mark
|
||||
// will be undefined. The new buffer will be direct if, and only if, this buffer
|
||||
// is direct, and it will be read-only if, and only if, this buffer is
|
||||
// read-only.
|
||||
//
|
||||
//Returns:
|
||||
//A new int buffer
|
||||
IntBuffer *ByteBuffer::asIntBuffer()
|
||||
{
|
||||
// TODO 4J Stu - Is it safe to just cast our byte array pointer to another type?
|
||||
return new IntBuffer( (m_limit-m_position)/4, (int *) (buffer+m_position) );
|
||||
// Returns:
|
||||
// A new float buffer
|
||||
FloatBuffer* ByteBuffer::asFloatBuffer() {
|
||||
// TODO 4J Stu - Is it safe to just cast our byte array pointer to another
|
||||
// type?
|
||||
return new FloatBuffer((m_limit - m_position) / 4,
|
||||
(float*)(buffer + m_position));
|
||||
}
|
||||
|
||||
//Creates a view of this byte buffer as a float buffer.
|
||||
//The content of the new buffer will start at this buffer's current position. Changes to this buffer's content will be
|
||||
//visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.
|
||||
//
|
||||
//The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer
|
||||
//divided by four, and its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct,
|
||||
//and it will be read-only if, and only if, this buffer is read-only.
|
||||
//
|
||||
//Returns:
|
||||
//A new float buffer
|
||||
FloatBuffer *ByteBuffer::asFloatBuffer()
|
||||
{
|
||||
// TODO 4J Stu - Is it safe to just cast our byte array pointer to another type?
|
||||
return new FloatBuffer( (m_limit-m_position)/4, (float *) (buffer+m_position) );
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef __PS3__
|
||||
// we're using the RSX now to upload textures to vram, so we need th main ram textures allocated from io space
|
||||
ByteBuffer_IO::ByteBuffer_IO( unsigned int capacity )
|
||||
: ByteBuffer(capacity, (uint8_t*)RenderManager.allocIOMem(capacity, 64))
|
||||
{
|
||||
memset( buffer,0,sizeof(uint8_t)*capacity);
|
||||
byteOrder = BIGENDIAN;
|
||||
// we're using the RSX now to upload textures to vram, so we need th main ram
|
||||
// textures allocated from io space
|
||||
ByteBuffer_IO::ByteBuffer_IO(unsigned int capacity)
|
||||
: ByteBuffer(capacity, (uint8_t*)RenderManager.allocIOMem(capacity, 64)) {
|
||||
memset(buffer, 0, sizeof(uint8_t) * capacity);
|
||||
byteOrder = BIGENDIAN;
|
||||
}
|
||||
|
||||
ByteBuffer_IO::~ByteBuffer_IO()
|
||||
{
|
||||
// delete buffer;
|
||||
RenderManager.freeIOMem(buffer);
|
||||
ByteBuffer_IO::~ByteBuffer_IO() {
|
||||
// delete buffer;
|
||||
RenderManager.freeIOMem(buffer);
|
||||
}
|
||||
#endif // __PS3__
|
||||
#endif // __PS3__
|
||||
|
||||
Reference in New Issue
Block a user