const std::vector<const runtime::Parameter*> ConvertPixelType::setupInitParameters()
{
std::vector<const runtime::Parameter*> parameters;
EnumParameter* dataFlow = new runtime::EnumParameter(DATA_FLOW);
dataFlow->setAccessMode(runtime::Parameter::NONE_WRITE);
dataFlow->setTitle("Data flow");
dataFlow->add(runtime::EnumDescription(runtime::Enum(MANUAL), "Manual"));
dataFlow->add(runtime::EnumDescription(runtime::Enum(ALLOCATE), "Allocate"));
parameters.push_back(dataFlow);
return parameters;
}
const std::vector<const Parameter*> ReadDirectory::setupParameters()
{
std::vector<const runtime::Parameter*> parameters;
EnumParameter* directory = new EnumParameter(DIRECTORY);
directory->setTitle(L_("Directory"));
directory->setAccessMode(runtime::Parameter::INITIALIZED_WRITE);
parameters.push_back(directory);
directory->add(EnumDescription(Enum(NO_DIRECTORY), L_("None")));
boost::filesystem::path path (BASE_DIRECTORY);
m_directoryMap.clear();
std::vector<std::string> dirNames;
if (boost::filesystem::exists(path))
{
if (boost::filesystem::is_directory(path))
{
for(boost::filesystem::directory_iterator iter(path);
iter != boost::filesystem::directory_iterator();
++iter)
{
if (! boost::filesystem::is_directory(iter->path()))
continue;
dirNames.push_back(iter->path().filename().string());
}
}
}
std::sort(dirNames.begin(), dirNames.end());
std::size_t i = NO_DIRECTORY + 1;
for (std::vector<std::string>::const_iterator iter = dirNames.begin();
iter != dirNames.end(); ++iter)
{
directory->add(EnumDescription(Enum(i), *iter));
m_directoryMap[i] = *iter;
i++;
}
return parameters;
}
const std::vector<const Parameter*> ConvertPixelType::setupParameters()
{
std::vector<const runtime::Parameter*> parameters;
EnumParameter* pixelType = new EnumParameter(PIXEL_TYPE);
pixelType->setTitle("Pixel type");
pixelType->setAccessMode(runtime::Parameter::ACTIVATED_WRITE);
pixelType->add(EnumDescription(Enum(runtime::Image::MONO_8), "Mono image 8-bit"));
pixelType->add(EnumDescription(Enum(runtime::Image::RGB_24), "RGB image 24-bit"));
pixelType->add(EnumDescription(Enum(runtime::Image::BGR_24), "BGR image 24-bit"));
pixelType->add(EnumDescription(Enum(runtime::Image::BAYERBG_8), "Bayer BG pattern 8-bit"));
pixelType->add(EnumDescription(Enum(runtime::Image::BAYERGB_8), "Bayer GB pattern 8-bit"));
parameters.push_back(pixelType);
return parameters;
}
virtual void run(ComponentInstance *ci,int out){
EnvGenData *d = (EnvGenData *)ci->privateData;
Component *c = ci->component;
Envelope& e = pEnv->get(c);
int trig;
// always trigger if not connected.
if(!c->isInputConnected(0))trig=1;
else trig = tInt->getInput(ci,0);
int finishout=0;
// do we retrigger?
bool retrig=false;
switch(pMode->get(c)){
case MODE_RETRIG: // we retrigger if input high
if(trig)retrig=true;break;
case MODE_ONESHOT: // we retrigger if input high AND we've never done before
if(trig && d->start<0 && !d->oneshotdone)retrig=true;break;
case MODE_NORETRIG: // we retrigger if input high AND we're done
if(trig && d->start<0)retrig=true;break;
case MODE_FREERUN: // we retrigger when we're done
if(d->start<0)retrig=true;break;
}
c->dprintf("Trig=%s retrig=%s start=%f nextstage=%d OSD=%s",
trig?"Y":"N",
retrig?"Y":"N",
d->start,d->nextstage,
d->oneshotdone?"Y":"N");
if(retrig){
d->start = Time::now();
d->nextstage=0;
d->op=0;
}
float mul = powf(2.0,(float)pPower2->get(c));
if(d->start>=0){
// running
float t = Time::now() - d->start;
t *= mul;
while(t>=e.times[d->nextstage]){
// we have hit the next stage
if(++d->nextstage == ENVSIZE){
// we have run out of envelope!
d->start = -1;
d->oneshotdone=true;
finishout=1;
break;
}
}
if(d->start>=0){ // are we *still* running?
// calculate the level - there is an implicit level 0 at
// time 0.
float l1 = d->nextstage ? e.levels[d->nextstage-1] : 0;
float t1 = d->nextstage ? e.times[d->nextstage-1] : 0;
float l2 = e.levels[d->nextstage];
float t2 = e.times[d->nextstage];
c->dprintf("time %f: waiting for %d, t1=%f,l1=%f t1=%f,l2=%f\n",
t-t1,d->nextstage,t1,l1,t2,l2);
// interpolate and deal with zero-length steps
if(t2-t1 > 0.0001f){
float a = (t-t1)/(t2-t1);
d->op = a*l2 + (1.0f-a)*l1;
} else {
d->op = l2; // use the second entry
}
}
}
c->dprintf("Out=%f",d->op);
tFloat->setOutput(ci,0,d->op);
tInt->setOutput(ci,1,finishout);
}
SimpleParametersPanel* SimplePanelBuilder::buildParametersPanel(Parameters& parameters, ParametersInterface* pParent, ParameterPanelType panelType)
{
if (parameters.m_aParameters.empty())
return NULL;
SimpleParametersPanel* pSPP = new SimpleParametersPanel(pParent);
std::vector<Parameter*>::iterator it = parameters.m_aParameters.begin();
for (; it != parameters.m_aParameters.end(); ++it)
{
Parameter* pParam = *it;
ParameterType parameterType = pParam->getType();
std::string name = pParam->getName();
std::string label = pParam->getLabel();
unsigned int flags = pParam->getFlags();
if (panelType == eMaterialParameter || panelType == eTextureParameter)
flags |= eParameterFloatSliderEdit;
// this isn't great, but due to wanting a completely clean separation between ParameterPanels/Controls and Parameters, the easiest
// way to do things...
Control* pControl = NULL;
switch (parameterType)
{
case eParameterBool:
{
BasicParameter<bool>* pTypedParam = static_cast<BasicParameter<bool>*>(pParam);
pControl = new BoolControl(name, pTypedParam->getPairedValue(), label);
break;
}
case eParameterUInt:
{
RangeParameter<unsigned int, unsigned int>* pTypedParam = static_cast<RangeParameter<unsigned int, unsigned int>*>(pParam);
bool scrub = pTypedParam->getFlags() & eParameterScrubButton;
pControl = new UIntControl(name, pTypedParam->getPairedValue(), pTypedParam->getMin(), pTypedParam->getMax(), label, scrub);
break;
}
case eParameterFloat:
{
RangeParameter<float, float>* pTypedParam = static_cast<RangeParameter<float, float>*>(pParam);
pControl = new FloatControl(name, pTypedParam->getPairedValue(), pTypedParam->getMin(), pTypedParam->getMax(), label,
pTypedParam->getFlags());
break;
}
case eParameterFloatSlider:
{
RangeParameter<float, float>* pTypedParam = static_cast<RangeParameter<float, float>*>(pParam);
bool editControl = (flags & eParameterFloatSliderEdit);
bool logScale = (flags & eParameterFloatSliderLogScale);
bool highPrecision = (flags & eParameterFloatSliderHighPrecision);
pControl = new FloatSliderControl(name, pTypedParam->getPairedValue(), pTypedParam->getMin(), pTypedParam->getMax(),
label, editControl, logScale, highPrecision);
break;
}
case eParameterFloatPair:
{
RangeParameterPair<float, float>* pTypedParam = static_cast<RangeParameterPair<float, float>*>(pParam);
pControl = new FloatPairControl(name, pTypedParam->getPairedValue1(), pTypedParam->getPairedValue2(), pTypedParam->getMin(),
pTypedParam->getMax(), label, pTypedParam->getFlags());
break;
}
case eParameterEnum:
{
EnumParameter* pTypedParam = static_cast<EnumParameter*>(pParam);
pControl = new EnumControl(name, pTypedParam->getPairedValue(), pTypedParam->getOptions(), label);
break;
}
case eParameterColour:
{
BasicParameter<Colour3f>* pTypedParam = static_cast<BasicParameter<Colour3f>*>(pParam);
pControl = new ColourControl(name, pTypedParam->getPairedValue(), label);
break;
}
case eParameterVector:
{
RangeParameter<Vector, float>* pTypedParam = static_cast<RangeParameter<Vector, float>*>(pParam);
pControl = new VectorControl(name, pTypedParam->getPairedValue(), pTypedParam->getMin(), pTypedParam->getMax(), label);
break;
}
case eParameterFile:
{
BasicParameter<std::string>* pTypedParam = static_cast<BasicParameter<std::string>*>(pParam);
// flags for type of category
FileControl::FileCategory category = FileControl::eNormal;
if (flags & eParameterFileParamTexture)
category = FileControl::eTexture;
else if (flags & eParameterFileParamEnvMap)
category = FileControl::eEnvironmentMap;
else if (flags & eParameterFileParamVolumeBuffer)
category = FileControl::eVolumeBuffer;
pControl = new FileControl(name, pTypedParam->getPairedValue(), label, category);
break;
}
case eParameterTexture1f:
case eParameterTexture3f:
{
BasicParameter<TextureParameters>* pTypedParam = static_cast<BasicParameter<TextureParameters>*>(pParam);
pControl = new TextureControl(name, pTypedParam->getPairedValue(), label, flags);
break;
}
default:
break;
}
pSPP->addControl(pControl);
delete pParam;
}
return pSPP;
}
const std::vector<const Parameter*> ParameterOperator::setupParameters()
{
std::vector<const Parameter*> parameters;
ParameterGroup* group1 = new ParameterGroup(PARAM_GROUP_1);
group1->setTitle("Group 1");
parameters.push_back(group1);
ParameterGroup* group2 = new ParameterGroup(PARAM_GROUP_2, group1);
group2->setTitle("Group 2");
parameters.push_back(group2);
NumericParameter<Int32>* intParam = new NumericParameter<Int32>(INT_PARAM, group1);
intParam->setTitle("Integer parameter");
intParam->setMax(Int32(1000));
intParam->setMin(Int32(-1000));
intParam->setAccessMode(Parameter::INITIALIZED_WRITE);
parameters.push_back(intParam);
EnumParameter* enumParam = new EnumParameter(ENUM_PARAM, group2);
enumParam->setTitle("Enum parameter");
enumParam->setAccessMode(Parameter::ACTIVATED_WRITE);
enumParam->add(EnumDescription(Enum(0), "Choice 0"));
enumParam->add(EnumDescription(Enum(1), "Choice 1"));
enumParam->add(EnumDescription(Enum(2), "Choice 2"));
parameters.push_back(enumParam);
Parameter* boolParam = new Parameter(BOOL_PARAM, Variant::BOOL);
boolParam->setTitle("Boolean parameter");
boolParam->setAccessMode(Parameter::INITIALIZED_WRITE);
parameters.push_back(boolParam);
Parameter* matrixParam = new MatrixParameter(MATRIX_PARAM, Variant::FLOAT_32_MATRIX);
matrixParam->setTitle("Matrix parameter");
matrixParam->setAccessMode(Parameter::INITIALIZED_WRITE);
parameters.push_back(matrixParam);
MatrixParameter* intMatrixParam = new MatrixParameter(INT_MATRIX_PARAM, Variant::UINT_32_MATRIX);
intMatrixParam->setTitle("Integer matrix parameter");
intMatrixParam->setAccessMode(Parameter::INITIALIZED_WRITE);
intMatrixParam->setRows(1);
intMatrixParam->setCols(2);
parameters.push_back(intMatrixParam);
Parameter* triggerValueParam = new Parameter(TRIGGER_VALUE_PARAM, Variant::BOOL);
triggerValueParam->setTitle("Trigger value");
triggerValueParam->setAccessMode(Parameter::INITIALIZED_WRITE);
parameters.push_back(triggerValueParam);
Parameter* triggerParam = new Parameter(TRIGGER_PARAM, Variant::TRIGGER);
triggerParam->setTitle("Trigger");
triggerParam->setAccessMode(Parameter::INITIALIZED_WRITE);
triggerParam->setUpdateBehavior(Parameter::PUSH);
parameters.push_back(triggerParam);
Parameter* pushParam = new Parameter(PUSH_PARAM, Variant::FLOAT_32);
pushParam->setTitle("Push");
pushParam->setAccessMode(Parameter::INITIALIZED_WRITE);
pushParam->setUpdateBehavior(Parameter::PUSH);
parameters.push_back(pushParam);
Parameter* pullParam = new Parameter(PULL_PARAM, Variant::FLOAT_32);
pullParam->setTitle("Pull");
pullParam->setAccessMode(Parameter::INITIALIZED_READ);
pullParam->setUpdateBehavior(Parameter::PULL);
parameters.push_back(pullParam);
return parameters;
}
