/** * @brief * Sets the node position */ void GraphNode::SetPos(float fX, float fY, float fZ) { // Set new position m_vPos.SetXYZ(fX, fY, fZ); { // Calculate all node distances Iterator<Neighbour*> cIterator = m_lstNeighbours.GetIterator(); while (cIterator.HasNext()) { Neighbour *pNeighbour = cIterator.Next(); pNeighbour->fDistance = GetDistance(*pNeighbour->pNode); } } { // Update all neighbour node distances Iterator<GraphNode*> cIterator = m_lstIsNeighbourFrom.GetIterator(); while (cIterator.HasNext()) { // Find this node within the neighbour Iterator<Neighbour*> cNeighbourIterator = cIterator.Next()->m_lstNeighbours.GetIterator(); while (cNeighbourIterator.HasNext()) { Neighbour *pNeighbour = cNeighbourIterator.Next(); if (pNeighbour->pNode == this) { pNeighbour->fDistance = GetDistance(*pNeighbour->pNode); break; } } } } }
void Gui::DefaultCallBackHandler() { // get the iterator for the windows Iterator<SRPWindows*> cIterator = m_pWindows->GetIterator(); // loop trough the windows while (cIterator.HasNext()) { SRPWindows *pSRPWindows = cIterator.Next(); // check if callback is present if (pSRPWindows->GetNumberOfCallBacks() > 0) { if (pSRPWindows->GetCallBack(DRAGWINDOW)) { m_pDragWindow = pSRPWindows; } if (pSRPWindows->GetCallBack(HIDEWINDOW)) { /*hide window*/ } if (pSRPWindows->GetCallBack(CLOSEWINDOW)) { /*close window*/ } // call back is processed so we clear them pSRPWindows->ClearCallBacks(); } } }
/** * @brief * Destructor */ World::~World() { // Destroy all visibility information Iterator<void*> cIterator = m_lstFreeBodyInformation.GetIterator(); while (cIterator.HasNext()) delete static_cast<Sensor::BodyInfo*>(cIterator.Next()); }
/** * @brief * Draws recursive */ void SRPDebugWireframesFixedFunctions::DrawRec(Renderer &cRenderer, const SQCull &cCullQuery) const { // Get the fixed functions interface (when we're in here, we know that it must exist!) FixedFunctions *pFixedFunctions = cRenderer.GetFixedFunctions(); // Get scene container SceneContainer &cSceneContainer = cCullQuery.GetSceneContainer(); const VisContainer &cVisContainer = cCullQuery.GetVisContainer(); // Set the new scissor rectangle cRenderer.SetScissorRect(&cVisContainer.GetProjection().cRectangle); // Draw the container scene node if (cSceneContainer.GetMeshHandler()) DrawMesh(cRenderer, cVisContainer, *cSceneContainer.GetMeshHandler()); // Render all visible scene nodes of this scene container Iterator<VisNode*> cIterator = cVisContainer.GetVisNodes().GetIterator(); while (cIterator.HasNext()) { // Get visibility node and scene node const VisNode *pVisNode = cIterator.Next(); SceneNode *pSceneNode = pVisNode->GetSceneNode(); if (pSceneNode) { // Set the current world matrix pFixedFunctions->SetTransformState(FixedFunctions::Transform::World, pVisNode->GetWorldMatrix()); // Is this scene node a portal? if (pVisNode->IsPortal()) { // Get the target cell visibility container const VisContainer *pVisCell = static_cast<const VisPortal*>(pVisNode)->GetTargetVisContainer(); if (pVisCell && pVisCell->GetCullQuery()) { // Draw the target cell DrawRec(cRenderer, *pVisCell->GetCullQuery()); // Set the previous scissor rectangle cRenderer.SetScissorRect(&cVisContainer.GetProjection().cRectangle); } // Draw the portal itself if (pSceneNode->GetMeshHandler()) DrawMesh(cRenderer, *pVisNode, *pSceneNode->GetMeshHandler()); // Is this scene node a container? We do not need to check for cells because we will // NEVER receive cells from SQCull directly, they are ONLY visible through portals! (see above) } else if (pVisNode->IsContainer()) { // Draw this container without special processing if (static_cast<const VisContainer*>(pVisNode)->GetCullQuery()) DrawRec(cRenderer, *static_cast<const VisContainer*>(pVisNode)->GetCullQuery()); // Set the previous scissor rectangle cRenderer.SetScissorRect(&cVisContainer.GetProjection().cRectangle); // This must just be a quite boring scene node :) } else { if (pSceneNode->GetMeshHandler()) DrawMesh(cRenderer, *pVisNode, *pSceneNode->GetMeshHandler()); } } } }
/** * @brief * Removes a neighbour connection */ bool GraphNode::RemoveNeighbour(GraphNode &cNode) { // Find neighbour list entry Neighbour *pNeighbour = nullptr; { Iterator<Neighbour*> cIterator = m_lstNeighbours.GetIterator(); while (cIterator.HasNext()) { Neighbour *pNeighbourT = cIterator.Next(); if (pNeighbourT->pNode == &cNode) { pNeighbour = pNeighbourT; break; } } } // Remove if (pNeighbour) { cNode.m_lstIsNeighbourFrom.Remove(this); delete pNeighbour; m_lstNeighbours.Remove(pNeighbour); // Done return true; } else return false; // Error! }
List<SRPWindows*> *Gui::GetMouseEnabledWindows() { // create an empty list List<SRPWindows*> *pList = new List<SRPWindows*>; // get the iterator for all the windows Iterator<SRPWindows*> cIterator = m_pWindows->GetIterator(); // loop trough the windows while (cIterator.HasNext()) { SRPWindows *pSRPWindows = cIterator.Next(); if (pSRPWindows->GetData()->bIsVisable && pSRPWindows->GetData()->bMouseEnabled) { // if the window is visible and the mouse for the window is enabled then add the window to the list pList->Add(pSRPWindows); } } if (pList->GetNumOfElements() > 0) { // list has items so return the list return pList; } else { // return nothing because the list is empty return nullptr; } }
Set<ElemType> *Set<ElemType>::Union(Set *otherSet) { Iterator<ElemType> *iterator; Set *result; result = new Set<ElemType>(cmp); iterator = CreateIterator(); while (iterator->HasNext()) { result->AddElement(iterator->Next()); } delete iterator; iterator = otherSet->CreateIterator(); while (iterator->HasNext()) { result->AddElement(iterator->Next()); } delete iterator; return (result); }
/** * @brief * Called when the scene node needs to be updated */ void PGSparkles::OnUpdate() { // If this scene node wasn't drawn at the last frame, we can skip some update stuff if ((GetFlags() & ForceUpdate) || m_bUpdate) { m_bUpdate = true; // If there are free particles, create new particles if (!(System::GetInstance()->GetMicroseconds() % BuildPerSec)) { while (Math::GetRand() % 5) { Particle *pParticle = AddParticle(); if (pParticle) InitParticle(*pParticle); else break; } } { // Update particles float fTimeDiff = Timing::GetInstance()->GetTimeDifference(); Iterator<Particle> cIterator = GetParticleIterator(); while (cIterator.HasNext()) { Particle &cParticle = cIterator.Next(); // Update velocity cParticle.vVelocity += GetGravity()*fTimeDiff*(200-cParticle.fEnergy)/10; cParticle.vVelocity -= cParticle.vVelocity*fTimeDiff; // Self induction to make the sparkles a bit more interesting ;-) if (!(System::GetInstance()->GetMicroseconds() % 500) && !(Math::GetRand() % 5)) { cParticle.fEnergy += 100; cParticle.fSize += 0.2f; } // Update position Vector3 vMove = cParticle.vVelocity*fTimeDiff*cParticle.fEnergy/100; cParticle.vPos += vMove/10; // Update distortion cParticle.fCustom1 += fTimeDiff; float dLength = cParticle.fCustom1/vMove.GetLength()*5; cParticle.vDistortion = vMove*dLength; // Update energy, size and lifetime cParticle.fEnergy -= fTimeDiff*EnergyPerSec; cParticle.fSize -= fTimeDiff; if (cParticle.fEnergy <= 0 || cParticle.fSize <= 0) InitParticle(cParticle); else cParticle.vColor[3] = cParticle.fEnergy/255; } } // We have to recalculate the current axis align bounding box in 'scene node space' DirtyAABoundingBox(); } }
/** * @brief * Clears all neighbour connectivity */ void GraphNode::ClearNeighbours() { { // Update neighbour connections Iterator<GraphNode*> cIterator = m_lstIsNeighbourFrom.GetIterator(); while (cIterator.HasNext()) { // Remove this node from the neighbours connectivity list cIterator.Next()->RemoveNeighbour(*this); } } m_lstIsNeighbourFrom.Clear(); { // Clear neighbours Iterator<Neighbour*> cIterator = m_lstNeighbours.GetIterator(); while (cIterator.HasNext()) { Neighbour *pNN = cIterator.Next(); pNN->pNode->m_lstIsNeighbourFrom.Remove(this); delete pNN; } } m_lstNeighbours.Clear(); }
void Gui::UnFocusAllWindows() { // focused window needs to be a nullptr m_pFocusedWindow = nullptr; // get the iterator for all the windows Iterator<SRPWindows*> cIterator = m_pWindows->GetIterator(); // loop trough the windows while (cIterator.HasNext()) { // unfocus the window cIterator.Next()->GetAwesomiumWindow()->Unfocus(); } }
/** * @brief * Called when the scene node needs to be updated */ void PGImage::OnUpdate() { // If this scene node wasn't drawn at the last frame, we can skip some update stuff if ((GetFlags() & ForceUpdate) || m_bUpdate) { m_bUpdate = false; { // Update particles float fTimeDiff = Timing::GetInstance()->GetTimeDifference(); Iterator<Particle> cIterator = GetParticleIterator(); while (cIterator.HasNext()) { Particle &cParticle = cIterator.Next(); cParticle.fSize = cParticle.fCustom1; for (int i=0; i<3; i++) { if (cParticle.vPos[i] > cParticle.vDistortion[i]) cParticle.vVelocity[i] -= fTimeDiff*10; else { if (cParticle.vPos[i] < cParticle.vDistortion[i]) cParticle.vVelocity[i] += fTimeDiff*10; } if (cParticle.vVelocity[i] > 100.0f) cParticle.vVelocity[i] = 100.0f; if (cParticle.vVelocity[i] < -100.0f) cParticle.vVelocity[i] = -100.0f; cParticle.vPos[i] += cParticle.vVelocity[i]*fTimeDiff; if ((cParticle.vPos[i] <= cParticle.vDistortion[i]+0.1f && cParticle.vPos[i] >= cParticle.vDistortion[i]-0.1f) || cParticle.vPos[i] >= cParticle.vFixPos[i]+0.2f || cParticle.vPos[i] <= cParticle.vFixPos[i]-0.2f) { if (cParticle.vDistortion[i] != cParticle.vFixPos[i]) cParticle.vVelocity[i] *= 0.8f; if (cParticle.vPos[i] > cParticle.vFixPos[i]+0.2f || cParticle.vPos[i] < cParticle.vFixPos[i]-0.2f) cParticle.vDistortion[i] = cParticle.vFixPos[i]; else { if (Math::GetRand() % 2) cParticle.vDistortion[i] = static_cast<float>(Math::GetRand() % 100)/1000+cParticle.vFixPos[i]; else cParticle.vDistortion[i] = static_cast<float>(Math::GetRand() % 100)/1000-cParticle.vFixPos[i]; } } } } } // We have to recalculate the current axis align bounding box in 'scene node space' DirtyAABoundingBox(); } }
/** * @brief * Destructor */ VisContainer::~VisContainer() { // Free all nodes FreeNodes(); // Destroy the query SceneQuery *pSceneQuery = m_pQueryHandler->GetElement(); if (pSceneQuery) pSceneQuery->GetSceneContainer().DestroyQuery(*pSceneQuery); delete m_pQueryHandler; { // Destroy all containers Iterator<VisContainer*> cIterator = m_mapContainers.GetIterator(); while (cIterator.HasNext()) delete cIterator.Next(); } { // Destroy all portals Iterator<VisPortal*> cIterator = m_mapPortals.GetIterator(); while (cIterator.HasNext()) delete cIterator.Next(); } }
bool Set<ElemType>::IsSubsetOf(Set *otherSet) { Iterator<ElemType> *iterator; bool result; result = true; iterator = CreateIterator(); while (result && iterator->HasNext()) { if (!otherSet->Contains(iterator->Next())) result = false; } delete iterator; return (result); }
/** * @brief * Returns whether a node is a neighbour of this node or not */ bool GraphNode::IsNeighbour(const GraphNode &cNode) const { // Check whether the given node is a neighbour of this node or not Iterator<Neighbour*> cIterator = m_lstNeighbours.GetIterator(); while (cIterator.HasNext()) { if (cIterator.Next()->pNode == &cNode) { // The given node is a neighbour of this node return true; } } // The given node is no neighbour of this node return false; }
/** * @brief * Destroys all registered event user data (a kind of "disconnect all slots at once") */ void Script::DestroyEventUserData() { // Iterate through the map content Iterator<String> cKeyIterator = m_mapEventUserData.GetKeyIterator(); while (cKeyIterator.HasNext()) { // Get the event user data instance EventUserData *pEventUserData = m_mapEventUserData.Get(cKeyIterator.Next()); // Destroy the event user data delete pEventUserData->pDynEventHandler; luaL_unref(m_pLuaState, LUA_REGISTRYINDEX, pEventUserData->nLuaFunctionReference); delete pEventUserData; } }
Set<ElemType> *Set<ElemType>::Intersection(Set *otherSet) { Iterator<ElemType> *iterator; Set *result; result = new Set<ElemType>(cmp); iterator = CreateIterator(); while (iterator->HasNext()) { ElemType elem = iterator->Next(); if (otherSet->Contains(elem)) result->AddElement(elem); } delete iterator; return (result); }
/** * @brief * Destructor */ SRPDirectionalLightingShaders::~SRPDirectionalLightingShaders() { { // SRPDirectionalLightingShaders-material cache cleanup Iterator<SRPDirectionalLightingShadersMaterial*> lstIterator = m_lstMaterialCache.GetIterator(); while (lstIterator.HasNext()) delete lstIterator.Next(); m_lstMaterialCache.Clear(); } // Destroy render states 'translator' delete m_pRenderStates; // Destroy the program generator if (m_pProgramGenerator) delete m_pProgramGenerator; }
/** * @brief * Draws recursive */ void SRPVolume::DrawRec(Renderer &cRenderer, const SQCull &cCullQuery) { // Set the new scissor rectangle const VisContainer &cVisContainer = cCullQuery.GetVisContainer(); cRenderer.SetScissorRect(&cVisContainer.GetProjection().cRectangle); // Render all visible scene nodes of this scene container Iterator<VisNode*> cIterator = (GetFlags() & DrawOrderFrontToBack) ? cVisContainer.GetVisNodes().GetIterator() : cVisContainer.GetVisNodes().GetEndIterator(); while ((GetFlags() & DrawOrderFrontToBack) ? cIterator.HasNext() : cIterator.HasPrevious()) { // Get visibility node and scene node const VisNode *pVisNode = (GetFlags() & DrawOrderFrontToBack) ? cIterator.Next() : cIterator.Previous(); SceneNode *pSceneNode = pVisNode->GetSceneNode(); if (pSceneNode) { // Is this scene node a portal? if (pVisNode->IsPortal()) { // Get the target cell visibility container const VisContainer *pVisCell = static_cast<const VisPortal*>(pVisNode)->GetTargetVisContainer(); if (pVisCell && pVisCell->GetCullQuery()) { // Draw the target cell DrawRec(cRenderer, *pVisCell->GetCullQuery()); // Set the previous scissor rectangle cRenderer.SetScissorRect(&cVisContainer.GetProjection().cRectangle); } // Is this scene node a container? We do not need to check for cells because we will // NEVER receive cells from SQCull directly, they are ONLY visible through portals! (see above) } else if (pVisNode->IsContainer()) { // Draw this container without special processing if (static_cast<const VisContainer*>(pVisNode)->GetCullQuery()) { DrawRec(cRenderer, *static_cast<const VisContainer*>(pVisNode)->GetCullQuery()); // Set the previous scissor rectangle cRenderer.SetScissorRect(&cVisContainer.GetProjection().cRectangle); } // This must just be a quite boring scene node :) } else { // Do only take "PLVolume::SNVolume"-instances into account in here const static Class *pSNVolumeClass = ClassManager::GetInstance()->GetClass("PLVolume::SNVolume"); if (pSceneNode->GetClass() == pSNVolumeClass) DrawVolumeSceneNode(cRenderer, cCullQuery, *pVisNode); } } } }
/** * @brief * Searches for the first (= nearest) visible clip plane scene node, recursive part */ const VisNode *SRPVolume::GetFirstClipPlaneRec(const SQCull &cCullQuery) const { // Get visibility container const VisContainer &cVisContainer = cCullQuery.GetVisContainer(); // Search through all visible scene nodes of this scene container Iterator<VisNode*> cIterator = cVisContainer.GetVisNodes().GetIterator(); while (cIterator.HasNext()) { // Get visibility node and scene node const VisNode *pVisNode = cIterator.Next(); SceneNode *pSceneNode = pVisNode->GetSceneNode(); if (pSceneNode) { // Is this scene node a portal? if (pVisNode->IsPortal()) { // Get the target cell visibility container const VisContainer *pVisCell = static_cast<const VisPortal*>(pVisNode)->GetTargetVisContainer(); if (pVisCell && pVisCell->GetCullQuery()) { // Search within the target cell const VisNode *pFoundVisNode = GetFirstClipPlaneRec(*pVisCell->GetCullQuery()); if (pFoundVisNode) return pFoundVisNode; } // Is this scene node a container? We do not need to check for cells because we will // NEVER receive cells from SQCull directly, they are ONLY visible through portals! (see above) } else if (pVisNode->IsContainer()) { // Search within this container without special processing if (static_cast<const VisContainer*>(pVisNode)->GetCullQuery()) { const VisNode *pFoundVisNode = GetFirstClipPlaneRec(*static_cast<const VisContainer*>(pVisNode)->GetCullQuery()); if (pFoundVisNode) return pFoundVisNode; } // This must just be a quite boring scene node :) } else { // Is this a clip plane scene node? if (pSceneNode->IsInstanceOf("PLVolume::SNClipPrimitivePlane")) return pVisNode; } } } // Sorry, no result :/ return nullptr; }
List<SRPWindows*> *Gui::GetMouseOverWindows(const List<SRPWindows*> *pEnabledWindows, const Vector2i &vMousePos) { if (!pEnabledWindows) { // return nothing because the enabled windows list is not valid return nullptr; } // create an empty list List<SRPWindows*> *pList = new List<SRPWindows*>; // get the iterator for the enabled windows Iterator<SRPWindows*> cIterator = pEnabledWindows->GetIterator(); // loop trough the enabled windows while (cIterator.HasNext()) { SRPWindows *pSRPWindows = cIterator.Next(); // get the relative mouse position for the window Vector2i vRelativeMousePos = pSRPWindows->GetRelativeMousePosition(vMousePos); if (vRelativeMousePos.x > 0 && vRelativeMousePos.y > 0 && vRelativeMousePos.x < pSRPWindows->GetSize().x && vRelativeMousePos.y < pSRPWindows->GetSize().y) { // the mouse is currently over the window, so we add the window to the list pList->Add(pSRPWindows); } else { // check if any widgets are drawn for the window /*maybe this needs to be implemented at a later point*/ } } if (pList->GetNumOfElements() > 0) { // list has items so return the list return pList; } else { // return nothing because the list is empty return nullptr; } }
/** * @brief * Set default configuration settings */ bool Config::SetDefault(const String &sClass, const String &sVariable) { // Set all classes to default settings? if (sClass.GetLength()) return SetClassDefault(sClass, sVariable); else { // Set a class to default settings bool bResult = true; // No error by default Iterator<ConfigGroup*> cIterator = m_lstConfig.GetIterator(); while (cIterator.HasNext()) { ConfigGroup *pClass = cIterator.Next(); if (!SetClassDefault(pClass->GetClass()->GetClassName(), sVariable)) bResult = false; // Something went wrong } // Done return bResult; } }
void Gui::OnUpdate() { UpdateAwesomium(); // mouse handler? KeyboardHandler(); DefaultCallBackHandler(); DragWindowHandler(); // resize window handler // test for awesomium update // get the iterator for all the windows Iterator<SRPWindows*> cIterator = m_pWindows->GetIterator(); // loop trough the windows while (cIterator.HasNext()) { // unfocus the window cIterator.Next()->UpdateCall(); } }
/** * @brief * Draws recursive */ void SRPDeferredLighting::DrawRec(Renderer &cRenderer, const SQCull &cCullQuery, SRPDeferredGBuffer &cSRPDeferredGBuffer) { // Get scene container const VisContainer &cVisContainer = cCullQuery.GetVisContainer(); // Render all visible scene nodes of this scene container Iterator<VisNode*> cIterator = cVisContainer.GetVisNodes().GetIterator(); while (cIterator.HasNext()) { // Get visibility node and scene node const VisNode *pVisNode = cIterator.Next(); SceneNode *pSceneNode = pVisNode->GetSceneNode(); if (pSceneNode) { // Is this scene node a portal? if (pVisNode->IsPortal()) { // Get the target cell visibility container const VisContainer *pVisCell = static_cast<const VisPortal*>(pVisNode)->GetTargetVisContainer(); if (pVisCell && pVisCell->GetCullQuery()) { // Draw the target cell DrawRec(cRenderer, *pVisCell->GetCullQuery(), cSRPDeferredGBuffer); } // Is this scene node a container? We do not need to check for cells because we will // NEVER receive cells from SQCull directly, they are ONLY visible through portals! (see above) } else if (pVisNode->IsContainer()) { // Draw this container without special processing if (static_cast<const VisContainer*>(pVisNode)->GetCullQuery()) DrawRec(cRenderer, *static_cast<const VisContainer*>(pVisNode)->GetCullQuery(), cSRPDeferredGBuffer); // Is this a light? } else if (pSceneNode->IsLight()) { if (static_cast<SNLight*>(pSceneNode)->IsRenderLight()) { // Render the light RenderLight(cRenderer, cCullQuery, cSRPDeferredGBuffer, *static_cast<SNLight*>(pSceneNode), *pVisNode); } // This must just be a quite boring scene node, ignore it } else { } } } }
void Gui::DestroyWindows() { if (m_bAwesomiumInitialized) { // get the iterator for all the windows created Iterator<SRPWindows*> cIterator = m_pWindows->GetIterator(); // loop trough the windows while (cIterator.HasNext()) { SRPWindows *pSRPWindows = cIterator.Next(); // remove the scene render pass from the renderer pSRPWindows->RemoveSceneRenderPass(); // destroy the window pSRPWindows->DestroyWindow(); // cleanup the instance pSRPWindows->DestroyInstance(); } // clear the hashmap m_pWindows->Clear(); } }
SRPWindows *Gui::GetTopMostWindow(List<SRPWindows*> *pWindows) { if (pWindows) { if (pWindows->GetNumOfElements() == 1) { // if the list has only one item return it return pWindows->Get(0); } else { // clear the current topmost window SRPWindows *pTopMostWindow = nullptr; int nHigherIndex = -1; // get the iterator for the windows in the list Iterator<SRPWindows*> cIterator = pWindows->GetIterator(); // loop trough the windows while (cIterator.HasNext()) { SRPWindows *pSRPWindows = cIterator.Next(); if (pSRPWindows->GetSceneRenderPassIndex() > nHigherIndex) { // if the window is top most, keep it nHigherIndex = pSRPWindows->GetSceneRenderPassIndex(); pTopMostWindow = pSRPWindows; } } // return the top most window return pTopMostWindow; } } else { // return nothing return nullptr; } }
/** * @brief * Returns a list of all visible scene node instances intersecting with the given scene node, recursive part */ void SRPVolume::GetIntersectingInstancesOfRec(const SQCull &cCullQuery, SceneNode &cSceneNode, const Class &cClass, Array<const VisNode*> &lstIntersecting) const { // Get visibility container const VisContainer &cVisContainer = cCullQuery.GetVisContainer(); // Search through all visible scene nodes of this scene container Iterator<VisNode*> cIterator = cVisContainer.GetVisNodes().GetIterator(); while (cIterator.HasNext()) { // Get visibility node and scene node const VisNode *pVisNode = cIterator.Next(); SceneNode *pSceneNode = pVisNode->GetSceneNode(); if (pSceneNode) { // Is this scene node a portal? if (pVisNode->IsPortal()) { // Get the target cell visibility container const VisContainer *pVisCell = static_cast<const VisPortal*>(pVisNode)->GetTargetVisContainer(); if (pVisCell && pVisCell->GetCullQuery()) { // Search within the target cell GetIntersectingInstancesOfRec(*pVisCell->GetCullQuery(), cSceneNode, cClass, lstIntersecting); } // Is this scene node a container? We do not need to check for cells because we will // NEVER receive cells from SQCull directly, they are ONLY visible through portals! (see above) } else if (pVisNode->IsContainer()) { // Search within this container without special processing if (static_cast<const VisContainer*>(pVisNode)->GetCullQuery()) GetIntersectingInstancesOfRec(*static_cast<const VisContainer*>(pVisNode)->GetCullQuery(), cSceneNode, cClass, lstIntersecting); // This must just be a quite boring scene node :) } else { // Is this a directional light scene node? if (pSceneNode->IsInstanceOfByReference(cClass)) { // [TODO] Intersection test lstIntersecting.Add(pVisNode); } } } } }
BNetworkCookieJar& BNetworkCookieJar::operator=(const BNetworkCookieJar& other) { if (&other == this) return *this; for (Iterator it = GetIterator(); it.Next() != NULL;) delete it.Remove(); BArchivable::operator=(other); BFlattenable::operator=(other); fFlattened = other.fFlattened; delete fCookieHashMap; fCookieHashMap = new(std::nothrow) PrivateHashMap(); for (Iterator it = other.GetIterator(); it.HasNext();) { const BNetworkCookie* cookie = it.Next(); AddCookie(*cookie); // Pass by reference so the cookie is copied. } return *this; }
/** * @brief * Called when the scene node needs to be updated */ void PGLeaf::OnUpdate() { // If this scene node wasn't drawn at the last frame, we can skip some update stuff if ((GetFlags() & ForceUpdate) || m_bUpdate) { m_bUpdate = false; // If there are free particles, create new particles Particle *pParticle = AddParticle(); while (pParticle) { InitParticle(*pParticle); // Next particle, please pParticle = AddParticle(); } { // Update particles float fTimeDiff = Timing::GetInstance()->GetTimeDifference(); Iterator<Particle> cIterator = GetParticleIterator(); while (cIterator.HasNext()) { Particle &cParticle = cIterator.Next(); // Update forces // One: gravity cParticle.vVelocity[1] -= fTimeDiff*(cParticle.vPos[1]-FloorHeight)/5; // Two wind (dot wind vector normal) Vector3 vRot; EulerAngles::FromQuaternion(*cParticle.pRot, vRot.x, vRot.y, vRot.z); vRot.x *= static_cast<float>(Math::RadToDeg); vRot.y *= static_cast<float>(Math::RadToDeg); vRot.z *= static_cast<float>(Math::RadToDeg); cParticle.vVelocity += Wind.Get()*fTimeDiff*Math::Abs(vRot.DotProduct(Wind.Get())); // Four collision (just check whether leaf would end up on wrong side) if (cParticle.vPos.y + cParticle.vVelocity.y*fTimeDiff < FloorHeight) { // Random bouncy and some friction cParticle.vVelocity.y *= -1.0; cParticle.vVelocity.z *= Math::GetRandNegFloat(); cParticle.vVelocity.x *= Math::GetRandNegFloat(); cParticle.nCustom1 = ((static_cast<int>(Math::GetRandNegFloat()*255.0f*8.0f))<<8) | (cParticle.nCustom1&0xff); } // Five check whether particle has left area and can die... if it is outside, let it die float fDistx = GetTransform().GetPosition().x - cParticle.vPos.x; float fDisty = GetTransform().GetPosition().z - cParticle.vPos.z; float fDistToCenter = fDistx*fDistx + fDisty*fDisty; uint32 nStart = cParticle.nCustom1 & 0xff; if (nStart < 0xff) { // It is being spawned nStart += static_cast<uint32>(fTimeDiff*512.0f + 0.5f); if (nStart > 0xff) nStart = 0xff; // Clamp cParticle.nCustom1 = (cParticle.nCustom1&0xffffff00)|nStart; // Write to lower 8 bits } if (fDistToCenter > Radius*Radius) { // Start dying... set alpha according to how far it is away fDistToCenter = 255 - (Math::Sqrt(fDistToCenter) - Radius)*3.0f; cParticle.fSize = static_cast<float>(static_cast<int>(fDistToCenter*(cParticle.nCustom1 & 0xff))>>8)/255*cParticle.fCustom1; if (cParticle.fSize < 0.2f) InitParticle(cParticle); } else { cParticle.fSize = static_cast<float>(cParticle.nCustom1 &0xff)/255*cParticle.fCustom1; } // Update position cParticle.vPos += cParticle.vVelocity*fTimeDiff*cParticle.fSize/2; // Update spin Vector3 vAxis = cParticle.vVelocity; vAxis.SetLength(1); // Transform normal and distortion vAxis *= ((static_cast<float>(cParticle.nCustom1>>8))/255.0f)*fTimeDiff/10; Quaternion qRotInc; EulerAngles::ToQuaternion(static_cast<float>(vAxis.x*Math::DegToRad), static_cast<float>(vAxis.y*Math::DegToRad), static_cast<float>(vAxis.z*Math::DegToRad), qRotInc); *cParticle.pRot *= qRotInc; Vector3 d = cParticle.vDistortion; d.SetLength(cParticle.fSize); cParticle.vDistortion = (*cParticle.pRot)*d; // Update color EulerAngles::FromQuaternion(*cParticle.pRot, vRot.x, vRot.y, vRot.z); vRot.x *= static_cast<float>(Math::RadToDeg); vRot.y *= static_cast<float>(Math::RadToDeg); vRot.z *= static_cast<float>(Math::RadToDeg); vAxis = vRot.Normalize(); fDistx = vAxis.x+vAxis.y*2+vAxis.z*3; if (fDistx > 1.0f) fDistx = 1.0f; if (fDistx < 0.5f) fDistx = 0.5f; cParticle.vColor[0] = cParticle.vFixPos.x*fDistx; cParticle.vColor[1] = cParticle.vFixPos.y*fDistx; cParticle.vColor[2] = cParticle.vFixPos.z*fDistx; }
void Gui::KeyboardHandler() { /*i am not yet satisfied with this method*/ if (m_pFocusedWindow) { if (m_pFocusedWindow->GetData()->bKeyboardEnabled) { if (m_pTextButtonHandler->GetNumOfElements() > 0) { Iterator<sButton*> cIterator = m_pTextButtonHandler->GetIterator(); while (cIterator.HasNext()) { sButton *psButton = cIterator.Next(); if (psButton->bValid) { if (m_nTextKeyHitCount == 0) { //m_pFocusedWindow->GetAwesomiumWindow()->textEvent(psButton->sKey.GetUnicode(), psButton->sKey.GetLength()); m_nLastTextKeySendTime = Timing::GetInstance()->GetPastTime(); m_nTextKeyHitCount++; } else { if (m_nTextKeyHitCount == 1) { if ((Timing::GetInstance()->GetPastTime() - m_nLastTextKeySendTime) > 400) { //m_pFocusedWindow->GetAwesomiumWindow()->textEvent(psButton->sKey.GetUnicode(), psButton->sKey.GetLength()); m_nLastTextKeySendTime = Timing::GetInstance()->GetPastTime(); m_nTextKeyHitCount++; } } else { if ((Timing::GetInstance()->GetPastTime() - m_nLastTextKeySendTime) > 50) { //m_pFocusedWindow->GetAwesomiumWindow()->textEvent(psButton->sKey.GetUnicode(), psButton->sKey.GetLength()); m_nLastTextKeySendTime = Timing::GetInstance()->GetPastTime(); m_nTextKeyHitCount++; } } } } } } if (m_pKeyButtonHandler->GetNumOfElements() > 0) { Iterator<sButton*> cIterator = m_pKeyButtonHandler->GetIterator(); while (cIterator.HasNext()) { sButton *psButton = cIterator.Next(); if (psButton->bValid) { if (m_nKeyHitCount == 0) { //m_pFocusedWindow->GetAwesomiumWindow()->keyEvent(true, 0, psButton->nKey, 0); m_nLastKeySendTime = Timing::GetInstance()->GetPastTime(); m_nKeyHitCount++; } else { if (m_nKeyHitCount == 1) { if ((Timing::GetInstance()->GetPastTime() - m_nLastKeySendTime) > 400) { //m_pFocusedWindow->GetAwesomiumWindow()->keyEvent(true, 0, psButton->nKey, 0); m_nLastKeySendTime = Timing::GetInstance()->GetPastTime(); m_nKeyHitCount++; } } else { if ((Timing::GetInstance()->GetPastTime() - m_nLastKeySendTime) > 50) { //m_pFocusedWindow->GetAwesomiumWindow()->keyEvent(true, 0, psButton->nKey, 0); m_nLastKeySendTime = Timing::GetInstance()->GetPastTime(); m_nKeyHitCount++; } } } } } } } } }
//[-------------------------------------------------------] //[ Public virtual PLCompositing::SNMPostProcess functions ] //[-------------------------------------------------------] void SNMPostProcessBloomToneMap::SetParameters() { // Call base implementation SNMPostProcess::SetParameters(); { // Strength // Update scale down parameters Parameter *pParameter = GetParameter("ScaleX", 0); if (pParameter) pParameter->SetValue1f(1.0f/Strength.Get().x); pParameter = GetParameter("ScaleY", 0); if (pParameter) pParameter->SetValue1f(1.0f/Strength.Get().y); // Update scale up parameters pParameter = GetParameter("ScaleX", 3); if (pParameter) pParameter->SetValue1f(Strength.Get().x); pParameter = GetParameter("ScaleY", 3); if (pParameter) pParameter->SetValue1f(Strength.Get().y); } { // BloomScale Array<Parameter*> lstParameters; if (GetParameters("BloomScale", lstParameters)) { Iterator<Parameter*> cIterator = lstParameters.GetIterator(); while (cIterator.HasNext()) cIterator.Next()->SetValue1f(BloomScale.Get()); } } { // ExposureLevel Array<Parameter*> lstParameters; if (GetParameters("ExposureLevel", lstParameters)) { Iterator<Parameter*> cIterator = lstParameters.GetIterator(); while (cIterator.HasNext()) cIterator.Next()->SetValue1f(ExposureLevel.Get()); } } { // GammaLevel Array<Parameter*> lstParameters; if (GetParameters("GammaLevel", lstParameters)) { Iterator<Parameter*> cIterator = lstParameters.GetIterator(); while (cIterator.HasNext()) cIterator.Next()->SetValue1f(GammaLevel.Get()); } } { // DeFogLevel Array<Parameter*> lstParameters; if (GetParameters("DeFogLevel", lstParameters)) { Iterator<Parameter*> cIterator = lstParameters.GetIterator(); while (cIterator.HasNext()) cIterator.Next()->SetValue1f(DeFogLevel.Get()); } } { // FogColor Array<Parameter*> lstParameters; if (GetParameters("FogColor", lstParameters)) { Iterator<Parameter*> cIterator = lstParameters.GetIterator(); while (cIterator.HasNext()) cIterator.Next()->SetValue3fv(FogColor.Get()); } } }