void Map::initializeOverlays()
{
ResourceManager *resman = ResourceManager::getInstance();
for (int i = 0;
hasProperty("overlay" + toString(i) + "image");
i++)
{
const std::string name = "overlay" + toString(i);
Image *img = resman->getImage(getProperty(name + "image"));
const float speedX = getFloatProperty(name + "scrollX");
const float speedY = getFloatProperty(name + "scrollY");
const float parallax = getFloatProperty(name + "parallax");
const bool keepRatio = getBoolProperty(name + "keepratio");
if (img)
{
mOverlays.push_back(
new AmbientOverlay(img, parallax, speedX, speedY, keepRatio));
// The AmbientOverlay takes control over the image.
img->decRef();
}
}
}
void SpherizeOperator::process(int tick)
{
if (mesh != 0)
delete mesh;
float radius = getFloatProperty(0);
float amount = getFloatProperty(1);
mesh = getInput(0)->mesh->clone();
for (int i = 0; i < mesh->getNumVertices(); i++)
{
Vec3 p = mesh->pos(i);
Vec3 n = normalize(p) * radius;
mesh->pos(i) = p + (n - p) * amount;
}
mesh->recalculateNormals();
}
void MLMultiSlider::sendSliderAction (float val, int selector)
{
ml::Symbol sliderName = ml::textUtils::addFinalNumber("value", selector);
float currentValue = getFloatProperty(sliderName);
float newValue = constrainedValue(val);
if (currentValue != newValue)
{
ml::Symbol targetPropertyName = ml::textUtils::addFinalNumber(getTargetPropertyName(), selector);
setPropertyImmediate(sliderName, newValue);
sendAction("change_property", targetPropertyName, getProperty(sliderName));
}
}
void MLMultiSlider::paint (Graphics& g)
{
MLLookAndFeel* myLookAndFeel = (&(getRootViewResources(this).mLookAndFeel));
if (isOpaque()) myLookAndFeel->drawBackground(g, this);
float outlineThickness = myLookAndFeel->getGridUnitSize() / 64.f;
MLRect r = mPos.getLocalOutline();
const Colour outlineColor (findColour(MLLookAndFeel::outlineColor).withAlpha (isEnabled() ? 1.f : 0.5f));
// draw fills
// vertical only
Path full, empty;
Colour fullColor, emptyColor;
MLRect fullRect, emptyRect;
float dialY;
MLRange drawRange(mRange);
drawRange.convertTo(MLRange(r.height(), 0.));
for (int i=0; i<mNumSliders; ++i)
{
MLRect sr = (mPos.getElementBounds(i));
dialY = drawRange(getFloatProperty(ml::textUtils::addFinalNumber(ml::Symbol("value"), i)));
fullRect = sr;
emptyRect = sr;
fullRect.setTop(dialY);
fullColor = findColour(trackFullDarkColor);
emptyColor = findColour(trackEmptyDarkColor);
// groups of 4
if (!(i&4))
{
emptyColor = emptyColor.brighter(0.10f);
fullColor = fullColor.brighter(0.20f);
}
empty.clear();
empty.addRectangle(MLToJuceRect(emptyRect));
g.setColour(emptyColor);
g.fillPath(empty);
full.clear();
full.addRectangle(MLToJuceRect(fullRect));
g.setColour(fullColor);
g.fillPath(full);
g.setColour(outlineColor);
g.strokePath(empty, PathStrokeType (outlineThickness));
}
}
void MLMultiSlider::mouseWheelMove (const MouseEvent& e, const MouseWheelDetails& wheel)
{
// filter out zero motions from trackpad
if ((wheel.deltaX == 0.) && (wheel.deltaY == 0.)) return;
if(mCurrDragSlider >= 0) return;
bool doFineAdjust = e.mods.isShiftDown();
float wheelSpeed = doFineAdjust ? 0.1f : 1.f;
float wheelDirection = (wheel.isReversed) ? -1.f : 1.f;
if (isEnabled())
{
int s = getSliderUnderPoint(Vec2(e.x, e.y));
if ((s >= 0) && ! isMouseButtonDownAnywhere())
{
float currentVal = getFloatProperty(ml::textUtils::addFinalNumber(ml::Symbol("value"), s));
float minPosDelta = 0.01f;
float deltaDir = (wheel.deltaY > 0.f) ? 1.f : -1.f;
float posDelta = (wheel.deltaY + deltaDir*minPosDelta)*wheelSpeed*wheelDirection;
const float currentPos = valueToProportionOfLength (currentVal);
const float newPos = ml::clamp (currentPos + posDelta, 0.f, 1.f);
float newValue = proportionOfLengthToValue (newPos);
if(newValue != currentVal)
{
if(!isMouseWheelMoving)
{
isMouseWheelMoving = true;
beginGesture();
}
mpTimer->startTimer(kWheelTimeoutDuration);
mCurrDragSlider = s;
sendSliderAction(snapValue (newValue, false), s);
mpTimer->startTimer(kWheelTimeoutDuration);
mCurrDragSlider = -1;
}
}
}
else
{
Component::mouseWheelMove (e, wheel);
}
}
void MLPluginProcessor::handleHubNotification(MLSymbol action, const float val)
{
if(action == "connected")
{
int protocol = val ? kInputProtocolOSC : kInputProtocolMIDI;
setInputProtocol(protocol);
}
else if(action == "data_rate")
{
int r = val;
if(r != (int)getFloatProperty("data_rate"))
{
setProperty("data_rate", r);
getEngine()->setInputDataRate(r);
}
}
}
void MLProgressBar::paint (Graphics& g)
{
const Colour fc = findColour(MLLookAndFeel::labelColor);
const float progress = getFloatProperty("progress");
Path gbounds;
const Rectangle<int> & boundsRect (getLocalBounds());
gbounds.addRectangle(boundsRect);
MLRange xRange(0., 1., boundsRect.getX(), boundsRect.getRight());
MLRect progressRect = juceToMLRect(boundsRect);
progressRect.setRight(xRange(progress));
Rectangle<int> fullRect = MLToJuceRectInt(progressRect);
Path fullBounds;
fullBounds.addRectangle(fullRect);
g.setColour(fc);
g.fillPath(fullBounds);
g.strokePath(gbounds, PathStrokeType(1.0f));
}
void MLMenuButton::doPropertyChangeAction(MLSymbol property, const MLProperty& val)
{
if (property == "text")
{
// TODO this file-specific stuff should not be here.
std::string processedText;
const std::string str = val.getStringValue();
if(getFloatProperty("strip"))
{
processedText = stripExtension(getShortName(str));
}
else
{
processedText = str;
}
setProperty("processed_text", processedText);
repaint();
}
else
{
MLButton::doPropertyChangeAction(property, val);
}
}
void MegaExtrudeOperator::process(int tick)
{
if (mesh != 0)
delete mesh;
float distance = getFloatProperty(0);
unsigned char count = getByteProperty(1);
D3DXVECTOR3 scaleVector = getVectorProperty(2);
D3DXVECTOR3 rotationVector = getVectorProperty(3);
D3DXMATRIX scaleMatrix;
D3DXMatrixScaling(&scaleMatrix,
scaleVector.x,
scaleVector.y,
scaleVector.z);
D3DXMATRIX rotationXMatrix;
D3DXMatrixRotationX(&rotationXMatrix, rotationVector.x);
D3DXMATRIX rotationYMatrix;
D3DXMatrixRotationY(&rotationYMatrix, rotationVector.y);
D3DXMATRIX rotationZMatrix;
D3DXMatrixRotationZ(&rotationZMatrix, rotationVector.z);
D3DXMATRIX translationMatrix;
D3DXMatrixTranslation(&translationMatrix,
0.0f,
distance / (float)count,
0.0f);
D3DXMATRIX extrudeMatrix = scaleMatrix * rotationXMatrix * rotationYMatrix * rotationZMatrix * translationMatrix;
Mesh *srcMesh = getInput(0)->mesh;
int numberOfVertices = srcMesh->getNumVertices();
int numberOfQuads = srcMesh->getNumQuads();
// Calculate the new number of quads and vertices.
// The number of triangles will be unchanged.
for (int i = 0; i < srcMesh->getNumFaces(); i++)
{
int n;
int *face = srcMesh->face(i, n);
if (srcMesh->faceSelected(i))
{
numberOfQuads += n * count;
numberOfVertices += n * count;
}
}
mesh = new Mesh(numberOfVertices, srcMesh->getNumTriangles(), numberOfQuads, 1);
int triangleIndex = 0;
int quadIndex = 0;
// Copy the src mesh vertices.
for (int i = 0; i < srcMesh->getNumVertices(); i++)
{
mesh->pos(i) = srcMesh->pos(i);
}
int vertexIndex = srcMesh->getNumVertices();
// Extrude each selected face and add triangles and quads.
Vec3* lastPositions = new Vec3[4];
int* lastIndices = new int[4];
int* currentIndices = new int[4];
for (int i = 0; i < srcMesh->getNumFaces(); i++)
{
int n;
int *face = srcMesh->face(i, n);
for (int f = 0; f < n; f++)
{
lastPositions[f] = srcMesh->pos(face[f]);
lastIndices[f] = face[f];
}
if (srcMesh->faceSelected(i))
{
// Get our base vectors.
Vec3 pos1 = srcMesh->pos(face[1]);
Vec3 pos0 = srcMesh->pos(face[0]);
Vec3 faceBase1 = normalize(pos1 - pos0);
Vec3 faceBase2 = normalize(srcMesh->getFaceNormal(i));
Vec3 faceBase3 = normalize(cross(faceBase2, faceBase1));
D3DXMATRIX fromFaceBaseMatrix = D3DXMATRIX(faceBase1.x, faceBase1.y, faceBase1.z, 0.0f,
faceBase2.x, faceBase2.y, faceBase2.z, 0.0f,
faceBase3.x, faceBase3.y, faceBase3.z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
D3DXMATRIX toFaceBaseMatrix = D3DXMATRIX(faceBase1.x, faceBase2.x, faceBase3.x, 0.0f,
faceBase1.y, faceBase2.y, faceBase3.y, 0.0f,
faceBase1.z, faceBase2.z, faceBase3.z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
D3DXMATRIX toFaceBaseAndOrigoMatrix = toFaceBaseMatrix;
D3DXMATRIX fromFaceBaseAndToFaceMatrix = extrudeMatrix * fromFaceBaseMatrix;
for (int c = 0; c < count; c++)
{
for (int f = 0; f < n; f++)
{
Vec3 pos = lastPositions[f];
Vec3 posInFaceBase;
D3DXVec3TransformCoord(&posInFaceBase, &pos, &toFaceBaseAndOrigoMatrix);
Vec3 posTransformed;
D3DXVec3TransformCoord(&posTransformed, &posInFaceBase, &fromFaceBaseAndToFaceMatrix);
mesh->pos(vertexIndex) = posTransformed;
currentIndices[f] = vertexIndex;
lastPositions[f] = posTransformed;
vertexIndex++;
}
for (int f = 0; f < n; f++)
{
mesh->setQuad(quadIndex,
lastIndices[f],
lastIndices[(f + 1) % n],
currentIndices[(f + 1) % n],
currentIndices[f]);
quadIndex++;
}
for (int f = 0; f < n; f++)
{
lastIndices[f] = currentIndices[f];
}
}
}
if (n == 3)
{
mesh->setTriangle(triangleIndex, lastIndices[0], lastIndices[1], lastIndices[2]);
triangleIndex++;
}
else
{
mesh->setQuad(quadIndex, lastIndices[0], lastIndices[1], lastIndices[2], lastIndices[3]);
quadIndex++;
}
}
delete[] lastIndices;
delete[] currentIndices;
delete[] lastPositions;
mesh->recalculateNormals();
}
void MLPluginProcessor::getStateAsXML (XmlElement& xml)
{
if( !(mEngine.getCompileStatus() == MLProc::OK)) return;
#if DEMO
xml.setAttribute ("pluginVersion", JucePlugin_VersionCode);
xml.setAttribute ("presetName", String("----"));
#else
const unsigned numParams = getNumParameters();
// TODO use string properties of model instead of these JUCE strings.
// also move to JSON.
xml.setAttribute ("pluginVersion", JucePlugin_VersionCode);
xml.setAttribute ("presetName", String(getStringProperty("preset").c_str()));
xml.setAttribute ("scaleName", String(getStringProperty("key_scale").c_str()));
// store parameter values to xml as a bunch of attributes.
// not XML best practice in general but takes fewer characters.
for(unsigned i=0; i<numParams; ++i)
{
const String paramName = symbolToXMLAttr(getParameterAlias(i));
const float defaultVal = getParameterDefault(i);
const float paramVal = getParameter(i);
if (paramVal != defaultVal)
{
xml.setAttribute(paramName, paramVal);
//debug() << "setting XML param " << paramName << " to " << paramVal << "\n";
}
}
// store patcher info to xml
{
MLProcList patchers = getPatcherList();
if (!patchers.empty())
{
MLProcPatcher& firstPatcher = static_cast<MLProcPatcher&>(**patchers.begin());
const int inputs = firstPatcher.getParam("inputs");
const int outputs = firstPatcher.getParam("outputs");
String outStr;
String patcherInput = "patcher_input_";
for(unsigned i=1; i<=inputs; ++i)
{
bool differentFromDefault = false;
outStr = "";
for(unsigned j=1; j<=outputs; ++j)
{
if (firstPatcher.getConnection(i, j))
{
outStr += "1";
differentFromDefault = true;
}
else
{
outStr += "0";
}
}
if(differentFromDefault)
{
String outNum (i);
xml.setAttribute(patcherInput + outNum, outStr);
}
}
}
}
// store editor state to XML if one exists
MLPluginEditor* pEditor = static_cast<MLPluginEditor*>(getActiveEditor());
if(pEditor)
{
MLRect r = pEditor->getWindowBounds();
xml.setAttribute("editor_x", r.x());
xml.setAttribute("editor_y", r.y());
xml.setAttribute("editor_width", r.getWidth());
xml.setAttribute("editor_height", r.getHeight());
xml.setAttribute("editor_num", getFloatProperty("patch_num"));
xml.setAttribute("editor_anim", getFloatProperty("patch_anim"));
}
// save blob as most recently saved state
mpLatestStateLoaded = XmlElementPtr(new XmlElement(xml));
#endif
}
void Map::initializeAmbientLayers()
{
ResourceManager *resman = ResourceManager::getInstance();
// search for "foreground*" or "overlay*" (old term) in map properties
for (int i = 0; /* terminated by a break */; i++)
{
std::string name;
if (hasProperty("foreground" + toString(i) + "image"))
{
name = "foreground" + toString(i);
}
else if (hasProperty("overlay" + toString(i) + "image"))
{
name = "overlay" + toString(i);
}
else
{
break; // the FOR loop
}
Image *img = resman->getImage(getProperty(name + "image"));
const float speedX = getFloatProperty(name + "scrollX");
const float speedY = getFloatProperty(name + "scrollY");
const float parallax = getFloatProperty(name + "parallax");
const bool keepRatio = getBoolProperty(name + "keepratio");
if (img)
{
mForegrounds.push_back(
new AmbientLayer(img, parallax, speedX, speedY, keepRatio));
// The AmbientLayer takes control over the image.
img->decRef();
}
}
// search for "background*" in map properties
for (int i = 0;
hasProperty("background" + toString(i) + "image");
i++)
{
const std::string name = "background" + toString(i);
Image *img = resman->getImage(getProperty(name + "image"));
const float speedX = getFloatProperty(name + "scrollX");
const float speedY = getFloatProperty(name + "scrollY");
const float parallax = getFloatProperty(name + "parallax");
const bool keepRatio = getBoolProperty(name + "keepratio");
if (img)
{
mBackgrounds.push_back(
new AmbientLayer(img, parallax, speedX, speedY, keepRatio));
// The AmbientLayer takes control over the image.
img->decRef();
}
}
}
void CylinderOperator::process(int tick)
{
if (mesh != 0)
delete mesh;
float radius1 = getFloatProperty(0);
float radius2 = getFloatProperty(1);
float length = getFloatProperty(2);
int slices = getByteProperty(3);
int stacks = getByteProperty(4);
int capCircles1 = (radius1 == 0.0f ? 0 : getByteProperty(5));
int capCircles2 = (radius2 == 0.0f ? 0 : getByteProperty(6));
int capVerts1 = capCircles1 == 0 ? 0 : capCircles1 * slices + 1;
int capQuads1 = capCircles2 == 0 ? 0 : capCircles1 * slices;
int capTriangles1 = slices;
int capVerts2 = capCircles2 == 0 ? 0 : capCircles2 * slices + 1;
int capQuads2 = capCircles2 * slices;
int capTriangles2 = capCircles2 == 0 ? 0 :slices;
int mantleVerts = stacks == 0 ? 0 : (stacks + 1) * (slices + 1);
int mantleQuads = stacks * slices;
mesh = new Mesh(capVerts1 + capVerts2 + mantleVerts, capTriangles1 + capTriangles2, capQuads1 + capQuads2 + mantleQuads);
int capVertBase1 = mantleVerts;
int capVertBase2 = mantleVerts + capVerts1;
int capQuadBase1 = mantleQuads;
int capQuadBase2 = mantleQuads + capQuads1;
if (mantleVerts > 0)
{
int vert = 0, quad = 0;
for (int x = 0; x <= slices; x++)
{
float u = x / (float)slices;
Vec2 p(cos(u * 2 * M_PI), sin(u * 2 * M_PI));
for (int y = 0; y <= stacks; y++)
{
float v = y / (float)stacks;
float r = radius1 + (radius2 - radius1) * v;
mesh->pos(vert) = Vec3(p.x * r, v * length, p.y * r);
mesh->normal(vert) = Vec3(p.x, 0.0f, p.y);
mesh->uv(vert) = Vec2(u, 1.0f - v);
if (x != slices && y != stacks)
{
mesh->setQuad(quad, vert, vert + 1, vert + stacks + 2, vert + stacks + 1);
quad++;
}
vert++;
}
}
}
int tri = 0;
int circles = capCircles1;
int vertBase = capVertBase1;
float radius = radius1;
int quad = capQuadBase1;
float h = 0.0f;
Vec3 n = Vec3(0.0f, -1.0f, 0.0f);
bool inv = false;
for (int i = 0; i < 2; i++)
{
int vert = 0;
if (circles)
{
for (int x = 0; x < slices; x++)
{
float u = (inv ? slices - x - 1 : x) / (float)slices;
for (int y = 0; y < circles; y++)
{
float v = 1.0f - y / (float)circles;
float r = v * radius;
Vec2 p(cos(u * 2 * M_PI), sin(u * 2 * M_PI));
mesh->pos(vert + vertBase) = Vec3(p.x * r, h, p.y * r);
mesh->normal(vert + vertBase) = n;
Vec2 uv = (p * v + Vec2(1.0f, 1.0f)) * 0.5f;
mesh->uv(vert + vertBase) = Vec2(uv.x, inv ? 1.0f - uv.y : uv.y);
if (y != circles - 1)
{
int x2 = (x + 1) % slices;
int y2 = (y + 1) % circles;
int v1 = x * circles + y;
int v2 = x2 * circles + y;
int v3 = x2 * circles + y2;
int v4 = x * circles + y2;
mesh->setQuad(quad, v1 + vertBase, v2 + vertBase, v3 + vertBase, v4 + vertBase);
quad++;
}
else
{
int x2 = (x + 1) % slices;
int v1 = x * circles + y;
int v2 = x2 * circles + y;
int v3 = slices * circles;
mesh->setTriangle(tri, v1 + vertBase, v2 + vertBase, v3 + vertBase);
tri++;
}
vert++;
}
}
mesh->pos(vert + vertBase) = Vec3(0.0f, h, 0.0f);
mesh->normal(vert + vertBase) = n;
mesh->uv(vert + vertBase) = Vec2(0.5f, 0.5f);
vert++;
}
circles = capCircles2;
vertBase = capVertBase2;
radius = radius2;
quad = capQuadBase2;
h = length;
n = Vec3(0.0f, 1.0f, 0.0f);
inv = true;
}
}
void Map::initializeAmbientLayers()
{
ResourceManager *const resman = ResourceManager::getInstance();
// search for "foreground*" or "overlay*" (old term) in map properties
for (int i = 0; /* terminated by a break */; i++)
{
std::string name;
if (hasProperty(std::string("foreground").append(
toString(i)).append("image")))
{
name = "foreground" + toString(i);
}
else if (hasProperty(std::string("overlay").append(
toString(i)).append("image")))
{
name = "overlay" + toString(i);
}
else
{
break; // the FOR loop
}
Image *const img = resman->getImage(getProperty(name + "image"));
if (img)
{
int mask = atoi(getProperty(name + "mask").c_str());
if (!mask)
mask = 1;
const float parallax = getFloatProperty(name + "parallax");
mForegrounds.push_back(new AmbientLayer(img,
getFloatProperty(name + "parallaxX", parallax),
getFloatProperty(name + "parallaxY", parallax),
getFloatProperty(name + "posX"),
getFloatProperty(name + "posY"),
getFloatProperty(name + "scrollX"),
getFloatProperty(name + "scrollY"),
getBoolProperty(name + "keepratio"),
mask));
// The AmbientLayer takes control over the image.
img->decRef();
}
}
// search for "background*" in map properties
for (int i = 0; hasProperty(std::string("background").append(
toString(i)).append("image")); i ++)
{
const std::string name("background" + toString(i));
Image *const img = resman->getImage(getProperty(name + "image"));
if (img)
{
int mask = atoi(getProperty(name + "mask").c_str());
if (!mask)
mask = 1;
const float parallax = getFloatProperty(name + "parallax");
mForegrounds.push_back(new AmbientLayer(img,
getFloatProperty(name + "parallaxX", parallax),
getFloatProperty(name + "parallaxY", parallax),
getFloatProperty(name + "posX"),
getFloatProperty(name + "posY"),
getFloatProperty(name + "scrollX"),
getFloatProperty(name + "scrollY"),
getBoolProperty(name + "keepratio"),
mask));
// The AmbientLayer takes control over the image.
img->decRef();
}
}
}
void SoundplaneModel::doPropertyChangeAction(MLSymbol p, const MLProperty & newVal)
{
// debug() << "SoundplaneModel::doPropertyChangeAction: " << p << " -> " << newVal << "\n";
int propertyType = newVal.getType();
switch(propertyType)
{
case MLProperty::kFloatProperty:
{
float v = newVal.getFloatValue();
if (p.withoutFinalNumber() == MLSymbol("carrier_toggle"))
{
// toggles changed -- mute carriers
unsigned long mask = 0;
for(int i=0; i<32; ++i)
{
MLSymbol tSym = MLSymbol("carrier_toggle").withFinalNumber(i);
bool on = (int)(getFloatProperty(tSym));
mask = mask | (on << i);
}
mCarriersMask = mask;
mCarrierMaskDirty = true; // trigger carriers set in a second or so
}
else if (p == "all_toggle")
{
bool on = (bool)(v);
for(int i=0; i<32; ++i)
{
MLSymbol tSym = MLSymbol("carrier_toggle").withFinalNumber(i);
setProperty(tSym, on);
}
mCarriersMask = on ? ~0 : 0;
mCarrierMaskDirty = true; // trigger carriers set in a second or so
}
else if (p == "max_touches")
{
mTracker.setMaxTouches(v);
mMIDIOutput.setMaxTouches(v);
mOSCOutput.setMaxTouches(v);
}
else if (p == "lopass")
{
mTracker.setLopass(v);
}
else if (p == "z_thresh")
{
mTracker.setThresh(v);
}
else if (p == "z_max")
{
mTracker.setMaxForce(v);
}
else if (p == "z_curve")
{
mTracker.setForceCurve(v);
}
else if (p == "snap")
{
sendParametersToZones();
}
else if (p == "vibrato")
{
sendParametersToZones();
}
else if (p == "lock")
{
sendParametersToZones();
}
else if (p == "data_freq_midi")
{
// TODO attribute
mMIDIOutput.setDataFreq(v);
}
else if (p == "data_freq_osc")
{
// TODO attribute
mOSCOutput.setDataFreq(v);
}
else if (p == "midi_active")
{
mMIDIOutput.setActive(bool(v));
}
else if (p == "midi_multi_chan")
{
mMIDIOutput.setMultiChannel(bool(v));
}
else if (p == "midi_start_chan")
{
mMIDIOutput.setStartChannel(int(v));
}
else if (p == "midi_pressure_active")
{
mMIDIOutput.setPressureActive(bool(v));
}
else if (p == "osc_active")
{
bool b = v;
mOSCOutput.setActive(b);
listenToOSC(b ? kDefaultUDPReceivePort : 0);
}
else if (p == "osc_send_matrix")
{
bool b = v;
mSendMatrixData = b;
}
else if (p == "t_thresh")
{
mTracker.setTemplateThresh(v);
}
else if (p == "bg_filter")
{
mTracker.setBackgroundFilter(v);
}
else if (p == "quantize")
{
bool b = v;
mTracker.setQuantize(b);
sendParametersToZones();
}
else if (p == "rotate")
{
bool b = v;
mTracker.setRotate(b);
}
else if (p == "retrig")
{
mMIDIOutput.setRetrig(bool(v));
sendParametersToZones();
}
else if (p == "hysteresis")
{
mMIDIOutput.setHysteresis(v);
sendParametersToZones();
}
else if (p == "transpose")
{
sendParametersToZones();
}
else if (p == "bend_range")
{
mMIDIOutput.setBendRange(v);
sendParametersToZones();
}
else if (p == "debug_pause")
{
debug().setActive(!bool(v));
}
else if (p == "kyma_poll")
{
mMIDIOutput.setKymaPoll(bool(v));
}
}
break;
case MLProperty::kStringProperty:
{
const std::string& str = newVal.getStringValue();
if (p == "viewmode")
{
// nothing to do for Model
}
else if (p == "midi_device")
{
mMIDIOutput.setDevice(str);
}
else if (p == "zone_JSON")
{
loadZonesFromString(str);
}
}
break;
case MLProperty::kSignalProperty:
{
const MLSignal& sig = newVal.getSignalValue();
if(p == MLSymbol("carriers"))
{
// get carriers from signal
assert(sig.getSize() == kSoundplaneSensorWidth);
for(int i=0; i<kSoundplaneSensorWidth; ++i)
{
mCarriers[i] = sig[i];
}
mNeedsCarriersSet = true;
}
if(p == MLSymbol("tracker_calibration"))
{
mTracker.setCalibration(sig);
}
if(p == MLSymbol("tracker_normalize"))
{
mTracker.setNormalizeMap(sig);
}
}
break;
default:
break;
}
}
void MLEnvelope::paint (Graphics& g)
{
float mDelay = getFloatProperty("delay");
float mAttack = getFloatProperty("attack");
float mSustain = getFloatProperty("sustain");
float mDecay = getFloatProperty("decay");
float mRelease = getFloatProperty("release");
float r = getFloatProperty("repeat");
float mRepeat = (r > 0.f) ? (1.f / (r + 0.0001f)) : 0.f;
MLLookAndFeel* myLookAndFeel = (&(getRootViewResources(this).mLookAndFeel));
if (isOpaque())
myLookAndFeel->drawBackground(g, this);
float margin = myLookAndFeel->getSmallMargin() * myLookAndFeel->getGridUnitSize();
int w = getWidth()-1;
int h = getHeight()-1;
float totalTime;
float startX, delX, attX, decX, susX, relX, repX, endX;
float attTime, decTime, relTime, susTime;
float leadIn = 0.01;
float leadOut = 0.01;
float susHeight;
float epsilon = 0.0005;
float susLevel = mDARMode ? 1.0f : mSustain;
attTime = mAttack + kMinAttack;
decTime = mDecay * (1.f - susLevel) + kMinDecay;
relTime = mRelease * susLevel + kMinDecay;
// get times
if (mDARMode)
{
susTime = (mSustain > 0.5) ? 1.f : 0.f; // is hold on?
decTime = 0.;
totalTime = leadIn + mDelay + attTime + susTime + relTime + leadIn + leadOut;
}
else
{
susTime = 1.f;
totalTime = leadIn + attTime + decTime + susTime + relTime + leadIn + leadOut;
}
if (mRepeat > epsilon)
{
totalTime = ml::max(totalTime, (float)(leadIn + mDelay + mRepeat + leadOut));
}
totalTime = ml::max(totalTime, 0.01f);
// get dims
MLRange vRange(UnityRange);
MLRange wRange(0.f, totalTime);
vRange.convertTo(MLRange(h - margin, margin));
wRange.convertTo(MLRange(margin, w - margin*2));
float t = 0.;
startX = wRange(0.);
delX = wRange(t += mDelay);
attX = wRange(t += attTime);
decX = wRange(t += decTime);
susX = wRange(t += susTime);
relX = wRange(t += relTime);
endX = wRange(totalTime);
repX = wRange(leadIn + mDelay + mRepeat);
susHeight = vRange(susLevel);
// draw env shape
Path envPath;
envPath.startNewSubPath(startX, floor(h - margin) + 0.5);
envPath.lineTo(delX, floor(h - margin) + 0.5);
envPath.quadraticTo(delX, floor(margin) + 0.5, attX, floor(margin) + 0.5); // up
envPath.quadraticTo(attX, floor(susHeight) + 0.5, decX, floor(susHeight) + 0.5); // down
envPath.quadraticTo(decX, floor(susHeight) + 0.5, susX, floor(susHeight) + 0.5); // across
envPath.quadraticTo(susX, floor(h - margin) + 0.5, relX, floor(h - margin) + 0.5); // down
envPath.quadraticTo(relX, floor(h - margin) + 0.5, endX, floor(h - margin) + 0.5); // across
g.setColour(findColour(MLLookAndFeel::outlineColor));
g.strokePath(envPath, PathStrokeType (mOutlineThickness));
g.setColour(findColour(MLLookAndFeel::outlineColor).withAlpha(0.125f));
g.fillPath(envPath);
// lines down
envPath.clear();
envPath.startNewSubPath(attX, floor(margin) + 0.5);
envPath.lineTo(attX, floor(h - margin) + 0.5);
envPath.startNewSubPath(decX, floor(susHeight) + 0.5);
envPath.lineTo(decX, floor(h - margin) + 0.5);
envPath.startNewSubPath(susX, floor(susHeight) + 0.5);
envPath.lineTo(susX, floor(h - margin) + 0.5);
g.setColour(findColour(MLLookAndFeel::outlineColor));
g.strokePath(envPath, PathStrokeType (mOutlineThickness / 2));
// draw repeat bracket
if (mRepeat > epsilon)
{
float thick = margin / 2;
float high = margin * 1.5;
envPath.clear();
envPath.startNewSubPath(floor(delX - thick/2) , floor(h - margin - high));
envPath.lineTo(floor(delX - thick/2) , floor(h - margin));
envPath.lineTo(floor( repX + thick/2) , floor(h - margin));
envPath.lineTo(floor( repX + thick/2) , floor(h - margin - high));
g.strokePath(envPath, PathStrokeType (mOutlineThickness * 4));
}
//debug() << "DEL " << mDelay << " ATT " << attTime << " DEC " << decTime << " SUS " << susTime << " REL " << relTime << " REP " << mRepeat << "\n";
//debug() << "repeatX: " << repX << " delayX: " << delX << "\n";
/*
// TEST
Path tbounds;
const Rectangle<int> & boundsRect ( getLocalBounds());
tbounds.addRectangle(boundsRect);
g.setColour(Colours::red);
g.strokePath(tbounds, PathStrokeType(0.5f));
*/
}
void TwoDimensionalPlaneOperator::render()
{
for (int i = 0; i < numberOfInputs; i++)
getInput(i)->render();
Texture* inputTexture = 0;
if (getInput(0) != 0)
inputTexture = getInput(0)->texture;
D3DXMATRIX lastViewMatrix;
D3DXMATRIX lastProjectionMatrix;
globalDirect3DDevice->GetTransform(D3DTS_VIEW, &lastViewMatrix);
globalDirect3DDevice->GetTransform(D3DTS_PROJECTION, &lastProjectionMatrix);
globalDirect3DDevice->SetTransform(D3DTS_VIEW, &identityMatrix);
globalDirect3DDevice->SetTransform(D3DTS_WORLD, &identityMatrix);
globalDirect3DDevice->SetTransform(D3DTS_PROJECTION, &projectionMatrix);
DWORD lastLightning;
globalDirect3DDevice->GetRenderState(D3DRS_LIGHTING, &lastLightning);
globalDirect3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
D3DXCOLOR color = getColorProperty(0);
color.a = getByteProperty(1) / 255.0f;
float x = getFloatProperty(2);
float width = getFloatProperty(3);
float y = getFloatProperty(4);
float height = getFloatProperty(5);
float z = getFloatProperty(6);
float uOffset = getFloatProperty(7);
float vOffset = getFloatProperty(8);
float uScale = getFloatProperty(9);
float vScale = getFloatProperty(10);
float ratio = (globalWindowHeight / (float)globalWindowWidth) / 4.0f;
float u1 = -ratio + uOffset;
float u2 = 1.0f + ratio + uOffset;
float v1 = vOffset;
float v2 = 1.0f + vOffset;
if (getByteProperty(11) == 1)
{
u1 = 0.0f;
u2 = 1.0f;
v1 = 0.0f;
v2 = 1.0f;
globalDirect3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
globalDirect3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
globalDirect3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSW, D3DTADDRESS_WRAP);
}
else
{
globalDirect3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
globalDirect3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
globalDirect3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSW, D3DTADDRESS_BORDER);
}
u1 *= uScale;
u2 *= uScale;
v1 *= vScale;
v2 *= vScale;
TwoDimensionalVertex quad[4];
quad[0].x = x;
quad[0].y = y;
quad[0].z = z;
quad[0].u = u1;
quad[0].v = v1;
quad[0].color = color;
quad[1].x = x + width;
quad[1].y = y;
quad[1].z = z;
quad[1].u = u2;
quad[1].v = v1;
quad[1].color = color;
quad[2].x = x + width;
quad[2].y = y + height;
quad[2].z = z;
quad[2].u = u2;
quad[2].v = v2;
quad[2].color = color;
quad[3].x = x;
quad[3].y = y + height;
quad[3].z = z;
quad[3].u = u1;
quad[3].v = v2;
quad[3].color = color;
DWORD oldFVF;
globalDirect3DDevice->GetFVF(&oldFVF);
globalDirect3DDevice->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1);
globalDirect3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
globalDirect3DDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
globalDirect3DDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
globalDirect3DDevice->SetRenderState(D3DRS_BLENDOP,D3DBLENDOP_ADD);
if (inputTexture != 0)
globalDirect3DDevice->SetTexture(0, inputTexture->getD3D9Texture());
globalDirect3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &quad, sizeof(TwoDimensionalVertex));
globalDirect3DDevice->SetTexture(0, 0);
globalDirect3DDevice->SetFVF(oldFVF);
globalDirect3DDevice->SetTransform(D3DTS_PROJECTION, &lastProjectionMatrix);
globalDirect3DDevice->SetTransform(D3DTS_VIEW, &lastViewMatrix);
globalDirect3DDevice->GetRenderState(D3DRS_LIGHTING, &lastLightning);
}
