//----[ update ]-------------------------------------------------------------
void EvidyonGUIModule_TradeDialog::update(ActionTargeter* action_targeter) {
if (pollAcceptTrade()) action_targeter->userEvent(TRADE_ACCEPT);
if (pollCancelTrade()) action_targeter->userEvent(TRADE_CANCEL);
if (pollWithdrawTrade()) action_targeter->userEvent(TRADE_WITHDRAW);
unsigned int inventory_index;
if (pollAddItemToTrade(&inventory_index)) {
action_targeter->tradeAddItem()->inventory_index_ = inventory_index;
}
unsigned int trade_index;
if (pollRemoveItemFromTrade(&trade_index)) {
action_targeter->tradeRemoveItem()->inventory_index_ = trade_index;
}
updateTooltip();
if (quantity_prompt_.isActive()) {
//TODO:
//CurrencyType quantity = quantity_prompt_.getValue();
//if (quantity > myCharacter.money) { disable the OK button }
if (quantity_prompt_.pollOK()) {
action_targeter->tradeSetCurrency()->currency_ = quantity_prompt_.getValue();
removeSubmodule(&quantity_prompt_);
}
if (quantity_prompt_.pollCancel()) {
removeSubmodule(&quantity_prompt_);
}
} else {
if (offer_currency_.pollPushed()) {
addSubmodule(&quantity_prompt_);
quantity_prompt_.initialize("How much gold do you want to offer?", "Add Gold", "Cancel");
}
}
}
//----[ showCreateListingPrompt ]--------------------------------------------
void EvidyonGUIModule_Bazaar::showCreateListingPrompt(
const char* item_name,
const ClientAvatarInventoryItem* item,
const Item::ItemClientDescription* description) {
clearSubmodules();
create_listing_prompt_.setListingPrompt(item_name, item, description);
addSubmodule(&create_listing_prompt_);
}
void EvidyonGUIModule_Bazaar::create(GUICanvas* source_canvas,
GUIFont* button_font,
const Item::ItemClientDescription* item_descriptions,
size_t number_of_item_descriptions,
const ClientAvatarInventoryItem* inventory,
EvidyonGUITooltipBox* tooltip) {
items_in_category_.create(this,
source_canvas,
button_font,
item_descriptions,
number_of_item_descriptions,
tooltip);
inventory_.create(this,
source_canvas,
button_font,
item_descriptions,
number_of_item_descriptions,
inventory,
tooltip);
create_listing_prompt_.create(source_canvas, this, button_font);
addSubmodule(&items_in_category_);
// Categories only shown if not listing own items
for (int i = 0; i < CATEGORY_COUNT; ++i) {
BazaarCategory category = BazaarCategory(i);
EvidyonGUIButton* button = getCategoryButton(category);
button->setText(BazaarCategoryString(category));
button->setFont(button_font);
alignButton(source_canvas, button, i);
}
{
EvidyonGUIButton* button = getCreateListingButton();
button->setText("Create Listing");
button->setFont(button_font);
alignButton(source_canvas, button, -1);
}
{
EvidyonGUIButton* button = getCategoryButton(CATEGORY_OWNITEMS);
button->setText("Listed Items");
button->setFont(button_font);
alignButton(source_canvas, button, -2);
}
{
EvidyonGUIButton* button = getExitButton();
button->setText("Leave the Bazaar");
button->setFont(button_font);
GUICanvas* canvas = button->getCanvas();
canvas->setSourceCanvas(items_in_category_.getListCanvas());
canvas->alignYBottomOutside(+10);
canvas->alignXCenter(0);
canvas->relativeWidth(-50);
canvas->absoluteHeight(35);
canvas->relativeDepth(0.0f);
}
for (int i = 0; i < CATEGORY_COUNT + 3; ++i) {
addComponent(getButton(i));
}
memset(own_items_, 0, sizeof(ItemInBazaar) * MAX_ITEMS_PER_BAZAAR_CATEGORY);
number_of_own_items_ = 0;
}
//----[ showCreateListing ]--------------------------------------------------
void EvidyonGUIModule_Bazaar::showCreateListing() {
clearSubmodules();
addSubmodule(&inventory_);
}
//----[ changeCategory ]-----------------------------------------------------
void EvidyonGUIModule_Bazaar::changeCategory(BazaarCategory category) {
clearSubmodules();
addSubmodule(&items_in_category_);
items_in_category_.changeCategory(category);
}
void HelmEngine::init() {
static const Value* minutes_per_second = new Value(1.0 / 60.0);
#ifdef FE_DFL_DISABLE_SSE_DENORMS_ENV
fesetenv(FE_DFL_DISABLE_SSE_DENORMS_ENV);
#endif
Processor* beats_per_minute = createMonoModControl("beats_per_minute", false);
Multiply* beats_per_second = new Multiply();
beats_per_second->plug(beats_per_minute, 0);
beats_per_second->plug(minutes_per_second, 1);
addProcessor(beats_per_second);
// Voice Handler.
Processor* polyphony = createMonoModControl("polyphony", true);
voice_handler_ = new HelmVoiceHandler(beats_per_second);
addSubmodule(voice_handler_);
voice_handler_->setPolyphony(32);
voice_handler_->plug(polyphony, VoiceHandler::kPolyphony);
// Monophonic LFO 1.
Processor* lfo_1_waveform = createMonoModControl("mono_lfo_1_waveform", true);
Processor* lfo_1_free_frequency = createMonoModControl("mono_lfo_1_frequency", true, false);
Processor* lfo_1_free_amplitude = createMonoModControl("mono_lfo_1_amplitude", true);
Processor* lfo_1_frequency = createTempoSyncSwitch("mono_lfo_1", lfo_1_free_frequency,
beats_per_second, false);
lfo_1_ = new HelmLfo();
lfo_1_->plug(lfo_1_waveform, HelmLfo::kWaveform);
lfo_1_->plug(lfo_1_frequency, HelmLfo::kFrequency);
Multiply* scaled_lfo_1 = new Multiply();
scaled_lfo_1->setControlRate();
scaled_lfo_1->plug(lfo_1_, 0);
scaled_lfo_1->plug(lfo_1_free_amplitude, 1);
addProcessor(lfo_1_);
addProcessor(scaled_lfo_1);
mod_sources_["mono_lfo_1"] = scaled_lfo_1->output();
mod_sources_["mono_lfo_1_phase"] = lfo_1_->output(Oscillator::kPhase);
// Monophonic LFO 2.
Processor* lfo_2_waveform = createMonoModControl("mono_lfo_2_waveform", true);
Processor* lfo_2_free_frequency = createMonoModControl("mono_lfo_2_frequency", true, false);
Processor* lfo_2_free_amplitude = createMonoModControl("mono_lfo_2_amplitude", true);
Processor* lfo_2_frequency = createTempoSyncSwitch("mono_lfo_2", lfo_2_free_frequency,
beats_per_second, false);
lfo_2_ = new HelmLfo();
lfo_2_->plug(lfo_2_waveform, HelmLfo::kWaveform);
lfo_2_->plug(lfo_2_frequency, HelmLfo::kFrequency);
Multiply* scaled_lfo_2 = new Multiply();
scaled_lfo_2->setControlRate();
scaled_lfo_2->plug(lfo_2_, 0);
scaled_lfo_2->plug(lfo_2_free_amplitude, 1);
addProcessor(lfo_2_);
addProcessor(scaled_lfo_2);
mod_sources_["mono_lfo_2"] = scaled_lfo_2->output();
mod_sources_["mono_lfo_2_phase"] = lfo_2_->output(Oscillator::kPhase);
// Step Sequencer.
Processor* num_steps = createMonoModControl("num_steps", true);
Processor* step_smoothing = createMonoModControl("step_smoothing", true);
Processor* step_free_frequency = createMonoModControl("step_frequency", false, false);
Processor* step_frequency = createTempoSyncSwitch("step_sequencer", step_free_frequency,
beats_per_second, false);
step_sequencer_ = new StepGenerator(MAX_STEPS);
step_sequencer_->plug(num_steps, StepGenerator::kNumSteps);
step_sequencer_->plug(step_frequency, StepGenerator::kFrequency);
for (int i = 0; i < MAX_STEPS; ++i) {
std::stringstream stream;
stream << i;
std::string num = stream.str();
if (num.length() == 1)
num = "0" + num;
Processor* step = createBaseControl(std::string("step_seq_") + num);
step_sequencer_->plug(step, StepGenerator::kSteps + i);
}
SmoothFilter* smoothed_step_sequencer = new SmoothFilter();
smoothed_step_sequencer->plug(step_sequencer_, SmoothFilter::kTarget);
smoothed_step_sequencer->plug(step_smoothing, SmoothFilter::kHalfLife);
addProcessor(step_sequencer_);
addProcessor(smoothed_step_sequencer);
mod_sources_["step_sequencer"] = smoothed_step_sequencer->output();
mod_sources_["step_sequencer_step"] = step_sequencer_->output(StepGenerator::kStep);
// Arpeggiator.
Processor* arp_free_frequency = createMonoModControl("arp_frequency", true, false);
Processor* arp_frequency = createTempoSyncSwitch("arp", arp_free_frequency,
beats_per_second, false);
Processor* arp_octaves = createMonoModControl("arp_octaves", true);
Processor* arp_pattern = createMonoModControl("arp_pattern", true);
Processor* arp_gate = createMonoModControl("arp_gate", true);
arp_on_ = createBaseControl("arp_on");
arpeggiator_ = new Arpeggiator(voice_handler_);
arpeggiator_->plug(arp_frequency, Arpeggiator::kFrequency);
arpeggiator_->plug(arp_octaves, Arpeggiator::kOctaves);
arpeggiator_->plug(arp_pattern, Arpeggiator::kPattern);
arpeggiator_->plug(arp_gate, Arpeggiator::kGate);
addProcessor(arpeggiator_);
addProcessor(voice_handler_);
// Delay effect.
Processor* delay_free_frequency = createMonoModControl("delay_frequency", false, false);
Processor* delay_frequency = createTempoSyncSwitch("delay", delay_free_frequency,
beats_per_second, false);
Processor* delay_feedback = createMonoModControl("delay_feedback", false, true);
Processor* delay_wet = createMonoModControl("delay_dry_wet", false, true);
Value* delay_on = createBaseControl("delay_on");
Clamp* delay_feedback_clamped = new Clamp(-1, 1);
delay_feedback_clamped->plug(delay_feedback);
SmoothFilter* delay_frequency_smoothed = new SmoothFilter();
delay_frequency_smoothed->plug(delay_frequency, SmoothFilter::kTarget);
delay_frequency_smoothed->plug(&utils::value_half, SmoothFilter::kHalfLife);
FrequencyToSamples* delay_samples = new FrequencyToSamples();
delay_samples->plug(delay_frequency_smoothed);
Delay* delay = new Delay(MAX_DELAY_SAMPLES);
delay->plug(voice_handler_, Delay::kAudio);
delay->plug(delay_samples, Delay::kSampleDelay);
delay->plug(delay_feedback_clamped, Delay::kFeedback);
delay->plug(delay_wet, Delay::kWet);
BypassRouter* delay_container = new BypassRouter();
delay_container->plug(delay_on, BypassRouter::kOn);
delay_container->plug(voice_handler_, BypassRouter::kAudio);
delay_container->addProcessor(delay_feedback_clamped);
delay_container->addProcessor(delay_frequency_smoothed);
delay_container->addProcessor(delay_samples);
delay_container->addProcessor(delay);
delay_container->registerOutput(delay->output());
addProcessor(delay_container);
// Reverb Effect.
Processor* reverb_feedback = createMonoModControl("reverb_feedback", false, true);
Processor* reverb_damping = createMonoModControl("reverb_damping", false, true);
Processor* reverb_wet = createMonoModControl("reverb_dry_wet", false, true);
Value* reverb_on = createBaseControl("reverb_on");
Clamp* reverb_feedback_clamped = new Clamp(-1, 1);
reverb_feedback_clamped->plug(reverb_feedback);
Reverb* reverb = new Reverb();
reverb->plug(delay, Reverb::kAudio);
reverb->plug(reverb_feedback_clamped, Reverb::kFeedback);
reverb->plug(reverb_damping, Reverb::kDamping);
reverb->plug(reverb_wet, Reverb::kWet);
BypassRouter* reverb_container = new BypassRouter();
reverb_container->plug(reverb_on, BypassRouter::kOn);
reverb_container->plug(delay, BypassRouter::kAudio);
reverb_container->addProcessor(reverb);
reverb_container->addProcessor(reverb_feedback_clamped);
reverb_container->registerOutput(reverb->output(0));
reverb_container->registerOutput(reverb->output(1));
addProcessor(reverb_container);
// Soft Clipping.
Distortion* distorted_clamp_left = new Distortion();
Value* distortion_type = new Value(Distortion::kTanh);
Value* distortion_threshold = new Value(0.9);
distorted_clamp_left->plug(reverb_container->output(0), Distortion::kAudio);
distorted_clamp_left->plug(distortion_type, Distortion::kType);
distorted_clamp_left->plug(distortion_threshold, Distortion::kThreshold);
Distortion* distorted_clamp_right = new Distortion();
distorted_clamp_right->plug(reverb_container->output(1), Distortion::kAudio);
distorted_clamp_right->plug(distortion_type, Distortion::kType);
distorted_clamp_right->plug(distortion_threshold, Distortion::kThreshold);
// Volume.
Processor* volume = createMonoModControl("volume", false, true);
Multiply* scaled_audio_left = new Multiply();
scaled_audio_left->plug(distorted_clamp_left, 0);
scaled_audio_left->plug(volume, 1);
Multiply* scaled_audio_right = new Multiply();
scaled_audio_right->plug(distorted_clamp_right, 0);
scaled_audio_right->plug(volume, 1);
addProcessor(distorted_clamp_left);
addProcessor(distorted_clamp_right);
addProcessor(scaled_audio_left);
addProcessor(scaled_audio_right);
registerOutput(scaled_audio_left->output());
registerOutput(scaled_audio_right->output());
HelmModule::init();
}
