void RotateTo::HandleSetClientModelNode(StringHash eventType, VariantMap& eventData) { Node* clientNode = (Node*)(eventData[SetClientModelNode::P_NODE].GetPtr()); if (clientNode == node_) { modelNode_ = (Node*)(eventData[SetClientModelNode::P_MODELNODE].GetPtr()); } UnsubscribeFromEvent(E_SETCLIENTMODELNODE); }
void StaticModel::SetModel(Model* model) { if (model == model_) return; // If script erroneously calls StaticModel::SetModel on an AnimatedModel, warn and redirect if (GetType() == AnimatedModel::GetTypeStatic()) { ATOMIC_LOGWARNING("StaticModel::SetModel() called on AnimatedModel. Redirecting to AnimatedModel::SetModel()"); AnimatedModel* animatedModel = static_cast<AnimatedModel*>(this); animatedModel->SetModel(model); return; } // Unsubscribe from the reload event of previous model (if any), then subscribe to the new if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); model_ = model; if (model) { SubscribeToEvent(model, E_RELOADFINISHED, ATOMIC_HANDLER(StaticModel, HandleModelReloadFinished)); // Copy the subgeometry & LOD level structure SetNumGeometries(model->GetNumGeometries()); const Vector<Vector<SharedPtr<Geometry> > >& geometries = model->GetGeometries(); const PODVector<Vector3>& geometryCenters = model->GetGeometryCenters(); const Matrix3x4* worldTransform = node_ ? &node_->GetWorldTransform() : (const Matrix3x4*)0; for (unsigned i = 0; i < geometries.Size(); ++i) { batches_[i].worldTransform_ = worldTransform; geometries_[i] = geometries[i]; geometryData_[i].center_ = geometryCenters[i]; // ATOMIC BEGIN geometryData_[i].enabled_ = true; geometryData_[i].batchGeometry_ = 0; // ATOMIC END } SetBoundingBox(model->GetBoundingBox()); ResetLodLevels(); } else { SetNumGeometries(0); SetBoundingBox(BoundingBox()); } MarkNetworkUpdate(); }
void TopDownCamera::HandleSetClientModelNode(StringHash eventType, VariantMap& eventData) { Node* clientNode = (Node*)(eventData[SetClientModelNode::P_NODE].GetPtr()); if (clientNode == node_) { modelNode_ = (Node*)(eventData[SetClientModelNode::P_MODELNODE].GetPtr()); beeBox_ = modelNode_->GetComponent<AnimatedModel>()->GetWorldBoundingBox(); UnsubscribeFromEvent(E_SETCLIENTMODELNODE); } }
void CubemapGenerator::EndRender() { UnsubscribeFromEvent(E_BEGINFRAME); UnsubscribeFromEvent(E_ENDFRAME); SaveCubemapXML(); cameraNode_->Remove(); cameraNode_ = 0; camera_ = 0; viewport_ = 0; renderSurface_ = 0; // release renderImage_ after renderSurface_, as it doesn't hold a ref renderImage_ = 0; updateCycle_ = 0; GetScene()->SendEvent(E_CUBEMAPRENDEREND); }
bool TextureCube::SetSize(int size, unsigned format, TextureUsage usage) { if (size <= 0) { LOGERROR("Zero or negative cube texture size"); return false; } if (usage == TEXTURE_DEPTHSTENCIL) { LOGERROR("Depth-stencil usage not supported for cube maps"); return false; } // Delete the old rendersurfaces if any for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i) { renderSurfaces_[i].Reset(); faceMemoryUse_[i] = 0; } pool_ = D3DPOOL_MANAGED; usage_ = 0; if (usage == TEXTURE_RENDERTARGET) { for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i) renderSurfaces_[i] = new RenderSurface(this); usage_ |= D3DUSAGE_RENDERTARGET; pool_ = D3DPOOL_DEFAULT; // Nearest filtering and mipmaps disabled by default filterMode_ = FILTER_NEAREST; requestedLevels_ = 1; } else if (usage == TEXTURE_DYNAMIC) { usage_ |= D3DUSAGE_DYNAMIC; pool_ = D3DPOOL_DEFAULT; } if (usage == TEXTURE_RENDERTARGET) SubscribeToEvent(E_RENDERSURFACEUPDATE, HANDLER(TextureCube, HandleRenderSurfaceUpdate)); else UnsubscribeFromEvent(E_RENDERSURFACEUPDATE); width_ = size; height_ = size; format_ = format; return Create(); }
void Silence::HandleSetConnection(StringHash eventType, VariantMap& eventData) { Node* clientNode = (Node*)(eventData[SetConnection::P_NODE].GetPtr()); if (main_->GetSceneNode(clientNode) == node_) { conn_ = (Connection*)(eventData[SetConnection::P_CONNECTION].GetPtr()); UnsubscribeFromEvent(E_SETCONNECTION); SubscribeToEvent(E_LCMSG, HANDLER(Silence, HandleLCMSG)); SubscribeToEvent(E_GETLC, HANDLER(Silence, HandleGetLc)); } }
void TopDownCamera::HandleSetCamera(StringHash eventType, VariantMap& eventData) { Node* clientNode = (Node*)(eventData[SetClientCamera::P_NODE].GetPtr()); if (clientNode == node_) { cameraNode_ = (Node*)(eventData[SetClientCamera::P_CAMERANODE].GetPtr()); camOrigin_ = cameraNode_->GetPosition(); UnsubscribeFromEvent(E_SETCLIENTCAMERA); } }
bool Texture2D::SetSize(int width, int height, unsigned format, TextureUsage usage, int multiSample, bool autoResolve) { if (width <= 0 || height <= 0) { URHO3D_LOGERROR("Zero or negative texture dimensions"); return false; } multiSample = Clamp(multiSample, 1, 16); if (multiSample == 1) autoResolve = false; else if (multiSample > 1 && usage < TEXTURE_RENDERTARGET) { URHO3D_LOGERROR("Multisampling is only supported for rendertarget or depth-stencil textures"); return false; } // Disable mipmaps if multisample & custom resolve if (multiSample > 1 && autoResolve == false) requestedLevels_ = 1; // Delete the old rendersurface if any renderSurface_.Reset(); usage_ = usage; if (usage >= TEXTURE_RENDERTARGET) { renderSurface_ = new RenderSurface(this); // Clamp mode addressing by default and nearest filtering addressModes_[COORD_U] = ADDRESS_CLAMP; addressModes_[COORD_V] = ADDRESS_CLAMP; filterMode_ = FILTER_NEAREST; } if (usage == TEXTURE_RENDERTARGET) SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(Texture2D, HandleRenderSurfaceUpdate)); else UnsubscribeFromEvent(E_RENDERSURFACEUPDATE); width_ = width; height_ = height; format_ = format; depth_ = 1; multiSample_ = multiSample; autoResolve_ = autoResolve; return Create(); }
void Silence::HandleSetClientID(StringHash eventType, VariantMap& eventData) { Node* clientNode = (Node*)(eventData[SetClientID::P_NODE].GetPtr()); if (main_->GetSceneNode(clientNode) == node_) { clientID_ = eventData[SetClientID::P_CLIENTID].GetInt(); UnsubscribeFromEvent(E_SETCLIENTID); VariantMap vm; vm[GetConnection::P_NODE] = main_->GetRootNode(node_); SendEvent(E_GETCONNECTION, vm); } }
bool TextureCube::SetSize(int size, unsigned format, TextureUsage usage) { if (size <= 0) { LOGERROR("Zero or negative cube texture size"); return false; } if (usage == TEXTURE_DEPTHSTENCIL) { LOGERROR("Depth-stencil usage not supported for cube maps"); return false; } // Delete the old rendersurfaces if any for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i) { renderSurfaces_[i].Reset(); faceMemoryUse_[i] = 0; } usage_ = usage; if (usage == TEXTURE_RENDERTARGET) { for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i) { renderSurfaces_[i] = new RenderSurface(this); renderSurfaces_[i]->SetTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i); } // Clamp mode addressing by default, nearest filtering, and mipmaps disabled addressMode_[COORD_U] = ADDRESS_CLAMP; addressMode_[COORD_V] = ADDRESS_CLAMP; addressMode_[COORD_W] = ADDRESS_CLAMP; filterMode_ = FILTER_NEAREST; requestedLevels_ = 1; } if (usage == TEXTURE_RENDERTARGET) SubscribeToEvent(E_RENDERSURFACEUPDATE, HANDLER(TextureCube, HandleRenderSurfaceUpdate)); else UnsubscribeFromEvent(E_RENDERSURFACEUPDATE); width_ = size; height_ = size; format_ = format; return Create(); }
void CollisionShape::SetStaticPlane(const Vector3& position, const Quaternion& rotation) { if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); shapeType_ = SHAPE_STATICPLANE; position_ = position; rotation_ = rotation; model_.Reset(); customGeometryID_ = 0; UpdateShape(); NotifyRigidBody(); MarkNetworkUpdate(); }
void CollisionShape::SetCone(float diameter, float height, const Vector3& position, const Quaternion& rotation) { if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); shapeType_ = SHAPE_CONE; size_ = Vector3(diameter, height, diameter); position_ = position; rotation_ = rotation; model_.Reset(); customGeometryID_ = 0; UpdateShape(); NotifyRigidBody(); MarkNetworkUpdate(); }
void CollisionShape::SetModel(Model* model) { if (model != model_) { if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); model_ = model; if (shapeType_ >= SHAPE_TRIANGLEMESH) { UpdateShape(); NotifyRigidBody(); } MarkNetworkUpdate(); } }
bool Texture2D::SetSize(int width, int height, unsigned format, TextureUsage usage) { if (width <= 0 || height <= 0) { URHO3D_LOGERROR("Zero or negative texture dimensions"); return false; } // Delete the old rendersurface if any renderSurface_.Reset(); pool_ = D3DPOOL_MANAGED; usage_ = 0; if (usage == TEXTURE_RENDERTARGET || usage == TEXTURE_DEPTHSTENCIL) { renderSurface_ = new RenderSurface(this); if (usage == TEXTURE_RENDERTARGET) usage_ |= D3DUSAGE_RENDERTARGET; else usage_ |= D3DUSAGE_DEPTHSTENCIL; pool_ = D3DPOOL_DEFAULT; // Clamp mode addressing by default, nearest filtering, and mipmaps disabled addressMode_[COORD_U] = ADDRESS_CLAMP; addressMode_[COORD_V] = ADDRESS_CLAMP; filterMode_ = FILTER_NEAREST; requestedLevels_ = 1; } else if (usage == TEXTURE_DYNAMIC) { usage_ |= D3DUSAGE_DYNAMIC; pool_ = D3DPOOL_DEFAULT; } if (usage == TEXTURE_RENDERTARGET) SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(Texture2D, HandleRenderSurfaceUpdate)); else UnsubscribeFromEvent(E_RENDERSURFACEUPDATE); width_ = width; height_ = height; format_ = format; return Create(); }
void CollisionShape::SetTerrain() { Terrain* terrain = GetComponent<Terrain>(); if (!terrain) { LOGERROR("No terrain component, can not set terrain shape"); return; } if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); shapeType_ = SHAPE_TERRAIN; UpdateShape(); NotifyRigidBody(); MarkNetworkUpdate(); }
void StaticModel::SetModel(Model* model) { if (model == model_) return; if (!node_) { URHO3D_LOGERROR("Can not set model while model component is not attached to a scene node"); return; } // Unsubscribe from the reload event of previous model (if any), then subscribe to the new if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); model_ = model; if (model) { SubscribeToEvent(model, E_RELOADFINISHED, URHO3D_HANDLER(StaticModel, HandleModelReloadFinished)); // Copy the subgeometry & LOD level structure SetNumGeometries(model->GetNumGeometries()); const ea::vector<ea::vector<ea::shared_ptr<Geometry> > >& geometries = model->GetGeometries(); const ea::vector<Vector3>& geometryCenters = model->GetGeometryCenters(); const Matrix3x4* worldTransform = node_ ? &node_->GetWorldTransform() : nullptr; for (unsigned i = 0; i < geometries.size(); ++i) { batches_[i].worldTransform_ = worldTransform; geometries_[i] = geometries[i]; geometryData_[i].center_ = geometryCenters[i]; } SetBoundingBox(model->GetBoundingBox()); ResetLodLevels(); } else { SetNumGeometries(0); SetBoundingBox(BoundingBox()); } MarkNetworkUpdate(); }
void Text::SetAutoLocalizable(bool enable) { if (enable != autoLocalizable_) { autoLocalizable_ = enable; if (enable) { stringId_ = text_; auto* l10n = GetSubsystem<Localization>(); text_ = l10n->Get(stringId_); SubscribeToEvent(E_CHANGELANGUAGE, URHO3D_HANDLER(Text, HandleChangeLanguage)); } else { text_ = stringId_; stringId_ = ""; UnsubscribeFromEvent(E_CHANGELANGUAGE); } DecodeToUnicode(); ValidateSelection(); UpdateText(); } }
void CollisionShape::SetConvexHull(Model* model, unsigned lodLevel, const Vector3& scale, const Vector3& position, const Quaternion& rotation) { if (!model) { LOGERROR("Null model, can not set convex hull"); return; } if (model_) UnsubscribeFromEvent(model_, E_RELOADFINISHED); shapeType_ = SHAPE_CONVEXHULL; model_ = model; lodLevel_ = lodLevel; size_ = scale; position_ = position; rotation_ = rotation; customGeometryID_ = 0; UpdateShape(); NotifyRigidBody(); MarkNetworkUpdate(); }
void TopDownCamera::HandleMechanicRequest(StringHash eventType, VariantMap& eventData) { String mechanicID = eventData[MechanicRequest::P_MECHANICID].GetString(); if (mechanicID == "CameraToggle") { if (!isEnabled_) { isEnabled_ = true; camOrigin_ = modelNode_->GetPosition(); camOrigin_.y_ += beeBox_.Size().y_ * distance_; cameraNode_->SetWorldPosition(camOrigin_); cameraNode_->SetRotation(Quaternion(90.0f, 0.0f, 0.0f)); SubscribeToEvent(E_POSTUPDATE, HANDLER(TopDownCamera, HandlePostUpdate)); } else { isEnabled_ = false; UnsubscribeFromEvent(E_POSTUPDATE); } } }
bool Texture3D::SetSize(int width, int height, int depth, unsigned format, TextureUsage usage) { // Delete the old rendersurface if any renderSurface_.Reset(); pool_ = D3DPOOL_MANAGED; usage_ = 0; if (usage == TEXTURE_RENDERTARGET) { renderSurface_ = new RenderSurface(this); usage_ |= D3DUSAGE_RENDERTARGET; pool_ = D3DPOOL_DEFAULT; // Clamp mode addressing by default, nearest filtering, and mipmaps disabled addressMode_[COORD_U] = ADDRESS_CLAMP; addressMode_[COORD_V] = ADDRESS_CLAMP; filterMode_ = FILTER_NEAREST; requestedLevels_ = 1; } else if (usage == TEXTURE_DYNAMIC) { usage_ |= D3DUSAGE_DYNAMIC; pool_ = D3DPOOL_DEFAULT; } if (usage == TEXTURE_RENDERTARGET) SubscribeToEvent(E_RENDERSURFACEUPDATE, HANDLER(Texture3D, HandleRenderSurfaceUpdate)); else UnsubscribeFromEvent(E_RENDERSURFACEUPDATE); width_ = width; height_ = height; depth_ = depth; format_ = format; return Create(); }
void ResourceCache::SetAutoReloadResources(bool enable) { if (enable != autoReloadResources_) { if (enable) { for (unsigned i = 0; i < resourceDirs_.Size(); ++i) { SharedPtr<FileWatcher> watcher(new FileWatcher(context_)); watcher->StartWatching(resourceDirs_[i], true); fileWatchers_.Push(watcher); } SubscribeToEvent(E_BEGINFRAME, HANDLER(ResourceCache, HandleBeginFrame)); } else { UnsubscribeFromEvent(E_BEGINFRAME); fileWatchers_.Clear(); } autoReloadResources_ = enable; } }
void Explosion::Disable() { UnsubscribeFromEvent(E_POSTUPDATE); Effect::Disable(); }
/// Called when the component is detached from a scene node, usually on destruction. Note that you will no longer have access to the node and scene at that point. void PlayerInterface::Stop() { // Unsubscribe from events UnsubscribeFromEvent(Urho3D::E_POSTRENDERUPDATE); }
void Silence::HandleSetIsServer(StringHash eventType, VariantMap& eventData) { isServer_ = eventData[SetIsServer::P_ISSERVER].GetBool(); UnsubscribeFromEvent(E_SETISSERVER); }