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; } }