static void
r300_flush_vb( RadeonDriverData *rdrv, RadeonDeviceData *rdev )
{
volatile u8 *mmio = rdrv->mmio_base;
EMIT_VERTICES( rdrv, rdev, mmio );
if (DFB_PLANAR_PIXELFORMAT(rdev->dst_format)) {
DFBRegion clip;
int i;
for (i = 0; i < rdev->vb_size; i += 8) {
rdev->vb[i+0] = f2d(d2f(rdev->vb[i+0])*0.5f);
rdev->vb[i+1] = f2d(d2f(rdev->vb[i+1])*0.5f);
}
clip.x1 = rdev->clip.x1 >> 1;
clip.y1 = rdev->clip.y1 >> 1;
clip.x2 = rdev->clip.x2 >> 1;
clip.y2 = rdev->clip.y2 >> 1;
/* Prepare Cb plane */
radeon_waitfifo( rdrv, rdev, 5 );
radeon_out32( mmio, R300_RB3D_COLOROFFSET0, rdev->dst_offset_cb );
radeon_out32( mmio, R300_RB3D_COLORPITCH0, (rdev->dst_pitch>>1) |
R300_COLOR_FORMAT_RGB8 );
radeon_out32( mmio, R300_TX_SIZE_0, ((rdev->src_width/2 -1) << R300_TX_WIDTH_SHIFT) |
((rdev->src_height/2-1) << R300_TX_HEIGHT_SHIFT) |
R300_TX_SIZE_TXPITCH_EN );
radeon_out32( mmio, R300_TX_PITCH_0, (rdev->src_pitch>>1) - 8 );
radeon_out32( mmio, R300_TX_OFFSET_0, rdev->src_offset_cb );
r300_set_clip3d( rdrv, rdev, &clip );
/* Fill Cb plane */
EMIT_VERTICES( rdrv, rdev, mmio );
/* Prepare Cr plane */
radeon_waitfifo( rdrv, rdev, 2 );
radeon_out32( mmio, R300_RB3D_COLOROFFSET0, rdev->dst_offset_cr );
radeon_out32( mmio, R300_TX_OFFSET_0, rdev->src_offset_cr );
/* Fill Cr plane */
EMIT_VERTICES( rdrv, rdev, mmio );
/* Reset */
radeon_waitfifo( rdrv, rdev, 5 );
radeon_out32( mmio, R300_RB3D_COLOROFFSET0, rdev->dst_offset );
radeon_out32( mmio, R300_RB3D_COLORPITCH0, rdev->dst_pitch |
R300_COLOR_FORMAT_RGB8 );
radeon_out32( mmio, R300_TX_SIZE_0, ((rdev->src_width -1) << R300_TX_WIDTH_SHIFT) |
((rdev->src_height-1) << R300_TX_HEIGHT_SHIFT) |
R300_TX_SIZE_TXPITCH_EN );
radeon_out32( mmio, R300_TX_PITCH_0, rdev->src_pitch - 8 );
radeon_out32( mmio, R300_TX_OFFSET_0, rdev->src_offset );
r300_set_clip3d( rdrv, rdev, &rdev->clip );
}
static void dump_float(char *buf, int sz)
{
uint8_t *ptr = (uint8_t *)buf;
uint8_t *end = ptr + sz - 3;
int i = 0;
while (ptr < end) {
uint32_t d = 0;
printf((i % 8) ? " " : "\t");
d |= *(ptr++) << 0;
d |= *(ptr++) << 8;
d |= *(ptr++) << 16;
d |= *(ptr++) << 24;
printf("%8f", d2f(d));
if ((i % 8) == 7) {
printf("\n");
}
i++;
}
if (i % 8) {
printf("\n");
}
}
std::tuple<real_type, vector_type, matrix_type>
operator()(const vector_type& x) const
{
real_type f(1.0);
vector_type df(0, 1.0);
matrix_type d2f(0, 0, 0.0);
return std::make_tuple(f, df, d2f);
}
double numeric::optimize_newton_stabalized(double a, double b)
{
double f1a=d1f(a);
double f1b=d1f(b);
double x, f1x;
if(f1a==0)
{
return a;
}
if(f1b==0)
{
return b;
}
if(f1a*f1b>0)
{
cout << "error! optimize_newton_stabalized: f(a) and f(b) must have opposite sign!\n";
exit(-1);
}
double f2x=0;
for(int k=0; k<NS; k++)
{
if(abs(f1x)>PRECISION)
{
x=x-f1x/f2x;
}
if((abs(f2x)<=PRECISION) || (x<=a) || (x>=b))
{
x=(a+b)/2;
}
f1x=d1f(x);
f2x=d2f(x);
if(abs(f1x)<PRECISION)
{
return x;
}
else if(f1x*f1a<0)
{
b=x; f1b=f1x;
}
else if(f1x*f1b<0)
{
a=x; f1a=f1x;
}
}
return x;
}
static void initShot(int pl)
{
SimPlayer* p = &(player[pl]);
SimShot* s = &(p->shot[p->currentShot]);
SimMissile* m = &(s->missile);
m->position = p->position;
if((conf.mode & GM_ENERGY) != 0) {
p->energy -= p->velocity;
}
m->speed.x = p->velocity * cos(p->angle / 180.0 * M_PI);
m->speed.y = p->velocity * -sin(p->angle / 180.0 * M_PI);
m->live = 1;
m->leftSource = 0;
s->dot[0] = d2f(m->position);
s->length = 1;
s->player = pl;
}
double numeric::optimize_newton(double x)
{
double x_old=x+PRECISION;
double f2x;
for(int k=0; k<NS; k++)
{
f2x=d2f(x);
if(abs(f2x)<PRECISION)
{
cout << "error! optimize_newton: Instability!\n";
exit(-1);
}
x_old=x;
x=x-d1f(x)/f2x;
if(abs(x-x_old)<PRECISION)
{
return x;
}
}
cout << "error! optimize_newton: no convergence!\n";
exit(-1);
}
int
main (int argc, char **argv)
{
#define d2f pixman_double_to_fixed
GtkWidget *window, *swindow;
GtkWidget *table;
uint32_t *dest = malloc (WIDTH * HEIGHT * 4);
uint32_t *src = malloc (WIDTH * HEIGHT * 4);
pixman_image_t *src_img;
pixman_image_t *dest_img;
pixman_point_fixed_t p1 = { -10 << 0, 0 };
pixman_point_fixed_t p2 = { WIDTH << 16, (HEIGHT - 10) << 16 };
uint16_t full = 0xcfff;
uint16_t low = 0x5000;
uint16_t alpha = 0xffff;
pixman_gradient_stop_t stops[6] =
{
{ d2f (0.0), { full, low, low, alpha } },
{ d2f (0.25), { full, full, low, alpha } },
{ d2f (0.4), { low, full, low, alpha } },
{ d2f (0.6), { low, full, full, alpha } },
{ d2f (0.8), { low, low, full, alpha } },
{ d2f (1.0), { full, low, full, alpha } },
};
int i;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_main_quit),
NULL);
table = gtk_table_new (G_N_ELEMENTS (operators) / 6, 6, TRUE);
src_img = pixman_image_create_linear_gradient (&p1, &p2, stops,
G_N_ELEMENTS (stops));
pixman_image_set_repeat (src_img, PIXMAN_REPEAT_PAD);
dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
WIDTH, HEIGHT,
dest,
WIDTH * 4);
pixman_image_set_accessors (dest_img, reader, writer);
for (i = 0; i < G_N_ELEMENTS (operators); ++i)
{
GtkWidget *image;
GdkPixbuf *pixbuf;
GtkWidget *vbox;
GtkWidget *label;
int j, k;
vbox = gtk_vbox_new (FALSE, 0);
label = gtk_label_new (operators[i].name);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 6);
gtk_widget_show (label);
for (j = 0; j < HEIGHT; ++j)
{
for (k = 0; k < WIDTH; ++k)
dest[j * WIDTH + k] = 0x7f6f6f00;
}
pixman_image_composite (operators[i].op, src_img, NULL, dest_img,
0, 0, 0, 0, 0, 0, WIDTH, HEIGHT);
pixbuf = pixbuf_from_argb32 (pixman_image_get_data (dest_img), TRUE,
WIDTH, HEIGHT, WIDTH * 4);
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
gtk_widget_show (image);
gtk_table_attach_defaults (GTK_TABLE (table), vbox,
i % 6, (i % 6) + 1, i / 6, (i / 6) + 1);
gtk_widget_show (vbox);
g_object_unref (pixbuf);
}
pixman_image_unref (src_img);
free (src);
pixman_image_unref (dest_img);
free (dest);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), table);
gtk_widget_show (table);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_widget_show (swindow);
gtk_widget_show (window);
gtk_main ();
return 0;
}
REAL d2fdy(const REAL h, const Matrix& f, const unsigned i, const unsigned j)
{
return d2f(h, f.at(i,j-1), f.at(i,j), f.at(i,j+1));
}
REAL d2fdx(const REAL h, const Matrix& f, const unsigned i, const unsigned j)
{
return d2f(h, f.at(i-1,j), f.at(i,j), f.at(i+1,j));
}
double d2Negate::operator()(const Vec &x, Vec &g, Mat &h)const{
double ans = d2f(x,g,h);
g*= -1;
h*= -1.0;
return -1*ans; }
integer Cas2Shuttle(CASblock & buffer, ShuttlePar & block){
/* Reading M1950 coordinates and velocities from CAs */
const int foot_cm=30.48;
double Coo_M1950[3], Vel_M1950[3], q[4], Greenw_Phi, Vel_angle;
polar Geo,Solar;
Euler Euler_LVLH;
Coo_M1950[0]=CASvalue(buffer,(4490),8) * foot_cm;
Coo_M1950[1]=CASvalue(buffer,(4508),8) * foot_cm;
Coo_M1950[2]=CASvalue(buffer,(4526),8) * foot_cm;
Vel_M1950[0]=CASvalue(buffer,(4687),8) * foot_cm;
Vel_M1950[1]=CASvalue(buffer,(4701),8) * foot_cm;
Vel_M1950[2]=CASvalue(buffer,(4715),8) * foot_cm;
q[0]=CASvalue(buffer,(3291),8);
q[1]=CASvalue(buffer,(3305),8);
q[2]=CASvalue(buffer,(3319),8);
q[3]=CASvalue(buffer,(3333),8);
double times= CAStime(buffer,10);
time_t utime = time_t(times+0.5) + Year1998;
// check record
if((Radius(Coo_M1950)<=.1) || (Radius(Vel_M1950)<=.1) || (times<=0))return 0;
// convert here
Coordinates(Coo_M1950,Vel_M1950,q,utime,&Geo,&Vel_angle,&Euler_LVLH,&Solar,&Greenw_Phi);
if(!td2f(Geo.Teta))return -1;
if(!td2f(Geo.Phi))return -1;
if(!td2f(Geo.R))return -1;
if(!td2f(Greenw_Phi))return -1;
if(!td2f(Euler_LVLH.Yaw))return -1;
if(!td2f(Euler_LVLH.Pitch))return -1;
if(!td2f(Euler_LVLH.Yaw))return -1;
if(!td2f(Vel_angle))return -1;
if(!td2f(Solar.R))return -1;
if(!td2f(Solar.Phi))return -1;
if(!td2f(Solar.Teta))return -1;
block.StationTheta=d2f(Geo.Teta);
block.StationPhi=d2f(Geo.Phi);
block.StationR=d2f(Geo.R);
block.GrMedPhi=d2f(Greenw_Phi);
block.StationYaw=d2f(Euler_LVLH.Yaw);
block.StationPitch=d2f(Euler_LVLH.Pitch);
block.StationRoll=d2f( Euler_LVLH.Roll);
block.StationSpeed=d2f( Vel_angle);
block.SunR=d2f(Solar.R);
block.SunPhi=d2f(Solar.Phi);
block.SunTheta=d2f(Solar.Teta);
//cout <<" "<<ClockTune(utime)<<" "<<ctime(&utime)<<endl;
block.Time=utime-ClockTune(utime);
}
static void simulate(void)
{
int sh, i, j, pl, pl2, actp;
double l;
Vec2d v;
for(i = 0; i < conf.segmentSteps; ++i)
{
for(pl = 0; pl < conf.maxPlayers; ++pl)
{
SimPlayer* p = &(player[pl]);
if(p->watch) continue;
if(!p->active) continue;
for(sh = 0; sh < conf.numShots; ++sh)
{
SimShot* s = &(p->shot[sh]);
SimMissile* m = &(s->missile);
if(!m->live) continue;
for(j = 0; j < conf.numPlanets; ++j)
{
v = vsub(planet[j].position, m->position);
l = length(v);
if (l <= planet[j].radius)
{
planetHit(s);
}
v = vdiv(v, l);
v = vmul(v, planet[j].mass / (l * l));
v = vdiv(v, conf.segmentSteps);
m->speed = vadd(m->speed, v);
}
v = vdiv(m->speed, conf.segmentSteps);
m->position = vadd(m->position, v);
for(pl2 = 0; pl2 < conf.maxPlayers; ++pl2)
{
if(!player[pl2].active) continue;
l = distance(player[pl2].position, m->position);
if ( (l <= conf.playerDiameter)
&& (m->leftSource == 1)
)
{
if(conf.debug & 1) printf("l = %.5f playerDiameter = %.5f missile.x = %.5f missile.y = %.5f player.x = %5f player.y = %5f\n",l,conf.playerDiameter,m->position.x,m->position.y,player[pl2].position.x,player[pl2].position.y);
playerHit(s, pl, pl2);
}
if ( (l > (conf.playerDiameter + 1))
&& (pl2 == pl)
)
{
m->leftSource = 1;
}
}
if ( (m->position.x < -conf.marginleft)
|| (m->position.x > conf.battlefieldW + conf.marginright)
|| (m->position.y < -conf.margintop)
|| (m->position.y > conf.battlefieldH + conf.marginbottom)
)
{
wallHit(s);
}
}
}
}
for(pl = 0, actp = 0; pl < conf.maxPlayers; ++pl) actp += player[pl].active;
for(pl = 0; pl < conf.maxPlayers; ++pl)
{
SimPlayer* p = &(player[pl]);
if(!p->active) continue;
if(p->watch) continue;
if(p->timeout) p->timeout--;
if(p->valid || actp == 1) p->timeout = conf.timeout;
for(sh = 0; sh < conf.numShots; ++sh)
{
SimShot* s = &(p->shot[sh]);
if(!s->missile.live) continue;
p->timeout = conf.timeout;
player[currentPlayer].timeoutcnt = 0;
s->dot[s->length++] = d2f(s->missile.position);
if(s->length == conf.maxSegments)
{
s->missile.live = 0;
allSendShotFinished(s);
}
}
}
}
static void missileEnd(SimShot* s)
{
s->missile.live = 0;
s->dot[s->length++] = d2f(s->missile.position);
allSendShotFinished(s);
}
int
main (int argc, char **argv)
{
#define WIDTH 200
#define HEIGHT 200
#define d2f pixman_double_to_fixed
uint32_t *src = malloc (WIDTH * HEIGHT * 4);
uint32_t *mask = malloc (WIDTH * HEIGHT * 4);
uint32_t *dest = malloc (WIDTH * HEIGHT * 4);
pixman_fixed_t convolution[] =
{
d2f (3), d2f (3),
d2f (0.5), d2f (0.5), d2f (0.5),
d2f (0.5), d2f (0.5), d2f (0.5),
d2f (0.5), d2f (0.5), d2f (0.5),
};
pixman_image_t *simg, *mimg, *dimg;
int i;
for (i = 0; i < WIDTH * HEIGHT; ++i)
{
src[i] = 0x7f007f00;
mask[i] = (i % 256) * 0x01000000;
dest[i] = 0;
}
simg = pixman_image_create_bits (PIXMAN_a8r8g8b8, WIDTH, HEIGHT, src, WIDTH * 4);
mimg = pixman_image_create_bits (PIXMAN_a8r8g8b8, WIDTH, HEIGHT, mask, WIDTH * 4);
dimg = pixman_image_create_bits (PIXMAN_a8r8g8b8, WIDTH, HEIGHT, dest, WIDTH * 4);
pixman_image_set_filter (mimg, PIXMAN_FILTER_CONVOLUTION,
convolution, 11);
pixman_image_composite (PIXMAN_OP_OVER, simg, mimg, dimg, 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT);
show_image (dimg);
return 0;
}
static void
r100_flush_vb( RadeonDriverData *rdrv, RadeonDeviceData *rdev )
{
volatile u8 *mmio = rdrv->mmio_base;
EMIT_VERTICES( rdrv, rdev, mmio );
if (DFB_PLANAR_PIXELFORMAT(rdev->dst_format)) {
DFBRegion *clip = &rdev->clip;
bool s420 = DFB_PLANAR_PIXELFORMAT(rdev->src_format);
int i;
if (DFB_BLITTING_FUNCTION(rdev->accel)) {
for (i = 0; i < rdev->vb_size; i += 4) {
rdev->vb[i+0] = f2d(d2f(rdev->vb[i+0])*0.5f);
rdev->vb[i+1] = f2d(d2f(rdev->vb[i+1])*0.5f);
if (s420) {
rdev->vb[i+2] = f2d(d2f(rdev->vb[i+2])*0.5f);
rdev->vb[i+3] = f2d(d2f(rdev->vb[i+3])*0.5f);
}
}
} else {
for (i = 0; i < rdev->vb_size; i += 2) {
rdev->vb[i+0] = f2d(d2f(rdev->vb[i+0])*0.5f);
rdev->vb[i+1] = f2d(d2f(rdev->vb[i+1])*0.5f);
}
}
/* Prepare Cb plane */
radeon_waitfifo( rdrv, rdev, 5 );
radeon_out32( mmio, RB3D_COLOROFFSET, rdev->dst_offset_cb );
radeon_out32( mmio, RB3D_COLORPITCH, rdev->dst_pitch/2 );
radeon_out32( mmio, RE_TOP_LEFT, (clip->y1/2 << 16) |
(clip->x1/2 & 0xffff) );
radeon_out32( mmio, RE_BOTTOM_RIGHT, (clip->y2/2 << 16) |
(clip->x2/2 & 0xffff) );
if (DFB_BLITTING_FUNCTION(rdev->accel)) {
radeon_out32( mmio, PP_TFACTOR_0, rdev->cb_cop );
if (s420) {
radeon_waitfifo( rdrv, rdev, 3 );
radeon_out32( mmio, PP_TEX_SIZE_0, ((rdev->src_height/2-1) << 16) |
((rdev->src_width/2-1) & 0xffff) );
radeon_out32( mmio, PP_TEX_PITCH_0, rdev->src_pitch/2 - 32 );
radeon_out32( mmio, PP_TXOFFSET_0, rdev->src_offset_cb );
}
} else {
radeon_out32( mmio, PP_TFACTOR_1, rdev->cb_cop );
}
/* Fill Cb plane */
EMIT_VERTICES( rdrv, rdev, mmio );
/* Prepare Cr plane */
radeon_waitfifo( rdrv, rdev, 2 );
radeon_out32( mmio, RB3D_COLOROFFSET, rdev->dst_offset_cr );
if (DFB_BLITTING_FUNCTION(rdev->accel)) {
radeon_out32( mmio, PP_TFACTOR_0, rdev->cr_cop );
if (s420) {
radeon_waitfifo( rdrv, rdev, 1 );
radeon_out32( mmio, PP_TXOFFSET_0, rdev->src_offset_cr );
}
} else {
radeon_out32( mmio, PP_TFACTOR_1, rdev->cr_cop );
}
/* Fill Cr plane */
EMIT_VERTICES( rdrv, rdev, mmio );
/* Reset */
radeon_waitfifo( rdrv, rdev, 5 );
radeon_out32( mmio, RB3D_COLOROFFSET, rdev->dst_offset );
radeon_out32( mmio, RB3D_COLORPITCH, rdev->dst_pitch );
radeon_out32( mmio, RE_TOP_LEFT, (clip->y1 << 16) |
(clip->x1 & 0xffff) );
radeon_out32( mmio, RE_BOTTOM_RIGHT, (clip->y2 << 16) |
(clip->x2 & 0xffff) );
if (DFB_BLITTING_FUNCTION(rdev->accel)) {
radeon_out32( mmio, PP_TFACTOR_0, rdev->y_cop );
if (s420) {
radeon_waitfifo( rdrv, rdev, 3 );
radeon_out32( mmio, PP_TEX_SIZE_0, ((rdev->src_height-1) << 16) |
((rdev->src_width-1) & 0xffff) );
radeon_out32( mmio, PP_TEX_PITCH_0, rdev->src_pitch - 32 );
radeon_out32( mmio, PP_TXOFFSET_0, rdev->src_offset );
}
} else {
radeon_out32( mmio, PP_TFACTOR_1, rdev->y_cop );
}
}
rdev->vb_size = 0;
rdev->vb_count = 0;
}
inline double d2f(const TinyVector<double,3>& pos) {
return d2f(pos[0],pos[1],pos[2]);
}
