//============================================================================
// Cup neighborlist generator - finite and infinite sets
//============================================================================
// a square grid of cups at even grid points
void cups_near(double *pos, double *cups, int *ncups){
int i, j;
*ncups = 0;
for (i=-1; i<=1; i++){
for (j=-1; j<=1; j++){
cups[2*(*ncups)+0] = pos[0]-(mymod(pos[0]+1, 2)-1) + 2*i;
cups[2*(*ncups)+1] = pos[1]-(mymod(pos[1]+1, 2)-1) + 2*j;
*ncups += 1;
}
}
}
float saw2(float f) {
float d=mymod(f,2.0);
if (d<=1.0)
return d;
else
return 2.0-d;
}
float mycos(float x) {
#ifdef TRIGLOOKUPOFF
return cos(x);
#endif
setuptriglookup();
float y=mymod(x,2*pi);
return coslookup[(int)(y*triglookupquant/2/pi)];
}
void redocolors() {
int i;
for (i = 0; i < COLORS; i++) { /* Set up the colors gradient */
// myRGB r=myRGB(thru,thru,thru);
// myRGB r=( thru < 1 ? myRGB(0.0,thru*5.0,0.0)
// : myRGB(thru*2.0-1.0,1.0,thru*2.0-1.0)
// );
float thru=4.0*mymod(frameno*palspeed/(float)COLORS+i/2.0/(float)COLORS);
myRGB r;
if (thru<1.0)
r=myRGB(0.0,thru,0.0);
else if (thru<2.0)
r=myRGB(thru-1.0,1.0,thru-1.0);
else if (thru<3.0)
r=myRGB(1.0-(thru-2.0),1.0-(thru-2.0),1.0);
else
r=myRGB(0.0,0.0,1.0-(thru-3.0));
#ifdef X11GFX
xrgb[i].red = 65535 * r.r/255; // (1.0 - 1.0 * i / COLORS);
xrgb[i].green = 65535 * r.g/255;
xrgb[i].blue = 65535 * r.b/255;
xrgb[i].flags = DoRed | DoGreen | DoBlue;
xrgb[i].pixel=i;
#endif
#ifdef ALLEGRO
RGB algrgb;
algrgb.r=r.r/4;
algrgb.g=r.g/4;
algrgb.b=r.b/4;
set_color(i,&algrgb);
#endif
}
#ifdef X11GFX
if (stylee == styleeTrueColor) {
// XInstallColormap (d, colormap);
for (int i=0;i<colors;i++) {
if ( XAllocColor(d,colormap,&xrgb[i]) == 0 )
printf("Error allocating %i\n",i);
// works for true-color
}
} else {
// for (int i=0;i<colors;i++) {
// xrgb[i].pixel=color[i];
// }
XStoreColors(d,colormap,xrgb,COLORS);
// fputs("Couldn't allocate enough colors cells.\n",
// stderr), exit(1);
}
#endif
}
float mysin(float x) {
#ifdef TRIGLOOKUPOFF
return sin(x);
#else
setuptriglookup();
float y=mymod(x,2*pi);
return sinlookup[(int)(y*triglookupquant/2/pi)];
#endif
}
void plotparts()
{
int i;
if (mymod(frame,traillength+1)==0)
BWClearArea(window1, 0, 0, SCR_WIDTH, SCR_HEIGHT);
for (i=0; i<numps; i++) {
plotpart(&particle[i]);
}
}
void plotparts()
{
int i;
if (mymod(frame,traillength+1)==0)
clear(screen);
for (i=0; i<numps; i++) {
plotpart(&particle[i]);
}
}
int main(int argc, char **argv)
{
int i,stillhappy;
Display *display;
int events;
p.x=-0.9; p.y=0;
q.x=0.9; q.y=0;
srand48(874984);
frame=0;
/* Connect to the server for display */
display = BWConnectToServer();
/* Open the windows */
window1 = BWCreateNewWindow(display, argc, argv, 882, 4);
window2 = BWCreateNewWindow(display, argc, argv, 882, 324);
for (i=0; i<numps; i++) {
randpart(&particle[i]);
}
while(1) {
events = BWCheckEvents(window1);
switch (events) {
/* Window exposed - redraw */
case EV_EXPOSED:
{
plotparts();
break;
}
/* Mouse button pressed - close both windows and exit*/
case EV_BUTTON:
{
BWCloseWindow(window1);
exit(0);
}
default: {
plotparts();
moveparts();
if (mymod(frame,32)==0)
plotfield();
frame=frame+speed;
break;
}
}
}
}
void main() {
allegrosetup(scrwid,scrhei);
psychedelicpalette();
mypalette(255,0,0,0);
V3d pos=V3d(0,0,0);
V3d vel=V3d(0,0,0);
V3d acc=V3d(0,0,0);
Ori ori;
float roll=0;
float yaw=0;
JBmp b=JBmp(scrwid,scrhei);
PPsetup(scrwid,scrhei,4);
do {
b.clear(255);
V3d off=V3d(mymod(pos.x,gjump),mymod(pos.y,gjump),mymod(pos.z,gjump));
int ioff=-mydiv(pos.x,gjump);
int joff=-mydiv(pos.y,gjump);
int koff=-mydiv(pos.z,gjump);
for (int k=gridsize;k>=-gridsize;k-=gjump)
for (int i=-gridsize;i<=gridsize;i+=gjump)
for (int j=-gridsize;j<=gridsize;j+=gjump) {
int x,y;
V3d cen=V3d(i,j,k)-off;
cen=V3d::orientate(cen,ori);
int c=256.0*mymod(5*mysquare((i-ioff)/gjump)-11*(j-joff)/gjump-7*(k-koff)/gjump,6)/6.0;
PPgetscrpos(cen,&x,&y);
b.filledcircle(x,y,0.1*PPgetunit(cen),c);
}
b.writetoscreen();
acc=hang(acc,V3d::origin,0.93,0.02);
vel=hang(vel,V3d::origin,0.93,0)+acc;
pos=pos+vel;
roll=hang(roll,0,0.92,0.01);
yaw=hang(yaw,0,0.92,0.01);
ori.roll(roll);
ori.yaw(yaw);
} while (!key[KEY_ESC]);
}
/*
* interp1_table0_complex_per()
* 1D, 0th order, complex, periodic
*/
void interp1_table0_complex_per(
const double *r_ck, /* [K1,1] in */
const double *i_ck,
const int K1,
const double *r_h1, /* [J1*L1+1,1] in */
const double *i_h1, /* imaginary part of complex interpolator */
const int J1,
const int L1,
const double *p_tm, /* [M,1] in */
const int M,
double *r_fm, /* [M,1] out */
double *i_fm)
{
int mm;
/* trick: shift table pointer to center */
{
const int ncenter1 = floor(J1 * L1/2.);
r_h1 += ncenter1;
i_h1 += ncenter1;
}
/* interp */
for (mm=0; mm < M; mm++) {
int jj1;
const double t1 = *p_tm++;
register double sum1r = 0;
register double sum1i = 0;
int k1 = 1 + floor(t1 - J1 / 2.);
for (jj1=0; jj1 < J1; jj1++, k1++) {
const double p1 = (t1 - k1) * L1;
const int n1 = /* ncenter1 + */ iround(p1);
register const double coef1r = r_h1[n1];
register const double coef1i = i_h1[n1];
const int k1mod = mymod(k1, K1);
/* sum1 += coef1 * ck */
sum1r += coef1r * r_ck[k1mod] - coef1i * i_ck[k1mod];
sum1i += coef1r * i_ck[k1mod] + coef1i * r_ck[k1mod];
}
*r_fm++ = sum1r;
*i_fm++ = sum1i;
}
}
void main() {
Map2d<uchar> *from=new Map2d<uchar>(scrwid,scrhei);
Map2d<uchar> *dest=new Map2d<uchar>(scrwid,scrhei);
JBmp *rto=new JBmp(scrwid*2,scrhei);
Map2d<int> *to=new Map2d<int>(scrwid,scrhei,0);
randomise();
allegrosetup(320,200);
for (int i=0;i<256;i++) {
mypalette(i,myRGB::hue(mymod(4.0*(float)i/256.0)));
}
for (int x=0;x<scrwid;x++)
for (int y=0;y<scrhei;y++) {
from->pos[x][y]=intrnd(512+256);
dest->pos[x][y]=intrnd(512+256);
}
do {
to->clear(0);
to->pos[0][0]=from->pos[0][0];
to->pos[scrwid-1][0]=from->pos[scrwid-1][0];
to->pos[0][scrhei-1]=from->pos[0][scrhei-1];
to->pos[scrwid-1][scrhei-1]=from->pos[scrwid-1][scrhei-1];
make(rto,to,from,0,0,toppow);
rto->display();
for (int x=0;x<scrwid;x++)
for (int y=0;y<scrhei;y++) {
// from->pos[x][y]=ucharchop(from->pos[x][y]+magrnd(10));
int speed=3;
if (from->pos[x][y]<=dest->pos[x][y]-speed)
from->pos[x][y]+=speed;
else
if (from->pos[x][y]>=dest->pos[x][y]+speed)
from->pos[x][y]-=speed;
else
dest->pos[x][y]=intrnd(512+256);
}
} while (!key[KEY_ESC]);
}
void main() {
allegrosetup(scrwid,scrhei);
makepalette(&greypalette);
mypalette(255,0,0,0);
mypalette(0,0,0,0);
mypalette(255,1,1,1);
mypalette(128,0,0,0);
for (int r=0;r<8;r++) {
for (int g=0;g<8;g++) {
int palc=r+g*8;
mypalette(palc,(r==0?0:0.3+0.4*r/7.0),(g==0?0:0.1+0.2*g/7.0),(g==0?0:0.3+0.5*g/7.0));
}
}
// randomise();
V3d pos=V3d(0,0,0);
V3d vel=V3d(0,0,0);
V3d acc=V3d(0,0,0);
Ori ori;
float droll=0;
float dyaw=0;
float roll=0;
float yaw=0;
float pitch=0;
int frame=0;
starttimer();
do {
frame++;
float pd=2.0+1.8*sin(2*pi*frame/1000.0);
PPsetup(scrwid,scrhei,pd);
left.clear(0);
right.clear(0);
// b.fadeby(16);
V3d off=V3d(mymod(pos.x,gjump),mymod(pos.y,gjump),mymod(pos.z,gjump));
int ioff=-mydiv(pos.x,gjump);
int joff=-mydiv(pos.y,gjump);
int koff=-mydiv(pos.z,gjump);
ori.quickorisetup();
// Need to find largest axis, and do loops with that one outside
int ks=mysgn(ori.qz.z);
int js=-mysgn(ori.qz.y);
int is=-mysgn(ori.qz.x);
for (int k=ks*gridsize;k!=-ks*gridsize;k=k-ks*gjump)
for (int i=-is*gridsize;i!=is*gridsize;i=i+is*gjump)
for (int j=-js*gridsize;j!=js*gridsize;j=j+js*gjump) {
int x,y;
V3d cen=V3d(i,j,k)-off;
cen=V3d::qorientate(cen,ori);
int c=7-chop(7*(cen.z+pd+1)/(gridsize+2),0,7);
plotsphere(cen,c);
}
for (int i=0;i<scrwid;i++) {
for (int j=0;j<scrhei;j++) {
b.bmp[j][i]=(left.bmp[j][i] | right.bmp[j][i]);
}
}
b.writetoscreen();
acc=hang(acc,V3d::origin,0.95,0.01);
vel=hang(vel,ori.qz/10,0.94,0)+acc;
pos=pos+vel;
droll=hang(droll,0,0.9,0.01);
dyaw=hang(dyaw,0,0.95,0.01);
roll=hang(roll,0,0.95,0)+droll;
yaw=hang(yaw,0,0.92,0)+dyaw;
pitch=hang(pitch,0,0.999,0.01);
pos=pos+ori.qz*4;
ori.roll(roll/5.0);
ori.yaw(yaw/5.0);
pos=pos-ori.z()*4;
framedone();
} while (!key[KEY_SPACE] && !key[KEY_ESC]);
savetimer();
allegro_exit();
displayframespersecond();
}
void main() {
allegrosetup(scrwid,scrhei);
makepalette(&greypalette);
mypalette(255,0,0,0);
mypalette(0,0,0,0);
mypalette(255,1,1,1);
mypalette(128,0,0,0);
randomise();
for (int i=0;i<=15;i++) {
waves+Wave();
// waves.num(i).display();
}
for (int r=0;r<16;r++) {
for (int g=0;g<16;g++) {
int palc=r+g*16;
mypalette(palc,(r==0?0:brightness+0.2+change*0.5*r/15.0),(g==0?0:brightness+change*0.1+0.2*g/15.0),(g==0?0:brightness+change*0.2+0.6*g/15.0));
// Groovy colours mypalette(palc,(r==0?0:0.1+0.6*r/15.0),(g==0?0:0.1+0.2*g/15.0),(g==0?0:0.1+0.7*g/15.0));
// Good colours: mypalette(palc,(r==0?0:0.3+0.4*r/15.0),(g==0?0:0.1+0.2*g/15.0),(g==0?0:0.3+0.5*g/15.0));
}
}
V3d vel=V3d(0,0,0);
V3d acc=V3d(0,0,0);
Ori ori;
float droll=0;
float dyaw=0;
float dpitch=0;
int frame=0;
List<V3d> particles=List<V3d>(gridsize*gridsize*gridsize);
/* for (int i=1;i<gridsize*gridsize*gridsize;i++) {
particles+gridsize*V3d(floatrnd(-1,1),floatrnd(-1,1),floatrnd(-1,1));
}*/
int ps=1;
float rad=0;
for (float thru=0;thru<1.0;thru+=0.0016) {
V3d here=getpos(thru);
V3d forward=getpos(thru+0.00001)-here;
V3d up=V3d::normcross(V3d::crazy,forward);
V3d right=V3d::normcross(forward,up);
for (int i=0;i<ps;i++) {
float t=2*pi*(float)i/(float)ps;
float s=sin(t);
float c=cos(t);
particles+(here+rad*(s*up+c*right));
}
// v.print();
}
starttimer();
float thru=0;
float marker=0;
V3d pos=getpos(marker);
V3d *tail=new V3d[taillen];
int tailpos=0;
do {
thru+=0.001;
// V3d last=V3d(pos.x,pos.y,pos.z);
// V3d pos=getpos(thru);
// V3d next=getpos(thru+0.00001);
// V3d newz=next-pos;
// ori.forcez(newz);
frame++;
// float pd=1.6+1.3*sin(2*pi*frame/1000.0);
float pd=2.0;
PPsetup(scrwid,scrhei,pd);
left.clear(0);
right.clear(0);
// b.fadeby(16);
int ioff=-mydiv(pos.x,gjump);
int joff=-mydiv(pos.y,gjump);
int koff=-mydiv(pos.z,gjump);
ori.quickorisetup();
// Need to find largest axis, and do loops with that one outside
int ks=mysgn(ori.qz.z);
int js=-mysgn(ori.qz.y);
int is=-mysgn(ori.qz.x);
for (int i=1;i<=particles.len;i++) {
int x,y;
V3d p=particles.num(i);
V3d cen=p-pos+0.0*ori.y;
cen=V3d::disorientate(cen,ori);
int c=15.0-chop(14.0*(cen.z+gridsize)/(float)(gridsize*2),0,14);
// int c=7.0-chop(6.0*(i/particles.len),0,6);
plotsphere(cen,c);
}
// Plot and move marker
V3d m;
for (int i=1;i<=15;i++) {
m=V3d::disorientate(getpos(marker)-pos,ori);
if (m.mod()<markerrange)
marker+=0.0002;
}
float u=PPgetunitnoadd(m);
bool plot=false;
if (u) {
int x,y;
float rad=0.08*u;
PPgetscrposnoadd(m,PPlefteye,&x,&y);
if (left.inimage(x,y)) {
plot=true;
left.opencircle(x,y,rad,15);
}
PPgetscrposnoadd(m,PPrighteye,&x,&y);
if (right.inimage(x,y)) {
plot=true;
right.opencircle(x,y,rad,15*16);
}
}
if (!plot) {
V2d v=scrwid*2*V2d(m.x,m.y).norm();
if (abs(v.x)>scrwid/2) {
float change=(float)scrwid/2.0/abs(v.x);
v=change*v;
}
if (abs(v.y)>scrhei/2) {
float change=(float)scrhei/2.0/abs(v.y);
v=change*v;
}
v=v+V2d(scrwid/2,scrhei/2);
left.opencircle(v,5,15);
right.opencircle(v,5,15*16);
}
// Pull player towards marker
// if (m.mod()>markerrange+.1) {
V3d pulldir=getpos(marker)-pos;
// vel=vel+pulldir*0.02;
// float amount=(V3d::normdot(ori.z(),pulldir)+5.0)/6.0;
float amount=chop(0.99-(m.mod()-markerrange)/5.0,0,1);
V3d newz=ori.z()*amount+(1.0-amount)*pulldir;
ori.forcez(newz);
// vel=vel*amount;
//
//}
// Draw and update tail
V3d last=(tail[tailpos]-pos).disorientate(ori);
for (int k=1;k<taillen;k++) {
int j=mymod(tailpos+k,taillen);
V3d next=(tail[j]-pos).disorientate(ori);
plotline(last,next,(float)k/(float)taillen);
last=next;
}
if ((frame % 5)==0) {
tail[tailpos]=pos-ori.qz;
tailpos=mymod(tailpos+1,taillen);
}
// Or screens
for (int i=0;i<scrwid;i++) {
for (int j=0;j<scrhei;j++) {
b.bmp[j][i]=(left.bmp[j][i] | right.bmp[j][i]);
}
}
b.writetoscreen();
// acc=hang(acc,V3d::origin,0.95,0.01);
// Movement
float angvel=turnability;
if (key[KEY_LCONTROL])
vel=vel+ori.z()*forcevel;
else
angvel=turnability*2.0;
if (key[KEY_UP])
dpitch=dpitch+angvel;
if (key[KEY_DOWN])
dpitch=dpitch-angvel;
if (key[KEY_LEFT])
if (key[KEY_ALT])
droll=droll-angvel;
else
dyaw=dyaw-angvel;
if (key[KEY_RIGHT])
if (key[KEY_ALT])
droll=droll+angvel;
else
dyaw=dyaw+angvel;
vel=hang(vel,V3d::o,0.91,0);
pos=pos+vel;
droll=hang(droll,0,0.9,0);
dyaw=hang(dyaw,0,0.9,0);
dpitch=hang(dpitch,0,0.9,0);
ori.roll(droll/5.0);
ori.yaw(dyaw/5.0);
ori.pitch(dpitch/5.0);
framedone();
} while (!key[KEY_SPACE] && !key[KEY_ESC]);
savetimer();
allegro_exit();
displayframespersecond();
}
/*
* interp3_table0_complex_per_adj()
*/
void interp3_table0_complex_per_adj(
double *r_ck, /* [K1,K2,K3] out */
double *i_ck,
const int K1,
const int K2,
const int K3,
const double *r_h1, /* [J1*L1+1,1] in */
const double *i_h1,
const double *r_h2, /* [J2*L2+1,1] in */
const double *i_h2,
const double *r_h3, /* [J3*L3+1,1] in */
const double *i_h3,
const int J1,
const int J2,
const int J3,
const int L1,
const int L2,
const int L3,
const double *p_tm, /* [M,3] in */
const int M,
const double *r_fm, /* [M,1] in */
const double *i_fm)
{
int mm;
/* trick: shift table pointer to center */
{
const int ncenter1 = floor(J1 * L1/2);
r_h1 += ncenter1;
i_h1 += ncenter1;
}
{
const int ncenter2 = floor(J2 * L2/2);
r_h2 += ncenter2;
i_h2 += ncenter2;
}
{
const int ncenter3 = floor(J3 * L3/2);
r_h3 += ncenter3;
i_h3 += ncenter3;
}
/* initialize output to zero */
(void) memset((void *) r_ck, 0, K1*K2*K3*sizeof(*r_ck));
(void) memset((void *) i_ck, 0, K1*K2*K3*sizeof(*i_ck));
/* interp */
for (mm=0; mm < M; mm++) {
int jj1, jj2, jj3;
const double t3 = p_tm[2*M];
const double t2 = p_tm[M];
const double t1 = *p_tm++;
const double fmr = *r_fm++;
const double fmi = *i_fm++;
const int koff1 = 1 + floor(t1 - J1 / 2.);
const int koff2 = 1 + floor(t2 - J2 / 2.);
int k3 = 1 + floor(t3 - J3 / 2.);
for (jj3=0; jj3 < J3; jj3++, k3++) {
const double p3 = (t3 - k3) * L3;
const int n3 = /* ncenter3 + */ iround(p3);
const double coef3r = r_h3[n3];
const double coef3i = i_h3[n3];
const int k3mod = mymod(k3, K3);
const double v3r = coef3r * fmr + coef3i * fmi;
const double v3i = coef3r * fmi - coef3i * fmr;
int k2 = koff2;
for (jj2=0; jj2 < J2; jj2++, k2++) {
const double p2 = (t2 - k2) * L2;
const int n2 = /* ncenter2 + */ iround(p2);
const double coef2r = r_h2[n2];
const double coef2i = i_h2[n2];
const int k2mod = mymod(k2, K2);
const int k23mod = (k3mod * K2 + k2mod) * K1;
const double v2r = coef2r * v3r + coef2i * v3i;
const double v2i = coef2r * v3i - coef2i * v3r;
int k1 = koff1;
for (jj1=0; jj1 < J1; jj1++, k1++) {
const double p1 = (t1 - k1) * L1;
const int n1 = /* ncenter1 + */ iround(p1);
register const double coef1r = r_h1[n1];
register const double coef1i = i_h1[n1];
const int k1mod = mymod(k1, K1);
const int kk = k23mod + k1mod; /* 3D array index */
r_ck[kk] += coef1r * v2r + coef1i * v2i;
i_ck[kk] += coef1r * v2i - coef1i * v2r;
} /* j1 */
} /* j2 */
} /* j3 */
}
}
uchar ucharmod(int x) {
return (uchar)mymod(x,256);
}
uchar ucharsaw(float x) {
return (uchar)mymod(x,256);
}
float mymod(float a) {
return mymod(a,1);
}
// interp4_table0_complex_per_adj()
void interp4_table0_complex_per_adj(
double *r_ck, /* [K1,K2,K3,K4] out */
double *i_ck,
const int K1,
const int K2,
const int K3,
const int K4,
const double *r_h1, /* [J1*L1+1,1] in */
const double *i_h1,
const double *r_h2, /* [J2*L2+1,1] in */
const double *i_h2,
const double *r_h3, /* [J3*L3+1,1] in */
const double *i_h3,
const double *r_h4, /* [J4*L4+1,1] in */
const double *i_h4,
const int J1,
const int J2,
const int J3,
const int J4,
const int L1,
const int L2,
const int L3,
const int L4,
const double *p_tm, /* [M,4] in */
const int M,
const double *r_fm, /* [M,1] in */
const double *i_fm)
{
int mm;
/* trick: shift table pointer to center */
{
const int ncenter1 = floor(J1 * L1/2.);
r_h1 += ncenter1;
i_h1 += ncenter1;
}
{
const int ncenter2 = floor(J2 * L2/2.);
r_h2 += ncenter2;
i_h2 += ncenter2;
}
{
const int ncenter3 = floor(J3 * L3/2.);
r_h3 += ncenter3;
i_h3 += ncenter3;
}
{
const int ncenter4 = floor(J4 * L4/2.);
r_h4 += ncenter4;
i_h4 += ncenter4;
}
/* initialize output to zero */
(void) memset((void *) r_ck, 0, K1*K2*K3*K4*sizeof(*r_ck));
(void) memset((void *) i_ck, 0, K1*K2*K3*K4*sizeof(*i_ck));
/* interp */
for (mm=0; mm < M; mm++) {
int jj1, jj2, jj3, jj4;
const double t4 = p_tm[3*M];
const double t3 = p_tm[2*M];
const double t2 = p_tm[M];
const double t1 = *p_tm++;
const double fmr = *r_fm++;
const double fmi = *i_fm++;
const int koff1 = 1 + floor(t1 - J1 / 2.);
const int koff2 = 1 + floor(t2 - J2 / 2.);
const int koff3 = 1 + floor(t3 - J3 / 2.);
int k4 = 1 + floor(t4 - J4 / 2.);
for (jj4=0; jj4 < J4; jj4++, k4++) {
const double p4 = (t4 - k4) * L4;
const int n4 = /* ncenter4 + */ iround(p4);
const double coef4r = r_h4[n4];
const double coef4i = i_h4[n4];
const int k4mod = mymod(k4, K4);
const mwIndex k4Idx = k4mod*K3*K2*K1;
const double v4r = coef4r * fmr + coef4i * fmi;
const double v4i = coef4r * fmi - coef4i * fmr;
int k3 = koff3;
for (jj3=0; jj3 < J3; jj3++, k3++) {
const double p3 = (t3 - k3) * L3;
const int n3 = /* ncenter3 + */ iround(p3);
const double coef3r = r_h3[n3];
const double coef3i = i_h3[n3];
const int k3mod = mymod(k3, K3);
const mwIndex k3Idx = k3mod*K2*K1;
const double v3r = coef3r * v4r + coef3i * v4i;
const double v3i = coef3r * v4i - coef3i * v4r;
int k2 = koff2;
for (jj2=0; jj2 < J2; jj2++, k2++) {
const double p2 = (t2 - k2) * L2;
const int n2 = /* ncenter2 + */ iround(p2);
const double coef2r = r_h2[n2];
const double coef2i = i_h2[n2];
const int k2mod = mymod(k2, K2);
const mwIndex k2Idx = k2mod*K1;
const double v2r = coef2r * v3r + coef2i * v3i;
const double v2i = coef2r * v3i - coef2i * v3r;
int k1 = koff1;
for (jj1=0; jj1 < J1; jj1++, k1++) {
const double p1 = (t1 - k1) * L1;
const int n1 = /* ncenter1 + */ iround(p1);
register const double coef1r = r_h1[n1];
register const double coef1i = i_h1[n1];
const int k1mod = mymod(k1, K1);
const mwIndex kk = k4Idx + k3Idx + k2Idx + k1mod; /* 4D array index */
r_ck[kk] += coef1r * v2r + coef1i * v2i;
i_ck[kk] += coef1r * v2i - coef1i * v2r;
} /* j1 */
} /* j2 */
} /* j3 */
} /* j4 */
}
}
/*----------------------------------------------------------------------------------------------------------------------------------------- */
void mlhoee_spyr(double *I , double *H, int ny , int nx , int nH , int dimcolor , struct opts options )
{
double *spyr = options.spyr , *norma = options.norma , *kernelx = options.kernelx , *kernely = options.kernely;
double min_bin , max_bin , diff_bin ;
double bin_size , center_offset , mini_b , f , absf;
double clamp = options.clamp , temp , scaley , scalex, angle , mag , tempsx , tempsy , ratiox , ratioy , maxfactor = 0.0 , ratio;
int i , j , p , l , x , y , o , q , v ;
int kyy = options.kyy , kxy = options.kxy , kyx = options.kyx , kxx = options.kxx , bndori = options.bndori;
int nspyr = options.nspyr , nori = options.nori , norm = options.norm , nori2 = nori - 1 , interpolate = options.interpolate;
int by , bx , ly , lx, pady , padx , nypad , nxpad , nypadnxpad , nynew , nxnew , nynxnew , nx1, ny1 , ny1nx1 , nygrady , nxgrady , nygradx , nxgradx;
int indjx , indjy , indjm , indi , indj , index , indexo , indexp , indtmpx , indtmpy , bin , nhd_bin;
int deltay, deltax, sy , sx, origy, origx , offsety , offsetx , offy , offx , extraoy , extraox , offye , offxe, x0 , y0 , x1 , y1;
int offyx , eyx , offxx , exx , offyy , eyy , offxy , exy , sf;
int nynx = ny*nx , norinH = nori*nH , vnynx , vnorinH;
double *Ipaded;
double *grady , *gradx , *R , *m , *sat , *cell;
if(bndori == 0)
{
min_bin = -PI/2;
max_bin = PI/2;
}
else
{
min_bin = -PI;
max_bin = PI;
}
diff_bin = (max_bin - min_bin);
bin_size = diff_bin/nori;
center_offset = bin_size*0.5;
mini_b = min_bin+center_offset;
for (p = 0 ; p < nspyr ; p++)
{
maxfactor = max(maxfactor , spyr[p + 0]*spyr[p + nspyr]);
}
by = (int) ceil(ny*norma[0]);
bx = (int) ceil(nx*norma[1]);
nynew = ((int) ceil(ny/(double)by))*by;
nxnew = ((int) ceil(nx/(double)bx))*bx;
nynxnew = nynew*nxnew;
ratioy = (nynew - ny)/2.0;
offy = (int) floor(ratioy);
extraoy = (int) ceil((ratioy - offy)/2.0);
offye = offy + extraoy;
ratiox = (nxnew - nx)/2.0;
offx = (int) floor(ratiox);
extraox = (int) ceil((ratiox - offx)/2.0);
offxe = offx + extraox;
/*
pady = max(1 , max(offy , max(kyx , kyy)));
padx = max(1 , max(offx , max(kxx , kxy)));
*/
pady = max(1 , max(offye , max(kyx , kyy)));
padx = max(1 , max(offxe , max(kxx , kxy)));
nypad = ny + 2*pady;
nxpad = nx + 2*padx;
nypadnxpad = nypad*nxpad;
offyx = (int) (floor((kyx + 1)/2));
eyx = 2*offyx - kyx;
offxx = (int) (floor((kxx + 1)/2));
exx = 2*offxx - kxx;
offyy = (int) (floor((kyy + 1)/2));
eyy = 2*offyy - kyy;
offxy = (int) (floor((kxy + 1)/2));
exy = 2*offxy - kxy;
Ipaded = (double *)malloc(nypadnxpad*sizeof(double));
nygrady = nypad + kyy - 1;
nxgrady = nxpad + kxy - 1;
nygradx = nypad + kyx - 1;
nxgradx = nxpad + kxx - 1;
grady = (double *)malloc(nygrady*nxgrady*sizeof(double));
gradx = (double *)malloc(nygradx*nxgradx*sizeof(double));
R = (double *)malloc(nynxnew*nori*sizeof(double));
m = (double *)malloc(nynxnew*sizeof(double));
nx1 = nxnew + 1;
ny1 = nynew + 1;
ny1nx1 = ny1*nx1;
sat = (double *)malloc(ny1nx1*sizeof(double));
cell = (double *)malloc(5*nH*sizeof(double));
for (v = 0 ; v < dimcolor ; v++)
{
vnynx = v*nynx;
vnorinH = v*norinH;
/* Pading */
for(i = 0 ; i < nypadnxpad ; i++)
{
Ipaded[i] = 0.0;
}
padarray(I + vnynx , ny , nx , pady , padx , Ipaded);
/* Gradient computation */
conv2(Ipaded , kernely , nypad , nxpad , kyy , kxy , nygrady , nygrady , grady);
conv2(Ipaded , kernelx , nypad , nxpad , kyx , kxx , nygradx , nxgradx , gradx);
/*
indtmpx = max(0,padx + offxx - exx - offxe);
indtmpy = max(0,pady + offxy - exy - offxe);
indtmpx = padx + offxx - exx - offxe;
indtmpy = pady + offxy - exy - offxe;
*/
indtmpx = max(0,padx + offxx - exx - offxe);
indtmpy = max(0,padx + offxy - exy - offxe);
for (i = 0 ; i < nynxnew*nori ; i++)
{
R[i] = 0.0;
}
if(bndori == 0)
{
for(j = 0 ; j < nxnew ; j++)
{
indjx = pady + offyx - eyx - offye + (j + indtmpx)*nygradx;
indjy = pady + offyy - eyy - offye + (j + indtmpy)*nygrady;
indjm = j*nynew;
for(i = 0 ; i < nynew ; i++)
{
tempsx = gradx[i + indjx];
tempsy = grady[i + indjy];
angle = atan(tempsy/(tempsx + verytiny));
mag = sqrt((tempsx*tempsx) + (tempsy*tempsy));
bin = min(nori2 , max(0 , (int)floor(nori*(angle - min_bin)/diff_bin)));
if(interpolate)
{
f = (angle - (mini_b + bin*bin_size))/bin_size;
absf = fabs(f);
sf = sign(f);
nhd_bin = mymod(bin + sf , nori2);
R[i + indjm + bin*nynxnew] = mag*(1.0 - absf);
R[i + indjm + nhd_bin*nynxnew] = mag*absf;
}
else
{
R[i + indjm + bin*nynxnew] = mag;
}
m[i + indjm] = mag;
}
}
}
else
{
for(j = 0 ; j < nxnew ; j++)
{
indjx = pady + offyx - eyx - offye + (j + indtmpx)*nygradx;
indjy = pady + offyy - eyy - offye + (j + indtmpy)*nygrady;
indjm = j*nynew;
for(i = 0 ; i < nynew ; i++)
{
tempsx = gradx[i + indjx];
tempsy = grady[i + indjy];
angle = atan2(-tempsy , -(tempsx + verytiny));
mag = sqrt((tempsx*tempsx) + (tempsy*tempsy));
bin = min(nori2 , max(0 , (int)floor(nori*(angle - min_bin)/diff_bin)));
if(interpolate)
{
f = (angle - (mini_b + bin*bin_size))/bin_size;
absf = fabs(f);
sf = sign(f);
nhd_bin = mymod(bin + sf , nori2);
R[i + indjm + bin*nynxnew] = mag*(1.0 - absf);
R[i + indjm + nhd_bin*nynxnew] = mag*absf;
}
else
{
R[i + indjm + bin*nynxnew] = mag;
}
m[i + indjm] = mag;
}
}
}
/* L1 block-normalization via the Integral Image*/
for(i = 0 ; i < ny1nx1 ; i++)
{
sat[i] = 0.0;
}
for (j=1 ; j < nx1; j++)
{
indj = j*ny1;
index = indj - ny1;
indi = (j-1)*nynew;
for (i = 1 ; i < ny1 ; i++)
{
sat[i + indj] = sat[i-1 + indj] + sat[i + index] - sat[(i-1) + index] + m[(i-1) + indi];
}
}
for(l = 0 ; l < (nxnew/bx) ; l++)
{
x = l*bx;
for(p = 0 ; p < (nynew/by) ; p++)
{
y = p*by;
x1 = x + bx;
y1 = y + by;
temp = (sat[y1 + x1*ny1] - (sat[y1 + x*ny1] + sat[y + x1*ny1]) + sat[y + x*ny1]);
if(temp != 0.0)
{
temp = 1.0/temp;
}
else
{
temp = 1.0;
}
for (o = 0 ; o < nori ; o++)
{
index = o*nynxnew;
for(i = x ; i < x + bx ; i++)
{
indi = i*nynew + index;
for(j = y ; j < y + by ; j++)
{
R[j + indi] *= temp;
}
}
}
}
}
/*---- Orientation block definitions ---- */
index = 0;
for (p = 0 ; p < nspyr ; p++)
{
scaley = (spyr[p + nspyr*2]);
ly = (int) ( (1 - spyr[p + 0])/scaley + 1);
deltay = (int) (ny*scaley);
sy = (int) (ny*spyr[p + 0]);
offsety = max(0 , (int) ( floor(ny - ( (ly-1)*deltay + sy + 1)) ));
scalex = (spyr[p + nspyr*3]);
lx = (int) ( (1 - spyr[p + nspyr*1])/scalex + 1);
deltax = (int) (nx*scalex);
sx = (int) (nx*spyr[p + nspyr*1]);
offsetx = max(0 , (int) ( floor(nx - ( (lx-1)*deltax + sx + 1)) ));
ratio = maxfactor/(spyr[p + 0]*spyr[p + nspyr]);
for(l = 0 ; l < lx ; l++) /* Loop shift on x-axis */
{
origx = offsetx + l*deltax ;
for(q = 0 ; q < ly ; q++) /* Loop shift on y-axis */
{
origy = offsety + q*deltay ;
cell[0 + index] = origy + offye;
cell[1 + index] = origx + offxe;
cell[2 + index] = origy + sy;
cell[3 + index] = origx + sx;
cell[4 + index] = ratio;
index += 5;
}
}
}
/*---- Compute Oriented Edge Energy via the cumulated Integral Image over each orientations ---- */
for(i = 0 ; i < ny1nx1 ; i++)
{
sat[i] = 0.0;
}
for (o = 0 ; o < nori ; o++)
{
indexo = o*nynxnew;
for (j = 1 + offxe; j<nx1; j++)
{
indj = j*ny1;
index = indj - ny1;
indi = (j-1)*nynew;
for (i = 1 + offye ; i<ny1; i++)
{
sat[i + indj] = sat[i-1 + indj] + sat[i + index] - sat[(i-1) + index] + R[(i-1) + indi + indexo];
}
}
index = 0;
indexp = o*nH + vnorinH;
for (j=0 ; j < nH ; j++)
{
y0 = (int) cell[0 + index];
x0 = (int) cell[1 + index];
y1 = (int) cell[2 + index];
x1 = (int) cell[3 + index];
H[j + indexp] = (sat[y1 + x1*ny1] - (sat[y1 + x0*ny1] + sat[y0 + x1*ny1]) + sat[y0 + x0*ny1])*cell[4 + index];
index += 5;
}
}
/*---- Normalization ---- */
if(norm == 1) /* L1-norm */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += H[i];
}
temp = 1.0/(temp + tiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
}
}
}
if(norm == 2) /* L2-norm */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += (H[i]*H[i]);
}
temp = 1.0/sqrt(temp + verytiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
}
}
}
if(norm == 3) /* L1-sqrt */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += H[i];
}
temp = 1.0/(temp + tiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] = sqrt(H[i]*temp);
}
}
}
if(norm == 4) /* L2-clamped */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += (H[i]*H[i]);
}
temp = 1.0/sqrt(temp + verytiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
if(H[i] > clamp)
{
H[i] = clamp;
}
}
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += (H[i]*H[i]);
}
temp = 1.0/sqrt(temp + verytiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
}
}
}
}
free(Ipaded);
free(grady);
free(gradx);
free(R);
free(m);
free(sat);
free(cell);
}
void main() {
allegrosetup(scrwid,scrhei);
makepalette(&greypalette);
mypalette(255,0,0,0);
randomise();
V3d pos=V3d(0,0,0);
V3d vel=V3d(0,0,0);
V3d acc=V3d(0,0,0);
Ori ori;
float droll=0;
float dyaw=0;
float roll=0;
float yaw=0;
float pitch=0;
for (int i=1;i<1000;i++) {
acc=hang(acc,V3d::origin,0.92,0.01);
vel=hang(vel,ori.qz/5,0.99,0)+acc;
pos=pos+vel;
droll=hang(droll,0,0.9,0.01);
dyaw=hang(dyaw,0,0.95,0.01);
roll=hang(roll,0,0.95,0)+droll;
yaw=hang(yaw,0,0.92,0)+dyaw;
pitch=hang(pitch,0,0.999,0.01);
pos=pos+ori.qz*4;
ori.roll(roll/5.0);
ori.yaw(yaw/5.0);
pos=pos-ori.z()*4;
}
JBmp b=JBmp(scrwid,scrhei);
int frame=0;
starttimer();
do {
frame++;
float pd=2.0-1.5*cos(2*pi*frame/200.0);
PPsetup(scrwid,scrhei,pd);
b.clear(255);
// b.fadeby(16);
V3d off=V3d(mymod(pos.x,gjump),mymod(pos.y,gjump),mymod(pos.z,gjump));
int ioff=-mydiv(pos.x,gjump);
int joff=-mydiv(pos.y,gjump);
int koff=-mydiv(pos.z,gjump);
ori.quickorisetup();
// Need to find largest axis, and do loops with that one outside
int ks=mysgn(ori.qz.z);
int js=-mysgn(ori.qz.y);
int is=-mysgn(ori.qz.x);
for (int k=ks*gridsize;k!=-ks*gridsize;k=k-ks*gjump)
for (int i=-is*gridsize;i!=is*gridsize;i=i+is*gjump)
for (int j=-js*gridsize;j!=js*gridsize;j=j+js*gjump) {
int x,y;
V3d cen=V3d(i,j,k)-off;
cen=V3d::qorientate(cen,ori);
if (PPgetscrpos(cen,&x,&y)) {
int c=255-ucharchop(255*(cen.z+pd+1)/(gridsize+2));
c=quantiseto(64,c+63);
b.filledcircle(x,y,0.1*PPgetunit(cen),c);
}
}
b.writetoscreen();
b.saveframe();
acc=hang(acc,V3d::origin,0.92,0.01);
vel=hang(vel,ori.qz/5,0.99,0)+acc;
pos=pos+vel;
droll=hang(droll,0,0.9,0.01);
dyaw=hang(dyaw,0,0.95,0.01);
roll=hang(roll,0,0.95,0)+droll;
yaw=hang(yaw,0,0.92,0)+dyaw;
pitch=hang(pitch,0,0.999,0.01);
pos=pos+ori.qz*4;
ori.roll(roll/5.0);
ori.yaw(yaw/5.0);
pos=pos-ori.z()*4;
framedone();
} while (!key[KEY_SPACE] && !key[KEY_ESC]);
savetimer();
allegro_exit();
displayframespersecond();
}
/*
* interp2_table0_complex_per()
* 2D, 0th order, complex, periodic
*/
void interp2_table0_complex_per(
const double *r_ck, /* [K1,K2] in */
const double *i_ck,
const int K1,
const int K2,
const double *r_h1, /* [J1*L1+1,1] in */
const double *i_h1,
const double *r_h2, /* [J2*L2+1,1] in */
const double *i_h2,
const int J1,
const int J2,
const int L1,
const int L2,
const double *p_tm, /* [M,2] in */
const int M,
double *r_fm, /* [M,1] out */
double *i_fm)
{
int mm;
/* trick: shift table pointer to center */
{
const int ncenter1 = floor(J1 * L1/2);
r_h1 += ncenter1;
i_h1 += ncenter1;
}
{
const int ncenter2 = floor(J2 * L2/2);
r_h2 += ncenter2;
i_h2 += ncenter2;
}
/* interp */
for (mm=0; mm < M; mm++) {
int jj1, jj2;
const double t2 = p_tm[M];
const double t1 = *p_tm++;
double sum2r = 0;
double sum2i = 0;
const int koff1 = 1 + floor(t1 - J1 / 2.);
int k2 = 1 + floor(t2 - J2 / 2.);
for (jj2=0; jj2 < J2; jj2++, k2++) {
const double p2 = (t2 - k2) * L2;
const int n2 = /* ncenter2 + */ iround(p2);
const double coef2r = r_h2[n2];
const double coef2i = i_h2[n2];
const int k2mod = mymod(k2, K2);
const int k12mod = k2mod * K1;
register double sum1r = 0;
register double sum1i = 0;
int k1 = koff1;
for (jj1=0; jj1 < J1; jj1++, k1++) {
const double p1 = (t1 - k1) * L1;
const int n1 = /* ncenter1 + */ iround(p1);
register const double coef1r = r_h1[n1];
register const double coef1i = i_h1[n1];
const int k1mod = mymod(k1, K1);
const int kk = k12mod + k1mod; /* 2D array index */
/* sum1 += coef1 * ck */
sum1r += coef1r * r_ck[kk] - coef1i * i_ck[kk];
sum1i += coef1r * i_ck[kk] + coef1i * r_ck[kk];
} /* j1 */
/* sum2 += coef2 * sum1 */
sum2r += coef2r * sum1r - coef2i * sum1i;
sum2i += coef2r * sum1i + coef2i * sum1r;
} /* j2 */
*r_fm++ = sum2r;
*i_fm++ = sum2i;
}
}
int p(int i, int j){
if(i < 5 && j < 5) return mymod(i + j, 5);
if(i < 5 && j >= 5) return mymod(i + j - 5, 5) + 5;
if(i >= 5 && j < 5) return mymod(i - 5 - j, 5) + 5;
return mymod(i - j, 5);
}
void main() {
allegrosetup(scrwid,scrhei);
makepalette(&greypalette);
mypalette(255,0,0,0);
mypalette(0,0,0,0);
mypalette(255,1,1,1);
mypalette(128,0,0,0);
randomise();
for (int i=0;i<=5;i++) {
waves+Wave();
//waves.num(i).display();
}
for (int r=0;r<8;r++) {
for (int g=0;g<8;g++) {
int palc=r+g*8;
mypalette(palc,(r==0?0:0.1+0.6*r/7.0),(g==0?0:0.1+0.2*g/7.0),(g==0?0:0.1+0.7*g/7.0));
// Good colours: mypalette(palc,(r==0?0:0.3+0.4*r/7.0),(g==0?0:0.1+0.2*g/7.0),(g==0?0:0.3+0.5*g/7.0));
}
}
V3d vel=V3d(0,0,0);
V3d acc=V3d(0,0,0);
Ori ori;
float droll=0;
float dyaw=0;
float roll=0;
float yaw=0;
float pitch=0;
int frame=0;
List<V3d> particles=List<V3d>(gridsize*gridsize*gridsize);
/* for (int i=1;i<gridsize*gridsize*gridsize;i++) {
particles+gridsize*V3d(floatrnd(-1,1),floatrnd(-1,1),floatrnd(-1,1));
}*/
for (float thru=0;thru<1.0;thru+=0.01) {
particles+getpos(thru);
//v.print();
}
starttimer();
float thru=0;
V3d pos=getpos(thru);
do {
thru+=0.001;
V3d last=pos;
V3d pos=getpos(thru);
V3d newz=pos-last;
ori.forcez(newz);
frame++;
float pd=1.6+1.3*sin(2*pi*frame/1000.0);
PPsetup(scrwid,scrhei,pd);
left.clear(0);
right.clear(0);
// b.fadeby(16);
V3d off=V3d(mymod(pos.x,gridsize),mymod(pos.y,gridsize),mymod(pos.z,gridsize));
int ioff=-mydiv(pos.x,gjump);
int joff=-mydiv(pos.y,gjump);
int koff=-mydiv(pos.z,gjump);
ori.quickorisetup();
// Need to find largest axis, and do loops with that one outside
int ks=mysgn(ori.qz.z);
int js=-mysgn(ori.qz.y);
int is=-mysgn(ori.qz.x);
for (int i=1;i<=particles.len;i++) {
int x,y;
V3d p=particles.num(i);
//V3d cen=p-off;
V3d cen=p+pos;
cen=V3d(mymod2(cen.x,-gridsize,gridsize),mymod2(cen.y,-gridsize,gridsize),mymod2(cen.z,-gridsize,gridsize));
cen=V3d::qorientate(cen,ori);
int c=7.0-chop(6.0*(cen.z+gridsize)/(float)(gridsize*2),0,6);
plotsphere(cen,c);
}
for (int i=0;i<scrwid;i++) {
for (int j=0;j<scrhei;j++) {
b.bmp[j][i]=(left.bmp[j][i] | right.bmp[j][i]);
}
}
b.writetoscreen();
// acc=hang(acc,V3d::origin,0.95,0.01);
// vel=hang(vel,(ori.qz/5.0).neg(),0.9,0)+acc;
// pos=pos+vel;
// droll=hang(droll,0,0.9,0.01);
// dyaw=hang(dyaw,0,0.95,0.01);
// roll=hang(roll,0,0.95,0)+droll;
// yaw=hang(yaw,0,0.92,0)+dyaw;
// pitch=hang(pitch,0,0.999,0.01);
// pos=pos+ori.qz*4;
// ori.roll(roll/5.0);
// ori.yaw(yaw/5.0);
// pos=pos-ori.z()*4;
framedone();
} while (!key[KEY_SPACE] && !key[KEY_ESC]);
savetimer();
allegro_exit();
displayframespersecond();
}
float saw(float f) {
return mymod(f);
}
void main() {
setuptriglookup();
allegrosetup(scrwid,scrhei);
makepalette(&greypalette);
mypalette(255,0,0,0);
mypalette(0,0,0,0);
mypalette(255,1,1,1);
mypalette(128,0,0,0);
for (int r=0;r<16;r++) {
for (int g=0;g<16;g++) {
int palc=r+g*16;
mypalette(palc,(r==0?0:brightness+0.2+change*0.5*r/15.0),(g==0?0:brightness+change*0.1+0.2*g/15.0),(g==0?0:brightness+change*0.2+0.6*g/15.0));
// Groovy colours mypalette(palc,(r==0?0:0.1+0.6*r/15.0),(g==0?0:0.1+0.2*g/15.0),(g==0?0:0.1+0.7*g/15.0));
// Good colours: mypalette(palc,(r==0?0:0.3+0.4*r/15.0),(g==0?0:0.1+0.2*g/15.0),(g==0?0:0.3+0.5*g/15.0));
}
}
float pd=2.5;
PPsetup(scrwid,scrhei,pd);
V3d vel=V3d(0,0,0);
V3d acc=V3d(0,0,0);
float droll=0;
float dyaw=0;
float dpitch=0;
int frame=0;
// Set up track
randomise();
for (int i=0;i<=15;i++) {
waves+Wave();
// waves.num(i).display();
}
for (float thru=0;thru<1.0;thru+=1.0/(float)numps) {
V3d here=getpos(thru);
V3d forward=getpos(thru+0.00001)-here;
V3d up=V3d::normcross(V3d::crazy,forward);
V3d right=V3d::normcross(forward,up);
for (int i=0;i<tunnelps;i++) {
float t=2*pi*(float)i/(float)tunnelps;
float s=sin(t);
float c=cos(t);
V3d v=here+tunnelrad*(s*up+c*right);
octree.add(v);
}
}
for (int i=1;i<500;i++) {
octree.add(8.0*V3d(floatrnd(-1,1),floatrnd(-1,1),floatrnd(-1,1)));
}
// Display track
float t=0;
do {
t=t+0.03;
V3d from=V3d::rotate(6.0*V3d::k,V3d::j,t);
ori.forcez(from.neg());
pos=from;
plotscene();
writescreen();
} while (!key[KEY_SPACE]);
do {
} while (key[KEY_SPACE]);
// Race
starttimer();
float thru=0;
float marker=0;
pos=getpos(marker);
V3d *tail=new V3d[taillen];
int tailpos=0;
do {
thru+=0.001;
// V3d last=V3d(pos.x,pos.y,pos.z);
// V3d pos=getpos(thru);
// V3d next=getpos(thru+0.00001);
// V3d newz=next-pos;
// ori.forcez(newz);
frame++;
// float pd=1.6+1.3*sin(2*pi*frame/1000.0);
plotscene();
// Plot and move marker
V3d m;
for (int i=1;i<=15;i++) {
m=V3d::disorientate(getpos(marker)-pos,ori);
if (m.mod()<markerrange)
marker+=0.0002;
}
float u=PPgetunitnoadd(m);
bool plot=false;
if (u) {
int x,y;
float rad=0.12*u;
if (PPgetscrposnoadd(m,PPlefteye,&x,&y))
if (left.inimage(x,y)) {
plot=true;
left.opencircle(x,y,rad,15);
left.opencircle(x,y,rad/2,15);
}
if (PPgetscrposnoadd(m,PPrighteye,&x,&y))
if (right.inimage(x,y)) {
plot=true;
right.opencircle(x,y,rad,15*16);
right.opencircle(x,y,rad/2,15*16);
}
}
if (!plot) {
V2d v=scrwid*2*V2d(m.x,m.y).norm();
if (abs(v.x)>scrwid/2) {
float change=(float)scrwid/2.0/abs(v.x);
v=change*v;
}
if (abs(v.y)>scrhei/2) {
float change=(float)scrhei/2.0/abs(v.y);
v=change*v;
}
v=v+V2d(scrwid/2,scrhei/2);
left.opencircle(v,5,15);
right.opencircle(v,5,15*16);
}
// Pull player towards marker
// if (m.mod()>markerrange+.1) {
V3d pulldir=getpos(marker)-pos;
// vel=vel+pulldir*0.02;
// float amount=(V3d::normdot(ori.z(),pulldir)+5.0)/6.0;
float amount=chop(0.99-(m.mod()-markerrange)/5.0,0,1);
V3d newz=ori.z()*amount+(1.0-amount)*pulldir;
ori.forcez(newz);
// vel=vel*amount;
//
//
// }
// Draw and update tail
V3d last=(tail[tailpos]-pos).disorientate(ori);
for (int k=1;k<taillen;k++) {
int j=mymod(tailpos+k,taillen);
V3d next=(tail[j]-pos).disorientate(ori);
plotline(last,next,(float)k/(float)taillen);
last=next;
}
if ((frame % 2)==0) {
tail[tailpos]=pos-ori.qz;
tailpos=mymod(tailpos+1,taillen);
}
writescreen();
// acc=hang(acc,V3d::origin,0.95,0.01);
// Movement
float angvel=turnability;
if (key[KEY_LCONTROL])
vel=vel+ori.z()*forcevel;
else
angvel=turnability*2.0;
if (key[KEY_DOWN])
dpitch=dpitch+angvel;
if (key[KEY_UP])
dpitch=dpitch-angvel;
if (key[KEY_LEFT])
if (key[KEY_ALT])
droll=droll-angvel;
else
dyaw=dyaw-angvel;
if (key[KEY_RIGHT])
if (key[KEY_ALT])
droll=droll+angvel;
else
dyaw=dyaw+angvel;
vel=hang(vel,V3d::o,0.92,0);
pos=pos+vel;
droll=hang(droll,0,0.9,0);
dyaw=hang(dyaw,0,0.9,0);
dpitch=hang(dpitch,0,0.9,0);
ori.roll(droll/5.0);
ori.yaw(dyaw/5.0);
ori.pitch(dpitch/5.0);
framedone();
} while (!key[KEY_SPACE] && !key[KEY_ESC]);
savetimer();
allegro_exit();
displayframespersecond();
}
//==================================================
// simulation
//==================================================
void simulate(int seed){
ran_seed(seed);
int N = 18*512;
double radius = 1.0;
double L = sqrt(1.02*pi*radius*radius*N);
int Npercell = 50;
int pbc[] = {1,1};
double epsilon = 180.0;
double damp_coeff = 0.3;
double kickforce = 20.0;
double dt = 1e-1;
double t = 0.0;
double R = 2*radius;
double R2 = R*R;
int i, j, k;
int *key;
int *type = (int*)malloc(sizeof(int)*N);
int *neigh = (int*)malloc(sizeof(int)*N);
double *rad = (double*)malloc(sizeof(double)*N);
double *col = (double*)malloc(sizeof(double)*N);
for (i=0; i<N; i++){ type[i] = neigh[i] = rad[i] = 0;}
double *x = (double*)malloc(sizeof(double)*2*N);
double *v = (double*)malloc(sizeof(double)*2*N);
double *f = (double*)malloc(sizeof(double)*2*N);
double *w = (double*)malloc(sizeof(double)*2*N);
double *o = (double*)malloc(sizeof(double)*2*N);
for (i=0; i<2*N; i++){o[i] = x[i] = v[i] = f[i] = w[i] = 0.0;}
#ifdef PLOT
double time_end = 1e20;
#else
double time_end = 1e2;
#endif
#ifdef PLOT
plot_init();
plot_clear_screen();
key = plot_render_particles(x, rad, type, N, L,col);
#endif
//-------------------------------------------------
// initialize
for (i=0; i<N; i++){
rad[i] = radius;
x[2*i+0] = L*ran_ran2();
x[2*i+1] = L*ran_ran2();
v[2*i+0] = 0.0;
v[2*i+1] = 0.0;
type[i] = BLACK;
if (i==0) type[i] = RED;
}
//-------------------------------------------------------
// make boxes for the neighborlist
int size[2];
int size_total = 1;
for (i=0; i<2; i++){
size[i] = (int)(L / (R));
size_total *= size[i];
}
int *count = (int*)malloc(sizeof(int)*2*size_total);
int *cells = (int*)malloc(sizeof(int)*2*size_total*Npercell);
for (i=0; i<size_total; i++){
for (j=0; j<Npercell; j++)
cells[i*Npercell + j] = 0;
count[i] = 0;
}
//==========================================================
// where the magic happens
//==========================================================
int frames = 0;
#ifdef FPS
struct timespec start;
clock_gettime(CLOCK_REALTIME, &start);
#endif
int STRESS = 1;
double T = 0.0;
for (t=0.0; t<time_end; t+=dt){
double colmax = 0.0;
int index[2];
for (i=0; i<size_total; i++)
count[i] = 0;
for (i=0; i<N; i++){
col[i] = 0.0;
coords_to_index(&x[2*i], size, index, L);
int t = index[0] + index[1]*size[0];
cells[t*Npercell+count[t]] = i;
count[t]++;
}
int tt[2];
int tix[2];
int image[2];
double dx[2];
for (i=0; i<N; i++){
f[2*i+0] = 0.0;
f[2*i+1] = 0.0;
coords_to_index(&x[2*i], size, index, L);
for (tt[0]=-1; tt[0]<=1; tt[0]++){
for (tt[1]=-1; tt[1]<=1; tt[1]++){
int goodcell = 1;
for (j=0; j<2; j++){
tix[j] = mod_rvec(index[j]+tt[j],size[j]-1,pbc[j],&image[j]);
if (pbc[j] < image[j])
goodcell=0;
}
if (goodcell){
int ind = tix[0] + tix[1]*size[0];
for (j=0; j<count[ind]; j++){
int n = cells[ind*Npercell+j];
double dist = 0.0;
for (k=0; k<2; k++){
dx[k] = x[2*n+k] - x[2*i+k];
if (image[k])
dx[k] += L*tt[k];
dist += dx[k]*dx[k];
}
//===============================================
// force calculation - hertz
if (dist > 1e-10 && dist < R2){
double r0 = R;
double l = sqrt(dist);
double co = epsilon * (1-l/r0)*(1-l/r0) * (l<r0);
for (k=0; k<2; k++){
f[2*i+k] += - dx[k] * co;
if (STRESS==1) col[i] += co*co*dx[k]*dx[k];//100*co*dx[k];//sqrt(co*co*dx[k]*dx[k]);
}
if (STRESS==2) col[i] += dx[1] * co*co*dx[1];
if (STRESS==3) col[i] += dx[0] * co*co*dx[0];
if (STRESS==4) col[i] += dx[1] * co*co*dx[0];
}
}
}
} }
//====================================
// damping
f[2*i+0] -= damp_coeff*v[2*i+0];
f[2*i+1] -= damp_coeff*v[2*i+1];
//=====================================
// noise
f[2*i+0] += T*(ran_ran2()-0.5);
f[2*i+1] += T*(ran_ran2()-0.5);
//=====================================
// kick force
f[2*i+0] += o[2*i+0]; o[2*i+0] = 0.0;
f[2*i+1] += o[2*i+1]; o[2*i+1] = 0.0;
//=======================
// color norm
if (col[i] > colmax) colmax = col[i];
}
// now integrate the forces since we have found them
for (i=0; i<N;i++){
// Newton-Stomer-Verlet
if (key['h'] != 1){
v[2*i+0] += f[2*i+0] * dt;
v[2*i+1] += f[2*i+1] * dt;
x[2*i+0] += v[2*i+0] * dt;
x[2*i+1] += v[2*i+1] * dt;
}
// boundary conditions
for (j=0; j<2; j++){
if (pbc[j] == 1){
if (x[2*i+j] >= L-EPSILON || x[2*i+j] < 0)
x[2*i+j] = mymod(x[2*i+j], L);
}
else {
const double restoration = 1.0;
if (x[2*i+j] >= L){x[2*i+j] = 2*L-x[2*i+j]; v[2*i+j] *= -restoration;}
if (x[2*i+j] < 0) {x[2*i+j] = -x[2*i+j]; v[2*i+j] *= -restoration;}
if (x[2*i+j] >= L-EPSILON || x[2*i+j] < 0){x[2*i+j] = mymod(x[2*i+j], L);}
}
}
// just check for errors
if (x[2*i+0] >= L || x[2*i+0] < 0.0 ||
x[2*i+1] >= L || x[2*i+1] < 0.0)
printf("out of bounds\n");
//col[i] += v[2*i+0]*v[2*i+0] + v[2*i+1]*v[2*i+1];
if (STRESS == 1) col[i] = col[i]/8;
if (STRESS == 2) col[i] = col[i]/16;
if (STRESS == 3) col[i] = col[i]/16;
if (STRESS == 4) col[i] = col[i]/4;
if (STRESS > 1) col[i] = fabs(col[i])+0.5;
}
#ifdef PLOT
const int FRAMESKIP = 1;
if (frames % FRAMESKIP == 0){
char filename[100];
sprintf(filename, "screen_%05d.png", frames/FRAMESKIP);
plot_clear_screen();
key = plot_render_particles(x, rad, type, N, L,col);
#ifdef IMAGES
plot_saveimage(filename);
#endif
}
#endif
frames++;
if (key['1'] == 1) STRESS = 1;
if (key['2'] == 1) STRESS = 2;
if (key['3'] == 1) STRESS = 3;
if (key['4'] == 1) STRESS = 4;
if (key['q'] == 1)
break;
if (key['w'] == 1){
for (i=0; i<N; i++){
if (type[i] == RED)
o[2*i+1] = -kickforce;
}
}
if (key['s'] == 1){
for (i=0; i<N; i++){
if (type[i] == RED)
o[2*i+1] = kickforce;
}
}
if (key['a'] == 1){
for (i=0; i<N; i++){
if (type[i] == RED)
o[2*i+0] = -kickforce;
}
}
if (key['d'] == 1){
for (i=0; i<N; i++){
if (type[i] == RED)
o[2*i+0] = kickforce;
}
}
if (key['9'] == 1)
T -= 0.01;
if (key['0'] == 1)
T += 0.01;
if (key['8'] == 1)
T = 0.0;
if (key['o'] == 1)
L -= 0.01;
if (key['p'] == 1)
L += 0.01;
}
// end of the magic, cleanup
//----------------------------------------------
#ifdef FPS
struct timespec end;
clock_gettime(CLOCK_REALTIME, &end);
printf("fps = %f\n", frames/(end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec)/1e9);
#endif
free(cells);
free(count);
free(x);
free(v);
free(f);
free(w);
free(o);
free(neigh);
free(rad);
free(type);
#ifdef PLOT
plot_clean();
#endif
}
int main(int argc, char **argv)
{
int i,j,stillhappy;
Display *display;
int events;
rep tmp;
p.x=-0.9; p.y=0;
q.x=0.9; q.y=0;
srand48(time(tloc));
frame=0;
/* Connect to the server for display */
display = BWConnectToServer();
/* Open the windows */
window1 = BWCreateNewWindow(display, argc, argv, 882, 4);
window2 = BWCreateNewWindow(display, argc, argv, 882, 324);
for (i=0; i<numps; i++) {
randpart(&particle[i]);
}
for (i=0; i<numrs; i++) {
randrepulsor(&repulsor[i]);
}
/* Choose repulsors spread out
for (i=0; i<numrs; i++) {
randrepulsor(&repulsor[i]);
for (j=0; j<500; j++) {
randrepulsor(&tmp);
if (isolation(tmp,i)>isolation(repulsor[i],i)) {
repulsor[i]=tmp;
plotrepulsor(tmp);
}
}
}*/
while(1) {
events = BWCheckEvents(window1);
switch (events) {
/* Window exposed - redraw */
case EV_EXPOSED:
{
plotparts();
break;
}
/* Mouse button pressed - close both windows and exit*/
case EV_BUTTON:
{
BWCloseWindow(window1);
exit(0);
}
default: {
/* plotparts();*/
moveparts();
if (mymod(frame,32)==0) {
/* plotfield();*/
plotrepulsors();
}
frame=frame+speed;
break;
}
}
}
}
float modtwopi(float a) {
return mymod(a,2.0*pi);
}
float floatmod(float a,float b) {
return mymod(a,b);
}
/*
* interp3_table0_complex_per()
* 3D, 0th order, complex, periodic
*/
void interp3_table0_complex_per(
const double *r_ck, /* [K1,K2,K3] in */
const double *i_ck,
const int K1,
const int K2,
const int K3,
const double *r_h1, /* [J1*L1+1,1] in */
const double *i_h1,
const double *r_h2, /* [J2*L2+1,1] in */
const double *i_h2,
const double *r_h3, /* [J3*L3+1,1] in */
const double *i_h3,
const int J1,
const int J2,
const int J3,
const int L1,
const int L2,
const int L3,
const double *p_tm, /* [M,3] in */
const int M,
double *r_fm, /* [M,1] out */
double *i_fm)
{
int mm;
/* trick: shift table pointer to center */
{
const int ncenter1 = floor(J1 * L1/2);
r_h1 += ncenter1;
i_h1 += ncenter1;
}
{
const int ncenter2 = floor(J2 * L2/2);
r_h2 += ncenter2;
i_h2 += ncenter2;
}
{
const int ncenter3 = floor(J3 * L3/2);
r_h3 += ncenter3;
i_h3 += ncenter3;
}
/* interp */
for (mm=0; mm < M; mm++) {
int jj1, jj2, jj3;
const double t3 = p_tm[2*M];
const double t2 = p_tm[M];
const double t1 = *p_tm++;
double sum3r = 0;
double sum3i = 0;
const int koff1 = 1 + floor(t1 - J1 / 2.);
const int koff2 = 1 + floor(t2 - J2 / 2.);
int k3 = 1 + floor(t3 - J3 / 2.);
for (jj3=0; jj3 < J3; jj3++, k3++) {
const double p3 = (t3 - k3) * L3;
const int n3 = /* ncenter3 + */ iround(p3);
const double coef3r = r_h3[n3];
const double coef3i = i_h3[n3];
const int k3mod = mymod(k3, K3);
double sum2r = 0;
double sum2i = 0;
int k2 = koff2;
for (jj2=0; jj2 < J2; jj2++, k2++) {
const double p2 = (t2 - k2) * L2;
const int n2 = /* ncenter2 + */ iround(p2);
const double coef2r = r_h2[n2];
const double coef2i = i_h2[n2];
const int k2mod = mymod(k2, K2);
const int k23mod = (k3mod * K2 + k2mod) * K1;
register double sum1r = 0;
register double sum1i = 0;
int k1 = koff1;
for (jj1=0; jj1 < J1; jj1++, k1++) {
const double p1 = (t1 - k1) * L1;
const int n1 = /* ncenter1 + */ iround(p1);
register const double coef1r = r_h1[n1];
register const double coef1i = i_h1[n1];
const int k1mod = mymod(k1, K1);
const int kk = k23mod + k1mod; /* 3D array index */
/* sum1 += coef1 * ck */
sum1r += coef1r * r_ck[kk] - coef1i * i_ck[kk];
sum1i += coef1r * i_ck[kk] + coef1i * r_ck[kk];
} /* j1 */
/* sum2 += coef2 * sum1 */
sum2r += coef2r * sum1r - coef2i * sum1i;
sum2i += coef2r * sum1i + coef2i * sum1r;
} /* j2 */
/* sum3 += coef3 * sum2 */
sum3r += coef3r * sum2r - coef3i * sum2i;
sum3i += coef3r * sum2i + coef3i * sum2r;
} /* j3 */
*r_fm++ = sum3r;
*i_fm++ = sum3i;
}
}
