/// Add vertex to buffers
static void addVertex(OglCanvas *c, GLfloat x, GLfloat y,
GLfloat r, GLfloat g, GLfloat b, GLfloat a,
GLfloat u, GLfloat v)
{
reserveSpace(c, 1);
Vector rv = c->transform.back() * Vector(x, y);
x = rv.getX();
y = rv.getY();
int i = c->numVertices * 2;
c->vertexBuffer[i] = x;
c->vertexBuffer[i + 1] = y;
c->texBuffer[i] = u;
c->texBuffer[i + 1] = v;
i = c->numVertices * 4;
c->colorBuffer[i] = r;
c->colorBuffer[i + 1] = g;
c->colorBuffer[i + 2] = b;
c->colorBuffer[i + 3] = a;
c->numVertices++;
}
bool VertexBufferInterface::storeRawData(const void* data, unsigned int size, unsigned int *outStreamOffset)
{
if (mWritePosition + size < mWritePosition)
{
return false;
}
if (!reserveSpace(mReservedSpace))
{
return false;
}
mReservedSpace = 0;
if (!mVertexBuffer->storeRawData(data, size, mWritePosition))
{
return false;
}
if (outStreamOffset)
{
*outStreamOffset = mWritePosition;
}
mWritePosition += size;
return true;
}
gl::Error VertexBufferInterface::storeVertexAttributes(const gl::VertexAttribute &attrib,
GLenum currentValueType,
GLint start,
GLsizei count,
GLsizei instances,
unsigned int *outStreamOffset,
const uint8_t *sourceData)
{
gl::Error error(GL_NO_ERROR);
unsigned int spaceRequired;
error = mVertexBuffer->getSpaceRequired(attrib, count, instances, &spaceRequired);
if (error.isError())
{
return error;
}
// Align to 16-byte boundary
unsigned int alignedSpaceRequired = roundUp(spaceRequired, 16u);
// Protect against integer overflow
if (!IsUnsignedAdditionSafe(mWritePosition, alignedSpaceRequired) ||
alignedSpaceRequired < spaceRequired)
{
return gl::Error(GL_OUT_OF_MEMORY, "Internal error, new vertex buffer write position would overflow.");
}
error = reserveSpace(mReservedSpace);
if (error.isError())
{
return error;
}
mReservedSpace = 0;
error = mVertexBuffer->storeVertexAttributes(attrib, currentValueType, start, count, instances, mWritePosition, sourceData);
if (error.isError())
{
return error;
}
if (outStreamOffset)
{
*outStreamOffset = mWritePosition;
}
mWritePosition += alignedSpaceRequired;
return gl::Error(GL_NO_ERROR);
}
int VertexBufferInterface::storeVertexAttributes(const gl::VertexAttribute &attrib, GLint start, GLsizei count, GLsizei instances)
{
if (!reserveSpace(mReservedSpace))
{
return -1;
}
mReservedSpace = 0;
if (!mVertexBuffer->storeVertexAttributes(attrib, start, count, instances, mWritePosition))
{
return -1;
}
int oldWritePos = static_cast<int>(mWritePosition);
mWritePosition += mVertexBuffer->getSpaceRequired(attrib, count, instances);
return oldWritePos;
}
int VertexBufferInterface::storeRawData(const void* data, unsigned int size)
{
if (!reserveSpace(mReservedSpace))
{
return -1;
}
mReservedSpace = 0;
if (!mVertexBuffer->storeRawData(data, size, mWritePosition))
{
return -1;
}
int oldWritePos = static_cast<int>(mWritePosition);
mWritePosition += size;
return oldWritePos;
}
gl::Error VertexBufferInterface::storeVertexAttributes(const gl::VertexAttribute &attrib, const gl::VertexAttribCurrentValueData ¤tValue,
GLint start, GLsizei count, GLsizei instances, unsigned int *outStreamOffset)
{
gl::Error error(GL_NO_ERROR);
unsigned int spaceRequired;
error = mVertexBuffer->getSpaceRequired(attrib, count, instances, &spaceRequired);
if (error.isError())
{
return error;
}
if (mWritePosition + spaceRequired < mWritePosition)
{
return gl::Error(GL_OUT_OF_MEMORY, "Internal error, new vertex buffer write position would overflow.");
}
error = reserveSpace(mReservedSpace);
if (error.isError())
{
return error;
}
mReservedSpace = 0;
error = mVertexBuffer->storeVertexAttributes(attrib, currentValue, start, count, instances, mWritePosition);
if (error.isError())
{
return error;
}
if (outStreamOffset)
{
*outStreamOffset = mWritePosition;
}
mWritePosition += spaceRequired;
// Align to 16-byte boundary
mWritePosition = roundUp(mWritePosition, 16u);
return gl::Error(GL_NO_ERROR);
}
bool VertexBufferInterface::storeVertexAttributes(const gl::VertexAttribute &attrib, GLint start, GLsizei count, GLsizei instances,
unsigned int *outStreamOffset)
{
unsigned int spaceRequired;
if (!mVertexBuffer->getSpaceRequired(attrib, count, instances, &spaceRequired))
{
return false;
}
// Align to 16-byte boundary
unsigned int alignedSpaceRequired = roundUp(spaceRequired, 16);
// Protect against integer overflow
if ((mWritePosition + alignedSpaceRequired < mWritePosition) ||
alignedSpaceRequired < spaceRequired)
{
return false;
}
if (!reserveSpace(mReservedSpace))
{
return false;
}
mReservedSpace = 0;
if (!mVertexBuffer->storeVertexAttributes(attrib, start, count, instances, mWritePosition))
{
return false;
}
if (outStreamOffset)
{
*outStreamOffset = mWritePosition;
}
mWritePosition += alignedSpaceRequired;
return true;
}
bool VertexBufferInterface::storeVertexAttributes(const gl::VertexAttribute &attrib, const gl::VertexAttribCurrentValueData ¤tValue,
GLint start, GLsizei count, GLsizei instances, unsigned int *outStreamOffset)
{
unsigned int spaceRequired;
if (!mVertexBuffer->getSpaceRequired(attrib, count, instances, &spaceRequired))
{
return false;
}
if (mWritePosition + spaceRequired < mWritePosition)
{
return false;
}
if (!reserveSpace(mReservedSpace))
{
return false;
}
mReservedSpace = 0;
if (!mVertexBuffer->storeVertexAttributes(attrib, currentValue, start, count, instances, mWritePosition))
{
return false;
}
if (outStreamOffset)
{
*outStreamOffset = mWritePosition;
}
mWritePosition += spaceRequired;
// Align to 16-byte boundary
mWritePosition = rx::roundUp(mWritePosition, 16u);
return true;
}
void
GlyphMemCache::reserveGlyphs(UInt16 numGlyphs, UInt32 memSize, Boolean *purged) {
reserveSpace(numGlyphs, memSize, purged);
}
eMesh::eMesh(Type type, eU32 primitiveCount, eU32 vertexCount) :
m_type(type)
{
reserveSpace(primitiveCount, vertexCount);
}
void eMesh::_fromTriangleEditMesh(eEditMesh &em)
{
ePROFILER_ZONE("To renderable mesh");
eASSERT(em.isTriangulated() == eTRUE);
clear();
reserveSpace(em.getFaceCount(), em.getFaceCount()*3);
m_bbox = em.getBoundingBox();
for(eU32 i = 0; i < em.getVertexCount(); i++)
{
em.getVertex(i)->_volatile_attribute1 = (ePtr)-1;
}
eArray<eU32> indices;
for (eU32 i=0; i<em.getFaceCount(); i++)
{
const eEditMesh::Face *face = em.getFace(i);
eASSERT(face != eNULL);
const eMaterial *mat = face->material;
eASSERT(mat != eNULL);
indices.clear();
eEditMesh::HalfEdge *he = face->he;
do
{
eEditMesh::Vertex *vtx = he->origin;
eASSERT(vtx != eNULL);
const eVector3 &normal = (mat->getFlatShaded() ? face->normal : vtx->normal);
// Check if vertices have to be duplicated.
if (!he->texCoord.equals(vtx->texCoord))
{
// Yes, so add new vertex.
addVertex(vtx->position, normal, he->texCoord, vtx->color);
indices.append(m_vertices.size()-1);
}
else if (mat->getFlatShaded())
{
addVertex(vtx->position, normal, vtx->texCoord, vtx->color);
indices.append(m_vertices.size()-1);
}
// With flat shading every vertex has to be duplicated,
// because vertices can't share normals anymore.
else if (vtx->_volatile_attribute1 == (ePtr)-1)
{
// No and vertex was not added yet.
addVertex(vtx->position, normal, vtx->texCoord, vtx->color);
indices.append(m_vertices.size()-1);
vtx->_volatile_attribute1 = (ePtr)(m_vertices.size()-1);
}
else
{
// Yes and vertex was already added before.
indices.append((eU32)vtx->_volatile_attribute1);
}
he = he->next;
}
while (he != face->he);
// Add triangle to mesh.
addTriangle(indices[0], indices[1], indices[2], mat);
}
}
retCode enoughRoom(heapPo H, labelPo lbl) {
return reserveSpace(H, NormalCellCount(labelArity(lbl)));
}
int saveUndo (git_sint32 * base, git_sint32 * sp)
{
git_uint32 undoSize = sizeof(UndoRecord);
git_uint32 mapSize = sizeof(MemoryPage*) * (gEndMem - gRamStart) / 256;
git_uint32 stackSize = sizeof(git_sint32) * (sp - base);
git_uint32 totalSize = undoSize + mapSize + stackSize;
git_uint32 addr = gRamStart; // Address in glulx memory.
git_uint32 slot = 0; // Slot in our memory map.
UndoRecord * undo = malloc (undoSize);
if (undo == NULL)
fatalError ("Couldn't allocate undo record");
undo->endMem = gEndMem;
undo->memoryMap = malloc (mapSize);
undo->stackSize = stackSize;
undo->stack = malloc (stackSize);
undo->prev = NULL;
undo->next = NULL;
if (undo->memoryMap == NULL || undo->stack == NULL)
fatalError ("Couldn't allocate memory for undo");
// Save the stack.
memcpy (undo->stack, base, undo->stackSize);
// Are we diffing against the previous undo record,
// or against the initial gamefile state?
if (gUndo == NULL)
{
// We're diffing against the gamefile.
for ( ; addr < gExtStart ; addr += 256, ++slot)
{
if (memcmp (gInitMem + addr, gMem + addr, 256) != 0)
{
// We need to save this page.
git_uint8 * page = malloc(256);
if (page == NULL)
fatalError ("Couldn't allocate memory for undo");
memcpy (page, gMem + addr, 256);
undo->memoryMap[slot] = page;
totalSize += 256;
}
else
{
// We don't need to save this page.
// Just make it point into ROM.
undo->memoryMap[slot] = gInitMem + addr;
}
}
// If the memory map has been extended, save the exended area
for (addr = gExtStart ; addr < gEndMem ; addr += 256, ++slot)
{
git_uint8 * page = malloc(256);
if (page == NULL)
fatalError ("Couldn't allocate memory for undo");
memcpy (page, gMem + addr, 256);
undo->memoryMap[slot] = page;
totalSize += 256;
}
}
else
{
// We're diffing against the most recent undo record.
git_uint32 endMem = (gUndo->endMem < gEndMem) ? gUndo->endMem : gEndMem;
for ( ; addr < endMem ; addr += 256, ++slot)
{
if (memcmp (gUndo->memoryMap [slot], gMem + addr, 256) != 0)
{
// We need to save this page.
git_uint8 * page = malloc(256);
memcpy (page, gMem + addr, 256);
undo->memoryMap[slot] = page;
totalSize += 256;
}
else
{
// We don't need to save this page. Just copy
// the pointer from the previous undo record.
undo->memoryMap[slot] = gUndo->memoryMap[slot];
}
}
// If the memory map has been extended, save the exended area
for (addr = endMem ; addr < gEndMem ; addr += 256, ++slot)
{
git_uint8 * page = malloc(256);
if (page == NULL)
fatalError ("Couldn't allocate memory for undo");
memcpy (page, gMem + addr, 256);
undo->memoryMap[slot] = page;
totalSize += 256;
}
}
// Save the heap.
if (heap_get_summary (&(undo->heapSize), &(undo->heap)))
fatalError ("Couldn't get heap summary");
totalSize += undo->heapSize * 4;
// Link this record into the undo list.
undo->prev = gUndo;
if (gUndo)
gUndo->next = undo;
gUndo = undo;
gUndoSize += totalSize;
// Delete old records until we have enough free space.
reserveSpace (0);
// And we're done.
return 0;
}
void resetUndo ()
{
reserveSpace (gMaxUndoSize);
assert (gUndo == NULL);
assert (gUndoSize == 0);
}
