void windy::content::composition::remove(std::shared_ptr<class instance> instance) {
for (auto child : instance->children()) {
auto groupable = std::dynamic_pointer_cast<class groupable>(child);
for (auto item_pair : this->_maps) {
if (item_pair.second->uuid() == groupable->asset_uuid()) {
item_pair.second->remove_instance(groupable);
}
}
}
}
void UDPAssetProvider::SendPendingRequests(boost::shared_ptr<ProtocolUtilities::ProtocolModuleInterface> net)
{
AssetRequestVector::iterator i = pending_requests_.begin();
while(i != pending_requests_.end())
{
RexUUID asset_uuid(i->asset_id_);
if (i->asset_type_ == RexAT_Texture)
RequestTexture(net, asset_uuid, i->tags_);
else
RequestOtherAsset(net, asset_uuid, i->asset_type_, i->tags_);
i = pending_requests_.erase(i);
}
}
void UDPAssetProvider::HandleTextureTimeouts(boost::shared_ptr<ProtocolUtilities::ProtocolModuleInterface> net, f64 frametime)
{
UDPAssetTransferMap::iterator i = texture_transfers_.begin();
std::vector<RexUUID> erase_tex;
while(i != texture_transfers_.end())
{
UDPAssetTransfer& transfer = i->second;
if (!transfer.Ready())
{
transfer.AddTime(frametime);
if (transfer.GetTime() > asset_timeout_)
{
RexUUID asset_uuid(transfer.GetAssetId());
AssetModule::LogInfo("Texture transfer " + transfer.GetAssetId() + " timed out.");
// Send cancel message
const ProtocolUtilities::ClientParameters& client = net->GetClientParameters();
ProtocolUtilities::NetOutMessage *m = net->StartMessageBuilding(RexNetMsgRequestImage);
assert(m);
m->AddUUID(client.agentID);
m->AddUUID(client.sessionID);
m->SetVariableBlockCount(1);
m->AddUUID(asset_uuid); // Image UUID
m->AddS8(-1); // Discard level, -1 = cancel
m->AddF32(0.0); // Download priority, 0 = cancel
m->AddU32(0); // Starting packet
m->AddU8(RexIT_Normal); // Image type
m->MarkReliable();
net->FinishMessageBuilding(m);
// Send transfer canceled event
SendAssetCanceled(transfer);
erase_tex.push_back(i->first);
}
}
++i;
}
for(int j = 0; j < erase_tex.size(); ++j)
texture_transfers_.erase(erase_tex[j]);
}
UDPAssetTransfer* UDPAssetProvider::GetTransfer(const std::string& asset_id)
{
RexUUID asset_uuid(asset_id);
UDPAssetTransferMap::iterator i = texture_transfers_.find(asset_uuid);
if (i != texture_transfers_.end())
return &i->second;
UDPAssetTransferMap::iterator j = asset_transfers_.begin();
while (j != asset_transfers_.end())
{
if (j->second.GetAssetId() == asset_id)
return &j->second;
++j;
}
return 0;
}
void windy::app::on_assets_delete_pressed(nana::menu::item_proxy& ip) {
if (this->_instance_creator->items().size() > 0) {
switch (this->_instance_creator->category()) {
case layer::kind::graphicable: {
// references from graphicables and nuke
{
for (auto item : this->_instance_creator->items()) {
for (auto instance : item->instances()) {
this->_environment->project()->remove(instance);
}
auto sprite =
std::dynamic_pointer_cast<content::sprite>(item);
this->_environment->project()->remove_sprite(sprite);
}
}
}
break;
case layer::kind::groupable: {
for (auto item : this->_instance_creator->items()) {
// references from compositions and nuke if single-animation remains
{
auto compositions =
this->_environment->project()->assets()->collection()->
get(layer::kind::compositable);
std::vector <std::shared_ptr<content::composition> >
compositions_nuked;
for (auto composition_item : compositions) {
auto composition =
std::dynamic_pointer_cast<content::composition>
(composition_item);
auto& instances = composition->instances();
for (auto instance : instances) {
auto compositable =
std::dynamic_pointer_cast
<content::compositable>(instance);
std::vector<std::shared_ptr<content::groupable> >
groupables_nuked;
for (auto child : compositable->children()) {
auto groupable =
std::dynamic_pointer_cast
<content::groupable>(child);
if (groupable->asset_uuid() == item->uuid()) {
groupables_nuked.push_back(groupable);
this->_environment->project()->assets()->
collection()->remove(groupable);
}
}
for (auto nuked : groupables_nuked) {
auto& children = compositable->children();
auto it = std::find(children.begin(),
children.end(),
nuked);
children.erase(it);
}
}
composition->unmap(item);
if (composition->maps().empty()) {
compositions_nuked.push_back(composition);
}
}
for (auto composition : compositions_nuked) {
for (auto instance : composition->instances()) {
this->_environment->project()->remove(instance);
}
this->_environment->project()->remove_composition(composition);
}
}
// nuke timeline triggers
{
for (auto instance : item->instances()) {
auto groupable =
std::dynamic_pointer_cast<content::groupable> (instance);
for (auto trigger : groupable->triggers()) {
this->_environment->timeline()->remove_trigger(trigger);
}
}
}
// references from groupables and nuke
{
auto instances = item->instances(); // copy by reference to store the instances
for (auto instance : instances) {
this->_environment->project()->remove(instance);
}
auto group = std::dynamic_pointer_cast<content::group>(item);
this->_environment->project()->remove_group(group);
}
}
}
break;
case layer::kind::compositable: {
// references from compositables and nuke
{
for (auto item : this->_instance_creator->items()) {
for (auto instance : item->instances()) {
this->_environment->project()->remove(instance);
}
auto composition =
std::dynamic_pointer_cast<content::composition>(item);
this->_environment->project()->remove_composition(composition);
}
}
}
break;
}
// refresh
{
this->_environment->project()->assets()->refresh();
// this->_selection_targets.clear();
this->_environment->edition()->refresh(this->_environment->project()->game()->container());
this->_environment->properties()->clear();
this->_environment->trigger_recalculation();
}
} else {
nana::msgbox error(this->handle(),
L"Error");
error << L"Please select one or more assets first.";
error.show();
}
}
