void MainSequencer::GetSelectedEffectsData(wxString& copy_data) {
int start_column = PanelEffectGrid->GetStartColumn();
int column_start_time = -1000;
EffectLayer* tel = mSequenceElements->GetVisibleEffectLayer(mSequenceElements->GetSelectedTimingRow());
if( tel != nullptr && start_column != -1) {
Effect* eff = tel->GetEffect(start_column);
if( eff != nullptr ) {
column_start_time = eff->GetStartTimeMS();
}
}
for(int i=0;i<mSequenceElements->GetRowInformationSize();i++)
{
int row_number = mSequenceElements->GetRowInformation(i)->Index-mSequenceElements->GetFirstVisibleModelRow();
EffectLayer* el = mSequenceElements->GetEffectLayer(i);
for (int x = 0; x < el->GetEffectCount(); x++) {
Effect *ef = el->GetEffect(x);
if (ef->GetSelected() != EFFECT_NOT_SELECTED) {
wxString start_time = wxString::Format("%d",ef->GetStartTimeMS());
wxString end_time = wxString::Format("%d",ef->GetEndTimeMS());
wxString row = wxString::Format("%d",row_number);
wxString column_start = wxString::Format("%d",column_start_time);
copy_data += ef->GetEffectName() + "\t" + ef->GetSettingsAsString() + "\t" + ef->GetPaletteAsString() +
"\t" + start_time + "\t" + end_time + "\t" + row + "\t" + column_start + "\n";
}
}
}
}
void SequenceElements::RenameTimingTrack(std::string oldname, std::string newname)
{
// actual timing track name already updated ... we just need to update any effects that care about the timing track name
// faces, state, piano, vumeter
std::vector<RenderableEffect*> effects(GetEffectManager().size());
int count = 0;
for (int x = 0; x < GetEffectManager().size(); x++) {
RenderableEffect *eff = GetEffectManager()[x];
effects[x] = eff;
}
for (size_t i = 0; i < GetElementCount(); i++) {
Element* elem = GetElement(i);
if (elem->GetType() == "model") {
for (int j = 0; j < elem->GetEffectLayerCount(); j++) {
EffectLayer* layer = elem->GetEffectLayer(j);
for (int k = 0; k < layer->GetEffectCount(); k++) {
Effect* eff = layer->GetEffect(k);
if (effects[eff->GetEffectIndex()] != nullptr) {
effects[eff->GetEffectIndex()]->RenameTimingTrack(oldname, newname, eff);
}
}
}
for (int j = 0; j < elem->getStrandLayerCount(); j++) {
StrandLayer* layer = elem->GetStrandLayer(j);
for (int k = 0; k < layer->GetEffectCount(); k++) {
Effect* eff = layer->GetEffect(k);
if (effects[eff->GetEffectIndex()] != nullptr) {
effects[eff->GetEffectIndex()]->RenameTimingTrack(oldname, newname, eff);
}
}
for (int k = 0; k < layer->GetNodeLayerCount(); k++) {
NodeLayer* nlayer = layer->GetNodeLayer(k);
for (int l = 0; l < nlayer->GetEffectCount(); l++) {
Effect* eff = nlayer->GetEffect(l);
if (effects[eff->GetEffectIndex()] != nullptr) {
effects[eff->GetEffectIndex()]->RenameTimingTrack(oldname, newname, eff);
}
}
}
}
}
}
}
void RowHeading::BreakdownTimingPhrases(Element* element)
{
element->SetFixedTiming(0);
EffectLayer* layer = element->GetEffectLayer(0);
if( element->GetEffectLayerCount() > 1 )
{
for( int k = element->GetEffectLayerCount()-1; k > 0; k--)
{
element->RemoveEffectLayer(k);
}
}
EffectLayer* word_layer = element->AddEffectLayer();
for( int i = 0; i < layer->GetEffectCount(); i++ )
{
Effect* effect = layer->GetEffect(i);
std::string phrase = effect->GetEffectName();
mSequenceElements->BreakdownPhrase(word_layer, effect->GetStartTimeMS(), effect->GetEndTimeMS(), phrase);
}
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
}
void MainSequencer::InsertTimingMarkFromRange()
{
bool is_range = true;
int x1;
int x2;
if( mPlayType == PLAY_TYPE_MODEL )
{
x1 = PanelTimeLine->GetPlayMarker();
x2 = x1;
}
else
{
x1 = PanelTimeLine->GetSelectedPositionStart();
x2 = PanelTimeLine->GetSelectedPositionEnd();
}
if( x2 == -1 ) x2 = x1;
if( x1 == x2) is_range = false;
int selectedTiming = mSequenceElements->GetSelectedTimingRow();
if(selectedTiming >= 0)
{
int t1 = PanelTimeLine->GetAbsoluteTimeMSfromPosition(x1);
int t2 = PanelTimeLine->GetAbsoluteTimeMSfromPosition(x2);
if(is_range)
{
Element* e = mSequenceElements->GetVisibleRowInformation(selectedTiming)->element;
EffectLayer* el = e->GetEffectLayer(mSequenceElements->GetVisibleRowInformation(selectedTiming)->layerIndex);
int index;
if(!el->HitTestEffectByTime(t1,index) && !el->HitTestEffectByTime(t2,index))
{
std::string name,settings;
el->AddEffect(0,name,settings,"",t1,t2,false,false);
PanelEffectGrid->ForceRefresh();
}
else
{
wxMessageBox("Timing exist already in the selected region","Timing placement error");
}
}
else
{
// x1 and x2 are the same. Insert from end time of timing to the left to x2
Element* e = mSequenceElements->GetVisibleRowInformation(selectedTiming)->element;
EffectLayer* el = e->GetEffectLayer(mSequenceElements->GetVisibleRowInformation(selectedTiming)->layerIndex);
int index;
if(!el->HitTestEffectByTime(t2,index))
{
// if there is an effect to left
std::string name,settings;
Effect * effect = nullptr;
for (int x = 0; x < el->GetEffectCount(); x++) {
Effect * e = el->GetEffect(x);
if (e->GetStartTimeMS() > t2 && x > 0) {
effect = el->GetEffect(x - 1);
break;
}
}
if(effect!=nullptr)
{
int t1 = effect->GetEndTimeMS();
el->AddEffect(0,name,settings,"",t1,t2,false,false);
}
// No effect to left start at time = 0
else
{
int t1 = 0;
if (el->GetEffectCount() > 0) {
Effect *e = el->GetEffect(el->GetEffectCount() - 1);
t1 = e->GetEndTimeMS();
}
el->AddEffect(0,name,settings,"",t1,t2,false,false);
}
PanelEffectGrid->ForceRefresh();
}
else
{
SplitTimingMark(); // inserting a timing mark inside a timing mark same as a split
}
}
}
}
void FireworksEffect::Render(Effect *effect, const SettingsMap &SettingsMap, RenderBuffer &buffer) {
int Number_Explosions = SettingsMap.GetInt("SLIDER_Fireworks_Explosions", 16);
int Count = SettingsMap.GetInt("SLIDER_Fireworks_Count", 50);
float Velocity = SettingsMap.GetDouble("SLIDER_Fireworks_Velocity", 2.0f);
int Fade = SettingsMap.GetInt("SLIDER_Fireworks_Fade", 50);
float f = 0.0;
bool useMusic = SettingsMap.GetBool("CHECKBOX_Fireworks_UseMusic", false);
float sensitivity = (float)SettingsMap.GetInt("SLIDER_Fireworks_Sensitivity", 50) / 100.0;
bool useTiming = SettingsMap.GetBool("CHECKBOX_FIRETIMING", false);
wxString timing = SettingsMap.Get("CHOICE_FIRETIMINGTRACK", "");
if (timing == "") useTiming = false;
if (useMusic)
{
if (buffer.GetMedia() != nullptr) {
std::list<float>* pf = buffer.GetMedia()->GetFrameData(buffer.curPeriod, FRAMEDATA_HIGH, "");
if (pf != nullptr)
{
f = *pf->begin();
}
}
}
FireworksRenderCache *cache = (FireworksRenderCache*)buffer.infoCache[id];
if (cache == nullptr) {
cache = new FireworksRenderCache();
buffer.infoCache[id] = cache;
}
int& next = cache->next;
int& sincelasttriggered = cache->sincelasttriggered;
int x25,x75,y25,y75;
//float velocity = 3.5;
int ColorIdx;
float v;
HSVValue hsv;
size_t colorcnt = buffer.GetColorCount();
if (buffer.needToInit) {
SetPanelTimingTracks();
cache->sincelasttriggered = 0;
cache->next = 0;
buffer.needToInit = false;
for(int i=0; i<maxFlakes; i++) {
cache->fireworkBursts[i]._bActive = false;
}
for (int x = 0; x < Number_Explosions; x++) {
double start = -1;
if (!useMusic)
{
start = buffer.curEffStartPer + buffer.rand01() * (buffer.curEffEndPer - buffer.curEffStartPer);
}
x25=(int)buffer.BufferWi*0.25;
x75=(int)buffer.BufferWi*0.75;
y25=(int)buffer.BufferHt*0.25;
y75=(int)buffer.BufferHt*0.75;
int startX;
int startY;
if((x75-x25)>0) startX = x25 + rand()%(x75-x25); else startX=0;
if((y75-y25)>0) startY = y25 + rand()%(y75-y25); else startY=0;
// Create a new burst
ColorIdx=rand() % colorcnt; // Select random numbers from 0 up to number of colors the user has checked. 0-5 if 6 boxes checked
for(int i=0; i<Count; i++) {
cache->fireworkBursts[x * Count + i].Reset(startX, startY, false, Velocity, ColorIdx, start);
}
}
if (timing != "")
{
effect->GetParentEffectLayer()->GetParentElement()->GetSequenceElements()->AddRenderDependency(timing.ToStdString(), buffer.cur_model);
}
}
if (useMusic)
{
// only trigger a firework if music is greater than the sensitivity
if (f > sensitivity)
{
// trigger if it was not previously triggered or has been triggered for REPEATTRIGGER frames
if (sincelasttriggered == 0 || sincelasttriggered > REPEATTRIGGER)
{
// activate all the particles in the next firework
for (int j = 0; j < Count; j++)
{
cache->fireworkBursts[Count*next + j]._bActive = true;
buffer.palette.GetHSV(cache->fireworkBursts[Count*next + j]._colorindex, hsv); // Now go and get the hsv value for this ColorIdx
cache->fireworkBursts[Count*next + j]._hsv = hsv;
}
// use the next firework next time
next++;
if (next == Number_Explosions)
{
next = 0;
}
}
// if music is over the trigger level for REPEATTRIGGER frames then we will trigger another firework
sincelasttriggered++;
if (sincelasttriggered > REPEATTRIGGER)
{
sincelasttriggered = 0;
}
}
else
{
// not triggered so clear last triggered counter
sincelasttriggered = 0;
}
}
if (useTiming)
{
if (mSequenceElements == nullptr)
{
// no timing tracks ... this shouldnt happen
}
else
{
// Load the names of the timing tracks
Element* t = nullptr;
for (size_t l = 0; l < mSequenceElements->GetElementCount(); l++)
{
Element* e = mSequenceElements->GetElement(l);
if (e->GetEffectLayerCount() == 1 && e->GetType() == ELEMENT_TYPE_TIMING)
{
if (e->GetName() == timing)
{
t = e;
break;
}
}
}
if (t == nullptr)
{
// timing track not found ... this shouldnt happen
}
else
{
sincelasttriggered = 0;
EffectLayer* el = t->GetEffectLayer(0);
for (int j = 0; j < el->GetEffectCount(); j++)
{
if (buffer.curPeriod == el->GetEffect(j)->GetStartTimeMS() / buffer.frameTimeInMs ||
buffer.curPeriod == el->GetEffect(j)->GetEndTimeMS() / buffer.frameTimeInMs)
{
// activate all the particles in the next firework
for (int k = 0; k < Count; k++)
{
cache->fireworkBursts[Count*next + k]._bActive = true;
buffer.palette.GetHSV(cache->fireworkBursts[Count*next + k]._colorindex, hsv); // Now go and get the hsv value for this ColorIdx
cache->fireworkBursts[Count*next + k]._hsv = hsv;
}
// use the next firework next time
next++;
if (next == Number_Explosions)
{
next = 0;
}
break;
}
}
}
}
}
for (int i=0; i<(Count*Number_Explosions); i++) {
if (!useMusic && !useTiming)
{
if (cache->fireworkBursts[i].startPeriod == buffer.curPeriod) {
cache->fireworkBursts[i]._bActive = true;
buffer.palette.GetHSV(cache->fireworkBursts[i]._colorindex, hsv); // Now go and get the hsv value for this ColorIdx
cache->fireworkBursts[i]._hsv = hsv;
}
}
// ... active flakes:
if (cache->fireworkBursts[i]._bActive)
{
// Update position
cache->fireworkBursts[i]._x += cache->fireworkBursts[i]._dx;
cache->fireworkBursts[i]._y += (-cache->fireworkBursts[i]._dy - cache->fireworkBursts[i]._cycles*cache->fireworkBursts[i]._cycles/10000000.0);
// If this flake run for more than maxCycle or this flake is out of bounds, time to switch it off
cache->fireworkBursts[i]._cycles+=20;
if (cache->fireworkBursts[i]._cycles >= 10000 || cache->fireworkBursts[i]._y >= buffer.BufferHt || cache->fireworkBursts[i]._y < 0 ||
cache->fireworkBursts[i]._x < 0. || cache->fireworkBursts[i]._x >= buffer.BufferWi)
{
cache->fireworkBursts[i]._bActive = false;
if (useMusic)
{
cache->fireworkBursts[i].Reset();
}
continue;
}
}
if(cache->fireworkBursts[i]._bActive == true)
{
v = ((Fade*10.0)-cache->fireworkBursts[i]._cycles)/(Fade*10.0);
if (v<0) v=0.0;
if (buffer.allowAlpha) {
xlColor c(cache->fireworkBursts[i]._hsv);
c.alpha = 255.0 * v;
buffer.SetPixel(cache->fireworkBursts[i]._x, cache->fireworkBursts[i]._y, c);
} else {
hsv=cache->fireworkBursts[i]._hsv;
hsv.value=v;
buffer.SetPixel(cache->fireworkBursts[i]._x, cache->fireworkBursts[i]._y, hsv);
}
}
}
}