//-----------------------------------------------------------------------------
void TempBlendedBufferInfo::extractFrom(const VertexData* sourceData)
{
// Release old buffer copies first
if (!destPositionBuffer.isNull())
{
destPositionBuffer->getManager()->releaseVertexBufferCopy(destPositionBuffer);
assert(destPositionBuffer.isNull());
}
if (!destNormalBuffer.isNull())
{
destNormalBuffer->getManager()->releaseVertexBufferCopy(destNormalBuffer);
assert(destNormalBuffer.isNull());
}
VertexDeclaration* decl = sourceData->vertexDeclaration;
VertexBufferBinding* bind = sourceData->vertexBufferBinding;
const VertexElement *posElem = decl->findElementBySemantic(VES_POSITION);
const VertexElement *normElem = decl->findElementBySemantic(VES_NORMAL);
assert(posElem && "Positions are required");
posBindIndex = posElem->getSource();
srcPositionBuffer = bind->getBuffer(posBindIndex);
if (!normElem)
{
posNormalShareBuffer = false;
srcNormalBuffer.setNull();
}
else
{
normBindIndex = normElem->getSource();
if (normBindIndex == posBindIndex)
{
posNormalShareBuffer = true;
srcNormalBuffer.setNull();
}
else
{
posNormalShareBuffer = false;
srcNormalBuffer = bind->getBuffer(normBindIndex);
}
}
}
void MovableText::_setupGeometry()
{
assert(mpFont);
assert(!mpMaterial.isNull());
unsigned int vertexCount = 0;
//count letters to determine how many vertices are needed
std::string::iterator i = mCaption.begin();
std::string::iterator iend = mCaption.end();
for ( ; i != iend; ++i )
{
if ((*i != ' ') && (*i != '\n'))
{
vertexCount += 6;
}
}
if (mRenderOp.vertexData)
{
delete mRenderOp.vertexData;
mRenderOp.vertexData = NULL;
mUpdateColors = true;
}
if (mCaption.empty())
{
return;
}
if (!mRenderOp.vertexData)
mRenderOp.vertexData = new VertexData();
mRenderOp.indexData = 0;
mRenderOp.vertexData->vertexStart = 0;
mRenderOp.vertexData->vertexCount = vertexCount;
mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
mRenderOp.useIndexes = false;
VertexDeclaration *decl = mRenderOp.vertexData->vertexDeclaration;
VertexBufferBinding *bind = mRenderOp.vertexData->vertexBufferBinding;
size_t offset = 0;
// create/bind positions/tex.ccord. buffer
if (!decl->findElementBySemantic(VES_POSITION))
decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
if (!decl->findElementBySemantic(VES_TEXTURE_COORDINATES))
decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT2,
Ogre::VES_TEXTURE_COORDINATES, 0);
HardwareVertexBufferSharedPtr ptbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(POS_TEX_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(POS_TEX_BINDING, ptbuf);
// Colours - store these in a separate buffer because they change less often
if (!decl->findElementBySemantic(VES_DIFFUSE))
decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
HardwareVertexBufferSharedPtr cbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(COLOUR_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(COLOUR_BINDING, cbuf);
float *pPCBuff =
static_cast<float*> (ptbuf->lock(HardwareBuffer::HBL_DISCARD));
Real spaceWidth = mSpaceWidth;
// Derive space width from a capital A
if (spaceWidth == 0)
spaceWidth = mpFont->getGlyphAspectRatio('A') * mCharHeight * 2.0;
float total_height = mCharHeight;
float total_width = 0.0f;
float current_width = 0.0f;
i = mCaption.begin();
iend = mCaption.end();
for ( ; i != iend; ++i )
{
if (*i == '\n')
{
total_height += mCharHeight + 0.01;
if ( current_width > total_width )
{
total_width = current_width;
current_width = 0.0;
}
}
else
{
current_width += mpFont->getGlyphAspectRatio(*i) * mCharHeight * 2.0;
}
}
if ( current_width > total_width )
{
total_width = current_width;
}
float top = 0.0f;
switch (mVerticalAlignment)
{
case MovableText::V_ABOVE:
top = total_height * 2;
break;
case MovableText::V_CENTER:
top = 0.5 * total_height * 2;
break;
case MovableText::V_BELOW:
top = 0.0f;
break;
}
float starting_left = 0.0f;
switch (mHorizontalAlignment)
{
case MovableText::H_LEFT:
starting_left = 0.0f;
break;
case MovableText::H_CENTER:
starting_left = -total_width / 2.0f;
break;
}
float left = starting_left;
bool newLine = true;
Real len = 0.0f;
// for calculation of AABB
Ogre::Vector3 min(9999999.0f), max(-9999999.0f), currPos(0.0f);
Ogre::Real maxSquaredRadius = -99999999.0f;
float largestWidth = 0.0f;
for (i = mCaption.begin(); i != iend; ++i)
{
if (newLine)
{
len = 0.0f;
for (String::iterator j = i; j != iend && *j != '\n'; j++)
{
if (*j == ' ')
len += spaceWidth;
else
len += mpFont->getGlyphAspectRatio(*j) * mCharHeight * 2.0;
}
newLine = false;
}
if (*i == '\n')
{
left = starting_left;
top -= mCharHeight * 2.0;
newLine = true;
continue;
}
if (*i == ' ')
{
// Just leave a gap, no tris
left += spaceWidth;
continue;
}
Real horiz_height = mpFont->getGlyphAspectRatio(*i);
Real u1, u2, v1, v2;
Ogre::Font::UVRect utmp;
utmp = mpFont->getGlyphTexCoords(*i);
u1 = utmp.left;
u2 = utmp.right;
v1 = utmp.top;
v2 = utmp.bottom;
// each vert is (x, y, z, u, v)
//-------------------------------------------------------------------------------------
// First tri
//
// Upper left
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u1;
*pPCBuff++ = v1;
// Deal with bounds
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top -= mCharHeight * 2.0;
// Bottom left
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
// Deal with bounds
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top += mCharHeight * 2.0;
left += horiz_height * mCharHeight * 2.0;
// Top right
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
//-------------------------------------------------------------------------------------
// Deal with bounds
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
//-------------------------------------------------------------------------------------
// Second tri
//
// Top right (again)
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top -= mCharHeight * 2.0;
left -= horiz_height * mCharHeight * 2.0;
// Bottom left (again)
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
left += horiz_height * mCharHeight * 2.0;
// Bottom right
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u2;
*pPCBuff++ = v2;
//-------------------------------------------------------------------------------------
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
// Go back up with top
top += mCharHeight * 2.0;
float currentWidth = (left + 1) / 2 - 0;
if (currentWidth > largestWidth)
largestWidth = currentWidth;
}
// Unlock vertex buffer
ptbuf->unlock();
// update AABB/Sphere radius
mAABB = Ogre::AxisAlignedBox(min, max);
mRadius = Ogre::Math::Sqrt(maxSquaredRadius);
if (mUpdateColors)
this->_updateColors();
mNeedUpdate = false;
}
void MovableText::_setupGeometry()
{
assert(mpFont);
assert(!mpMaterial.isNull());
unsigned int vertexCount = static_cast<unsigned int>(mCaption.size() * 6);
if (mRenderOp.vertexData)
{
// Removed this test as it causes problems when replacing a caption
// of the same size: replacing "Hello" with "hello"
// as well as when changing the text alignment
//if (mRenderOp.vertexData->vertexCount != vertexCount)
{
delete mRenderOp.vertexData;
mRenderOp.vertexData = NULL;
mUpdateColors = true;
}
}
if (!mRenderOp.vertexData)
mRenderOp.vertexData = new VertexData();
mRenderOp.indexData = 0;
mRenderOp.vertexData->vertexStart = 0;
mRenderOp.vertexData->vertexCount = vertexCount;
mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
mRenderOp.useIndexes = false;
VertexDeclaration *decl = mRenderOp.vertexData->vertexDeclaration;
VertexBufferBinding *bind = mRenderOp.vertexData->vertexBufferBinding;
size_t offset = 0;
// create/bind positions/tex.ccord. buffer
if (!decl->findElementBySemantic(VES_POSITION))
decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
if (!decl->findElementBySemantic(VES_TEXTURE_COORDINATES))
decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
HardwareVertexBufferSharedPtr ptbuf = HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(POS_TEX_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(POS_TEX_BINDING, ptbuf);
// Colours - store these in a separate buffer because they change less often
if (!decl->findElementBySemantic(VES_DIFFUSE))
decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
HardwareVertexBufferSharedPtr cbuf = HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(COLOUR_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(COLOUR_BINDING, cbuf);
size_t charlen = mCaption.size();
float *pPCBuff = static_cast<float*>(ptbuf->lock(HardwareBuffer::HBL_DISCARD));
float largestWidth = 0;
float left = 0 * 2.0 - 1.0;
float top = -((0 * 2.0) - 1.0);
Real spaceWidth = mSpaceWidth;
// Derive space width from a capital A
if (spaceWidth == 0)
spaceWidth = mpFont->getGlyphAspectRatio('A') * mCharHeight * 2.0;
// for calculation of AABB
Ogre::Vector3 min, max, currPos;
Ogre::Real maxSquaredRadius;
bool first = true;
// Use iterator
String::iterator i, iend;
iend = mCaption.end();
bool newLine = true;
Real len = 0.0f;
Real verticalOffset = 0;
switch (mVerticalAlignment)
{
case MovableText::V_ABOVE:
verticalOffset = mCharHeight;
break;
case MovableText::V_CENTER:
verticalOffset = 0.5*mCharHeight;
break;
case MovableText::V_BELOW:
verticalOffset = 0;
break;
}
// Raise the first line of the caption
top += verticalOffset;
for (i = mCaption.begin(); i != iend; ++i)
{
if (*i == '\n')
top += verticalOffset * 2.0;
}
for (i = mCaption.begin(); i != iend; ++i)
{
if (newLine)
{
len = 0.0f;
for (String::iterator j = i; j != iend && *j != '\n'; j++)
{
if (*j == ' ')
len += spaceWidth;
else
len += mpFont->getGlyphAspectRatio((unsigned char)*j) * mCharHeight * 2.0;
}
newLine = false;
}
if (*i == '\n')
{
left = 0 * 2.0 - 1.0;
top -= mCharHeight * 2.0;
newLine = true;
// Bugfix by Wladimir Lukutin - thanks :)
// Also reduce tri count
mRenderOp.vertexData->vertexCount -= 6;
// Bugfix end.
continue;
}
if (*i == ' ')
{
// Just leave a gap, no tris
left += spaceWidth;
// Also reduce tri count
mRenderOp.vertexData->vertexCount -= 6;
continue;
}
Real horiz_height = mpFont->getGlyphAspectRatio((unsigned char)*i);
Real u1, u2, v1, v2;
Ogre::Font::UVRect utmp;
utmp = mpFont->getGlyphTexCoords((unsigned char)*i);
u1 = utmp.left;
u2 = utmp.right;
v1 = utmp.top;
v2 = utmp.bottom;
// each vert is (x, y, z, u, v)
//-------------------------------------------------------------------------------------
// First tri
//
// Upper left
if(mHorizontalAlignment == MovableText::H_LEFT)
*pPCBuff++ = left;
else
*pPCBuff++ = left - (len / 2);
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u1;
*pPCBuff++ = v1;
// Deal with bounds
if(mHorizontalAlignment == MovableText::H_LEFT)
currPos = Ogre::Vector3(left, top, -1.0);
else
currPos = Ogre::Vector3(left - (len / 2), top, -1.0);
if (first)
{
min = max = currPos;
maxSquaredRadius = currPos.squaredLength();
first = false;
}
else
{
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
}
top -= mCharHeight * 2.0;
// Bottom left
if(mHorizontalAlignment == MovableText::H_LEFT)
*pPCBuff++ = left;
else
*pPCBuff++ = left - (len / 2);
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
// Deal with bounds
if(mHorizontalAlignment == MovableText::H_LEFT)
currPos = Ogre::Vector3(left, top, -1.0);
else
currPos = Ogre::Vector3(left - (len / 2), top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top += mCharHeight * 2.0;
left += horiz_height * mCharHeight * 2.0;
// Top right
if(mHorizontalAlignment == MovableText::H_LEFT)
*pPCBuff++ = left;
else
*pPCBuff++ = left - (len / 2);
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
//-------------------------------------------------------------------------------------
// Deal with bounds
if(mHorizontalAlignment == MovableText::H_LEFT)
currPos = Ogre::Vector3(left, top, -1.0);
else
currPos = Ogre::Vector3(left - (len / 2), top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
//-------------------------------------------------------------------------------------
// Second tri
//
// Top right (again)
if(mHorizontalAlignment == MovableText::H_LEFT)
*pPCBuff++ = left;
else
*pPCBuff++ = left - (len / 2);
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top -= mCharHeight * 2.0;
left -= horiz_height * mCharHeight * 2.0;
// Bottom left (again)
if(mHorizontalAlignment == MovableText::H_LEFT)
*pPCBuff++ = left;
else
*pPCBuff++ = left - (len / 2);
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
left += horiz_height * mCharHeight * 2.0;
// Bottom right
if(mHorizontalAlignment == MovableText::H_LEFT)
*pPCBuff++ = left;
else
*pPCBuff++ = left - (len / 2);
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u2;
*pPCBuff++ = v2;
//-------------------------------------------------------------------------------------
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
// Go back up with top
top += mCharHeight * 2.0;
float currentWidth = (left + 1)/2 - 0;
if (currentWidth > largestWidth)
largestWidth = currentWidth;
}
// Unlock vertex buffer
ptbuf->unlock();
// update AABB/Sphere radius
mAABB = Ogre::AxisAlignedBox(min, max);
mRadius = Ogre::Math::Sqrt(maxSquaredRadius);
if (mUpdateColors)
this->_updateColors();
mNeedUpdate = false;
}
void OgreMesh::syncFromOgreMesh(Ogre::Entity *entity,Ogre::SubMesh*subMesh)
{
const Ogre::Vector3 &position = entity->getParentNode()->_getDerivedPosition();
const Ogre::Quaternion &orient = entity->getParentNode()->_getDerivedOrientation();
const Ogre::Vector3 &scale = entity->getParentNode()->_getDerivedScale();
VertexData *vertexData = subMesh->vertexData;
if (vertexData) {
VertexDeclaration *vertexDecl = vertexData->vertexDeclaration;
// find the element for position
const VertexElement *element = vertexDecl->findElementBySemantic(Ogre::VES_POSITION);
// find and lock the buffer containing position information
VertexBufferBinding *bufferBinding = vertexData->vertexBufferBinding;
HardwareVertexBuffer *buffer = bufferBinding->getBuffer(element->getSource()).get();
unsigned char *pVert = static_cast<unsigned char*>(buffer->lock(HardwareBuffer::HBL_READ_ONLY));
std::vector<Ogre::Vector3> lvertices;
for (size_t vert = 0; vert < vertexData->vertexCount; vert++) {
Real *vertex = 0;
Real x, y, z;
element->baseVertexPointerToElement(pVert, &vertex);
x = *vertex++;
y = *vertex++;
z = *vertex++;
Ogre::Vector3 vec(x, y, z);
vec = (orient * (vec * scale)) + position;
lvertices.push_back(vec);
pVert += buffer->getVertexSize();
}
buffer->unlock();
// find and lock buffer containg vertex indices
IndexData * indexData = subMesh->indexData;
HardwareIndexBuffer *indexBuffer = indexData->indexBuffer.get();
void *pIndex = static_cast<unsigned char *>(indexBuffer->lock(HardwareBuffer::HBL_READ_ONLY));
if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT) {
for (size_t index = indexData->indexStart; index < indexData->indexCount; ) {
uint16 *uint16Buffer = (uint16 *) pIndex;
uint16 v1 = uint16Buffer[index++];
uint16 v2 = uint16Buffer[index++];
uint16 v3 = uint16Buffer[index++];
mTriangles.push_back(Triangle(lvertices[v1], lvertices[v2], lvertices[v3]));
}
} else if (indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT) {
for (size_t index = indexData->indexStart; index < indexData->indexCount; ) {
uint32 *uint16Buffer = (uint32 *) pIndex;
uint32 v1 = uint16Buffer[index++];
uint32 v2 = uint16Buffer[index++];
uint32 v3 = uint16Buffer[index++];
mTriangles.push_back(Triangle(lvertices[v1], lvertices[v2], lvertices[v3]));
}
} else {
assert(0);
}
indexBuffer->unlock();
}
}
//---------------------------------------------------------------------
void TangentSpaceCalc::insertTangents(Result& res,
VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet,
unsigned short index)
{
// Make a new tangents semantic or find an existing one
VertexDeclaration *vDecl = mVData->vertexDeclaration ;
VertexBufferBinding *vBind = mVData->vertexBufferBinding ;
const VertexElement *tangentsElem = vDecl->findElementBySemantic(targetSemantic, index);
bool needsToBeCreated = false;
VertexElementType tangentsType = mStoreParityInW ? VET_FLOAT4 : VET_FLOAT3;
if (!tangentsElem)
{ // no tex coords with index 1
needsToBeCreated = true ;
}
else if (tangentsElem->getType() != tangentsType)
{
// buffer exists, but not 3D
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Target semantic set already exists but is not of the right size, therefore "
"cannot contain tangents. You should delete this existing entry first. ",
"TangentSpaceCalc::insertTangents");
}
HardwareVertexBufferSharedPtr targetBuffer, origBuffer;
unsigned char* pSrc = NULL;
if (needsToBeCreated)
{
// To be most efficient with our vertex streams,
// tack the new tangents onto the same buffer as the
// source texture coord set
const VertexElement* prevTexCoordElem =
mVData->vertexDeclaration->findElementBySemantic(
VES_TEXTURE_COORDINATES, sourceTexCoordSet);
if (!prevTexCoordElem)
{
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
"Cannot locate the first texture coordinate element to "
"which to append the new tangents.",
"Mesh::orgagniseTangentsBuffer");
}
// Find the buffer associated with this element
origBuffer = mVData->vertexBufferBinding->getBuffer(
prevTexCoordElem->getSource());
// Now create a new buffer, which includes the previous contents
// plus extra space for the 3D coords
targetBuffer = HardwareBufferManager::getSingleton().createVertexBuffer(
origBuffer->getVertexSize() + VertexElement::getTypeSize(tangentsType),
origBuffer->getNumVertices(),
origBuffer->getUsage(),
origBuffer->hasShadowBuffer() );
// Add the new element
tangentsElem = &(vDecl->addElement(
prevTexCoordElem->getSource(),
origBuffer->getVertexSize(),
tangentsType,
targetSemantic,
index));
// Set up the source pointer
pSrc = static_cast<unsigned char*>(
origBuffer->lock(HardwareBuffer::HBL_READ_ONLY));
// Rebind the new buffer
vBind->setBinding(prevTexCoordElem->getSource(), targetBuffer);
}
else
{
// space already there
origBuffer = mVData->vertexBufferBinding->getBuffer(
tangentsElem->getSource());
targetBuffer = origBuffer;
}
unsigned char* pDest = static_cast<unsigned char*>(
targetBuffer->lock(HardwareBuffer::HBL_DISCARD));
size_t origVertSize = origBuffer->getVertexSize();
size_t newVertSize = targetBuffer->getVertexSize();
for (size_t v = 0; v < origBuffer->getNumVertices(); ++v)
{
if (needsToBeCreated)
{
// Copy original vertex data as well
memcpy(pDest, pSrc, origVertSize);
pSrc += origVertSize;
}
// Write in the tangent
float* pTangent;
tangentsElem->baseVertexPointerToElement(pDest, &pTangent);
VertexInfo& vertInfo = mVertexArray[v];
*pTangent++ = vertInfo.tangent.x;
*pTangent++ = vertInfo.tangent.y;
*pTangent++ = vertInfo.tangent.z;
if (mStoreParityInW)
*pTangent++ = (float)vertInfo.parity;
// Next target vertex
pDest += newVertSize;
}
targetBuffer->unlock();
if (needsToBeCreated)
{
origBuffer->unlock();
}
}
//---------------------------------------------------------------------
void TangentSpaceCalc::populateVertexArray(unsigned short sourceTexCoordSet)
{
// Just pull data out into more friendly structures
VertexDeclaration *dcl = mVData->vertexDeclaration;
VertexBufferBinding *bind = mVData->vertexBufferBinding;
// Get the incoming UV element
const VertexElement* uvElem = dcl->findElementBySemantic(
VES_TEXTURE_COORDINATES, sourceTexCoordSet);
if (!uvElem || uvElem->getType() != VET_FLOAT2)
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"No 2D texture coordinates with selected index, cannot calculate tangents.",
"TangentSpaceCalc::build");
}
HardwareVertexBufferSharedPtr uvBuf, posBuf, normBuf;
unsigned char *pUvBase, *pPosBase, *pNormBase;
size_t uvInc, posInc, normInc;
uvBuf = bind->getBuffer(uvElem->getSource());
pUvBase = static_cast<unsigned char*>(
uvBuf->lock(HardwareBuffer::HBL_READ_ONLY));
uvInc = uvBuf->getVertexSize();
// offset for vertex start
pUvBase += mVData->vertexStart * uvInc;
// find position
const VertexElement *posElem = dcl->findElementBySemantic(VES_POSITION);
if (posElem->getSource() == uvElem->getSource())
{
pPosBase = pUvBase;
posInc = uvInc;
}
else
{
// A different buffer
posBuf = bind->getBuffer(posElem->getSource());
pPosBase = static_cast<unsigned char*>(
posBuf->lock(HardwareBuffer::HBL_READ_ONLY));
posInc = posBuf->getVertexSize();
// offset for vertex start
pPosBase += mVData->vertexStart * posInc;
}
// find a normal buffer
const VertexElement *normElem = dcl->findElementBySemantic(VES_NORMAL);
if (!normElem)
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
"No vertex normals found",
"TangentSpaceCalc::build");
if (normElem->getSource() == uvElem->getSource())
{
pNormBase = pUvBase;
normInc = uvInc;
}
else if (normElem->getSource() == posElem->getSource())
{
// normals are in the same buffer as position
// this condition arises when an animated(skeleton) mesh is not built with
// an edge list buffer ie no shadows being used.
pNormBase = pPosBase;
normInc = posInc;
}
else
{
// A different buffer
normBuf = bind->getBuffer(normElem->getSource());
pNormBase = static_cast<unsigned char*>(
normBuf->lock(HardwareBuffer::HBL_READ_ONLY));
normInc = normBuf->getVertexSize();
// offset for vertex start
pNormBase += mVData->vertexStart * normInc;
}
// Preinitialise vertex info
mVertexArray.clear();
mVertexArray.resize(mVData->vertexCount);
float* pFloat;
VertexInfo* vInfo = &(mVertexArray[0]);
for (size_t v = 0; v < mVData->vertexCount; ++v, ++vInfo)
{
posElem->baseVertexPointerToElement(pPosBase, &pFloat);
vInfo->pos.x = *pFloat++;
vInfo->pos.y = *pFloat++;
vInfo->pos.z = *pFloat++;
pPosBase += posInc;
normElem->baseVertexPointerToElement(pNormBase, &pFloat);
vInfo->norm.x = *pFloat++;
vInfo->norm.y = *pFloat++;
vInfo->norm.z = *pFloat++;
pNormBase += normInc;
uvElem->baseVertexPointerToElement(pUvBase, &pFloat);
vInfo->uv.x = *pFloat++;
vInfo->uv.y = *pFloat++;
pUvBase += uvInc;
}
// unlock buffers
uvBuf->unlock();
if (!posBuf.isNull())
{
posBuf->unlock();
}
if (!normBuf.isNull())
{
normBuf->unlock();
}
}
void BtOgreSoftBody::updateOgreMesh()
{
Ogre::Node *ogreNode = mEntity->getParentNode();
//printf("updateOgreMesh %d %s %s\n", internalId, mEntity->getName().c_str(), ogreNode->getName().c_str());
MeshPtr mesh = mEntity->getMesh();
Mesh::SubMeshIterator subMeshI = mesh->getSubMeshIterator();
SubMesh* subMesh = NULL;
VertexData* vData = NULL;
VertexDeclaration* vDeclaration = NULL;
const VertexElement* vPosElement = NULL;
bool isSharedVerticesAdded = false;
unsigned short bufferIndex = 0;
HardwareVertexBufferSharedPtr vBuffer;
// Can not do arithmetic operations on void*
unsigned char* lockedMem = NULL;
float* vPosition;
btSoftBody::tNodeArray& btNodes = mSoftBody->m_nodes;
//printf("Bullet nodes size %d\n", btNodes.size());
int ogreVertexIdx = 0;
btVector3 btPosOffset;
while (subMeshI.hasMoreElements())
{
subMesh = subMeshI.getNext();
if (subMesh->useSharedVertices)
{
if (isSharedVerticesAdded)
{
continue;
}
vData = mesh->sharedVertexData;
// We need to add shared vertices only once
isSharedVerticesAdded = true;
}
else
{
vData = subMesh->vertexData;
}
vDeclaration = vData->vertexDeclaration;
vPosElement = vDeclaration->findElementBySemantic(VES_POSITION);
bufferIndex = vPosElement->getSource();
vBuffer = vData->vertexBufferBinding->getBuffer(bufferIndex);
// Lock the buffer before reading from it
lockedMem = static_cast<unsigned char*>(vBuffer->lock(HardwareBuffer::HBL_DISCARD));
// Read each vertex
for (unsigned int i = 0; i < vData->vertexCount; ++i)
{
vPosElement->baseVertexPointerToElement(lockedMem, &vPosition);
int idx = getBulletIndex(ogreVertexIdx);
const btVector3 &btPos = btNodes[idx].m_x;
if (ogreVertexIdx == 0)
{
btPosOffset = btPos;
}
*vPosition++ = btPos.x() - btPosOffset.x();
*vPosition++ = btPos.y() - btPosOffset.y();
*vPosition = btPos.z() - btPosOffset.z();
// Point to the next vertex
lockedMem += vBuffer->getVertexSize();
ogreVertexIdx++;
}
vBuffer->unlock();
}
ogreNode->setPosition(btPosOffset.x(), btPosOffset.y(), btPosOffset.z());
}
void OgreMesh::syncFromOgreMesh(Ogre::SubMesh*subMesh, bool texcoord, std::vector<TriVertex>& sharedVertices)
{
VertexData *vertexData;
std::vector<TriVertex> subVertices;
std::vector<TriVertex> *lpvertices;
if (subMesh->useSharedVertices) {
vertexData = subMesh->parent->sharedVertexData;
lpvertices=&sharedVertices;
}else {
vertexData = subMesh->vertexData;
lpvertices=&subVertices;
}
std::vector<TriVertex>&lvertices=*lpvertices;
if (vertexData)
{
VertexDeclaration *vertexDecl = vertexData->vertexDeclaration;
// find the element for position
const VertexElement *element = vertexDecl->findElementBySemantic(Ogre::VES_POSITION);
const VertexElement *texelement = texcoord ? vertexDecl->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES) : NULL;
// find and lock the buffer containing position information
VertexBufferBinding *bufferBinding = vertexData->vertexBufferBinding;
HardwareVertexBuffer *buffer = bufferBinding->getBuffer(element->getSource()).get();
if (lvertices.empty()) {
unsigned char *pVert = static_cast<unsigned char*>(buffer->lock(HardwareBuffer::HBL_READ_ONLY));
HardwareVertexBuffer *texbuffer = texelement ? bufferBinding->getBuffer(texelement->getSource()).get() : NULL;
unsigned char *pTexVert = texbuffer
? (texbuffer == buffer ? pVert : static_cast<unsigned char*>(texbuffer->lock(HardwareBuffer::HBL_READ_ONLY)))
: NULL;
for (size_t vert = 0; vert < vertexData->vertexCount; vert++)
{
float *vertex = 0;
Real x, y, z;
element->baseVertexPointerToElement(pVert, &vertex);
x = *vertex++;
y = *vertex++;
z = *vertex++;
Ogre::Vector3 vec(x, y, z);
Ogre::Vector2 texvec(0,0);
if (texelement)
{
float *texvertex = 0;
float u, v, w;
texelement->baseVertexPointerToElement(pTexVert, &texvertex);
u = *texvertex++;
v = *texvertex++;
texvec = Ogre::Vector2(u, v);
pTexVert += texbuffer->getVertexSize();
}
lvertices.push_back(TriVertex(vec, texvec.x, texvec.y));
pVert += buffer->getVertexSize();
}
buffer->unlock();
}
// find and lock buffer containg vertex indices
Ogre::RenderOperation ro;
subMesh->_getRenderOperation(ro);
if (ro.useIndexes)
{
IndexData * indexData = subMesh->indexData;
HardwareIndexBuffer *indexBuffer = indexData->indexBuffer.get();
void *pIndex = static_cast<unsigned char *>(indexBuffer->lock(HardwareBuffer::HBL_READ_ONLY));
if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
{
for (size_t index = indexData->indexStart; index < indexData->indexCount; )
{
uint16 *uint16Buffer = (uint16 *) pIndex;
uint16 v1 = uint16Buffer[index++];
uint16 v2 = uint16Buffer[index++];
uint16 v3 = uint16Buffer[index++];
if (v1 < lvertices.size() && v2 < lvertices.size() && v3 < lvertices.size())
mTriangles.push_back(Triangle(lvertices[v1], lvertices[v2], lvertices[v3]));
}
}
else if (indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT)
{
for (size_t index = indexData->indexStart; index < indexData->indexCount; )
{
uint32 *uint16Buffer = (uint32 *) pIndex;
uint32 v1 = uint16Buffer[index++];
uint32 v2 = uint16Buffer[index++];
uint32 v3 = uint16Buffer[index++];
if (v1 < lvertices.size() && v2 < lvertices.size() && v3 < lvertices.size())
mTriangles.push_back(Triangle(lvertices[v1], lvertices[v2], lvertices[v3]));
}
}
else
{
assert(0);
}
indexBuffer->unlock();
}
else
{
for (unsigned int i=0; i<lvertices.size(); i+=3)
{
mTriangles.push_back(Triangle(lvertices[i], lvertices[i+1], lvertices[i+2]));
}
}
}
}
void MovableText::_setupGeometry()
{
RlAssert1(mFont);
RlAssert1(!mMaterial.isNull());
unsigned int vertexCount = mCaption.size() * 6;
if (mRenderOp.vertexData)
{
if (mRenderOp.vertexData->vertexCount != vertexCount)
{
delete mRenderOp.vertexData;
mRenderOp.vertexData = NULL;
mUpdateColours = true;
}
}
if (!mRenderOp.vertexData)
{
mRenderOp.vertexData = new VertexData();
}
mRenderOp.indexData = 0;
mRenderOp.vertexData->vertexStart = 0;
mRenderOp.vertexData->vertexCount = vertexCount;
mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
mRenderOp.useIndexes = false;
VertexDeclaration *decl = mRenderOp.vertexData->vertexDeclaration;
VertexBufferBinding *bind = mRenderOp.vertexData->vertexBufferBinding;
size_t offset = 0;
// create/bind positions/tex.ccord. buffer
if (!decl->findElementBySemantic(VES_POSITION))
{
decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION);
}
offset += VertexElement::getTypeSize(VET_FLOAT3);
if (!decl->findElementBySemantic(VES_TEXTURE_COORDINATES))
{
decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);
}
HardwareVertexBufferSharedPtr ptbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(POS_TEX_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(POS_TEX_BINDING, ptbuf);
// Colours - store these in a separate buffer because they change less often
if (!decl->findElementBySemantic(VES_DIFFUSE))
{
decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
}
HardwareVertexBufferSharedPtr cbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(COLOUR_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(COLOUR_BINDING, cbuf);
size_t charlen = mCaption.size();
Real *pPCBuff = static_cast<Real*>(ptbuf->lock(HardwareBuffer::HBL_DISCARD));
float largestWidth = 0;
float left = 0 * 2.0 - 1.0;
float top = -((0 * 2.0) - 1.0);
// Derive space width from a capital A
if (mSpaceWidth == 0)
{
mSpaceWidth = mFont->getGlyphAspectRatio('A') * mCharHeight * 2.0;
}
// for calculation of AABB
Ogre::Vector3 min, max, currPos;
Ogre::Real maxSquaredRadius;
bool first = true;
// Use iterator
String::iterator i, iend;
iend = mCaption.end();
bool newLine = true;
for (i = mCaption.begin(); i != iend; ++i)
{
if (newLine)
{
Real len = 0.0f;
for (String::iterator j = i; j != iend && *j != '\n'; j++)
{
if (*j == ' ')
len += mSpaceWidth;
else
len += mFont->getGlyphAspectRatio(*j) * mCharHeight * 2.0;
}
newLine = false;
}
if (*i == '\n')
{
left = 0 * 2.0 - 1.0;
top -= mCharHeight * 2.0;
newLine = true;
continue;
}
if (*i == ' ')
{
// Just leave a gap, no tris
left += mSpaceWidth;
// Also reduce tri count
mRenderOp.vertexData->vertexCount -= 6;
continue;
}
Real horiz_height = mFont->getGlyphAspectRatio(*i);
Real u1, u2, v1, v2;
mFont->getGlyphTexCoords(*i, u1, v1, u2, v2);
// each vert is (x, y, z, u, v)
//---------------------------------------------------------------
// First tri
//
// Upper left
*pPCBuff++ = left;
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u1;
*pPCBuff++ = v1;
// Deal with bounds
currPos = Ogre::Vector3(left, top, -1.0);
if (first)
{
min = max = currPos;
maxSquaredRadius = currPos.squaredLength();
first = false;
}
else
{
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
}
top -= mCharHeight * 2.0;
// Bottom left
*pPCBuff++ = left;
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
// Deal with bounds
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top += mCharHeight * 2.0;
left += horiz_height * mCharHeight * 2.0;
// Top right
*pPCBuff++ = left;
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
//---------------------------------------------------------------
// Deal with bounds
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
//---------------------------------------------------------------
// Second tri
//
// Top right (again)
*pPCBuff++ = left;
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top -= mCharHeight * 2.0;
left -= horiz_height * mCharHeight * 2.0;
// Bottom left (again)
*pPCBuff++ = left;
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
left += horiz_height * mCharHeight * 2.0;
// Bottom right
*pPCBuff++ = left;
*pPCBuff++ = top;
*pPCBuff++ = -1.0;
*pPCBuff++ = u2;
*pPCBuff++ = v2;
//---------------------------------------------------------------
currPos = Ogre::Vector3(left, top, -1.0);
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
// Go back up with top
top += mCharHeight * 2.0;
float currentWidth = (left + 1)/2 - 0;
if (currentWidth > largestWidth)
{
largestWidth = currentWidth;
}
}
// Unlock vertex buffer
ptbuf->unlock();
// update AABB/Sphere radius
mAABB = Ogre::AxisAlignedBox(min, max);
mRadius = Ogre::Math::Sqrt(maxSquaredRadius);
if (mUpdateColours)
{
this->_updateColours();
}
mNeedUpdate = false;
}
void PlanetFilter::initVertexData(int lod, int x, int y, int size, int border) {
// Prepare new vertex buffer
VertexData* vertexData = mRenderOp.vertexData;
VertexDeclaration *vertexDeclaration = vertexData->vertexDeclaration;
size_t offset = 0;
vertexDeclaration->addElement(0, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
vertexDeclaration->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);
offset += VertexElement::getTypeSize(VET_FLOAT2);
vertexDeclaration->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 1);
offset += VertexElement::getTypeSize(VET_FLOAT2);
HardwareVertexBufferSharedPtr vertexBuffer = HardwareBufferManager::getSingleton()
.createVertexBuffer(offset, 4, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
vertexData->vertexBufferBinding->setBinding(0, vertexBuffer);
vertexData->vertexCount = 0;
// Get offsets / pointers into vertex declaration
const VertexElement* poselem = vertexDeclaration->findElementBySemantic(VES_POSITION);
const VertexElement* texelem1 = vertexDeclaration->findElementBySemantic(VES_TEXTURE_COORDINATES, 0);
const VertexElement* texelem2 = vertexDeclaration->findElementBySemantic(VES_TEXTURE_COORDINATES, 1);
unsigned char* pBase = static_cast<unsigned char*>(vertexBuffer->lock(HardwareBuffer::HBL_DISCARD));
// Calculate tile's position in the virtual cubemap
Real tileSize = 2.0 / (1 << lod);
Real borderSize = (Real(border) / size) * tileSize;
Real left = -1.f + tileSize * x - borderSize;
Real bottom = -1.f + tileSize * ((1 << lod) - y - 1) - borderSize;
Real right = left + tileSize + borderSize * 2.0;
Real top = bottom + tileSize + borderSize * 2.0;
// Draw a full size quad.
for (int y = 0; y < 2; ++y) {
for (int x = 0; x < 2; ++x) {
float* pPos;
float* pTex1;
float* pTex2;
poselem->baseVertexPointerToElement(pBase, &pPos);
texelem1->baseVertexPointerToElement(pBase, &pTex1);
texelem2->baseVertexPointerToElement(pBase, &pTex2);
Vector3 point = Vector3(x ? -1.0f : 1.0f, y ? -1.0f : 1.0f, -1.0f);
*pTex1++ = x ? 0.0f : 1.0f;
*pTex1++ = y ? 1.0f : 0.0f;
// Mystery handedness change, invert y.
*pTex2++ = x ? left : right;
*pTex2++ = y ? bottom : top;
//point = faceTransform * point;
//point = point * uvScale;
*pPos++ = point.x;
*pPos++ = point.y;
*pPos++ = point.z;
pBase += vertexBuffer->getVertexSize();
}
}
vertexData->vertexCount += 4;
vertexBuffer->unlock();
}
