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