bool EffectManager::DoEffect(const PluginID & ID,
wxWindow *parent,
double projectRate,
TrackList *list,
TrackFactory *factory,
SelectedRegion *selectedRegion,
bool shouldPrompt /* = true */)
{
this->SetSkipStateFlag(false);
Effect *effect = GetEffect(ID);
if (!effect)
{
return false;
}
#if defined(EXPERIMENTAL_EFFECTS_RACK)
if (effect->SupportsRealtime())
{
GetRack()->Add(effect);
}
#endif
bool res = effect->DoEffect(parent,
projectRate,
list,
factory,
selectedRegion,
shouldPrompt);
return res;
}
static int get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
// Correct width/height if necessary
if ( *width == 0 || *height == 0 )
{
*width = profile->width;
*height = profile->height;
}
int iwidth = *width;
int iheight = *height;
double factor = mlt_properties_get_double( filter_properties, "factor" );
factor = factor > 0 ? factor : 1.0;
int owidth = *width * factor;
int oheight = *height * factor;
// If meta.media.width/height exist, we want that as minimum information
if ( mlt_properties_get_int( properties, "meta.media.width" ) )
{
iwidth = mlt_properties_get_int( properties, "meta.media.width" );
iheight = mlt_properties_get_int( properties, "meta.media.height" );
}
mlt_properties_set_int( properties, "rescale_width", *width );
mlt_properties_set_int( properties, "rescale_height", *height );
// Deinterlace if height is changing to prevent fields mixing on interpolation
if ( iheight != oheight )
mlt_properties_set_int( properties, "consumer_deinterlace", 1 );
GlslManager::get_instance()->lock_service( frame );
mlt_properties_set_int( filter_properties, "movit.parms.int.width", owidth );
mlt_properties_set_int( filter_properties, "movit.parms.int.height", oheight );
bool disable = ( iwidth == owidth && iheight == oheight );
mlt_properties_set_int( filter_properties, "movit.parms.int.disable", disable );
*width = owidth;
*height = oheight;
GlslManager::get_instance()->unlock_service( frame );
// Get the image as requested
if ( *format != mlt_image_none )
*format = mlt_image_glsl;
int error = mlt_frame_get_image( frame, image, format, &iwidth, &iheight, writable );
GlslManager::set_effect_input( MLT_FILTER_SERVICE( filter ), frame, (mlt_service) *image );
Effect *effect = GlslManager::set_effect( MLT_FILTER_SERVICE( filter ), frame, new OptionalEffect<ResampleEffect> );
// This needs to be something else than 0x0 at chain finalization time.
bool ok = effect->set_int("width", owidth);
ok |= effect->set_int("height", oheight);
assert( ok );
*image = (uint8_t *) MLT_FILTER_SERVICE( filter );
return error;
}
wxString EffectManager::GetDefaultPreset(const PluginID & ID)
{
Effect *effect = GetEffect(ID);
if (!effect)
{
return wxEmptyString;
}
wxString preset;
if (effect->HasCurrentSettings())
{
preset = Effect::kCurrentSettingsIdent;
}
else if (effect->HasFactoryDefaults())
{
preset = Effect::kFactoryDefaultsIdent;
}
if (!preset.IsEmpty())
{
EffectAutomationParameters eap;
eap.Write(wxT("Use Preset"), preset);
eap.GetParameters(preset);
}
return preset;
}
void Bloom::Render(const ITexture* input, RenderTarget* output) const {
RenderTarget* downsampled_rt = Assets<RenderTarget>::Get(s_RTName);
RenderTarget* downsampled_rt_blur_x = Assets<RenderTarget>::Get(s_RTNameBlurX);
RenderTarget* downsampled_rt_blur_y = Assets<RenderTarget>::Get(s_RTNameBlurY);
const Model* model = m_Object->GetModel();
const Mesh& mesh = *model->GetMesh();
Effect* effect = model->GetEffect();
effect->SetTexture(input, TextureIndex::Texture0);
m_Object->PopulateObjectBuffer();
// The bloom effect needs a downsampled texture, so we first render into that.
downsampled_rt->Set();
effect->RenderPass(bloom_downsample_pass, mesh);
// Render from downsampled to x-blurred
downsampled_rt_blur_x->Set();
effect->SetTexture(downsampled_rt, TextureIndex::Texture0);
effect->RenderPass(bloom_blur_pass_1, mesh);
// Render from x-blurred to xy-blurred
downsampled_rt_blur_y->Set();
effect->SetTexture(downsampled_rt_blur_x, TextureIndex::Texture0);
effect->RenderPass(bloom_blur_pass_2, mesh);
// Then combine the original and the downsampled copy.
output->Set();
effect->SetTexture(input, TextureIndex::Texture0);
effect->SetTexture(downsampled_rt_blur_y, TextureIndex::Texture1);
effect->RenderPass(bloom_postprocess_pass, mesh);
}
void
Participant::restoreEffect(const QVariant &state)
{
Effect *effect = addEffect();
const QVariantMap map = state.toMap();
effect->setName(map.value("name", tr("Reverser")).toString());
}
//Apply an effect to the audio input
//Because apply also sets some internal values
//it has to be called for every effect all the time
//The difference is just which value gets returned
float EffectProcessor::applyEffects(float input){
Effect* effect = chooseEffect();
float strength = calculateEffectStrength(effect->getPosition());
if(effect == e1){
e2->apply(input, 0);
e3->apply(input, 0);
e4->apply(input, 0);
return e1->apply(input, strength);
} else if (effect == e2){
e1->apply(input, 0);
e3->apply(input, 0);
e4->apply(input, 0);
return e2->apply(input, strength);
} else if (effect == e3){
e1->apply(input, 0);
e2->apply(input, 0);
e4->apply(input, 0);
return e3->apply(input, strength);
} else if (effect == e4){
e1->apply(input, 0);
e2->apply(input, 0);
e3->apply(input, 0);
return e4->apply(input, strength);
} else {
return input;
}
}
QVariant data (const QModelIndex &index, int role = Qt::DisplayRole) const
{
if (role != Qt::DisplayRole || !index.isValid () || !_effect || index.column () >= 2)
{
return QVariant ();
}
unsigned num = _effect->GetNumberOfPrograms (_stage);
if (index.row () >= num)
{
return QVariant ();
}
if (index.column () == 0)
{
return QVariant (_effect->GetProgramName (_stage, index.row ()));
}
else if (index.column () == 1)
{
Program* prog = _effect->GetProgram (_stage, _effect->GetProgramName (_stage, index.row ()));
if (prog)
{
return QVariant (prog->GetCategory().GetFullName()+"."+prog->GetFullname());
}
return QVariant ("<undefined>");
}
return QVariant ();
}
TEST(PaddingEffectTest, Crop) {
float data[2 * 2] = {
1.0f, 0.5f,
0.8f, 0.3f,
};
float expected_data[1 * 1] = {
0.3f,
};
float out_data[1 * 1];
EffectChainTester tester(NULL, 1, 1);
ImageFormat format;
format.color_space = COLORSPACE_sRGB;
format.gamma_curve = GAMMA_LINEAR;
FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 2, 2);
input->set_pixel_data(data);
tester.get_chain()->add_input(input);
Effect *effect = tester.get_chain()->add_effect(new PaddingEffect());
CHECK(effect->set_int("width", 1));
CHECK(effect->set_int("height", 1));
CHECK(effect->set_float("left", -1.0f));
CHECK(effect->set_float("top", -1.0f));
tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_PREMULTIPLIED);
expect_equal(expected_data, out_data, 1, 1);
}
wxString EffectManager::GetPreset(const PluginID & ID, const wxString & params, wxWindow * parent)
{
Effect *effect = GetEffect(ID);
if (!effect)
{
return wxEmptyString;
}
EffectAutomationParameters eap(params);
wxString preset;
if (eap.HasEntry(wxT("Use Preset")))
{
preset = eap.Read(wxT("Use Preset"));
}
preset = effect->GetPreset(parent, preset);
if (preset.IsEmpty())
{
return preset;
}
eap.DeleteAll();
eap.Write(wxT("Use Preset"), preset);
eap.GetParameters(preset);
return preset;
}
bool AudioView::ProcessEvent(wxEvent& event)
{
if (event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED &&
event.GetId() >= FirstEffectID &&
event.GetId() < FirstEffectID + numEffects) {
Effect *f = Effect::GetEffect(event.GetId() - FirstEffectID);
TrackList *tracks = GetTracks();
VTrack *t = tracks->First();
while(t) {
if (t->selected && t->GetKind() == (VTrack::Wave)) {
f->DoInPlaceEffect((WaveTrack *)t, sel0, sel1);
}
t = tracks->Next();
}
PushState();
FixScrollbars();
REDRAW(trackPanel);
REDRAW(rulerPanel);
// This indicates we handled the event.
return true;
}
return wxView::ProcessEvent(event);
}
TEST(PaddingEffectTest, NonIntegerOffset) {
float data[4 * 1] = {
0.25f, 0.50f, 0.75f, 1.0f,
};
float expected_data[5 * 2] = {
0.1875f, 0.4375f, 0.6875f, 0.9375f, 0.25f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
};
float out_data[5 * 2];
EffectChainTester tester(NULL, 5, 2);
ImageFormat format;
format.color_space = COLORSPACE_sRGB;
format.gamma_curve = GAMMA_LINEAR;
FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 4, 1);
input->set_pixel_data(data);
tester.get_chain()->add_input(input);
Effect *effect = tester.get_chain()->add_effect(new PaddingEffect());
CHECK(effect->set_int("width", 5));
CHECK(effect->set_int("height", 2));
CHECK(effect->set_float("left", 0.25f));
CHECK(effect->set_float("top", 0.0f));
tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_PREMULTIPLIED);
expect_equal(expected_data, out_data, 5, 2);
}
void Renderer::RenderXModel(const XModel& model, const Effect& effect, const D3DXMATRIX& model_matrix)
{
assert(model.IsCorrect());
assert(effect.IsCorrect());
D3DXMATRIX full_matrix = model_matrix * view_ * projection_;
const auto& effect_data = effect.d3d9_effect();
effect_data->SetMatrix
("matrix_world_view_proj", &full_matrix);
UINT passes;
D3DXHANDLE tech;
effect_data->FindNextValidTechnique(0, &tech);
effect_data->SetTechnique(tech);
effect_data->Begin(&passes, 0);
for (UINT pass = 0; pass < passes; ++pass)
{
effect_data->BeginPass(pass);
const auto& materials = model.textures();
for (UINT i = 0; i < model.subset_number(); ++i) {
if (i < materials.size())
effect_data->SetTexture("tex0", materials[i]->d3d9_texture());
effect_data->CommitChanges();
model.mesh()->DrawSubset(i);
}
effect_data->EndPass();
}
effect_data->End();
}
void StartMenu::flareEffect(CCObject *node)
{
onButtonEffect();
Effect* flareEffect = Effect::create();
CCCallFunc *callback = CCCallFunc::create(this, callfunc_selector(StartMenu::newGame));
flareEffect->flareEffect(this, callback);
}
void Renderer::RenderRawModel(const gfx::Model3d& model, const Effect& effect, const D3DXMATRIX& model_matrix)
{
assert(effect.IsCorrect());
for (auto& data : model.render_data()) {
D3DXMATRIX full_matrix = model_matrix * view_ * projection_;
const auto& effect_data = effect.d3d9_effect();
effect_data->SetMatrix
("matrix_world_view_proj", &full_matrix);
UINT passes;
D3DXHANDLE tech;
effect_data->FindNextValidTechnique(0, &tech);
effect_data->SetTechnique(tech);
effect_data->Begin(&passes, 0);
for (UINT pass = 0; pass < passes; ++pass)
{
effect_data->BeginPass(pass);
effect_data->SetTexture("tex0", storage_->FetchTexture(data));
effect_data->CommitChanges();
device_->SetFVF(VERTEX_XYZ_FVF);
device_->SetStreamSource(0, storage_->FetchVertexBuffer(data), 0, sizeof(Vertex_xyz));
device_->SetIndices(storage_->FetchIndexBuffer(data));
device_->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, data.vertices_number, 0, data.faces_number);
effect_data->EndPass();
}
effect_data->End();
}
}
void SpriteShape::Draw(IGraphicsDevice *device, RenderState &state)
{
IGraphicsContext *context = device->GetContext();
Effect *effect = context->GetEffect("Sprite");
if(mHasBackgroundImage) {
effect->SetActiveTechnique("SpriteTexture");
} else {
effect->SetActiveTechnique("SpriteColor");
}
glm::mat4 wvp = state.GetWorldViewProjection();
state.SetShaderData(mWVPIndex, &wvp);
state.SetShaderData(mFrameIndex, &mFrame);
state.SetShaderData(mTextureFrameIndex, &mTexFrame);
state.SetShaderData(mBackgroundColorIndex, &mBackgroundColor);
if(mBackgroundImage) {
state.SetShaderData(mBackgroundImageIndex, mBackgroundImage);
}
state.SetShaderData(mBorderWidthIndex, &mBorderWidth);
state.SetShaderData(mBorderColorIndex, &mBorderColor);
if(sSpriteVertexBuffer) {
Technique *technique = effect->GetActiveTechnique();
technique->Begin();
while(technique->HasNextPass()) {
sSpriteVertexBuffer->Activate();
technique->ProcessNextPass(device, state);
device->Draw(PrimitiveTypeTriangleStrip, 4, 0);
}
}
}
Effect WindowsGame::createBasicEffect()
{
Effect effect;
PassDescription passDesc;
passDesc.shaderProgram = std::move(std::unique_ptr<ShaderProgram>(createShaderProgram()));
passDesc.name = "Light";
DepthStencilStateDescription depthDesc;
depthDesc.depthEnabled = true;
depthDesc.writeEnabled = true;
depthDesc.function = CompareFunction::Less;
depthDesc.stencilEnabled = false;
DepthStencilState* depthState = new DepthStencilState();
depthState->initialize(graphicsDevice, depthDesc);
passDesc.depthStencilState = std::move(std::unique_ptr<DepthStencilState>(depthState));
EffectDescription effectDesc;
effectDesc.passDescriptions = &passDesc;
effectDesc.passCount = 1;
effectDesc.instanceParameters.push_back(InstanceParameterBinding("PointLights", 0));
effectDesc.instanceParameters.push_back(InstanceParameterBinding("Camera", 1));
effectDesc.instanceParameters.push_back(InstanceParameterBinding("Transformation", 2));
effect.initialize(effectDesc);
return effect;
}
bool Shader::setEffect(engine::IEffect* effect)
{
Effect* e = dynamic_cast<Effect*>( effect );
if( e && !e->isCompatible( this ) ) return false;
_effect = e;
return true;
}
int AudioOutputDevice::RenderAudio(uint Samples) {
if (Channels.empty()) return 0;
// reset all channels with silence
{
std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
std::vector<AudioChannel*>::iterator end = Channels.end();
for (; iterChannels != end; iterChannels++)
(*iterChannels)->Clear(Samples); // zero out audio buffer
}
// do the same for master effects
{
std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
std::vector<EffectChain*>::iterator end = vEffectChains.end();
for (; iterChains != end; ++iterChains)
(*iterChains)->ClearAllChannels(); // zero out audio buffers
}
int result = 0;
// let all connected engines render audio for the current audio fragment cycle
const std::set<Engine*>& engines = EnginesReader.Lock();
#if CONFIG_RT_EXCEPTIONS
try
#endif // CONFIG_RT_EXCEPTIONS
{
std::set<Engine*>::iterator iterEngine = engines.begin();
std::set<Engine*>::iterator end = engines.end();
for (; iterEngine != end; iterEngine++) {
int res = (*iterEngine)->RenderAudio(Samples);
if (res != 0) result = res;
}
}
#if CONFIG_RT_EXCEPTIONS
catch (std::runtime_error se) {
std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
exit(EXIT_FAILURE);
}
#endif // CONFIG_RT_EXCEPTIONS
EnginesReader.Unlock();
// now that the engines (might) have left fx send signals for master
// effects, render all master effects
{
std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
std::vector<EffectChain*>::iterator end = vEffectChains.end();
for (; iterChains != end; ++iterChains) {
if (!(*iterChains)->EffectCount()) continue;
(*iterChains)->RenderAudio(Samples);
// mix the result of the last effect in the chain to the audio
// output device channel(s)
Effect* pLastEffect =
(*iterChains)->GetEffect((*iterChains)->EffectCount() - 1);
for (int iChan = 0; iChan < pLastEffect->OutputChannelCount() && iChan < ChannelCount(); ++iChan)
pLastEffect->OutputChannel(iChan)->MixTo(Channel(iChan), Samples);
}
}
return result;
}
boost::shared_ptr<NodeCollection>
App::getCollectionFromGroup(Group* group) const
{
boost::shared_ptr<NodeCollection> collection;
if (group) {
App* isApp = dynamic_cast<App*>(group);
Effect* isEffect = dynamic_cast<Effect*>(group);
if (isApp) {
collection = boost::dynamic_pointer_cast<NodeCollection>(isApp->getInternalApp()->getProject());
} else if (isEffect) {
NodePtr node = isEffect->getInternalNode();
assert(node);
boost::shared_ptr<NodeGroup> isGrp = boost::dynamic_pointer_cast<NodeGroup>(node->getEffectInstance()->shared_from_this());
if (!isGrp) {
qDebug() << "The group passed to createNode() is not a group, defaulting to the project root.";
} else {
collection = boost::dynamic_pointer_cast<NodeCollection>(isGrp);
assert(collection);
}
}
}
if (!collection) {
collection = boost::dynamic_pointer_cast<NodeCollection>(_instance->getProject());
}
return collection;
}
void Pipeline::setVideoEffect(const QString &value)
{
Effect *newEffect = EffectManager::instance()->getEffect(value);
// close valves
g_object_set(effectValve, "drop", TRUE, NULL);
// unlink current effect, remove and destroy it
gst_element_unlink_many(effectCapsFilter, effect, effectPostCS, NULL);
g_object_ref(effect);
gst_bin_remove(GST_BIN(effectInternalBin), effect);
gst_element_set_state(effect, GST_STATE_NULL);
g_object_unref(GST_OBJECT(effect));
effect = gst_parse_bin_from_description(newEffect->desc().toUtf8(), TRUE, NULL);
// add new effect to the bin and link it
gst_bin_add(GST_BIN(effectInternalBin), effect);
gst_element_link_many(effectCapsFilter, effect, effectPostCS, NULL);
gst_element_set_state(effectInternalBin, GST_STATE_READY);
gst_element_set_state(effectInternalBin, GST_STATE_PAUSED);
//open valve
g_object_set(effectValve, "drop", FALSE, NULL);
}
void EffectManager::addEffect(EffectInfo& effectInfo)
{
if (effectInfo.m_configData.m_particleName=="" || !effectInfo.m_effectParent)
{
return;
}
Effect* effect = new Effect();
effect->setEffectInfo(effectInfo);
effect->init();
std::map<EffectNode*, std::map<std::string, Effect*> >::iterator itr = effectDic.find(effectInfo.m_effectParent);
if (itr!=effectDic.end())
{
itr->second.insert(std::map<std::string, Effect*>::value_type(effectInfo.m_configData.m_effectName, effect));
}
else
{
std::map<std::string, Effect*> effDic;
effDic.insert(std::map<std::string, Effect*>::value_type(effectInfo.m_configData.m_effectName, effect));
effectDic.insert(std::map<EffectNode*, std::map<std::string, Effect*> >::value_type(effectInfo.m_effectParent, effDic));
}
if (effectDic.size()==1)
{
CCDirector::sharedDirector()->getScheduler()->resumeTarget(this);
}
}
/**\brief Update the Projectile
*
* Projectiles do all the normal Sprite things like moving.
* Projectiles check for collisions with nearby Ships, and if they collide,
* they deal damage to that ship. Note that since each projectile knows which ship fired it and will never collide with them.
*
* Projectiles have a life time limit (in milli-seconds). Each tick they need
* to check if they've lived to long and need to disappear.
*
* Projectiles have the ability to track down a specific target. This only
* means that they will turn slightly to head towards their target.
*/
void Projectile::Update( void ) {
Sprite::Update(); // update momentum and other generic sprite attributes
SpriteManager *sprites = SpriteManager::Instance();
// Check for projectile collisions
Sprite* impact = sprites->GetNearestSprite( (Sprite*)this, 100,DRAW_ORDER_SHIP|DRAW_ORDER_PLAYER );
if( (impact != NULL) && (impact->GetID() != ownerID) && ((this->GetWorldPosition() - impact->GetWorldPosition()).GetMagnitude() < impact->GetRadarSize() )) {
((Ship*)impact)->Damage( (weapon->GetPayload())*damageBoost );
sprites->Delete( (Sprite*)this );
// Create a fire burst where this projectile hit the ship's shields.
// TODO: This shows how much we need to improve our collision detection.
Effect* hit = new Effect(this->GetWorldPosition(), "Resources/Animations/shield.ani", 0);
hit->SetAngle( -this->GetAngle() );
hit->SetMomentum( impact->GetMomentum() );
sprites->Add( hit );
}
// Expire the projectile after a time period
if (( Timer::GetTicks() > secondsOfLife + start )) {
sprites->Delete( (Sprite*)this );
}
// Track the target
Sprite* target = sprites->GetSpriteByID( targetID );
float tracking = weapon->GetTracking();
if( target != NULL && tracking > 0.00000001f ) {
float angleTowards = normalizeAngle( ( target->GetWorldPosition() - this->GetWorldPosition() ).GetAngle() - GetAngle() );
SetMomentum( GetMomentum().RotateBy( angleTowards*tracking ) );
SetAngle( GetMomentum().GetAngle() );
}
}
/**
* @brief
* Constructor
*/
EffectManager::EffectManager(RendererContext &cRendererContext) :
m_pRendererContext(&cRendererContext),
m_pDefault(new EffectHandler())
{
PL_LOG(Debug, "Create effect manager")
// Set manager name
SetManagerName("Effect manager");
// Unload unused resources, please
SetUnloadUnused(true);
// Create the standard effect
Effect *pFX = CreateResource(Default);
if (pFX) {
// Create the effect
EffectTechnique *pEffectTechnique = pFX->AddTechnique();
if (pEffectTechnique) {
pEffectTechnique->AddPass();
pFX->SelectTechnique(0);
}
// Setup effect
pFX->SetProtected(true);
m_pDefault->SetResource(pFX);
SetStandard(pFX);
}
}
bool BulletRapidFire::update( ) {
_exist_time++;
if ( _exist_time < WAIT_TIME ) {
return true;
}
if ( _exist_time >= VANISH_TIME ) {
return false;
}
Effect effect;
if ( _exist_time == RAPID_TIME ) {
_bullet_effect_handle[ 1 ] = effect.setEffect( Effect::EFFECT_ENEMY_ATTACK_FIRE_BALL );
_exist_bullet[ 1 ] = true;
}
for ( int i = 0; i < BULLET_NUM; i++ ) {
if ( !_exist_bullet[ i ] ) {
continue;
}
// ˆÚ“®
_bullet_pos[ i ] += _dir * _speed;
attackEnemy( _bullet_pos[ i ], _power );
Effect effect;
effect.drawEffect( _bullet_effect_handle[ i ], Vector( 0.3, 0.3, 0.3 ), _bullet_pos[ i ], _dir );
}
return true;
}
void AfterEffectManager::update(float dt)
{
if (core->particlesPaused) return;
resetGrid();
if (core->frameBuffer.isInited())
active = true;
else
active = false;
for (int i = 0; i < effects.size(); i++)
{
Effect *e = effects[i];
if (e)
{
active = true;
e->update(dt, drawGrid, xDivs, yDivs);
if (e->done)
{
numEffects--;
destroyEffect(i);
}
}
}
}
Effect* ResourceManager::GetEffect(const std::string& name)
{
hash_map<string,Effect*>::iterator iterator = effects.find(name);
if(iterator == effects.end()) return NULL;
Effect* result = iterator->second;
result->AddRef();
return result;
}
void Engine::Init()
{
GUI gui;
gui.Init();
Effect effect;
effect.Init();
}
void Actor::kill()
{
mbIsDead = true;
AudioManager::Instance().PlaySFX("scifi_explosion-001.ogg");
Effect * pExplosion = ModContentManager::Instance().SpawnEffect("explosion");
pExplosion->SetPosition(mPosition);
Game::Instance().QueueEffect(pExplosion);
}
void EffectRackView::deletePlugin( EffectView* view )
{
Effect * e = view->effect();
m_effectViews.erase( qFind( m_effectViews.begin(), m_effectViews.end(), view ) );
delete view;
fxChain()->removeEffect( e );
e->deleteLater();
update();
}
void GameMap::ShowEffect(int dataid,const string& name,const Point& pos,float duration /* = 0.0f */,float scale /* = 1.0f */)
{
Effect* pEffect = Effect::createWithDataID(dataid);
if ( pEffect )
{
pEffect->setName(name);
ShowEffect(pEffect,pos,duration,scale);
}
}
