void JSONValue::SetBuffer(const String& name, const PODVector<unsigned char>& value)
{
if (!value.Size())
SetString(name, String::EMPTY);
else
SetBuffer(name, &value[0], value.Size());
}
bool Model::SetVertexBuffers(const Vector<SharedPtr<VertexBuffer> >& buffers, const PODVector<unsigned>& morphRangeStarts,
const PODVector<unsigned>& morphRangeCounts)
{
for (unsigned i = 0; i < buffers.Size(); ++i)
{
if (!buffers[i])
{
URHO3D_LOGERROR("Null model vertex buffers specified");
return false;
}
if (!buffers[i]->IsShadowed())
{
URHO3D_LOGERROR("Model vertex buffers must be shadowed");
return false;
}
}
vertexBuffers_ = buffers;
morphRangeStarts_.Resize(buffers.Size());
morphRangeCounts_.Resize(buffers.Size());
// If morph ranges are not specified for buffers, assume to be zero
for (unsigned i = 0; i < buffers.Size(); ++i)
{
morphRangeStarts_[i] = i < morphRangeStarts.Size() ? morphRangeStarts[i] : 0;
morphRangeCounts_[i] = i < morphRangeCounts.Size() ? morphRangeCounts[i] : 0;
}
return true;
}
bool XMLElement::SetBuffer(const String& name, const PODVector<unsigned char>& value)
{
if (!value.Size())
return SetAttribute(name, String::EMPTY);
else
return SetBuffer(name, &value[0], value.Size());
}
void ConvexData::BuildHull(const PODVector<Vector3>& vertices)
{
if (vertices.Size())
{
// Build the convex hull from the raw geometry
StanHull::HullDesc desc;
desc.SetHullFlag(StanHull::QF_TRIANGLES);
desc.mVcount = vertices.Size();
desc.mVertices = vertices[0].Data();
desc.mVertexStride = 3 * sizeof(float);
desc.mSkinWidth = 0.0f;
StanHull::HullLibrary lib;
StanHull::HullResult result;
lib.CreateConvexHull(desc, result);
vertexCount_ = result.mNumOutputVertices;
vertexData_ = new Vector3[vertexCount_];
indexCount_ = result.mNumIndices;
indexData_ = new unsigned[indexCount_];
// Copy vertex data & index data
memcpy(vertexData_.Get(), result.mOutputVertices, vertexCount_ * sizeof(Vector3));
memcpy(indexData_.Get(), result.mIndices, indexCount_ * sizeof(unsigned));
lib.ReleaseResult(result);
}
else
{
vertexCount_ = 0;
indexCount_ = 0;
}
}
void JSONValue::AddBuffer(const PODVector<unsigned char>& value)
{
if (!value.Size())
AddString(String::EMPTY);
else
AddBuffer(&value[0], value.Size());
}
void CrowdManager::SetCrowdTarget(const Vector3& position, Node* node)
{
if (!crowd_)
return;
PODVector<CrowdAgent*> agents = GetAgents(node, false); // Get all crowd agent components
Vector3 moveTarget(position);
for (unsigned i = 0; i < agents.Size(); ++i)
{
// Give application a chance to determine the desired crowd formation when they reach the target position
CrowdAgent* agent = agents[i];
using namespace CrowdAgentFormation;
VariantMap& map = GetEventDataMap();
map[P_NODE] = agent->GetNode();
map[P_CROWD_AGENT] = agent;
map[P_INDEX] = i;
map[P_SIZE] = agents.Size();
map[P_POSITION] = moveTarget; // Expect the event handler will modify this position accordingly
SendEvent(E_CROWD_AGENT_FORMATION, map);
moveTarget = map[P_POSITION].GetVector3();
agent->SetTargetPosition(moveTarget);
}
}
DllExport unsigned char *
urho_map_get_buffer (VariantMap &map, int hash, unsigned *size)
{
StringHash h (hash);
PODVector<unsigned char> p (map [h].GetBuffer ());
*size = p.Size();
unsigned char * result = new unsigned char[p.Size()];
for (int i = 0; i < p.Size(); i++) {
result[i] = p[i];
}
return result;
}
void NavigationMesh::CollectGeometries(Vector<NavigationGeometryInfo>& geometryList)
{
ATOMIC_PROFILE(CollectNavigationGeometry);
// Get Navigable components from child nodes, not from whole scene. This makes it possible to partition
// the scene into several navigation meshes
PODVector<Navigable*> navigables;
node_->GetComponents<Navigable>(navigables, true);
HashSet<Node*> processedNodes;
for (unsigned i = 0; i < navigables.Size(); ++i)
{
if (navigables[i]->IsEnabledEffective())
CollectGeometries(geometryList, navigables[i]->GetNode(), processedNodes, navigables[i]->IsRecursive());
}
// Get offmesh connections
Matrix3x4 inverse = node_->GetWorldTransform().Inverse();
PODVector<OffMeshConnection*> connections;
node_->GetComponents<OffMeshConnection>(connections, true);
for (unsigned i = 0; i < connections.Size(); ++i)
{
OffMeshConnection* connection = connections[i];
if (connection->IsEnabledEffective() && connection->GetEndPoint())
{
const Matrix3x4& transform = connection->GetNode()->GetWorldTransform();
NavigationGeometryInfo info;
info.component_ = connection;
info.boundingBox_ = BoundingBox(Sphere(transform.Translation(), connection->GetRadius())).Transformed(inverse);
geometryList.Push(info);
}
}
// Get nav area volumes
PODVector<NavArea*> navAreas;
node_->GetComponents<NavArea>(navAreas, true);
areas_.Clear();
for (unsigned i = 0; i < navAreas.Size(); ++i)
{
NavArea* area = navAreas[i];
if (area->IsEnabledEffective())
{
NavigationGeometryInfo info;
info.component_ = area;
info.boundingBox_ = area->GetWorldBoundingBox();
geometryList.Push(info);
areas_.Push(WeakPtr<NavArea>(area));
}
}
}
VertexDeclaration::VertexDeclaration(Graphics* graphics, const PODVector<VertexBuffer*>& buffers) :
declaration_(nullptr)
{
PODVector<VertexDeclarationElement> elements;
unsigned prevBufferElements = 0;
for (unsigned i = 0; i < buffers.Size(); ++i)
{
if (!buffers[i])
continue;
const PODVector<VertexElement>& srcElements = buffers[i]->GetElements();
bool isExisting = false;
for (unsigned j = 0; j < srcElements.Size(); ++j)
{
const VertexElement& srcElement = srcElements[j];
if (srcElement.semantic_ == SEM_OBJECTINDEX)
{
URHO3D_LOGWARNING("Object index attribute is not supported on Direct3D9 and will be ignored");
continue;
}
// Override existing element if necessary
for (unsigned k = 0; k < prevBufferElements; ++k)
{
if (elements[k].semantic_ == srcElement.semantic_ && elements[k].index_ == srcElement.index_)
{
isExisting = true;
elements[k].streamIndex_ = i;
elements[k].offset_ = srcElement.offset_;
break;
}
}
if (isExisting)
continue;
VertexDeclarationElement element;
element.semantic_ = srcElement.semantic_;
element.type_ = srcElement.type_;
element.index_ = srcElement.index_;
element.streamIndex_ = i;
element.offset_ = srcElement.offset_;
elements.Push(element);
}
prevBufferElements = elements.Size();
}
Create(graphics, elements);
}
void Renderer2D::ProcessRayQuery(const RayOctreeQuery& query, PODVector<RayQueryResult>& results)
{
unsigned resultSize = results.Size();
for (unsigned i = 0; i < drawables_.Size(); ++i)
{
if (drawables_[i]->GetViewMask() & query.viewMask_)
drawables_[i]->ProcessRayQuery(query, results);
}
if (results.Size() != resultSize)
Sort(results.Begin() + resultSize, results.End(), CompareRayQueryResults);
}
void Cursor::GetBatches(PODVector<UIBatch>& batches, PODVector<float>& vertexData, const IntRect& currentScissor)
{
unsigned initialSize = vertexData.Size();
const IntVector2& offset = shapeInfos_[shape_].hotSpot_;
Vector2 floatOffset(-(float)offset.x_, -(float)offset.y_);
BorderImage::GetBatches(batches, vertexData, currentScissor);
for (unsigned i = initialSize; i < vertexData.Size(); i += 6)
{
vertexData[i] += floatOffset.x_;
vertexData[i + 1] += floatOffset.y_;
}
}
//
// returns: null on no matches
// otherwise, a pointer that should be released with free() that
// contains a first element (pointer sized) with the number of elements
// followed by the number of pointers
//
DllExport
void *urho_node_get_components (Node *node, int code, int recursive, int *count)
{
PODVector<Node*> dest;
node->GetChildrenWithComponent (dest, StringHash(code), recursive);
if (dest.Size () == 0)
return NULL;
*count = dest.Size ();
void **t = (void **) malloc (sizeof(Node*)*dest.Size());
for (int i = 0; i < dest.Size (); i++){
t [i] = dest [i];
}
return t;
}
DllExport Interop::Vector3 *
urho_navigationmesh_findpath(NavigationMesh * navMesh, const class Urho3D::Vector3 & start, const class Urho3D::Vector3 & end, int *count)
{
PODVector<Vector3> dest;
navMesh->FindPath(dest, start, end);
if (dest.Size() == 0)
return NULL;
*count = dest.Size();
Interop::Vector3 * results = new Interop::Vector3[dest.Size()];
for (int i = 0; i < dest.Size(); i++) {
auto vector = *((Interop::Vector3 *) &(dest[i]));
results[i] = vector;
}
return results;
}
void Technique::ReleaseShaders()
{
PODVector<SharedPtr<Pass>*> allPasses = passes_.Values();
for (unsigned i = 0; i < allPasses.Size(); ++i)
allPasses[i]->Get()->ReleaseShaders();
}
void World::FillPortalsWorldWithVisibleObstaclesFrom(World& w)
{
ResourceCache* cache = context->GetSubsystem<ResourceCache>();
Material* black = cache->GetResource<Material>("Materials/Black.xml"); // notexture unlit black mat (for override white portals on screen)
if (black)
if (w.scene)
{
PODVector<Node*> nodes;
w.scene->GetChildrenWithComponent<StaticModel>(nodes, true);
for (int i = 0; i < nodes.Size(); i++)
{
Node* n = nodes[i];
if (n)
{
StaticModel* model = n->GetComponent<StaticModel>();
if (model)
{
Node* newNode = scene->CreateChild(n->GetName(), LOCAL);
StaticModel* newModel = newNode->CreateComponent<StaticModel>();
newModel->SetModel(model->GetModel());
newModel->SetMaterial(black);
newNode->SetWorldPosition(n->GetWorldPosition());
newNode->SetWorldRotation(n->GetWorldRotation());
newNode->SetWorldScale(n->GetWorldScale());
}
}
}
}
}
String AssetDatabase::GenerateAssetGUID()
{
Time* time = GetSubsystem<Time>();
while (true)
{
Poco::MD5Engine md5;
PODVector<unsigned> data;
for (unsigned i = 0; i < 16; i++)
{
data.Push(time->GetTimeSinceEpoch() + Rand());
}
md5.update(&data[0], data.Size() * sizeof(unsigned));
String guid = Poco::MD5Engine::digestToHex(md5.digest()).c_str();
if (!usedGUID_.Contains(guid))
{
RegisterGUID(guid);
return guid;
}
}
assert(0);
return "";
}
static void ClipPolygon(PODVector<DecalVertex>& dest, const PODVector<DecalVertex>& src, const Plane& plane, bool skinned)
{
unsigned last = 0;
float lastDistance = 0.0f;
dest.Clear();
if (src.Empty())
return;
for (unsigned i = 0; i < src.Size(); ++i)
{
float distance = plane.Distance(src[i].position_);
if (distance >= 0.0f)
{
if (lastDistance < 0.0f)
dest.Push(ClipEdge(src[last], src[i], lastDistance, distance, skinned));
dest.Push(src[i]);
}
else
{
if (lastDistance >= 0.0f && i != 0)
dest.Push(ClipEdge(src[last], src[i], lastDistance, distance, skinned));
}
last = i;
lastDistance = distance;
}
// Recheck the distances of the last and first vertices and add the final clipped vertex if applicable
float distance = plane.Distance(src[0].position_);
if ((lastDistance < 0.0f && distance >= 0.0f) || (lastDistance >= 0.0f && distance < 0.0f))
dest.Push(ClipEdge(src[last], src[0], lastDistance, distance, skinned));
}
void AnimatedModel::SetMorphWeight(unsigned index, float weight)
{
if (index >= morphs_.Size())
return;
// If morph vertex buffers have not been created yet, create now
if (weight != 0.0f && morphVertexBuffers_.Empty())
CloneGeometries();
if (weight != morphs_[index].weight_)
{
morphs_[index].weight_ = weight;
// For a master model, set the same morph weight on non-master models
if (isMaster_)
{
PODVector<AnimatedModel*> models;
GetComponents<AnimatedModel>(models);
// Indexing might not be the same, so use the name hash instead
for (unsigned i = 1; i < models.Size(); ++i)
{
if (!models[i]->isMaster_)
models[i]->SetMorphWeight(morphs_[index].nameHash_, weight);
}
}
MarkMorphsDirty();
MarkNetworkUpdate();
}
}
PODVector<IntVector2> Graphics::GetResolutions() const
{
PODVector<IntVector2> ret;
// Emscripten is not able to return a valid list
#ifndef __EMSCRIPTEN__
unsigned numModes = (unsigned)SDL_GetNumDisplayModes(0);
for (unsigned i = 0; i < numModes; ++i)
{
SDL_DisplayMode mode;
SDL_GetDisplayMode(0, i, &mode);
int width = mode.w;
int height = mode.h;
// Store mode if unique
bool unique = true;
for (unsigned j = 0; j < ret.Size(); ++j)
{
if (ret[j].x_ == width && ret[j].y_ == height)
{
unique = false;
break;
}
}
if (unique)
ret.Push(IntVector2(width, height));
}
#endif
return ret;
}
bool Urho3DTemplate::RayCast(float maxDistance, Vector3 &hitPos, Drawable *&hitDrawable)
{
hitDrawable = 0;
UI* ui = GetSubsystem<UI>();
IntVector2 pos = ui->GetCursorPosition();
//Check the cursor is visible and there is no UI element in front of the cursor
if (!ui->GetCursor()->IsVisible() || ui->GetElementAt(pos, true))
return false;
Graphics* graphics = GetSubsystem<Graphics>();
Camera* camera = cameraNode_->GetComponent<Camera>();
Ray cameraRay = camera->GetScreenRay((float)pos.x_/graphics->GetWidth(), (float)pos.y_/graphics->GetHeight());
//Pick only geometry objects, not eg zones or lights, only get the first (closest) hit
PODVector<RayQueryResult> results;
RayOctreeQuery query(results, cameraRay, RAY_TRIANGLE, maxDistance, DRAWABLE_GEOMETRY);
scene_->GetComponent<Octree>()->RaycastSingle(query);
if (results.Size())
{
RayQueryResult& result = results[0];
hitPos = result.position_;
hitDrawable = result.drawable_;
return true;
}
return false;
}
VertexDeclaration::VertexDeclaration(Graphics* graphics, const PODVector<VertexElement>& srcElements) :
declaration_(nullptr)
{
PODVector<VertexDeclarationElement> elements;
for (unsigned i = 0; i < srcElements.Size(); ++i)
{
const VertexElement& srcElement = srcElements[i];
if (srcElement.semantic_ == SEM_OBJECTINDEX)
{
URHO3D_LOGWARNING("Object index attribute is not supported on Direct3D9 and will be ignored");
continue;
}
VertexDeclarationElement element;
element.semantic_ = srcElement.semantic_;
element.type_ = srcElement.type_;
element.index_ = srcElement.index_;
element.streamIndex_ = 0;
element.offset_ = srcElement.offset_;
elements.Push(element);
}
Create(graphics, elements);
}
static void js_atomic_destroy_node(Node* node, duk_context* ctx, bool root = false)
{
if (root)
{
PODVector<Node*> children;
node->GetChildren(children, true);
for (unsigned i = 0; i < children.Size(); i++)
{
if (children.At(i)->JSGetHeapPtr())
js_atomic_destroy_node(children.At(i), ctx);
}
}
const Vector<SharedPtr<Component> >& components = node->GetComponents();
for (unsigned i = 0; i < components.Size(); i++)
{
Component* component = components[i];
if (component->GetType() == JSComponent::GetTypeStatic())
{
JSComponent* jscomponent = (JSComponent*) component;
jscomponent->SetDestroyed();
}
component->UnsubscribeFromAllEvents();
}
node->RemoveAllComponents();
node->UnsubscribeFromAllEvents();
node->Remove();
}
bool ValueAnimationInfo::Update(float timeStep)
{
if (!animation_ || !target_)
return true;
currentTime_ += timeStep * speed_;
if (!animation_->IsValid())
return true;
bool finished = false;
// Calculate scale time by wrap mode
float scaledTime = CalculateScaledTime(currentTime_, finished);
// Apply to the target object
ApplyValue(animation_->GetAnimationValue(scaledTime));
// Send keyframe event if necessary
if (animation_->HasEventFrames())
{
PODVector<const VAnimEventFrame*> eventFrames;
GetEventFrames(lastScaledTime_, scaledTime, eventFrames);
for (unsigned i = 0; i < eventFrames.Size(); ++i)
target_->SendEvent(eventFrames[i]->eventType_, const_cast<VariantMap&>(eventFrames[i]->eventData_));
}
lastScaledTime_ = scaledTime;
return finished;
}
void Player::SetCurrentScene(Scene* scene, Camera* camera)
{
Vector<SharedPtr<Scene>>::ConstIterator citr = loadedScenes_.Find(SharedPtr<Scene>(scene));
if (citr == loadedScenes_.End())
{
ATOMIC_LOGERROR("Player::UnloadScene - unknown scene");
return;
}
currentScene_ = scene;
if (!camera)
{
PODVector<Node*> cameraNodes;
scene->GetChildrenWithComponent(cameraNodes, Camera::GetTypeStatic(), true);
if (cameraNodes.Size())
{
camera = cameraNodes[0]->GetComponent<Camera>();
}
}
viewport_->SetScene(scene);
if (camera)
viewport_->SetCamera(camera);
}
void VertexDeclaration::Create(Graphics* graphics, const PODVector<VertexDeclarationElement>& elements)
{
SharedArrayPtr<D3DVERTEXELEMENT9> elementArray(new D3DVERTEXELEMENT9[elements.Size() + 1]);
D3DVERTEXELEMENT9* dest = elementArray;
for (Vector<VertexDeclarationElement>::ConstIterator i = elements.Begin(); i != elements.End(); ++i)
{
dest->Stream = (WORD)i->streamIndex_;
dest->Offset = (WORD)i->offset_;
dest->Type = d3dElementType[i->type_];
dest->Method = D3DDECLMETHOD_DEFAULT;
dest->Usage = d3dElementUsage[i->semantic_];
dest->UsageIndex = i->index_;
dest++;
}
dest->Stream = 0xff;
dest->Offset = 0;
dest->Type = D3DDECLTYPE_UNUSED;
dest->Method = 0;
dest->Usage = 0;
dest->UsageIndex = 0;
IDirect3DDevice9* device = graphics->GetImpl()->GetDevice();
HRESULT hr = device->CreateVertexDeclaration(elementArray, &declaration_);
if (FAILED(hr))
{
URHO3D_SAFE_RELEASE(declaration_);
URHO3D_LOGD3DERROR("Failed to create vertex declaration", hr);
}
}
void Explosion::UpdateExplosion(StringHash eventType, VariantMap& eventData)
{
float timeStep = eventData[Update::P_TIMESTEP].GetFloat();
rigidBody_->SetMass(Max(initialMass_*((0.1f - age_)/0.1f),0.01f));
light_->SetBrightness(Max(initialBrightness_*(0.32f - age_)/0.32f,0.0f));
if (rootNode_->IsEnabled() && masterControl_->world.scene->IsUpdateEnabled()) {
PODVector<RigidBody* > hitResults;
float radius = 2.0f * initialMass_ + age_ * 7.0f;
if (masterControl_->PhysicsSphereCast(hitResults,rootNode_->GetPosition(), radius, M_MAX_UNSIGNED)) {
for (int i = 0; i < hitResults.Size(); i++) {
Vector3 hitNodeWorldPos = hitResults[i]->GetNode()->GetWorldPosition();
if (!hitResults[i]->IsTrigger() && hitResults[i]->GetPosition().y_ > -0.1f) {
//positionDelta is used for force calculation
Vector3 positionDelta = hitNodeWorldPos - rootNode_->GetWorldPosition();
float distance = positionDelta.Length();
Vector3 force = positionDelta.Normalized() * Max(radius-distance, 0.0f)
* timeStep * 2342.0f * rigidBody_->GetMass();
hitResults[i]->ApplyForce(force);
//Deal damage
unsigned hitID = hitResults[i]->GetNode()->GetID();
float damage = rigidBody_->GetMass()*timeStep;
if(masterControl_->spawnMaster_->spires_.Keys().Contains(hitID)) {
masterControl_->spawnMaster_->spires_[hitID]->Hit(damage, 1);
}
else if(masterControl_->spawnMaster_->razors_.Keys().Contains(hitID)) {
masterControl_->spawnMaster_->razors_[hitID]->Hit(damage, 1);
}
}
}
}
}
}
static int AssetDatabase_GetAssetsByImporterType(duk_context* ctx)
{
JSVM* vm = JSVM::GetJSVM(ctx);
ToolSystem* ts = vm->GetSubsystem<ToolSystem>();
AssetDatabase* db = vm->GetSubsystem<AssetDatabase>();
Project* project = ts->GetProject();
StringHash type = duk_require_string(ctx, 0);
String resourceType = duk_require_string(ctx, 1);
duk_push_array(ctx);
if (!project)
return 1;
PODVector<Asset*> assets;
db->GetAssetsByImporterType(type, resourceType, assets);
for(unsigned i = 0; i < assets.Size(); i++)
{
js_push_class_object_instance(ctx, assets[i], 0);
duk_put_prop_index(ctx, -2, i);
}
return 1;
}
bool AttributeAnimationInfo::Update(float timeStep)
{
if (!animation_)
return true;
currentTime_ += timeStep * speed_;
if (!animation_->IsValid())
return true;
bool finished = false;
// Calculate scale time by wrap mode
float scaledTime = CalculateScaledTime(currentTime_, finished);
animatable_->OnSetAttribute(attributeInfo_, animation_->GetAnimationValue(scaledTime));
if (animation_->HasEventFrames())
{
PODVector<const VAnimEventFrame*> eventFrames;
GetEventFrames(lastScaledTime_, scaledTime, eventFrames);
for (unsigned i = 0; i < eventFrames.Size(); ++i)
animatable_->SendEvent(eventFrames[i]->eventType_, const_cast<VariantMap&>(eventFrames[i]->eventData_));
}
lastScaledTime_ = scaledTime;
return finished;
}
void VertexDeclaration::Create(Graphics* graphics, const PODVector<VertexDeclarationElement>& elements)
{
SharedArrayPtr<D3DVERTEXELEMENT9> elementArray(new D3DVERTEXELEMENT9[elements.Size() + 1]);
D3DVERTEXELEMENT9* dest = elementArray;
for (Vector<VertexDeclarationElement>::ConstIterator i = elements.Begin(); i != elements.End(); ++i)
{
dest->Stream = i->stream_;
dest->Offset = i->offset_;
dest->Type = d3dElementType[i->element_];
dest->Method = D3DDECLMETHOD_DEFAULT;
dest->Usage = d3dElementUsage[i->element_];
dest->UsageIndex = d3dElementUsageIndex[i->element_];
dest++;
}
dest->Stream = 0xff;
dest->Offset = 0;
dest->Type = D3DDECLTYPE_UNUSED;
dest->Method = 0;
dest->Usage = 0;
dest->UsageIndex = 0;
IDirect3DDevice9* device = graphics->GetImpl()->GetDevice();
if (!device)
return;
device->CreateVertexDeclaration(elementArray, &declaration_);
}
void Text::ConstructBatch(UIBatch& pageBatch, const PODVector<GlyphLocation>& pageGlyphLocation, float dx, float dy, Color* color,
float depthBias)
{
unsigned startDataSize = pageBatch.vertexData_->Size();
if (!color)
pageBatch.SetDefaultColor();
else
pageBatch.SetColor(*color);
for (unsigned i = 0; i < pageGlyphLocation.Size(); ++i)
{
const GlyphLocation& glyphLocation = pageGlyphLocation[i];
const FontGlyph& glyph = *glyphLocation.glyph_;
pageBatch.AddQuad(dx + glyphLocation.x_ + glyph.offsetX_, dy + glyphLocation.y_ + glyph.offsetY_, glyph.width_,
glyph.height_, glyph.x_, glyph.y_, glyph.texWidth_, glyph.texHeight_);
}
if (depthBias != 0.0f)
{
unsigned dataSize = pageBatch.vertexData_->Size();
for (unsigned i = startDataSize; i < dataSize; i += UI_VERTEX_SIZE)
pageBatch.vertexData_->At(i + 2) += depthBias;
}
}
