From: Alexander Green Date: Fri, 15 Nov 2013 07:44:26 +0000 (-0800) Subject: Merge branch 'master' of https://github.com/sugarcubes/SugarCubes into alexgreen X-Git-Url: https://git.piment-noir.org/?a=commitdiff_plain;h=09f7f5dff86f1b54a789e39b4f6ab24ed072c17d;p=SugarCubes.git Merge branch 'master' of https://github.com/sugarcubes/SugarCubes into alexgreen LX point stuff, etc don't know if it works yet Conflicts: AlexGreen.pde SugarCubes.pde --- 09f7f5dff86f1b54a789e39b4f6ab24ed072c17d diff --cc AlexGreen.pde index e3897cf,e8b55ce..e507d20 --- a/AlexGreen.pde +++ b/AlexGreen.pde @@@ -1,20 -1,6 +1,12 @@@ class SineSphere extends SCPattern { - private SinLFO yrot = new SinLFO(0, TWO_PI, 2000); + private SawLFO yrot = new SawLFO(0, TWO_PI, 3000); + private SawLFO yrot2 = new SawLFO(0, -TWO_PI, 8000); + public BasicParameter huespread = new BasicParameter("Hue", 0, 180); + public BasicParameter widthparameter= new BasicParameter("Width", .2); + private int pitch = 0; + private int channel = 0; + private int velocity = 0; - public final Projection sinespin; - public final Projection sinespin2; - - //to-do: how to sync all hues across sphery's via one basicparameter - //public BasicParameter huespread = new BasicParameter("HueSpread", 180, 360); - public BasicParameter rotationx = new BasicParameter("rotx", 0, 0, 1 ); - public BasicParameter rotationy = new BasicParameter("roty", 1, 0, 1); - public BasicParameter rotationz = new BasicParameter("rotz", 0, 0, 1); - + public final LXProjection sinespin; float modelrad = sqrt((model.xMax)*(model.xMax) + (model.yMax)*(model.yMax) + (model.zMax)*(model.zMax)); Pick Sshape; public final PVector P = new PVector(); @@@ -160,16 -99,8 +152,16 @@@ final Sphery[] spherys SineSphere(GLucose glucose) { super(glucose); - sinespin = new Projection(model); + sinespin = new LXProjection(model); + sinespin2 = new Projection(model); + addParameter(huespread); + addParameter(rotationx); + addParameter(rotationy); + addParameter(rotationz); addModulator(yrot).trigger(); + addModulator(yrot2).trigger(); + + //addParameter(huespread); //Sshape = addPick("Shape", , 1); spherys = new Sphery[] { new Sphery(model.xMax/4, model.yMax/2, model.zMax/2, modelrad/16, modelrad/8, 3000), @@@ -203,87 -130,49 +195,87 @@@ // } // } - void run( double deltaMs) { - float t = lx.tempo.rampf(); - float bpm = lx.tempo.bpmf(); + public void run( double deltaMs) { + double t = lx.tempo.ramp(); + double bpm = lx.tempo.bpm(); - spherys[0].run(deltaMs); - spherys[1].run(deltaMs); - spherys[2].run(deltaMs); - spherys[3].run(deltaMs); - ++ //spherys[0].run(deltaMs); + //spherys[1].run(deltaMs); + //spherys[2].run(deltaMs); + //spherys[3].run(deltaMs);] + sinespin.reset() ++ .center ++ .rotate(yrot.getValuef(), 0, 1, 0); - // Translate so the center of the car is the origin, offset by yPos - .center() - - // Rotate around the origin (now the center of the car) about an X-vector - .rotate(yrot.getValuef(), 0, 1, 0); + switch (pitch) + { + case 53: t = .5*t; bpm = .5*bpm; break; + case 54: t = t; bpm = bpm; break; + case 55: t = 2*t; bpm = 2*bpm; break; - for (LXPoint p : model.points){ - color c = 0; - c = blendColor(c, spherys[1].spheryvalue(p.x, p.y, p.z, .75*model.xMax, model.yMax/2, model.zMax/2), ADD); - c = blendColor(c, spherys[0].spheryvalue(p.x, p.y, p.z, model.xMax/4, model.yMax/4, model.zMax/2), ADD); - c = blendColor(c, spherys[2].spheryvalue(p.x, p.y, p.z, model.xMax/2, model.yMax/2, model.zMax/2),ADD); + default: t= t; bpm = bpm; - ++} - colors[p.index] = lx.hsb(lx.h(c), lx.s(c), lx.b(c)); + } + + for ( Sphery s: spherys){ + s.setVibrationPeriod(480000/bpm); + s.vibration.setBasis(t); + } + sinespin.reset(model) + + + // Translate so the center of the car is the origin, offset + .translateCenter(model, 0, 0, 0) + // .scale(1.3,1.3,1.3) + // Rotate around the origin (now the center of the car) about an y-vector + .rotate(yrot.getValuef(), rotationx.getValuef(), rotationy.getValuef() , rotationz.getValuef()) + .translate(model.cx, model.cy, model.cz); + - } + + + + for (Coord p: sinespin) + // for (Point p: model.points) + { + P.set(p.x, p.y, p.z); + // PVector P = new PVector(p.x, p.y, p.z); + color c = #000000; + c = blendIfColor(c, spherys[1].spheryvalue(P, .75*model.xMax, model.yMax/2, model.zMax/2), ADD); + c = blendIfColor(c, spherys[0].spheryvalue(P, model.xMax/4, model.yMax/4, model.zMax/2), ADD); + c = blendIfColor(c, spherys[2].spheryvalue(P, model.xMax/2, model.yMax/2, model.zMax/2),ADD); + + + colors[p.index] = c; + + } + sinespin2.reset(model). + translateCenter(model,0,0,0). + rotate(yrot2.getValuef(), 0, 1, 0). + translate(model.cx,model.cy,model.cz); + + for (Coord p: sinespin2) + { color c = 0; + // PVector P = new PVector(p.x, p.y, p.z); + P.set(p.x, p.y, p.z); + c = blendIfColor(c, spherys[3].spheryvalue(P, .3*model.xMax, .7*model.yMax, .6*model.zMax),ADD); + + colors[p.index] = blendIfColor(colors[p.index], c , ADD); + } - - } - int spheremode = 0; - // void keyPressed() { - // spheremode++; - // } - - // color CalcPoint(PVector Px) - // { - // // if (spheremode == 0 ) - //{ - - //} - // else if (spheremode == 1) - // { + color blendIfColor(color c1, color c2, int mode) { + if (c2 != 0) { + return blendColor(c1, c2, mode); + } + return c1; + } + // color c = 0; // c = blendColor(c, spherys[3].ellipsevalue(Px.x, Px.y, Px.z, model.xMax/4, model.yMax/4, model.zMax/4, 3*model.xMax/4, 3*model.yMax/4, 3*model.zMax/4),ADD); diff --cc AlexGreen.pde.orig index 13abdfe,0000000..9d657e9 mode 100644,000000..100644 --- a/AlexGreen.pde.orig +++ b/AlexGreen.pde.orig @@@ -1,362 -1,0 +1,446 @@@ +class SineSphere extends SCPattern { ++<<<<<<< HEAD + private SawLFO yrot = new SawLFO(0, TWO_PI, 3000); + private SawLFO yrot2 = new SawLFO(0, -TWO_PI, 8000); ++ public BasicParameter huespread = new BasicParameter("Hue", 0, 180); ++ public BasicParameter widthparameter= new BasicParameter("Width", .2); ++ private int pitch = 0; ++ private int channel = 0; ++ private int velocity = 0; + public final Projection sinespin; + public final Projection sinespin2; - private BasicParameter rotation = new BasicParameter("rotation", 0); ++ ++ //to-do: how to sync all hues across sphery's via one basicparameter ++ //public BasicParameter huespread = new BasicParameter("HueSpread", 180, 360); ++ public BasicParameter rotationx = new BasicParameter("rotx", 0, 0, 1 ); ++ public BasicParameter rotationy = new BasicParameter("roty", 1, 0, 1); ++ public BasicParameter rotationz = new BasicParameter("rotz", 0, 0, 1); ++ ++======= ++ private SinLFO yrot = new SinLFO(0, TWO_PI, 2000); ++ public final LXProjection sinespin; ++>>>>>>> b8bb27489db7dc687bf150576e9d9439f1fa17a6 + float modelrad = sqrt((model.xMax)*(model.xMax) + (model.yMax)*(model.yMax) + (model.zMax)*(model.zMax)); + Pick Sshape; + public final PVector P = new PVector(); + + class Sphery { + float f1xcenter, f1ycenter, f1zcenter, f2xcenter , f2ycenter, f2zcenter; //second three are for an ellipse with two foci + private SinLFO vibration; + private SinLFO surface; + private SinLFO vx; + private SinLFO xbounce; + public SinLFO ybounce; + private SinLFO zbounce; + float vibration_min, vibration_max, vperiod; - public BasicParameter widthparameter; - public BasicParameter huespread; ++ ++ //public BasicParameter huespread; + public BasicParameter bouncerate; + public BasicParameter bounceamp; - <<<<<<< HEAD - ======= ++ public BasicParameter vibrationrate; + public final PVector circlecenter = new PVector(); - >>>>>>> 4ad9f85959980d306800ad50636f4fd7c2a5d36b + + public Sphery(float f1xcenter, float f1ycenter, float f1zcenter, float vibration_min, float vibration_max, float vperiod) + { + this.f1xcenter = f1xcenter; + this.f1ycenter = f1ycenter; + this.f1zcenter = f1zcenter; + this.vibration_min = vibration_min; + this.vibration_max = vibration_max; + this.vperiod = vperiod; + //addParameter(bounceamp = new BasicParameter("Amp", .5)); + //addParameter(bouncerate = new BasicParameter("Rate", .5)); //ybounce.modulateDurationBy(bouncerate); - addParameter(widthparameter = new BasicParameter("Width", .1)); - addParameter(huespread = new BasicParameter("Hue", .5, 10)); ++ //addParameter(vibrationrate = new BasicParameter("vibration", 1000, 10000)); ++ //addParameter(widthparameter = new BasicParameter("Width", .2)); ++ + - addModulator( vx = new SinLFO(-4000, 10000, 100000)).trigger() ; ++ addModulator( vx = new SinLFO(500, 10000, 100000)).trigger() ; + //addModulator(xbounce = new SinLFO(model.xMax/3, 2*model.yMax/3, 2000)).trigger(); - addModulator(ybounce= new SinLFO(model.yMax/3, 2*model.yMax/3, 240000./lx.tempo.bpm())).trigger(); //ybounce.modulateDurationBy ++ addModulator(ybounce= new SinLFO(model.yMax/3, 2*model.yMax/3, 240000./lx.tempo.bpm())).trigger(); //bounce.modulateDurationBy + + //addModulator(bounceamp); //ybounce.setMagnitude(bouncerate); - addModulator( vibration = new SinLFO(vibration_min , vibration_max, 240000./lx.tempo.bpm())).trigger(); //vibration.modulateDurationBy(vx); ++ addModulator( vibration = new SinLFO(vibration_min , vibration_max, 10000)).trigger(); //vibration.setPeriod(240000/lx.tempo.bpm()); + + } - public Sphery(float f1xcenter, float f1ycenter, float f1zcenter, float f2xcenter, float f2ycenter, float f2zcenter, - float vibration_min, float vibration_max, float vperiod) ++ ++ //for an ellipse ++// public Sphery(float f1xcenter, float f1ycenter, float f1zcenter, float f2xcenter, float f2ycenter, float f2zcenter, ++// float vibration_min, float vibration_max, float vperiod) + - { - this.f1xcenter = f1xcenter; - this.f1ycenter = f1ycenter; - this.f1zcenter = f1zcenter; - this.f2xcenter = f2xcenter; - this.f2ycenter = f2ycenter; - this.f2zcenter = f2zcenter; - this.vibration_min = vibration_min; - this.vibration_max = vibration_max; - this.vperiod = vperiod; - //addModulator(xbounce = new SinLFO(model.xMax/3, 2*model.yMax/3, 2000)).trigger(); - addModulator(ybounce).trigger(); - addModulator( vibration = new SinLFO(vibration_min , vibration_max, lx.tempo.rampf())).trigger(); //vibration.modulateDurationBy(vx); - addParameter(widthparameter = new BasicParameter("Width", .1)); - addParameter(huespread = new BasicParameter("Hue", .2)); ++// { ++// this.f1xcenter = f1xcenter; ++// this.f1ycenter = f1ycenter; ++// this.f1zcenter = f1zcenter; ++// this.f2xcenter = f2xcenter; ++// this.f2ycenter = f2ycenter; ++// this.f2zcenter = f2zcenter; ++// this.vibration_min = vibration_min; ++// this.vibration_max = vibration_max; ++// this.vperiod = vperiod; ++// //addModulator(xbounce = new SinLFO(model.xMax/3, 2*model.yMax/3, 2000)).trigger(); ++// addModulator(ybounce).trigger(); ++// addModulator( vibration = new SinLFO(vibration_min , vibration_max, lx.tempo.rampf())).trigger(); //vibration.modulateDurationBy(vx); ++// addParameter(widthparameter = new BasicParameter("Width", .1)); ++// //addParameter(huespread = new BasicParameter("bonk", .2)); + - } ++// } ++ + + ++void setVibrationPeriod(double period){ ++// to-do: make this conditional upon time signature + ++vibration.setPeriod(period); ++ ++} + + +float distfromcirclecenter(float px, float py, float pz, float f1x, float f1y, float f1z) +{ + return dist(px, py, pz, f1x, f1y, f1z); + } + //void updatespherey(deltaMs, ) + + float quadrant(PVector q) { + float qtheta = atan2( (q.x-f1xcenter) , (q.z - f1zcenter) ); - //println( "qtheta " + qtheta); + - return map(qtheta, -PI/2, PI/2, 140, 240); ++ ++ return map(qtheta, -PI/2, PI/2, 160-huespread.getValuef(), 240 +huespread.getValuef()); + //if (q.x > f1xcenter ) {return 140 ;} + //else {return 250;} + } + color spheryvalue (PVector p, float f1xcenter, float f1ycenter, float f1zcenter) { + circlecenter.set(f1xcenter, f1ycenter, f1zcenter); + - // circlecenter = new PVector(f1xcenter, f1ycenter, f1zcenter); ++ +//switch(sShpape.cur() ) {} + + float b = max(0, 100 - 100*widthparameter.getValuef()*abs(p.dist(circlecenter) + - vibration.getValuef() ) ); + + if (b <= 0) { + return 0; + } + + return lx.hsb( - constrain(huespread.getValuef()*5*quadrant(p), 0, 360), ++ constrain(quadrant(p), 0, 360), + 80, + b + ); + } + color ellipsevalue(float px, float py, float pz , float f1xc, float f1yc, float f1zc, float f2xc, float f2yc, float f2zc) + { +//switch(sShpape.cur() ) {} + return lx.hsb(huespread.getValuef()*5*px, dist(model.xMax-px, model.yMax-py, model.zMax-pz, f1xc, f1yc, f1zc) , + max(0, 100 - 100*widthparameter.getValuef() * + abs( (dist(px, py, pz, f1xc, ybounce.getValuef(), f1zc) + + (dist(px, py , pz, f2xc, ybounce.getValuef(), f2zc) ) )/2 + - 1.2*vibration.getValuef() ) ) ) ; + } + +void run(double deltaMs) { + float vv = vibration.getValuef(); + float ybv = ybounce.getValuef(); + + } + +} + ++// public boolean gridPressed(int row, int co){ ++// midiengine.grid.setState(); ++ ++// return true; ++ ++// } ++ ++public boolean noteOn(Note note) { ++pitch= note.getPitch(); ++velocity=note.getVelocity(); ++channel=note.getChannel(); ++return true; ++} + +final Sphery[] spherys; + + SineSphere(GLucose glucose) + { + super(glucose); ++<<<<<<< HEAD + sinespin = new Projection(model); + sinespin2 = new Projection(model); ++ addParameter(huespread); ++ addParameter(rotationx); ++ addParameter(rotationy); ++ addParameter(rotationz); ++======= ++ sinespin = new LXProjection(model); ++>>>>>>> b8bb27489db7dc687bf150576e9d9439f1fa17a6 + addModulator(yrot).trigger(); + addModulator(yrot2).trigger(); - addParameter(rotation); ++ ++ //addParameter(huespread); + //Sshape = addPick("Shape", , 1); + spherys = new Sphery[] { + new Sphery(model.xMax/4, model.yMax/2, model.zMax/2, modelrad/16, modelrad/8, 3000), + new Sphery(.75*model.xMax, model.yMax/2, model.zMax/2, modelrad/20, modelrad/10, 2000), + new Sphery(model.xMax/2, model.yMax/2, model.zMax/2, modelrad/4, modelrad/8, 2300), + + new Sphery(.3*model.xMax, .4*model.yMax, .6*model.zMax, modelrad/16, modelrad/8, 4000), + new Sphery(.75*model.xMax, model.yMax/2, model.zMax/2, modelrad/20, modelrad/10, 2000), + new Sphery(model.xMax/2, model.yMax/2, model.zMax/2, modelrad/4, modelrad/8, 2300), + + }; + } + +// public void onParameterChanged(LXParameter parameter) +// { + + +// for (Sphery s : spherys) { +// if (s == null) continue; +// double bampv = s.bounceamp.getValue(); +// double brv = s.bouncerate.getValue(); +// double tempobounce = lx.tempo.bpm(); +// if (parameter == s.bounceamp) +// { +// s.ybounce.setRange(bampv*model.yMax/3 , bampv*2*model.yMax/3, brv); +// } +// else if ( parameter == s.bouncerate ) +// { +// s.ybounce.setDuration(120000./tempobounce); +// } +// } +// } + ++<<<<<<< HEAD + public void run( double deltaMs) { - float t = lx.tempo.rampf(); - float bpm = lx.tempo.bpmf(); ++ double t = lx.tempo.ramp(); ++ double bpm = lx.tempo.bpm(); + spherys[0].run(deltaMs); + spherys[1].run(deltaMs); + spherys[2].run(deltaMs); + spherys[3].run(deltaMs); + ++ ++ switch (pitch) ++ { ++ case 53: t = .5*t; bpm = .5*bpm; break; ++======= ++ void run( double deltaMs) { ++ float t = lx.tempo.rampf(); ++ float bpm = lx.tempo.bpmf(); ++ //spherys[1].run(deltaMs); ++ //spherys[2].run(deltaMs); ++ //spherys[3].run(deltaMs);] ++ sinespin.reset() ++ ++ // Translate so the center of the car is the origin, offset by yPos ++ .center() ++>>>>>>> b8bb27489db7dc687bf150576e9d9439f1fa17a6 ++ ++ case 54: t = t; bpm = bpm; break; ++ ++ case 55: t = 2*t; bpm = 2*bpm; break; ++ ++ default: t= t; bpm = bpm; ++ ++<<<<<<< HEAD ++======= ++ for (LXPoint p : model.points){ ++ color c = 0; ++ c = blendColor(c, spherys[1].spheryvalue(p.x, p.y, p.z, .75*model.xMax, model.yMax/2, model.zMax/2), ADD); ++ c = blendColor(c, spherys[0].spheryvalue(p.x, p.y, p.z, model.xMax/4, model.yMax/4, model.zMax/2), ADD); ++ c = blendColor(c, spherys[2].spheryvalue(p.x, p.y, p.z, model.xMax/2, model.yMax/2, model.zMax/2),ADD); ++>>>>>>> b8bb27489db7dc687bf150576e9d9439f1fa17a6 ++ ++ } ++ ++ for ( Sphery s: spherys){ ++ s.setVibrationPeriod(480000/bpm); ++ s.vibration.setBasis(t); ++ } + sinespin.reset(model) + + + // Translate so the center of the car is the origin, offset + .translateCenter(model, 0, 0, 0) + // .scale(1.3,1.3,1.3) + // Rotate around the origin (now the center of the car) about an y-vector - .rotate(yrot.getValuef(), 0, 1 , 0) ++ .rotate(yrot.getValuef(), rotationx.getValuef(), rotationy.getValuef() , rotationz.getValuef()) + .translate(model.cx, model.cy, model.cz); + + + + + + for (Coord p: sinespin) + // for (Point p: model.points) + { + P.set(p.x, p.y, p.z); + // PVector P = new PVector(p.x, p.y, p.z); + color c = #000000; + c = blendIfColor(c, spherys[1].spheryvalue(P, .75*model.xMax, model.yMax/2, model.zMax/2), ADD); + c = blendIfColor(c, spherys[0].spheryvalue(P, model.xMax/4, model.yMax/4, model.zMax/2), ADD); + c = blendIfColor(c, spherys[2].spheryvalue(P, model.xMax/2, model.yMax/2, model.zMax/2),ADD); + + + colors[p.index] = c; + + + } + sinespin2.reset(model). + translateCenter(model,0,0,0). + rotate(yrot2.getValuef(), 0, 1, 0). + translate(model.cx,model.cy,model.cz); + + for (Coord p: sinespin2) + { color c = 0; + // PVector P = new PVector(p.x, p.y, p.z); + P.set(p.x, p.y, p.z); + c = blendIfColor(c, spherys[3].spheryvalue(P, .3*model.xMax, .7*model.yMax, .6*model.zMax),ADD); + + colors[p.index] = blendIfColor(colors[p.index], c , ADD); + + } + + + + } + + color blendIfColor(color c1, color c2, int mode) { + if (c2 != 0) { + return blendColor(c1, c2, mode); + } + return c1; + } + + + // color c = 0; + // c = blendColor(c, spherys[3].ellipsevalue(Px.x, Px.y, Px.z, model.xMax/4, model.yMax/4, model.zMax/4, 3*model.xMax/4, 3*model.yMax/4, 3*model.zMax/4),ADD); + // return c; + // } + // return lx.hsb(0,0,0); + // // else if(spheremode ==2) + // { color c = 0; + // return lx.hsb(CalcCone( (xyz by = new xyz(0,spherys[2].ybounce.getValuef(),0) ), Px, mid) ); + + // } + + + // } + + } + +class CubeCurl extends SCPattern{ +float CH, CW, diag; +ArrayList cubeorigin = new ArrayList(); +ArrayList centerlist = new ArrayList(); +private SinLFO curl = new SinLFO(0, Cube.EDGE_HEIGHT, 5000 ); + +private SinLFO bg = new SinLFO(180, 220, 3000); + +CubeCurl(GLucose glucose){ +super(glucose); +addModulator(curl).trigger(); +addModulator(bg).trigger(); + this.CH = Cube.EDGE_HEIGHT; + this.CW = Cube.EDGE_WIDTH; + this.diag = sqrt(CW*CW + CW*CW); + + +ArrayList centerlistrelative = new ArrayList(); +for (int i = 0; i < model.cubes.size(); i++){ + Cube a = model.cubes.get(i); + cubeorigin.add(new PVector(a.x, a.y, a.z)); + centerlist.add(new PVector(a.cx, a.cy, a.cz) ); + +} + +} +//there is definitely a better way of doing this! +PVector centerofcube(int i) { +Cube c = model.cubes.get(i); + +println(" cube #: " + i + " c.x " + c.x + " c.y " + c.y + " c.z " + c.z ); +// PVector cubeangle = new PVector(c.rx, c.ry, c.rz); +println("raw x angle: " + c.rx + "raw y angle: " + c.ry + "raw z angle: " + c.rz); +PVector cubecenter = new PVector(c.x + CW/2, c.y + CH/2, c.z + CW/2); +println("cubecenter unrotated: " + cubecenter.x + " " +cubecenter.y + " " +cubecenter.z ); +PVector centerrot = new PVector(cos(c.rx)*CW/2 - sin(c.rx)*CW/2, cubecenter.y, cos(c.rz)*CW/2 + sin(c.rz)*CW/2); + // nCos*(y-o.y) - nSin*(z-o.z) + o.y +cubecenter = PVector.add(new PVector(c.x, c.y, c.z), centerrot); +println( " cubecenter.x " + cubecenter.x + " cubecenter.y " + cubecenter.y + " cubecenter.z " + cubecenter.z + " "); + + +return cubecenter; +} + + +void run(double deltaMs){ +for (int i =0; i < model.cubes.size(); i++) { +Cube c = model.cubes.get(i); +float cfloor = c.y; + +// if (i%3 == 0){ + - // for (Point p : c.points ){ ++// for (LXPoint p : c.points ){ +// // colors[p.index]=color(0,0,0); +// //float dif = (p.y - c.y); +// //colors[p.index] = color( bg.getValuef() , 80 , dif < curl.getValuef() ? 80 : 0, ADD); +// } +// } + +// else if (i%3 == 1) { + - // for (Point p: c.points){ ++// for (LXPoint p: c.points){ +// colors[p.index]=color(0,0,0); +// float dif = (p.y - c.y); +// // colors[p.index] = +// // color(bg.getValuef(), +// // map(curl.getValuef(), 0, Cube.EDGE_HEIGHT, 20, 100), +// // 100 - 10*abs(dif - curl.getValuef()), ADD ); +// } +// } +// else if (i%3 == 2){ + // centerlist[i].sub(cubeorigin(i); - for (Point p: c.points) { ++ for (LXPoint p: c.points) { + PVector pv = new PVector(p.x, p.y, p.z); + colors[p.index] =color( constrain(4* pv.dist(centerlist.get(i)), 0, 360) , 50, 100 ); + // colors[p.index] =color(constrain(centerlist[i].x, 0, 360), constrain(centerlist[i].y, 0, 100), ); + + + } + + + //} + + } + } + } + + class HueTestHSB extends SCPattern{ + BasicParameter HueT = new BasicParameter("Hue", .5); + BasicParameter SatT = new BasicParameter("Sat", .5); + BasicParameter BriT = new BasicParameter("Bright", .5); + +HueTestHSB(GLucose glucose) { + super(glucose); + addParameter(HueT); + addParameter(SatT); + addParameter(BriT); +} + void run(double deltaMs){ + - for (Point p : model.points) { ++ for (LXPoint p : model.points) { + color c = 0; + c = blendColor(c, lx.hsb(360*HueT.getValuef(), 100*SatT.getValuef(), 100*BriT.getValuef()), ADD); + colors[p.index]= c; + } + int now= millis(); + if (now % 1000 <= 20) + { + println("Hue: " + 360*HueT.getValuef() + "Sat: " + 100*SatT.getValuef() + "Bright: " + 100*BriT.getValuef()); + } + } + + } diff --cc SugarCubes.pde.orig index 0000000,0000000..e989980 new file mode 100644 --- /dev/null +++ b/SugarCubes.pde.orig @@@ -1,0 -1,0 +1,148 @@@ ++/** ++ * +-+-+-+-+-+ +-+-+-+-+-+ ++ * / /| |\ \ ++ * / / + + \ \ ++ * +-+-+-+-+-+ | +-+-+-+-+ | +-+-+-+-+-+ ++ * | | + / \ + | | ++ * + THE + / / \ \ + CUBES + ++ * | |/ +-+-+-+-+-+-+-+ \| | ++ * +-+-+-+-+-+ | | +-+-+-+-+-+ ++ * + + ++ * | SUGAR | ++ * + + ++ * | | ++ * +-+-+-+-+-+-+-+ ++ * ++ * Welcome to the Sugar Cubes! This Processing sketch is a fun place to build ++ * animations, effects, and interactions for the platform. Most of the icky ++ * code guts are embedded in the GLucose library extension. If you're an ++ * artist, you shouldn't need to worry about any of that. ++ * ++ * Below, you will find definitions of the Patterns, Effects, and Interactions. ++ * If you're an artist, create a new tab in the Processing environment with ++ * your name. Implement your classes there, and add them to the list below. ++ */ ++ ++LXPattern[] patterns(GLucose glucose) { ++ return new LXPattern[] { ++ ++<<<<<<< HEAD ++ new SineSphere(glucose), ++ new CubeCurl(glucose), ++======= ++>>>>>>> b8bb27489db7dc687bf150576e9d9439f1fa17a6 ++ // Slee ++ new Cathedrals(glucose), ++ new MidiMusic(glucose), ++ new Pulley(glucose), ++ new Swarm(glucose), ++ new ViolinWave(glucose), ++ new BouncyBalls(glucose), ++ new SpaceTime(glucose), ++ new ShiftingPlane(glucose), ++ new AskewPlanes(glucose), ++ new Blinders(glucose), ++ new CrossSections(glucose), ++ new Psychedelia(glucose), ++ ++ new Traktor(glucose).setEligible(false), ++ new BassPod(glucose).setEligible(false), ++ new CubeEQ(glucose).setEligible(false), ++ new PianoKeyPattern(glucose).setEligible(false), ++ ++ // DanH ++ new Noise(glucose), ++ new Play (glucose), ++ new Pong (glucose), ++ new Worms(glucose), ++ ++ // Alex G ++ ++ ++ // Shaheen ++ new HelixPattern(glucose).setEligible(false), ++ ++ // Toby ++ new GlitchPlasma(glucose), ++ new FireEffect(glucose).setEligible(false), ++ new StripBounce(glucose), ++ new SoundRain(glucose).setEligible(false), ++ new SoundSpikes(glucose).setEligible(false), ++ new FaceSync(glucose), ++ ++ // Jack ++ new Swim(glucose), ++ new Balance(glucose), ++ ++ // Tim ++ new TimPlanes(glucose), ++ new TimPinwheels(glucose), ++ new TimRaindrops(glucose), ++ new TimCubes(glucose), ++ // new TimTrace(glucose), ++ new TimSpheres(glucose), ++ ++ // Ben ++ // new Sandbox(glucose), ++ new TowerParams(glucose), ++ new DriveableCrossSections(glucose), ++ new GranimTestPattern2(glucose), ++ ++ //JR ++ new Gimbal(glucose), ++ ++ // Sam ++ new JazzRainbow(glucose), ++ ++ // Arjun ++ new TelevisionStatic(glucose), ++ new AbstractPainting(glucose), ++ new Spirality(glucose), ++ ++ // Basic test patterns for reference, not art ++ new TestCubePattern(glucose), ++ new TestTowerPattern(glucose), ++ new TestProjectionPattern(glucose), ++ new TestStripPattern(glucose), ++ new TestBassMapping(glucose), ++ new TestFloorMapping(glucose), ++ new TestSpeakerMapping(glucose), ++ // new TestHuePattern(glucose), ++ // new TestXPattern(glucose), ++ // new TestYPattern(glucose), ++ // new TestZPattern(glucose), ++ ++ }; ++} ++ ++LXTransition[] transitions(GLucose glucose) { ++ return new LXTransition[] { ++ new DissolveTransition(lx), ++ new AddTransition(glucose), ++ new MultiplyTransition(glucose), ++ new OverlayTransition(glucose), ++ new DodgeTransition(glucose), ++ new SwipeTransition(glucose), ++ new FadeTransition(lx), ++// new SubtractTransition(glucose), // similar to multiply - dh ++// new BurnTransition(glucose), // similar to multiply - dh ++// new ScreenTransition(glucose), // same as add -dh ++// new SoftLightTransition(glucose), // same as overlay -dh ++ }; ++} ++ ++// Handles to globally triggerable effects ++class Effects { ++ FlashEffect flash = new FlashEffect(lx); ++ BoomEffect boom = new BoomEffect(glucose); ++ BlurEffect blur = new BlurEffect(glucose); ++ QuantizeEffect quantize = new QuantizeEffect(glucose); ++ ColorFuckerEffect colorFucker = new ColorFuckerEffect(glucose); ++ ++ Effects() { ++ blur.enable(); ++ quantize.enable(); ++ colorFucker.enable(); ++ } ++} ++