template <> void* ToluaToPODVector<bool>(double /*overload*/, lua_State* L, int narg, void* /*def*/)
{
if (!lua_istable(L, narg))
return 0;
static PODVector<bool> result;
result.Clear();
result.Resize((unsigned)lua_objlen(L, narg));
for (unsigned i = 0; i < result.Size(); ++i)
{
lua_rawgeti(L, narg, i + 1);
result[i] = (bool)tolua_toboolean(L, -1, 0);
lua_pop(L, 1);
}
return &result;
}
void StringToBuffer(PODVector<unsigned char>& dest, const char* source)
{
if (!source)
{
dest.Clear();
return;
}
unsigned size = CountElements(source, ' ');
dest.Resize(size);
bool inSpace = true;
unsigned index = 0;
unsigned value = 0;
// Parse values
const char* ptr = source;
while (*ptr)
{
if (inSpace && *ptr != ' ')
{
inSpace = false;
value = (unsigned)(*ptr - '0');
}
else if (!inSpace && *ptr != ' ')
{
value *= 10;
value += *ptr - '0';
}
else if (!inSpace && *ptr == ' ')
{
dest[index++] = (unsigned char)value;
inSpace = true;
}
++ptr;
}
// Write the final value
if (!inSpace && index < size)
dest[index] = (unsigned char)value;
}
//=============================================================================
//=============================================================================
void UTBRendererBatcher::GetBatches(PODVector<UIBatch>& batches, PODVector<float>& vertexData, const IntRect& currentScissor)
{
for ( unsigned i = 0; i < batches_.Size(); ++i )
{
// get batch
UIBatch &batch = batches_[ i ];
unsigned beg = batch.vertexStart_;
unsigned end = batch.vertexEnd_;
batch.vertexStart_ = vertexData.Size();
batch.vertexEnd_ = vertexData.Size() + (end - beg);
// resize and copy
vertexData.Resize( batch.vertexEnd_ );
memcpy( &vertexData[ batch.vertexStart_ ], &vertexData_[ beg ], (end - beg) * sizeof(float) );
// store
UIBatch::AddOrMerge( batch, batches );
}
// clear buffers
vertexData_.Clear();
batches_.Clear();
}
void LoadMesh(const String& inputFileName, bool generateTangents, bool splitSubMeshes, bool exportMorphs)
{
File meshFileSource(context_);
meshFileSource.Open(inputFileName);
if (!meshFile_->Load(meshFileSource))
ErrorExit("Could not load input file " + inputFileName);
XMLElement root = meshFile_->GetRoot("mesh");
XMLElement subMeshes = root.GetChild("submeshes");
XMLElement skeletonLink = root.GetChild("skeletonlink");
if (root.IsNull())
ErrorExit("Could not load input file " + inputFileName);
String skeletonName = skeletonLink.GetAttribute("name");
if (!skeletonName.Empty())
LoadSkeleton(GetPath(inputFileName) + GetFileName(skeletonName) + ".skeleton.xml");
// Check whether there's benefit of avoiding 32bit indices by splitting each submesh into own buffer
XMLElement subMesh = subMeshes.GetChild("submesh");
unsigned totalVertices = 0;
unsigned maxSubMeshVertices = 0;
while (subMesh)
{
materialNames_.Push(subMesh.GetAttribute("material"));
XMLElement geometry = subMesh.GetChild("geometry");
if (geometry)
{
unsigned vertices = geometry.GetInt("vertexcount");
totalVertices += vertices;
if (maxSubMeshVertices < vertices)
maxSubMeshVertices = vertices;
}
++numSubMeshes_;
subMesh = subMesh.GetNext("submesh");
}
XMLElement sharedGeometry = root.GetChild("sharedgeometry");
if (sharedGeometry)
{
unsigned vertices = sharedGeometry.GetInt("vertexcount");
totalVertices += vertices;
if (maxSubMeshVertices < vertices)
maxSubMeshVertices = vertices;
}
if (!sharedGeometry && (splitSubMeshes || (totalVertices > 65535 && maxSubMeshVertices <= 65535)))
{
useOneBuffer_ = false;
vertexBuffers_.Resize(numSubMeshes_);
indexBuffers_.Resize(numSubMeshes_);
}
else
{
vertexBuffers_.Resize(1);
indexBuffers_.Resize(1);
}
subMesh = subMeshes.GetChild("submesh");
unsigned indexStart = 0;
unsigned vertexStart = 0;
unsigned subMeshIndex = 0;
PODVector<unsigned> vertexStarts;
vertexStarts.Resize(numSubMeshes_);
while (subMesh)
{
XMLElement geometry = subMesh.GetChild("geometry");
XMLElement faces = subMesh.GetChild("faces");
// If no submesh vertexbuffer, process the shared geometry, but do it only once
unsigned vertices = 0;
if (!geometry)
{
vertexStart = 0;
if (!subMeshIndex)
geometry = root.GetChild("sharedgeometry");
}
if (geometry)
vertices = geometry.GetInt("vertexcount");
ModelSubGeometryLodLevel subGeometryLodLevel;
ModelVertexBuffer* vBuf;
ModelIndexBuffer* iBuf;
if (useOneBuffer_)
{
vBuf = &vertexBuffers_[0];
if (vertices)
vBuf->vertices_.Resize(vertexStart + vertices);
iBuf = &indexBuffers_[0];
subGeometryLodLevel.vertexBuffer_ = 0;
subGeometryLodLevel.indexBuffer_ = 0;
}
else
{
vertexStart = 0;
indexStart = 0;
vBuf = &vertexBuffers_[subMeshIndex];
vBuf->vertices_.Resize(vertices);
iBuf = &indexBuffers_[subMeshIndex];
subGeometryLodLevel.vertexBuffer_ = subMeshIndex;
subGeometryLodLevel.indexBuffer_ = subMeshIndex;
}
// Store the start vertex for later use
vertexStarts[subMeshIndex] = vertexStart;
// Ogre may have multiple buffers in one submesh. These will be merged into one
XMLElement bufferDef;
if (geometry)
bufferDef = geometry.GetChild("vertexbuffer");
while (bufferDef)
{
if (bufferDef.HasAttribute("positions"))
vBuf->elementMask_ |= MASK_POSITION;
if (bufferDef.HasAttribute("normals"))
vBuf->elementMask_ |= MASK_NORMAL;
if (bufferDef.HasAttribute("texture_coords"))
{
vBuf->elementMask_ |= MASK_TEXCOORD1;
if (bufferDef.GetInt("texture_coords") > 1)
vBuf->elementMask_ |= MASK_TEXCOORD2;
}
unsigned vertexNum = vertexStart;
if (vertices)
{
XMLElement vertex = bufferDef.GetChild("vertex");
while (vertex)
{
XMLElement position = vertex.GetChild("position");
if (position)
{
// Convert from right- to left-handed
float x = position.GetFloat("x");
float y = position.GetFloat("y");
float z = position.GetFloat("z");
Vector3 vec(x, y, -z);
vBuf->vertices_[vertexNum].position_ = vec;
boundingBox_.Merge(vec);
}
XMLElement normal = vertex.GetChild("normal");
if (normal)
{
// Convert from right- to left-handed
float x = normal.GetFloat("x");
float y = normal.GetFloat("y");
float z = normal.GetFloat("z");
Vector3 vec(x, y, -z);
vBuf->vertices_[vertexNum].normal_ = vec;
}
XMLElement uv = vertex.GetChild("texcoord");
if (uv)
{
float x = uv.GetFloat("u");
float y = uv.GetFloat("v");
Vector2 vec(x, y);
vBuf->vertices_[vertexNum].texCoord1_ = vec;
if (vBuf->elementMask_ & MASK_TEXCOORD2)
{
uv = uv.GetNext("texcoord");
if (uv)
{
float x = uv.GetFloat("u");
float y = uv.GetFloat("v");
Vector2 vec(x, y);
vBuf->vertices_[vertexNum].texCoord2_ = vec;
}
}
}
vertexNum++;
vertex = vertex.GetNext("vertex");
}
}
bufferDef = bufferDef.GetNext("vertexbuffer");
}
unsigned triangles = faces.GetInt("count");
unsigned indices = triangles * 3;
XMLElement triangle = faces.GetChild("face");
while (triangle)
{
unsigned v1 = triangle.GetInt("v1");
unsigned v2 = triangle.GetInt("v2");
unsigned v3 = triangle.GetInt("v3");
iBuf->indices_.Push(v3 + vertexStart);
iBuf->indices_.Push(v2 + vertexStart);
iBuf->indices_.Push(v1 + vertexStart);
triangle = triangle.GetNext("face");
}
subGeometryLodLevel.indexStart_ = indexStart;
subGeometryLodLevel.indexCount_ = indices;
if (vertexStart + vertices > 65535)
iBuf->indexSize_ = sizeof(unsigned);
XMLElement boneAssignments = subMesh.GetChild("boneassignments");
if (bones_.Size())
{
if (boneAssignments)
{
XMLElement boneAssignment = boneAssignments.GetChild("vertexboneassignment");
while (boneAssignment)
{
unsigned vertex = boneAssignment.GetInt("vertexindex") + vertexStart;
unsigned bone = boneAssignment.GetInt("boneindex");
float weight = boneAssignment.GetFloat("weight");
BoneWeightAssignment assign;
assign.boneIndex_ = bone;
assign.weight_ = weight;
// Source data might have 0 weights. Disregard these
if (assign.weight_ > 0.0f)
{
subGeometryLodLevel.boneWeights_[vertex].Push(assign);
// Require skinning weight to be sufficiently large before vertex contributes to bone hitbox
if (assign.weight_ > 0.33f)
{
// Check distance of vertex from bone to get bone max. radius information
Vector3 bonePos = bones_[bone].derivedPosition_;
Vector3 vertexPos = vBuf->vertices_[vertex].position_;
float distance = (bonePos - vertexPos).Length();
if (distance > bones_[bone].radius_)
{
bones_[bone].collisionMask_ |= 1;
bones_[bone].radius_ = distance;
}
// Build the hitbox for the bone
bones_[bone].boundingBox_.Merge(bones_[bone].inverseWorldTransform_ * (vertexPos));
bones_[bone].collisionMask_ |= 2;
}
}
boneAssignment = boneAssignment.GetNext("vertexboneassignment");
}
}
if ((subGeometryLodLevel.boneWeights_.Size()) && bones_.Size())
{
vBuf->elementMask_ |= MASK_BLENDWEIGHTS | MASK_BLENDINDICES;
bool sorted = false;
// If amount of bones is larger than supported by HW skinning, must remap per submesh
if (bones_.Size() > maxBones_)
{
HashMap<unsigned, unsigned> usedBoneMap;
unsigned remapIndex = 0;
for (HashMap<unsigned, PODVector<BoneWeightAssignment> >::Iterator i =
subGeometryLodLevel.boneWeights_.Begin(); i != subGeometryLodLevel.boneWeights_.End(); ++i)
{
// Sort the bone assigns by weight
Sort(i->second_.Begin(), i->second_.End(), CompareWeights);
// Use only the first 4 weights
for (unsigned j = 0; j < i->second_.Size() && j < 4; ++j)
{
unsigned originalIndex = i->second_[j].boneIndex_;
if (!usedBoneMap.Contains(originalIndex))
{
usedBoneMap[originalIndex] = remapIndex;
remapIndex++;
}
i->second_[j].boneIndex_ = usedBoneMap[originalIndex];
}
}
// If still too many bones in one subgeometry, error
if (usedBoneMap.Size() > maxBones_)
ErrorExit("Too many bones (limit " + String(maxBones_) + ") in submesh " + String(subMeshIndex + 1));
// Write mapping of vertex buffer bone indices to original bone indices
subGeometryLodLevel.boneMapping_.Resize(usedBoneMap.Size());
for (HashMap<unsigned, unsigned>::Iterator j = usedBoneMap.Begin(); j != usedBoneMap.End(); ++j)
subGeometryLodLevel.boneMapping_[j->second_] = j->first_;
sorted = true;
}
for (HashMap<unsigned, PODVector<BoneWeightAssignment> >::Iterator i = subGeometryLodLevel.boneWeights_.Begin();
i != subGeometryLodLevel.boneWeights_.End(); ++i)
{
// Sort the bone assigns by weight, if not sorted yet in bone remapping pass
if (!sorted)
Sort(i->second_.Begin(), i->second_.End(), CompareWeights);
float totalWeight = 0.0f;
float normalizationFactor = 0.0f;
// Calculate normalization factor in case there are more than 4 blend weights, or they do not add up to 1
for (unsigned j = 0; j < i->second_.Size() && j < 4; ++j)
totalWeight += i->second_[j].weight_;
if (totalWeight > 0.0f)
normalizationFactor = 1.0f / totalWeight;
for (unsigned j = 0; j < i->second_.Size() && j < 4; ++j)
{
vBuf->vertices_[i->first_].blendIndices_[j] = i->second_[j].boneIndex_;
vBuf->vertices_[i->first_].blendWeights_[j] = i->second_[j].weight_ * normalizationFactor;
}
// If there are less than 4 blend weights, fill rest with zero
for (unsigned j = i->second_.Size(); j < 4; ++j)
{
vBuf->vertices_[i->first_].blendIndices_[j] = 0;
vBuf->vertices_[i->first_].blendWeights_[j] = 0.0f;
}
vBuf->vertices_[i->first_].hasBlendWeights_ = true;
}
}
}
else if (boneAssignments)
PrintLine("No skeleton loaded, skipping skinning information");
// Calculate center for the subgeometry
Vector3 center = Vector3::ZERO;
for (unsigned i = 0; i < iBuf->indices_.Size(); i += 3)
{
center += vBuf->vertices_[iBuf->indices_[i]].position_;
center += vBuf->vertices_[iBuf->indices_[i + 1]].position_;
center += vBuf->vertices_[iBuf->indices_[i + 2]].position_;
}
if (iBuf->indices_.Size())
center /= (float)iBuf->indices_.Size();
subGeometryCenters_.Push(center);
indexStart += indices;
vertexStart += vertices;
OptimizeIndices(&subGeometryLodLevel, vBuf, iBuf);
PrintLine("Processed submesh " + String(subMeshIndex + 1) + ": " + String(vertices) + " vertices " +
String(triangles) + " triangles");
Vector<ModelSubGeometryLodLevel> thisSubGeometry;
thisSubGeometry.Push(subGeometryLodLevel);
subGeometries_.Push(thisSubGeometry);
subMesh = subMesh.GetNext("submesh");
subMeshIndex++;
}
// Process LOD levels, if any
XMLElement lods = root.GetChild("levelofdetail");
if (lods)
{
try
{
// For now, support only generated LODs, where the vertices are the same
XMLElement lod = lods.GetChild("lodgenerated");
while (lod)
{
float distance = M_EPSILON;
if (lod.HasAttribute("fromdepthsquared"))
distance = sqrtf(lod.GetFloat("fromdepthsquared"));
if (lod.HasAttribute("value"))
distance = lod.GetFloat("value");
XMLElement lodSubMesh = lod.GetChild("lodfacelist");
while (lodSubMesh)
{
unsigned subMeshIndex = lodSubMesh.GetInt("submeshindex");
unsigned triangles = lodSubMesh.GetInt("numfaces");
ModelSubGeometryLodLevel newLodLevel;
ModelSubGeometryLodLevel& originalLodLevel = subGeometries_[subMeshIndex][0];
// Copy all initial values
newLodLevel = originalLodLevel;
ModelVertexBuffer* vBuf;
ModelIndexBuffer* iBuf;
if (useOneBuffer_)
{
vBuf = &vertexBuffers_[0];
iBuf = &indexBuffers_[0];
}
else
{
vBuf = &vertexBuffers_[subMeshIndex];
iBuf = &indexBuffers_[subMeshIndex];
}
unsigned indexStart = iBuf->indices_.Size();
unsigned indexCount = triangles * 3;
unsigned vertexStart = vertexStarts[subMeshIndex];
newLodLevel.distance_ = distance;
newLodLevel.indexStart_ = indexStart;
newLodLevel.indexCount_ = indexCount;
// Append indices to the original index buffer
XMLElement triangle = lodSubMesh.GetChild("face");
while (triangle)
{
unsigned v1 = triangle.GetInt("v1");
unsigned v2 = triangle.GetInt("v2");
unsigned v3 = triangle.GetInt("v3");
iBuf->indices_.Push(v3 + vertexStart);
iBuf->indices_.Push(v2 + vertexStart);
iBuf->indices_.Push(v1 + vertexStart);
triangle = triangle.GetNext("face");
}
OptimizeIndices(&newLodLevel, vBuf, iBuf);
subGeometries_[subMeshIndex].Push(newLodLevel);
PrintLine("Processed LOD level for submesh " + String(subMeshIndex + 1) + ": distance " + String(distance));
lodSubMesh = lodSubMesh.GetNext("lodfacelist");
}
lod = lod.GetNext("lodgenerated");
}
}
catch (...) {}
}
// Process poses/morphs
// First find out all pose definitions
if (exportMorphs)
{
try
{
Vector<XMLElement> poses;
XMLElement posesRoot = root.GetChild("poses");
if (posesRoot)
{
XMLElement pose = posesRoot.GetChild("pose");
while (pose)
{
poses.Push(pose);
pose = pose.GetNext("pose");
}
}
// Then process animations using the poses
XMLElement animsRoot = root.GetChild("animations");
if (animsRoot)
{
XMLElement anim = animsRoot.GetChild("animation");
while (anim)
{
String name = anim.GetAttribute("name");
float length = anim.GetFloat("length");
HashSet<unsigned> usedPoses;
XMLElement tracks = anim.GetChild("tracks");
if (tracks)
{
XMLElement track = tracks.GetChild("track");
while (track)
{
XMLElement keyframes = track.GetChild("keyframes");
if (keyframes)
{
XMLElement keyframe = keyframes.GetChild("keyframe");
while (keyframe)
{
float time = keyframe.GetFloat("time");
XMLElement poseref = keyframe.GetChild("poseref");
// Get only the end pose
if (poseref && time == length)
usedPoses.Insert(poseref.GetInt("poseindex"));
keyframe = keyframe.GetNext("keyframe");
}
}
track = track.GetNext("track");
}
}
if (usedPoses.Size())
{
ModelMorph newMorph;
newMorph.name_ = name;
if (useOneBuffer_)
newMorph.buffers_.Resize(1);
else
newMorph.buffers_.Resize(usedPoses.Size());
unsigned bufIndex = 0;
for (HashSet<unsigned>::Iterator i = usedPoses.Begin(); i != usedPoses.End(); ++i)
{
XMLElement pose = poses[*i];
unsigned targetSubMesh = pose.GetInt("index");
XMLElement poseOffset = pose.GetChild("poseoffset");
if (useOneBuffer_)
newMorph.buffers_[bufIndex].vertexBuffer_ = 0;
else
newMorph.buffers_[bufIndex].vertexBuffer_ = targetSubMesh;
newMorph.buffers_[bufIndex].elementMask_ = MASK_POSITION;
ModelVertexBuffer* vBuf = &vertexBuffers_[newMorph.buffers_[bufIndex].vertexBuffer_];
while (poseOffset)
{
// Convert from right- to left-handed
unsigned vertexIndex = poseOffset.GetInt("index") + vertexStarts[targetSubMesh];
float x = poseOffset.GetFloat("x");
float y = poseOffset.GetFloat("y");
float z = poseOffset.GetFloat("z");
Vector3 vec(x, y, -z);
if (vBuf->morphCount_ == 0)
{
vBuf->morphStart_ = vertexIndex;
vBuf->morphCount_ = 1;
}
else
{
unsigned first = vBuf->morphStart_;
unsigned last = first + vBuf->morphCount_ - 1;
if (vertexIndex < first)
first = vertexIndex;
if (vertexIndex > last)
last = vertexIndex;
vBuf->morphStart_ = first;
vBuf->morphCount_ = last - first + 1;
}
ModelVertex newVertex;
newVertex.position_ = vec;
newMorph.buffers_[bufIndex].vertices_.Push(MakePair(vertexIndex, newVertex));
poseOffset = poseOffset.GetNext("poseoffset");
}
if (!useOneBuffer_)
++bufIndex;
}
morphs_.Push(newMorph);
PrintLine("Processed morph " + name + " with " + String(usedPoses.Size()) + " sub-poses");
}
anim = anim.GetNext("animation");
}
}
}
catch (...) {}
}
// Check any of the buffers for vertices with missing blend weight assignments
for (unsigned i = 0; i < vertexBuffers_.Size(); ++i)
{
if (vertexBuffers_[i].elementMask_ & MASK_BLENDWEIGHTS)
{
for (unsigned j = 0; j < vertexBuffers_[i].vertices_.Size(); ++j)
if (!vertexBuffers_[i].vertices_[j].hasBlendWeights_)
ErrorExit("Found a vertex with missing skinning information");
}
}
// Tangent generation
if (generateTangents)
{
for (unsigned i = 0; i < subGeometries_.Size(); ++i)
{
for (unsigned j = 0; j < subGeometries_[i].Size(); ++j)
{
ModelVertexBuffer& vBuf = vertexBuffers_[subGeometries_[i][j].vertexBuffer_];
ModelIndexBuffer& iBuf = indexBuffers_[subGeometries_[i][j].indexBuffer_];
unsigned indexStart = subGeometries_[i][j].indexStart_;
unsigned indexCount = subGeometries_[i][j].indexCount_;
// If already has tangents, do not regenerate
if (vBuf.elementMask_ & MASK_TANGENT || vBuf.vertices_.Empty() || iBuf.indices_.Empty())
continue;
vBuf.elementMask_ |= MASK_TANGENT;
if ((vBuf.elementMask_ & (MASK_POSITION | MASK_NORMAL | MASK_TEXCOORD1)) != (MASK_POSITION | MASK_NORMAL |
MASK_TEXCOORD1))
ErrorExit("To generate tangents, positions normals and texcoords are required");
GenerateTangents(&vBuf.vertices_[0], sizeof(ModelVertex), &iBuf.indices_[0], sizeof(unsigned), indexStart,
indexCount, offsetof(ModelVertex, normal_), offsetof(ModelVertex, texCoord1_), offsetof(ModelVertex,
tangent_));
PrintLine("Generated tangents");
}
}
}
}
void OptimizeIndices(ModelSubGeometryLodLevel* subGeom, ModelVertexBuffer* vb, ModelIndexBuffer* ib)
{
PODVector<Triangle> oldTriangles;
PODVector<Triangle> newTriangles;
if (subGeom->indexCount_ % 3)
{
PrintLine("Index count is not divisible by 3, skipping index optimization");
return;
}
for (unsigned i = 0; i < vb->vertices_.Size(); ++i)
{
vb->vertices_[i].useCount_ = 0;
vb->vertices_[i].cachePosition_ = -1;
}
for (unsigned i = subGeom->indexStart_; i < subGeom->indexStart_ + subGeom->indexCount_; i += 3)
{
Triangle triangle;
triangle.v0_ = ib->indices_[i];
triangle.v1_ = ib->indices_[i + 1];
triangle.v2_ = ib->indices_[i + 2];
vb->vertices_[triangle.v0_].useCount_++;
vb->vertices_[triangle.v1_].useCount_++;
vb->vertices_[triangle.v2_].useCount_++;
oldTriangles.Push(triangle);
}
for (unsigned i = 0; i < vb->vertices_.Size(); ++i)
CalculateScore(vb->vertices_[i]);
PODVector<unsigned> vertexCache;
while (oldTriangles.Size())
{
unsigned bestTriangle = M_MAX_UNSIGNED;
float bestTriangleScore = -1.0f;
// Find the best triangle at this point
for (unsigned i = 0; i < oldTriangles.Size(); ++i)
{
Triangle& triangle = oldTriangles[i];
float triangleScore =
vb->vertices_[triangle.v0_].score_ +
vb->vertices_[triangle.v1_].score_ +
vb->vertices_[triangle.v2_].score_;
if (triangleScore > bestTriangleScore)
{
bestTriangle = i;
bestTriangleScore = triangleScore;
}
}
if (bestTriangle == M_MAX_UNSIGNED)
{
PrintLine("Could not find next triangle, aborting index optimization");
return;
}
// Add the best triangle
Triangle triangleCopy = oldTriangles[bestTriangle];
newTriangles.Push(triangleCopy);
oldTriangles.Erase(oldTriangles.Begin() + bestTriangle);
// Reduce the use count
vb->vertices_[triangleCopy.v0_].useCount_--;
vb->vertices_[triangleCopy.v1_].useCount_--;
vb->vertices_[triangleCopy.v2_].useCount_--;
// Model the LRU cache behaviour
// Erase the triangle vertices from the middle of the cache, if they were there
for (unsigned i = 0; i < vertexCache.Size(); ++i)
{
if ((vertexCache[i] == triangleCopy.v0_) ||
(vertexCache[i] == triangleCopy.v1_) ||
(vertexCache[i] == triangleCopy.v2_))
{
vertexCache.Erase(vertexCache.Begin() + i);
--i;
}
}
// Then push them to the front
vertexCache.Insert(vertexCache.Begin(), triangleCopy.v0_);
vertexCache.Insert(vertexCache.Begin(), triangleCopy.v1_);
vertexCache.Insert(vertexCache.Begin(), triangleCopy.v2_);
// Update positions & scores of all vertices in the cache
// Give position -1 if vertex is going to be erased
for (unsigned i = 0; i < vertexCache.Size(); ++i)
{
ModelVertex& vertex = vb->vertices_[vertexCache[i]];
if (i >= VERTEX_CACHE_SIZE)
vertex.cachePosition_ = -1;
else
vertex.cachePosition_ = i;
CalculateScore(vertex);
}
// Finally erase the extra vertices
if (vertexCache.Size() > VERTEX_CACHE_SIZE)
vertexCache.Resize(VERTEX_CACHE_SIZE);
}
// Rewrite the index data now
unsigned i = subGeom->indexStart_;
for (unsigned j = 0; j < newTriangles.Size(); ++j)
{
ib->indices_[i++] = newTriangles[j].v0_;
ib->indices_[i++] = newTriangles[j].v1_;
ib->indices_[i++] = newTriangles[j].v2_;
}
}
void Text::UpdateText()
{
int width = 0;
int height = 0;
rowWidths_.Clear();
printText_.Clear();
PODVector<unsigned> printToText;
if (font_)
{
const FontFace* face = font_->GetFace(fontSize_);
if (!face)
return;
rowHeight_ = face->rowHeight_;
int rowWidth = 0;
int rowHeight = (int)(rowSpacing_ * rowHeight_);
// First see if the text must be split up
if (!wordWrap_)
{
printText_ = unicodeText_;
printToText.Resize(printText_.Size());
for (unsigned i = 0; i < printText_.Size(); ++i)
printToText[i] = i;
}
else
{
int maxWidth = GetWidth();
unsigned nextBreak = 0;
unsigned lineStart = 0;
for (unsigned i = 0; i < unicodeText_.Size(); ++i)
{
unsigned j;
unsigned c = unicodeText_[i];
if (c != '\n')
{
bool ok = true;
if (nextBreak <= i)
{
int futureRowWidth = rowWidth;
for (j = i; j < unicodeText_.Size(); ++j)
{
unsigned d = unicodeText_[j];
if (d == ' ' || d == '\n')
{
nextBreak = j;
break;
}
const FontGlyph* glyph = face->GetGlyph(d);
if (glyph)
{
futureRowWidth += glyph->advanceX_;
if (j < unicodeText_.Size() - 1)
futureRowWidth += face->GetKerning(d, unicodeText_[j + 1]);
}
if (d == '-' && futureRowWidth <= maxWidth)
{
nextBreak = j + 1;
break;
}
if (futureRowWidth > maxWidth)
{
ok = false;
break;
}
}
}
if (!ok)
{
// If did not find any breaks on the line, copy until j, or at least 1 char, to prevent infinite loop
if (nextBreak == lineStart)
{
while (i < j)
{
printText_.Push(unicodeText_[i]);
printToText.Push(i);
++i;
}
}
printText_.Push('\n');
printToText.Push(Min((int)i, (int)unicodeText_.Size() - 1));
rowWidth = 0;
nextBreak = lineStart = i;
}
if (i < unicodeText_.Size())
{
// When copying a space, position is allowed to be over row width
c = unicodeText_[i];
const FontGlyph* glyph = face->GetGlyph(c);
if (glyph)
{
rowWidth += glyph->advanceX_;
if (i < text_.Length() - 1)
rowWidth += face->GetKerning(c, unicodeText_[i + 1]);
}
if (rowWidth <= maxWidth)
{
printText_.Push(c);
printToText.Push(i);
}
}
}
else
{
printText_.Push('\n');
printToText.Push(Min((int)i, (int)unicodeText_.Size() - 1));
rowWidth = 0;
nextBreak = lineStart = i;
}
}
}
rowWidth = 0;
for (unsigned i = 0; i < printText_.Size(); ++i)
{
unsigned c = printText_[i];
if (c != '\n')
{
const FontGlyph* glyph = face->GetGlyph(c);
if (glyph)
{
rowWidth += glyph->advanceX_;
if (i < printText_.Size() - 1)
rowWidth += face->GetKerning(c, printText_[i + 1]);
}
}
else
{
width = Max(width, rowWidth);
height += rowHeight;
rowWidths_.Push(rowWidth);
rowWidth = 0;
}
}
if (rowWidth)
{
width = Max(width, rowWidth);
height += rowHeight;
rowWidths_.Push(rowWidth);
}
// Set row height even if text is empty
if (!height)
height = rowHeight;
// Store position & size of each character
charPositions_.Resize(unicodeText_.Size() + 1);
charSizes_.Resize(unicodeText_.Size());
unsigned rowIndex = 0;
int x = GetRowStartPosition(rowIndex);
int y = 0;
for (unsigned i = 0; i < printText_.Size(); ++i)
{
charPositions_[printToText[i]] = IntVector2(x, y);
unsigned c = printText_[i];
if (c != '\n')
{
const FontGlyph* glyph = face->GetGlyph(c);
charSizes_[printToText[i]] = IntVector2(glyph ? glyph->advanceX_ : 0, rowHeight_);
if (glyph)
{
x += glyph->advanceX_;
if (i < printText_.Size() - 1)
x += face->GetKerning(c, printText_[i + 1]);
}
}
else
{
charSizes_[printToText[i]] = IntVector2::ZERO;
x = GetRowStartPosition(++rowIndex);
y += rowHeight;
}
}
// Store the ending position
charPositions_[unicodeText_.Size()] = IntVector2(x, y);
}
// Set minimum and current size according to the text size, but respect fixed width if set
if (!IsFixedWidth())
{
SetMinWidth(wordWrap_ ? 0 : width);
SetWidth(width);
}
SetFixedHeight(height);
}
bool GetBlendData(OutModel& model, aiMesh* mesh, PODVector<unsigned>& boneMappings, Vector<PODVector<unsigned char> >&
blendIndices, Vector<PODVector<float> >& blendWeights, String& errorMessage, unsigned maxBones)
{
blendIndices.Resize(mesh->mNumVertices);
blendWeights.Resize(mesh->mNumVertices);
boneMappings.Clear();
// If model has more bones than can fit vertex shader parameters, write the per-geometry mappings
if (model.bones_.Size() > maxBones)
{
if (mesh->mNumBones > maxBones)
{
errorMessage = "Geometry (submesh) has over " + String(maxBones) + " bone influences. Try splitting to more submeshes\n"
"that each stay at " + String(maxBones) + " bones or below.";
return false;
}
boneMappings.Resize(mesh->mNumBones);
for (unsigned i = 0; i < mesh->mNumBones; ++i)
{
aiBone* bone = mesh->mBones[i];
String boneName = FromAIString(bone->mName);
unsigned globalIndex = GetBoneIndex(model, boneName);
if (globalIndex == M_MAX_UNSIGNED)
{
errorMessage = "Bone " + boneName + " not found";
return false;
}
boneMappings[i] = globalIndex;
for (unsigned j = 0; j < bone->mNumWeights; ++j)
{
unsigned vertex = bone->mWeights[j].mVertexId;
blendIndices[vertex].Push(i);
blendWeights[vertex].Push(bone->mWeights[j].mWeight);
}
}
}
else
{
for (unsigned i = 0; i < mesh->mNumBones; ++i)
{
aiBone* bone = mesh->mBones[i];
String boneName = FromAIString(bone->mName);
unsigned globalIndex = GetBoneIndex(model, boneName);
if (globalIndex == M_MAX_UNSIGNED)
{
errorMessage = "Bone " + boneName + " not found";
return false;
}
for (unsigned j = 0; j < bone->mNumWeights; ++j)
{
unsigned vertex = bone->mWeights[j].mVertexId;
blendIndices[vertex].Push(globalIndex);
blendWeights[vertex].Push(bone->mWeights[j].mWeight);
}
}
}
// Normalize weights now if necessary, also remove too many influences
for (unsigned i = 0; i < blendWeights.Size(); ++i)
{
if (blendWeights[i].Size() > 4)
{
PrintLine("Warning: more than 4 bone influences in vertex " + String(i));
while (blendWeights[i].Size() > 4)
{
unsigned lowestIndex = 0;
float lowest = M_INFINITY;
for (unsigned j = 0; j < blendWeights[i].Size(); ++j)
{
if (blendWeights[i][j] < lowest)
{
lowest = blendWeights[i][j];
lowestIndex = j;
}
}
blendWeights[i].Erase(lowestIndex);
blendIndices[i].Erase(lowestIndex);
}
}
float sum = 0.0f;
for (unsigned j = 0; j < blendWeights[i].Size(); ++j)
sum += blendWeights[i][j];
if (sum != 1.0f && sum != 0.0f)
{
for (unsigned j = 0; j < blendWeights[i].Size(); ++j)
blendWeights[i][j] /= sum;
}
}
return true;
}
