//------------------------------------------------------------------------------------
void vectorField::addNoise( float _scale ,float _speed, float _turbulence, bool _signed){
float t = ofGetElapsedTimef() * 0.5;
for (int i = 0; i < fieldWidth; i++){
for (int j = 0; j < fieldHeight; j++){
// pos in array
int pos = j * fieldWidth + i;
float normx = ofNormalize(i, 0, fieldWidth);
float normy = ofNormalize(j, 0, fieldHeight);
float u, v;
if (_signed){
u = ofSignedNoise(t + TWO_PI, normx * _turbulence + TWO_PI, normy * _turbulence + TWO_PI);
v = ofSignedNoise(t - TWO_PI, normx * _turbulence - TWO_PI, normy * _turbulence + TWO_PI);
} else {
u = ofNoise(t + TWO_PI, normx * _turbulence + TWO_PI, normy * _turbulence + TWO_PI);
v = ofNoise(t - TWO_PI, normx * _turbulence - TWO_PI, normy * _turbulence + TWO_PI);
}
ofPoint force = ofPoint(u,v,0.0) ;
field[ pos ] = field[ pos ] * (1.0-_scale) + force * _scale;
}
}
}
//--------------------------------------------------------------
ofVec2f testApp::getField(ofVec2f position) {
float normx = ofNormalize(position.x, 0, ofGetWidth());
float normy = ofNormalize(position.y, 0, ofGetHeight());
float u = ofNoise(t + phase, normx * complexity + phase, normy * complexity + phase);
float v = ofNoise(t - phase, normx * complexity - phase, normy * complexity + phase);
return ofVec2f(u, v);
}
ofPoint ofApp::noiseField(ofPoint position) {
float normx = ofNormalize(position.x, 0, ofGetWidth());
float normy = ofNormalize(position.y, 0, ofGetHeight());
float u = ofNoise(t + phase, normx * jitter + phase, normy * jitter + phase);
float v = ofNoise(t - phase, normx * jitter - phase, normy * jitter + phase);
return ofPoint(u, v);
}
ofVec2f ofApp::getField(ofVec2f position) {
float normx = ofNormalize(position.x, 0, width);
float normy = ofNormalize(position.y, 0, height);
float u = ofNoise(t + phase, normx * complexity + phase, normy * complexity + phase);
float v = ofNoise(t - phase, normx * complexity - phase, normy * complexity + phase);
return ofVec2f(u, v);
}
//--------------------------------------------------------------
ofVec2f NoiseMachine::getField(ofVec2f position) {
float normx = ofNormalize(position.x, 0, ofGetWidth());
float normy = ofNormalize(position.y, 0, ofGetHeight());
float u = ofNoise(t + phase / phaseDivider, normx * noiseComplexity + phase / phaseDivider, normy * noiseComplexity + phase / phaseDivider);
float v = ofNoise(t - phase / phaseDivider, normx * noiseComplexity - phase / phaseDivider, normy * noiseComplexity + phase / phaseDivider);
return ofVec2f(u, v);
}
ofPoint ofApp::getField(ofPoint position) {
float phase = TWO_PI;
float normx = ofNormalize(position.x, 0, vidWidth);
float normy = ofNormalize(position.y, 0, vidHeight);
float u = ofNoise(noiset + phase, normx * 3 + phase, normy * 3 + phase);
float v = ofNoise(noiset - phase, normx * 3 - phase, normy * 3 + phase);
return ofVec2f(u, v);
}
void ofxEQ::updateFFTAnalyzer (float * currentArr, float * finalArr, float * finalAverageArr, float * finalArrPreview, float * finalAverageArrPreview) {
float avg_power = 0.0f;
/* do the FFT */
myfft.powerSpectrum(0,(int)BUFFER_SIZE/2, currentArr,BUFFER_SIZE,&magnitude[0],&phase[0],&power[0],&avg_power);
for (int i = 0; i < (int)(BUFFER_SIZE/2); i++){
freq[i] = magnitude[i];
}
FFTanalyzer.calculate(freq);
float numOfAverages = FFTanalyzer.nAverages;
int step = int( BUFFER_SIZE / numOfAverages);
int count = 0;
float tempArr[BUFFER_SIZE];
float tempArrAvg[BUFFER_SIZE];
float tempArrPreview[BUFFER_SIZE];
float tempArrAvgPreview[BUFFER_SIZE];
while ( count < numOfAverages) {
int start, end, i;
start = step * count;
end = start + step;
if ( count == numOfAverages - 1 ) end = BUFFER_SIZE;
for ( i = start; i < end; i++){
tempArrAvg[i] = ofNormalize(FFTanalyzer.peaks[count]/50,0, 1);
tempArr[i] = ofNormalize(FFTanalyzer.averages[count]/50, 0, 1);
tempArrAvgPreview[i] = ofNormalize(FFTanalyzer.peaks[count]/50,0, 1);
tempArrPreview[i] = ofNormalize(FFTanalyzer.averages[count]/50, 0, 1);
}
count++;
}
applyRange(tempArr,tempArrPreview);
applyRange(tempArrAvg,tempArrAvgPreview);
for (int i= 0; i<BUFFER_SIZE; i++ ) {
finalArr[i] = tempArr[i];
finalAverageArr[i] = tempArrAvg[i];
finalArrPreview[i] = tempArrPreview[i];
finalAverageArrPreview[i] = tempArrAvgPreview[i];
}
}
//---------------------------------------------------------------
void audioInputChannel::normalizeValues(){
// volume detection
_osc_chVolume = ofNormalize(_s_chVolume,0.0f,10.0f);
// pitch detection
_osc_chPitch = ofNormalize(_s_chPitch,20.0f,20000.0f);
// bark scale bins
for(unsigned int i=0;i<BARK_SCALE_CRITICAL_BANDS;i++){
_osc_barkBins[i] = hardClip(_s_barkBins[i]);
}
}
//--------------------------------------------------------------
//用perlinz杂来制造一个矢量场
ofVec2f ofApp::getField(ofVec2f position) {
// ofNormalize()只不过把一个数字在最小和最大的范围内重新规范为0至1
float normx = ofNormalize(position.x, 0, ofGetWidth());
float normy = ofNormalize(position.y, 0, ofGetHeight());
// 这些计算没什么理论的根据不要看得太细，致使试验后表现出最有趣的图案
float u = ofNoise(t + phase, normx * complexity + phase, normy * complexity + phase);
float v = ofNoise(t - phase, normx * complexity - phase, normy * complexity + phase);
return ofVec2f(u, v);
}
void mousePressed(int x, int y, int button) {
x /= globalScale;
y /= globalScale;
canvas.mousePressed(x, y, button);
side.mousePressed(x, y, button);
// cout << btnHelpPos.distance(ofPoint(x,y)) << endl;
if (btnHelpPos.distance(ofPoint(x,y))<btnHelp.width/2) showHelp();
if (btnNew.hitTest(x,y)) { files.cur=-1; canvas.clear(); files.unloadFile(); }
if (btnSave.hitTest(x,y)) files.save();
if (btnLoadPrevious.hitTest(x,y)) files.loadPrevious();
if (btnLoadNext.hitTest(x,y)) files.loadNext();
if (btnPrint.hitTest(x,y)) print();
if (btnStop.hitTest(x,y)) stop();
if (btnOops.hitTest(x,y)) { btnOops.selected=true; }
if (btnZoomIn.hitTest(x,y)) btnZoomIn.selected=true;
if (btnZoomOut.hitTest(x,y)) btnZoomOut.selected=true;
if (btnHigher.hitTest(x,y)) btnHigher.selected=true;
if (btnLower.hitTest(x,y)) btnLower.selected=true;
if (btnTwistLeft.hitTest(x,y)) btnTwistLeft.selected=true;
if (btnTwistRight.hitTest(x,y)) btnTwistRight.selected=true;
if (shapeButtons.inside(x,y)) {
int index = ofNormalize(x,shapeButtons.x,shapeButtons.x+shapeButtons.width) * shapeString.size();
side.setShape(shapeString.at(index));
}
}
void BPMTapper::update() {
float beatStartTime = _timer.getSeconds();
_beatTime = beatStartTime / _lengthOfBeat;
_beatPerc = _beatTime - static_cast<int>(_beatTime);
float lerpSpeed;
if(beatStartTime < kBeatLerpSeconds) {
lerpSpeed = ofNormalize(beatStartTime, 0, kBeatLerpSeconds);
printf("lerpSpeed: %f\n", lerpSpeed);
} else {
lerpSpeed = 1;
}
sin1 += (beatSinS(1) - sin1) * lerpSpeed;
sin2 += (beatSinS(2) - sin2) * lerpSpeed;
sin4 += (beatSinS(4) - sin4) * lerpSpeed;
sin8 += (beatSinS(8) - sin8) * lerpSpeed;
sin16 += (beatSinS(16) - sin16) * lerpSpeed;
cos1 += (beatCosS(1) - cos1) * lerpSpeed;
cos2 += (beatCosS(2) - cos2) * lerpSpeed;
cos4 += (beatCosS(4) - cos4) * lerpSpeed;
cos8 += (beatCosS(8) - cos8) * lerpSpeed;
cos16 += (beatCosS(16) - cos16) * lerpSpeed;
}
//--------------------------------------------------------------
void ofxMuiKnob::onPress() {
registerMousePosition(mousePosition);
float nv = getNormalizedKnobPosition();
if(getBounds().isBounded()) {
if(isRangeEnabled() && isShiftPressed()) {
if(isCtrlPressed()) {
setRightOrLeftRangeLimit(nv);
} else {
setClosestRangeLimit(nv);
}
} else if(isRangeEnabled() && isCtrlPressed()) {
normCtrlDragStartMin = getNormalizedRangeMin();
normCtrlDragStartMax = getNormalizedRangeMax();
} else {
setNormalizedValue(nv);
}
} else {
//setNormalizedValue(nv);
ofVec2f v = screenToHitBox(mousePosition);
float d = v.distance(getHitBoxCenter());
float ds = ofNormalize(d,0,getHitBoxWidth()*2.0f) * 10.0f;
add(ds*dKnobScaler*dKnobAngle);
}
}
void G_CircularSlider::dragSlider(int x, int y){
if(isMovingScrollThumb){
prevX=x;
angle=ofClamp(angle+((y-prevY)), 0, 360.0);
prevY=y;
response=ofNormalize(scrollPosition, 0, this->height-(this->width));
dispatchOnDrag(response);
}
}
void mouseMoved(int x, int y) {
x /= globalScale;
y /= globalScale;
if (shapeButtons.inside(x,y)) {
previewShape = shapeString.at(ofNormalize(x,shapeButtons.x,shapeButtons.x+shapeButtons.width) * shapeString.size());
} else {
previewShape = 0;
}
}
void Page::setHandAt(ofPoint _hand, float lerpPct){
if ( inside(_hand) ){
hand.x = ofLerp(hand.x,ofNormalize(_hand.x, x, x+width),lerpPct);
hand.y = ofLerp(hand.y,ofNormalize(_hand.y, y, y+height),lerpPct);
bChange = true;
} else {
if ( (hand != ofPoint(1.0,1.0)) && ( hand != ofPoint(0.0,0.5))){
if (hand.x >= 0.5){
hand.x = ofLerp(hand.x, 1.0, lerpPct);
hand.y = ofLerp(hand.y, 1.0, lerpPct);
} else {
hand.x = ofLerp(hand.x, 0.0, lerpPct);
hand.y = ofLerp(hand.y, 0.5, lerpPct);
}
bChange = true;
}
}
}
void G_CircularRangeSlider::dragSlider(int x, int y){
if(isMovingScrollThumb){
//printf("dragging!!!");
float range=(highAngle-lowAngle+((x-prevX)));
prevX=x;
range=fmin(fmax(range, 0), 360);
lowAngle=ofClamp(lowAngle+((y-prevY)), 0, 360.0-range);
prevY=y;
highAngle=lowAngle+range;
response=ofNormalize(scrollPosition, 0, this->height-(this->width));
dispatchOnDrag(response);
}
}
kinectCapture::kinectCapture() {
//SETUP NORMALIZATION TABLES
for (int i = 0 ; i < 640 ; i++) {
norm640[i] = ofNormalize(i, 640, 640);
}
for (int i = 0; i < 480; i++) {
norm480[i] = ofNormalize(i, 0, 480);
}
for (int i = 0; i < 960; i++) {
norm960[i] = ofNormalize(i, 960, 960);
}
for (int i = 0; i < 4000; i++) {
norm4000[i] = ofNormalize(i, 0, 4000);
}
iBufferSize = 15;
iCurBufferIdx = 0;
}
//--------------------------------------------------------------
int ofxKeyFrameInterpolator::getIndexToLeft(ofPoint _point) {
MSA::Vec2f s = _data.front();
MSA::Vec2f e = _data.back();
float t = ofNormalize(_point.x, s.x, e.x);
float mu;
int leftIndex;
//findPosition(t, leftIndex, mu);
findArrayPositionForX(_point.x, leftIndex);
//cout << t << " " << leftIndex << endl;;
return leftIndex;
}
//--------------------------------------------------------------
void testApp::update(){
float elapsedTimeBetweenFrames = ofGetElapsedTimef() - timeOfLastFrame;
//audio
float totalLeft = 0.f;
float totalRight = 0.f;
for (int i = 0; i < 256; i++){
totalLeft += abs(left[i]);
totalRight += abs(right[i]);
}
totalLeft = totalLeft / 256.f;
totalRight = totalRight / 256.f;
audioLevel = (totalLeft+totalRight)/2.f;
audioLevel += gui.getValueF("AUDIO_BOOST");
audioLevel = ofNormalize(audioLevel, gui.getValueF("AUDIO_CUT_DOWN"), gui.getValueF("AUDIO_CUT_UP"));
//box2d
box2d.update();
//gui
//some dummy vars we will update to show the variable lister object
elapsedTime = ofGetElapsedTimef();
appFrameCount = ofGetFrameNum();
appFrameRate = ofGetFrameRate();
gui.update();
currentScene->update(elapsedTimeBetweenFrames, audioLevel);
timeOfLastFrame = ofGetElapsedTimef();
}
/*
Painting
*/
void Particle::addAlphaFade(bool _fadeOut = true){
if (_fadeOut)
alphaF = 1.0f - ofNormalize(life, 0, initialLife);
else
alphaF = ofNormalize(life, 0, initialLife);
}
//--------------------------------------------------------------
void testApp::draw(){
ofBackground(0,0,0);
//audio level
float levelToUse = 0.5f;
float rawAudioLevel = AA.amplitude;
if(rawAudioLevel > loudestAudioLevelRecieved){
loudestAudioLevelRecieved = rawAudioLevel;
}
float scaledAmplitude = ofNormalize(rawAudioLevel, gui.getValueF("AUDIO_MIN"), gui.getValueF("AUDIO_MAX"));
if(scaledAmplitude > decayedAudioLevel){
decayedAudioLevel = scaledAmplitude;
}else{
//decay it
decayedAudioLevel = decayedAudioLevel * gui.getValueF("AUDIO_DECAY");
}
decayedAudioLevel = ofNormalize(decayedAudioLevel, gui.getValueF("AUDIO_MIN"), 1.f);
int audioMode = gui.getValueI("AUDIO_MODE");
if(audioMode == 0){
//normal mode
levelToUse = scaledAmplitude;
}else if(audioMode == 1){
//decay mode
levelToUse = decayedAudioLevel;
}else if(audioMode == 2){
//manual mode
levelToUse = gui.getValueF("AUDIO_MANUAL_LEVEL");
}
// // draw the left:
// ofSetColor(0x333333);
// ofRect(100,100,256,200);
// ofSetColor(0xFFFFFF);
// for (int i = 0; i < 256; i++){
// ofLine(100+i,200,100+i,200+left[i]*100.0f);
// }
//
// // draw the right:
// ofSetColor(0x333333);
// ofRect(600,100,256,200);
// ofSetColor(0xFFFFFF);
// for (int i = 0; i < 256; i++){
// ofLine(600+i,200,600+i,200+right[i]*100.0f);
// }
//
//
// ofSetColor(0x333333);
// drawCounter++;
// char reportString[255];
// sprintf(reportString, "buffers received: %i\ndraw routines called: %i\n", bufferCounter,drawCounter);
// ofDrawBitmapString(reportString,80,380);
//from avsys/analysis2/aubioExample
// draw the pitchAmplitudeLeft:
ofSetColor(0x333333);
ofRect(0,0,BUFFER_SIZE,200);
ofSetColor(0xFFFFFF);
for (int i = 0; i < BUFFER_SIZE; i++){
ofLine(i,100,i,100+pitchAmplitudeLeft[i]*200);
}
ofSetColor(255,0,0);
ofDrawBitmapString("pitch is : " + ofToString((int)AA.pitch), 50, 300);
ofDrawBitmapString("raw audio is : " + ofToString(rawAudioLevel, 3), 50, 320);
ofDrawBitmapString("scaled audio is : " + ofToString(scaledAmplitude, 3), 50, 340);
ofDrawBitmapString("decayed audio is : " + ofToString(decayedAudioLevel, 3), 50, 360);
ofDrawBitmapString("loudest raw audio is : " + ofToString(loudestAudioLevelRecieved, 3), 50, 380);
ofDrawBitmapString("used audio is : " + ofToString(levelToUse, 3), 50, 400);
//from avsys/analysis2/fft
static int index=0;
float avg_power = 0.0f;
/* do the FFT */
myfft.powerSpectrum(0,(int)BUFFER_SIZE/2, FFTLeft,BUFFER_SIZE,&magnitude[0],&phase[0],&power[0],&avg_power);
for (int i = 0; i < (int)(BUFFER_SIZE/2); i++){
freq[i] = magnitude[i];
}
FFTanalyzer.calculate(freq);
ofSetColor(0xffffff);
for (int i = 0; i < (int)(BUFFER_SIZE/2 - 1); i++){
//ofRect(200+(i*4),600,4,-freq[i]*10.0f);
}
for (int i = 0; i < FFTanalyzer.nAverages; i++){
ofRect(i*20,600,20,-FFTanalyzer.averages[i] * 6);
}
ofSetColor(0xff0000);
for (int i = 0; i < FFTanalyzer.nAverages; i++){
ofRect(i*20,600-FFTanalyzer.peaks[i] * 6,20,-4);
}
//display each channel
ofSetColor(0xffffff);
//mixing
//mixResult.clear();
float mix = 1.f-gui.getValueF("MIX");
int AMix = 255*mix;
int BMix = 255-AMix;
//cout << "Scaled amplitude " << scaledAmplitude << endl;
float triggerLevel = gui.getValueF("AUDIO_TRIGGER_LEVEL");
if(channelAImages.size() > 0){
int imageIndexToUse = 0;//default to first image
int drawModeA = gui.getValueI("DRAW_MODE_A");
if(drawModeA == 0){
//select on level
imageIndexToUse = levelToUse*(channelAImages.size()-1);
}else if(drawModeA == 1){
//next image on peak
if(levelToUse > triggerLevel){
currentChannelAIndex++;
}
if (currentChannelAIndex > (channelAImages.size()-1)) {
currentChannelAIndex = 0;
}
imageIndexToUse = currentChannelAIndex;
}else if(drawModeA == 2){
//next image unless peak
if(!(levelToUse > triggerLevel)){
currentChannelAIndex++;
}
if (currentChannelAIndex > (channelAImages.size()-1)) {
currentChannelAIndex = 0;
}
imageIndexToUse = currentChannelAIndex;
}else if (drawModeA == 3) {
//next image on space
if(spaceDown){
currentChannelAIndex++;
}
if (currentChannelAIndex > (channelAImages.size()-1)) {
currentChannelAIndex = 0;
}
imageIndexToUse = currentChannelAIndex;
}
channelASource.resize(channelAImages[imageIndexToUse].width,channelAImages[imageIndexToUse].height);
channelASource.setFromPixels(channelAImages[imageIndexToUse].getPixels(), channelAImages[imageIndexToUse].width, channelAImages[imageIndexToUse].height, OF_IMAGE_COLOR);
channelASource.draw(0,600, 160, 120);
}
if(channelBImages.size() > 0){
int imageIndexToUse = 0;//default to first image
int drawModeB = gui.getValueI("DRAW_MODE_B");
if(drawModeB == 0){
//select on level
imageIndexToUse = levelToUse*(channelBImages.size()-1);
}else if(drawModeB == 1){
//next image on peak
if(levelToUse > triggerLevel){
currentChannelBIndex++;
}
if (currentChannelBIndex > (channelBImages.size()-1)) {
currentChannelBIndex = 0;
}
imageIndexToUse = currentChannelBIndex;
}else if(drawModeB == 2){
//next image unless peak
if(!(levelToUse > triggerLevel)){
currentChannelBIndex++;
}
if (currentChannelBIndex > (channelBImages.size()-1)) {
currentChannelBIndex = 0;
}
imageIndexToUse = currentChannelBIndex;
}else if (drawModeB == 3) {
//next image on space
if(spaceDown){
currentChannelBIndex++;
}
if (currentChannelBIndex > (channelBImages.size()-1)) {
currentChannelBIndex = 0;
}
imageIndexToUse = currentChannelBIndex;
}
channelBSource.resize(channelBImages[imageIndexToUse].width,channelBImages[imageIndexToUse].height);
channelBSource.setFromPixels(channelBImages[imageIndexToUse].getPixels(), channelBImages[imageIndexToUse].width, channelBImages[imageIndexToUse].height, OF_IMAGE_COLOR);
channelBSource.draw(160,600, 160, 120);
if(channelAImages.size() > 0){
setMixImageFromImages(&channelASource, &channelBSource, mix);
}
}
// gui.addToggle("Brightness on Audio?", "AUDIO_BRIGHTNESS_ON_LEVEL", 0);
// gui.addToggle("Scale on Audio?", "AUDIO_SCALE_ON_LEVEL", 0);
float imageScale = 1.f;
float centreProjectionX = settings.GUI_W + (settings.PROJECTION_W/2.f);
float centreProjectionY = (settings.PROJECTION_H/2.f);
if(gui.getValueB("AUDIO_SCALE_ON_LEVEL")){
imageScale = levelToUse;
}
ofPushStyle();
ofSetRectMode(OF_RECTMODE_CENTER);
ofEnableAlphaBlending();
if(gui.getValueB("AUDIO_BRIGHTNESS_ON_LEVEL")){
ofSetColor(255, 255, 255, (int)(levelToUse*255.f));
}else {
ofSetColor(255, 255, 255, 255);
}
mixResult.draw(centreProjectionX, centreProjectionY, imageScale*settings.PROJECTION_W, imageScale*settings.PROJECTION_H);
ofDisableAlphaBlending();
ofPopStyle();
ofSetColor(0xffffff);
gui.draw();
spaceDown = false;
}
void NSMidiMiniManager::newMidiMessage(ofxMidiMessage& msg) {
// if(msg.control > 0 )
printf("channel received %d, pitch %d,note %d, velocity %d, control %d \n", msg.channel, msg.pitch, msg.value, msg.velocity, msg.control);
float normalized = ofNormalize((float)msg.value, 0, 127);
float val;
switch (msg.control) {
case 8:
Globals::instance()->nsSceneManager->getScene(0)->globalAlpha = normalized;
break;
case 9:
Globals::instance()->nsSceneManager->getScene(0)->globalGobo = normalized;
break;
case 10:
Globals::instance()->editor->playVel = normalized;
Globals::instance()->app->editorPreview.playVel = normalized;
break;
case 11:
Globals::instance()->nsSceneManager->getScene(0)->globalDecay = 1 + (normalized * 9.0);
break;
default:
break;
}
switch (msg.pitch) {
case 0:
if(msg.velocity != 127) {
Globals::instance()->editor->pushFrame();
}
break;
case 4:
printf("gogogo");
Globals::instance()->editor->bTapTempoMode = !Globals::instance()->editor->bTapTempoMode;
break;
case 14:
printf("gogogo");
Globals::instance()->editor->bTapTempoMode = !Globals::instance()->editor->bTapTempoMode;
break;
default:
break;
}
if(msg.pitch == 14)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,255,255), "BLANC");
if(msg.pitch == 15)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,0,0), "ROUGE");
if(msg.pitch == 16)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,90,0), "ORANGE");
if(msg.pitch == 17)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(0,255,255), "CYAN");
if(msg.pitch == 18)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(0,255,0), "VERT");
if(msg.pitch == 19)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(161,255,161), "VERT CLAIR");
if(msg.pitch == 20)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,144,255), "LILA");
if(msg.pitch == 21)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,150,255), "ROSE");
if(msg.pitch == 22)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,255,0), "JAUNE");
if(msg.pitch == 23)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(255,0,255), "MAGENTA");
if(msg.pitch == 24)
Globals::instance()->nsSceneManager->getScene(0)->setSharpyColor(ofColor(0,0,255), "BLEU");
}
//--------------------------------------------------------------
void openniTracking::normalizeValues(){
// blobs tracking from contour finder
if(computeContourFinder){
// blobs data
for(unsigned int b=0;b<contourFinder.nBlobs;b++){
_osc_blobInfo[b].center.x = ofNormalize(_s_blobInfo[b].center.x,0.0f,(float)_width);
_osc_blobInfo[b].center.y = ofNormalize(_s_blobInfo[b].center.y,0.0f,(float)_height);
_osc_blobInfo[b].angle = ofNormalize(_s_blobInfo[b].angle,0.0f,360.0f);
_osc_blobInfo[b].size.width = ofNormalize(_s_blobInfo[b].size.width,0.0f,(float)_width);
_osc_blobInfo[b].size.height = ofNormalize(_s_blobInfo[b].size.height,0.0f,(float)_height);
// blob smoohContour points
for(unsigned int j = 0; j < contourSmooth[b].size(); j++){
_osc_contourSmooth[b].at(j).x = ofNormalize(_s_contourSmooth[b].at(j).x, 0.0f, (float)_width);
_osc_contourSmooth[b].at(j).y = ofNormalize(_s_contourSmooth[b].at(j).y, 0.0f, (float)_height);
}
// blob simpleContour (redux) points
for(unsigned int j = 0; j < contourSimple[b].size(); j++){
_osc_contourSimple[b].at(j).x = ofNormalize(_s_contourSimple[b].at(j).x, 0.0f, (float)_width);
_osc_contourSimple[b].at(j).y = ofNormalize(_s_contourSimple[b].at(j).y, 0.0f, (float)_height);
}
}
}
// contour geometry from contour finder
if(computeContourFinder && computeContourGeometry){
for(unsigned int b=0;b<contourFinder.nBlobs;b++){
for(unsigned int g = 0; g < geomLines[b].size(); g++){
_osc_blobGeom[b].at(g).x = ofNormalize(_s_blobGeom[b].at(g).x,0.0f,(float)_width);
_osc_blobGeom[b].at(g).y = ofNormalize(_s_blobGeom[b].at(g).y,0.0f,(float)_height);
_osc_blobGeom[b].at(g).z = ofNormalize(_s_blobGeom[b].at(g).z,0.0f,(float)_width);
_osc_blobGeom[b].at(g).w = ofNormalize(_s_blobGeom[b].at(g).w,0.0f,(float)_height);
}
}
}
// optical flow pixels velocity
if(computeOpticalFlow){
unsigned int oo=0;
for (unsigned int y = 0; y < _height; y += OPTICAL_FLOW_ROWS_STEP ){
for (unsigned int x = 0; x < _width; x += OPTICAL_FLOW_COLS_STEP ){
_osc_opfVel[oo].x = _s_opfVel[oo].x;
_osc_opfVel[oo].y = _s_opfVel[oo].y;
_osc_opfVel[oo].z = _s_opfVel[oo].z;
_osc_opfVel[oo].w = _s_opfVel[oo].w;
oo++;
}
}
}
// getting hand normalized positions for all detected users
if(isTrackingHands){
/*for(unsigned int i=0;i<maxHands;i++){
//ofxTrackedHand *hand = recordHandTracker.tracked_hands[i];
if(hand->isBeingTracked){
_osc_hands_Pos[i] = hand->progPos;
}
}*/
}
// openni sensor kinect hardware
_osc_sensorAcc.x = ofNormalize(sensor_accelerometer.x,-10.0f,10.0f);
_osc_sensorAcc.y = ofNormalize(sensor_accelerometer.y,-10.0f,10.0f);
_osc_sensorAcc.z = ofNormalize(sensor_accelerometer.z,-10.0f,10.0f);
_osc_sensorTilt = ofNormalize(sensor_tilt,0.0f,360.0f);
}
void Flower::draw() {
// chose random flowers
// alpha blend the flowers in
if ( dice == 6) {
long timeDiff = ofGetElapsedTimeMillis() - time;
float alpha = ofNormalize(timeDiff, 0, 10000);
ofSetColor(r, g, b, 255 * alpha);
ofBeginShape();
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+10, fPos.y -20);
ofVertex(fPos.x+30, fPos.y-30);
ofVertex(fPos.x+20, fPos.y-10);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+20, fPos.y+10);
ofVertex(fPos.x+30, fPos.y+30);
ofVertex(fPos.x+10, fPos.y+20);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-10, fPos.y+20);
ofVertex(fPos.x-30, fPos.y+30);
ofVertex(fPos.x-20, fPos.y+10);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-20, fPos.y-10);
ofVertex(fPos.x-30, fPos.y-30);
ofVertex(fPos.x-10, fPos.y-20);
ofVertex(fPos.x, fPos.y);
ofEndShape();
}
if ( dice == 5 ) {
long timeDiff = ofGetElapsedTimeMillis() - time;
float alpha = ofNormalize(timeDiff, 0, 10000);
ofSetColor(r, g, b, 255 * alpha);
ofBeginShape();
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-16, fPos.y -25);
ofVertex(fPos.x, fPos.y-50);
ofVertex(fPos.x+16, fPos.y-25);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+33, fPos.y-16);
ofVertex(fPos.x+50, fPos.y);
ofVertex(fPos.x+33, fPos.y+16);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+16, fPos.y+25);
ofVertex(fPos.x, fPos.y+50);
ofVertex(fPos.x-16, fPos.y+25);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-33, fPos.y+16);
ofVertex(fPos.x-50, fPos.y);
ofVertex(fPos.x-33, fPos.y-16);
ofVertex(fPos.x, fPos.y);
ofEndShape();
}
if ( dice == 4 ) {
long timeDiff = ofGetElapsedTimeMillis() - time;
float alpha = ofNormalize(timeDiff, 0, 10000);
ofSetColor(r, g, b, 255 * alpha);
ofBeginShape();
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-10, fPos.y -20);
ofVertex(fPos.x, fPos.y-40);
ofVertex(fPos.x+10, fPos.y-20);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+25, fPos.y-10);
ofVertex(fPos.x+40, fPos.y);
ofVertex(fPos.x+25, fPos.y+10);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+10, fPos.y+20);
ofVertex(fPos.x, fPos.y+40);
ofVertex(fPos.x-10, fPos.y+20);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-25, fPos.y+10);
ofVertex(fPos.x-40, fPos.y);
ofVertex(fPos.x-25, fPos.y-10);
ofVertex(fPos.x, fPos.y);
ofEndShape();
}
if ( dice == 3 ) {
long timeDiff = ofGetElapsedTimeMillis() - time;
float alpha = ofNormalize(timeDiff, 0, 10000);
ofSetColor(r, g, b, 255 * alpha);
ofBeginShape();
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-5, fPos.y -15);
ofVertex(fPos.x, fPos.y-30);
ofVertex(fPos.x+5, fPos.y-15);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+20, fPos.y-5);
ofVertex(fPos.x+30, fPos.y);
ofVertex(fPos.x+20, fPos.y+5);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+5, fPos.y+15);
ofVertex(fPos.x, fPos.y+30);
ofVertex(fPos.x-5, fPos.y+15);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-20, fPos.y+5);
ofVertex(fPos.x-30, fPos.y);
ofVertex(fPos.x-20, fPos.y-5);
ofVertex(fPos.x, fPos.y);
ofEndShape();
}
if ( dice == 2) {
long timeDiff = ofGetElapsedTimeMillis() - time;
float alpha = ofNormalize(timeDiff, 0, 10000);
ofSetColor(r, g, b, 255 * alpha);
ofBeginShape();
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+5, fPos.y -10);
ofVertex(fPos.x+15, fPos.y-15);
ofVertex(fPos.x+10, fPos.y-5);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+10, fPos.y+5);
ofVertex(fPos.x+15, fPos.y+15);
ofVertex(fPos.x+5, fPos.y+10);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-5, fPos.y+10);
ofVertex(fPos.x-15, fPos.y+15);
ofVertex(fPos.x-10, fPos.y+5);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-10, fPos.y-5);
ofVertex(fPos.x-15, fPos.y-15);
ofVertex(fPos.x-5, fPos.y-10);
ofVertex(fPos.x, fPos.y);
ofEndShape();
}
if ( dice == 1) {
long timeDiff = ofGetElapsedTimeMillis() - time;
float alpha = ofNormalize(timeDiff, 0, 10000);
ofSetColor(r, g, b, 255 * alpha);
ofBeginShape();
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+15, fPos.y -30);
ofVertex(fPos.x+40, fPos.y-40);
ofVertex(fPos.x+30, fPos.y-15);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x+30, fPos.y+15);
ofVertex(fPos.x+40, fPos.y+40);
ofVertex(fPos.x+15, fPos.y+30);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-15, fPos.y+30);
ofVertex(fPos.x-40, fPos.y+40);
ofVertex(fPos.x-30, fPos.y+15);
ofVertex(fPos.x, fPos.y);
ofVertex(fPos.x-30, fPos.y-15);
ofVertex(fPos.x-40, fPos.y-40);
ofVertex(fPos.x-15, fPos.y-30);
ofVertex(fPos.x, fPos.y);
ofEndShape();
}
};
void Particle::addNoise(float _angle, float _turbulence){
float angle = ofSignedNoise(pos.x * 0.005f, pos.y * 0.005f) * _angle;
ofVec2f noiseVector ( cos (angle), sin (angle) );
acc += noiseVector * _turbulence * (1.0 - ofNormalize(life, 0, initialLife));
}
void Pelota::agregarAlphaFade(bool _fadeOut = true){
if (_fadeOut)
alphaF = 1.0f-ofNormalize(vida, 0,vidaInicial);
else
alphaF = ofNormalize(vida, 0,vidaInicial);
}
void Pelota::agregarNoise(float _angulo, float _turbulencia){
float angulo = ofSignedNoise(pos.x * 0.005f, pos.y *0.005f) * angulo;
ofVec2f noiseVector( cos( angulo ), sin( angulo ) );
acc += noiseVector * _turbulencia * (1.0 - ofNormalize(vida, 0, vidaInicial));
}
void Particle::addScaleFade(bool _melt = true){
if(_melt)
scaleF = 1.0f - ofNormalize(life, 0, initialLife);
else
scaleF = ofNormalize(life, 0, initialLife);
}
void Pelota::agregarScaleFade(bool _melt = true){
if (_melt)
escalaF = 1.0f-ofNormalize(vida, 0,vidaInicial);
else
escalaF = ofNormalize(vida, 0,vidaInicial);
}
//--------------------------------------------------------------
void ofApp::audioRequested (float * output, int bufferSize, int nChannels){
for (int i = 0; i < bufferSize; i++){
/* Stick your maximilian 'play()' code in here ! Declare your objects in ofApp.h.
For information on how maximilian works, take a look at the example code at
http://www.maximilian.strangeloop.co.uk
under 'Tutorials'.
*/
// sample=beat.play(0.25, 0, beat.length);
// wave=sine1.sinebuf(abs(mouseX));/* mouse controls sinewave pitch. we get abs value to stop it dropping
// delow zero and killing the soundcard*/
wave=0;
wave2=0;
for(int i=0; i < curveVertices.size(); i++) {
double f0 = abs(curveVertices[i].x);
double f1 = abs(curveVertices[i].y);
double f2 = abs(curveVertices[i].z);
double rgb = abs(colorPicked.b*colorPicked.r*colorPicked.g);
double sound2 = ofMap(rgb,0,(powf(255,3)),20,600);
// double thisSine = wave + sineBank[i].sinewave(f0 + (i * f1))*sin(i)+ sineBank[i-1].square(f1);
double thisSine = (sineBank[i-1].sinewave(sound2)*sin(i*f2))*(sineBank[i].sinewave(f1)*cos(i));
if (camActive) {
double thisSine2 = (sineBank[i-1].triangle(f2)*sin(i)*sin(colorPicked.b))*(sineBank[i].sinewave(colorPicked.r)*sin(colorPicked.g));
wave2 = wave2 + thisSine2;
} else {
double thisSine2 = (sineBank[i-1].sawn(f2)*sin(i)*sin(colorPicked.b))*(sineBank[i].sinewave(colorPicked.r)*sin(colorPicked.g));
wave2 = wave2 + thisSine2;
}
// double multiplier = 1.0 / (i+1.0);
// double multiplier = 1.0 / (i);
// thisSine = (thisSine)*multiplier;
wave = wave + thisSine;
// f0+=sin(multiplier)*i*10;
}
if (curveVertices.size()>0){
wave *=ofNormalize((curveVertices.size()),.1,.5);
wave2 *=ofNormalize((curveVertices.size()),.1,.5);
// ofNormalize(wave, 0, .1);
}
*output = wave;//simple as that!
*output = wave2;
mymix.stereo(sample + wave + wave2, outputs, 0.5);
output[i*nChannels ] = outputs[0]; /* You may end up with lots of outputs. add them here */
output[i*nChannels + 1] = outputs[1];
}
}
