GravityMap (Var: Merkelig feilmelding fra GCC)

[kyrsjo]

Når jeg kompilerer gravitasjons-kart programmet mitt, får jeg følgende feilmelding:

 

main.c: In function `grav_calc':
main.c:91: warning: left-hand operand of comma expression has no effect

 

Dette peker på denne lille funksjonen:

double grav_calc (double dx, double dy, double mass) {
return ((GAMMA * mass) / (dy*dy + dx*dx)); <- gir feil
}

Forøvrig har det ikke noe å si om jeg skriver slik:

double result;
result = (GAMMA * mass ... <- gir samme feil
return result;

 

Et annet problem, er at det gir litt feil resultat når jeg regner:

bash-3.00$ ./GravityMap
esd: Failed to fix owner of /tmp/.esd.
Try -trust to force esd to start.
esd: Esound sound daemon unable to create unix domain socket:
/tmp/.esd/socket
The socket is not accessible by esd.
Exiting...
Testing with the radius of the earth: 64612199945301.320312
QUIT!!
bash-3.00$

 

Nå er vel tyngdeakserelasjonen ved jordas overflate 9,81 da - noe denne gir:

//testprog.c

#include <stdlib.h>
#include <stdio.h>

#define GAMMA 0.0000000000667

int main () {


       double dy = 0;
       double dx = 6371000;
       double mass = 5974000000000000000000000.0;

       printf ("%d\n", (int)sizeof (double));
       double result;
       result = (GAMMA * mass) / (dy*dy + dx*dx);
       printf ("%f\n", result);
       return 0;
}

Kjøring:

bash-3.00$ ./test
8
9.816933
bash-3.00$

 

Tilsist: den fulle og hele koden:

 

#include <stdlib.h>
#include "SDL.h"

//Resolution. Shold be autodetected...
#define ROWS 640
#define COLS 480

//Plotting stuff. Should eventually become dynamical...
// 6*10^8 / 640
#define METERPRPIXEL 937500
// 10^8 / 640
#define Xcenter 156250
// 480 / 2
#define Ycenter 240

//Input values. MUST get dynamical ASAP, those here are just for testing!
//Object 1 (Earth) - 5,974*10^24
#define MASS1 5974000000000000000000000

//Natural constants
//Gravitational constant, 6,67*10^-11
#define GAMMA 0,0000000000667

//Functions
double grav_calc (double dx, double dy, double mass);

void lock();
void unlock();
void drawrect(int x1, int y1, int x2, int y2, Uint8 r, Uint8 g, Uint8 b);
void setpixel(int x, int y, Uint8 r, Uint8 g, Uint8 b);



//Arrays to keep the info
double gravDepth1   [ROWS] [COLS];
double gravDepth2   [ROWS] [COLS];
double gravDepthSum [ROWS] [COLS];

//SDL stuff
SDL_Surface *screen;
SDL_Event event;

int main(int argc, char *argv[]) {
//Initialize SDL
if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0 ) {
 fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
 exit(1);
}
atexit(SDL_Quit);


screen = SDL_SetVideoMode(ROWS, COLS, 16, SDL_SWSURFACE);
if ( screen == NULL ) {
 fprintf(stderr, "Unable to set 640x480 video: %s\n", SDL_GetError());
       	exit(1);
}

//Create some data!
printf ("Testing with the radius of the earth: %f \n", grav_calc (6371000,0,5974000000000000000000000.0));

//Wait for input
while(SDL_WaitEvent(&event)) {
 switch(event.type) {
 	case SDL_QUIT:
   printf ("QUIT!!\n");
   return (0);
 	break;
 	
 	/*
 	case SDL_KEYDOWN:
   switch (event.key.keysym.sym)
   	case SDLK_SPACE:
     //drawrect (50,50,200,200,255,255,255);
     printf ("SPACE!!\n");
     break;
   	//Why isn't this working? (i get a whole lot of error
   	//messages at compile time)
   	//I do not want to handle every key i don't use...
   	default:
     printf ("DEFAULT!!\n");
     break;
 	*/
 }
 SDL_Flip(screen);
}

return (0);
}

double grav_calc (double dx, double dy, double mass) {
return ((GAMMA * mass) / (dy*dy + dx*dx));
}
//**************************************************************************
//********************** SDL DRAWING FUNCTIONS *****************************
//**************************************************************************
void lock()
{
 /* Lock the screen, if needed */
 if(SDL_MUSTLOCK(screen)) 
 {
   if(SDL_LockSurface(screen) < 0) 
     return;
 }
}

void unlock()
{
 /* Unlock the screen if needed */
 if(SDL_MUSTLOCK(screen)) {
   SDL_UnlockSurface(screen);
 }
}


void drawrect(int x1, int y1, int x2, int y2, Uint8 r, Uint8 g, Uint8 b)
{

   Uint32 color;
   color = SDL_MapRGB (screen->format, r, g, b);

   SDL_Rect rect;
   rect.w = x2;
   rect.h = y2;
   rect.x = x1;
   rect.y = y1;
   lock();
   SDL_FillRect (screen, &rect, color);
   unlock();
}



void setpixel(int x, int y, Uint8 r, Uint8 g, Uint8 b)
{
 Uint8  *ubuff8;
 Uint16 *ubuff16;
 Uint32 *ubuff32;
 Uint32 color;
 char c1, c2, c3;

 lock();
 /* Get the color */
 color = SDL_MapRGB( screen->format, r, g, b );
 
 /* How we draw the pixel depends on the bitdepth */
 switch(screen->format->BytesPerPixel) 
 {
   case 1: 
     ubuff8 = (Uint8*) screen->pixels;
     ubuff8 += (y * screen->pitch) + x; 
     *ubuff8 = (Uint8) color;
     break;

   case 2:
     ubuff8 = (Uint8*) screen->pixels;
     ubuff8 += (y * screen->pitch) + (x*2);
     ubuff16 = (Uint16*) ubuff8;
     *ubuff16 = (Uint16) color; 
     break;  

   case 3:
     ubuff8 = (Uint8*) screen->pixels;
     ubuff8 += (y * screen->pitch) + (x*3);
     

     if(SDL_BYTEORDER == SDL_LIL_ENDIAN) 
     {
c1 = (color & 0xFF0000) >> 16;
c2 = (color & 0x00FF00) >> 8;
c3 = (color & 0x0000FF);
     } else 
     {
c3 = (color & 0xFF0000) >> 16;
c2 = (color & 0x00FF00) >> 8;
c1 = (color & 0x0000FF);	
     }

     ubuff8[0] = c3;
     ubuff8[1] = c2;
     ubuff8[2] = c1;
     break;
     
   case 4:
     ubuff8 = (Uint8*) screen->pixels;
     ubuff8 += (y*screen->pitch) + (x*4);
     ubuff32 = (Uint32*)ubuff8;
     *ubuff32 = color;
     break;
     
   default:
     fprintf(stderr, "Error: Unknown bitdepth!\n");
   }
 
unlock();
}

 

Hva kan forårsake dette? Sterkt undrende...

Endret 4. april 2005 av kyrsjo

[A_N_K]

Når jeg kompilerer gravitasjons-kart programmet mitt, får jeg følgende feilmelding:

 

main.c: In function `grav_calc':
main.c:91: warning: left-hand operand of comma expression has no effect

Du bør undersøke definisjonen av GAMMA .

[Feynman]

//Natural constants
//Gravitational constant, 6,67*10^-11
#define GAMMA 0,0000000000667

Du bør i hvert fall erstatte kommaet med et punktum.

[kyrsjo]

D'oh. Hadde retta det opp i "test.c"...

 

Takker! Nå fiksa det seg

 

Da var det over til å begynne å fylle matrisen, og tegne ut...

[☀ ❄]

Moralen er: Bruk C++. Unngå #defines.

[hishadow]

Moralen er: Bruk C++. Unngå #defines.

Hør! Hør!

 

Og jeg vil også minne om const, som mange overser nytten av.

[A_N_K]

Mye moro med makroer

[kyrsjo]

Bah... C! C! Ikke at forskjellen er kjeeempestor... Har uansett ingen anelse om hva jeg skal bytte ut defines'ene med... Ender vel med at jeg lager en variabel, og endrer define - definisjonen til å peke til variabelen

 

Kommet opp i et nytt problem:

 

gcc -Wall `sdl-config --cflags --libs` main.c -o gravitymap
main.c: In function `main':
main.c:60: error: `for' loop initial declaration used outside C99 mode
main.c:61: error: `for' loop initial declaration used outside C99 mode

 

WFT? Noen som vet om en liste over GCC-feilmelinger og deres løsning?

 

Aktuelle kode:

for (int x = 0; x <= ROWS; x++) {
 for (int y = 0; y <= COLS; y++) {
 	printf("x = %d, y = %d\n", x, y);
 }
}

 

Forøvrig lar programmet seg fin-fint kompilere og kjøre som C++ (om jeg bytter ut gcc med g++ altså). Men det var ikke det jeg ville...

[Feynman]

Siste rad (kolonne) har verdien ROWS-1 (COLS-1). Løkken må derfor stoppe ved x < ROWS (y < COLS).

[☀ ❄]

Jeg er ikke enig i at forskjellen mellom C og C++ ikke er kjempestor. Jeg synes den er det, bare ikke syntaksmessig. Men det er en annen diskusjon

 

Feilen du gjør er at du deklarerer variabler i første del av en for-løkke. Det har du ikke lov til i C (med unntak av C99), for deklarasjoner skal dukke opp i begynnelsen av en blokk.

 

Riktig:

void f()
{
    int i;
    for (i = 0; i < 5; ++i) {
        /* ... */
    }
}

 

 

Galt:

void f()
{
    for (int i = 0; i < 5; ++i) {
         /* ... */
    }
}

[hishadow]

for (int x = 0; x <= ROWS; x++) {
 for (int y = 0; y <= COLS; y++) {
 	printf("x = %d, y = %d\n", x, y);
 }
}

Hvorfor teller du fra 0 til og med ROWS/COLS?

[kyrsjo]

Ahh.. Gjorde vist et par feil der - er ikke helt stø på c(++) ennå. Men da får vi deklarere dem.

 

Forøvrig teller jeg til rows/cols fordi jeg skal bruke dem til å fylle array'et etterpå... Noe som medfører at jeg glemte at array's i C(++) går fra null og har cols-1 som maks... Ups. Hadde vel funnet ut av det etter en "uforklarlig" segfault eller femten...

 

const var kansje en idé.

[kyrsjo]

Har putta inn en del mer (denne tråden blir rene CVS'en ) - nå regner den faktisk ut gravitasjons-verdiene, og putter dem inn. Den tegner til og med! Men tegningen har et ørlite problem (nevermind the speed - men der er vel "printf" en av de større synderene...) - den er for svak. Programmet genererer et veldig lite tall som stort sett ligger under 0,001 -> må forsterkes. Med nåværende algoritme (ønsker ikke å sprenge Uint8 heller! - maks 255...) får jeg i beste fall "2,0,0" som fargeverdi, og det er rimelig svart. Regner med at jeg trenger noe logaritme-greier... - eller i alle fall x^value. Men hvordan man utrykker "^" i C (samt log etc) er meg ukjent. Pluss at en enkel "x^value" vil være motsatt av det jeg trenger - jeg vil forsterke de svake mye, de sterke lite, og få dem til å fylle skalaen 0-255 ganske bra.

 

Noen idé'er? Takk for all hjelp hitil!

 

Foreløpig kode:

#include <stdlib.h>
#include "SDL.h"

//Resolution. Shold be autodetected...
#define ROWS 640
#define COLS 480

//Plotting stuff. Should eventually become dynamical...
// 6*10^8 / 640
#define METERPRPIXEL 937500
// 640 / 5
#define Xcenter 128
// 480 / 2
#define Ycenter 240

//Input values. MUST get dynamical ASAP, those here are just for testing!
//Object 1 (Earth) - 5,974*10^24
#define MASS1 5974000000000000000000000.0

//Natural constants
//Gravitational constant, 6,67*10^-11
#define GAMMA 0.0000000000667

//Functions
double grav_calc (double dx, double dy, double mass);
double grav_UnitConv (int grav_PixelValue);

Uint8 grav_colorConvR (double value);
Uint8 grav_colorConvG (double value);
Uint8 grav_colorConvB (double value);

void lock();
void unlock();
void drawrect(int x1, int y1, int x2, int y2, Uint8 r, Uint8 g, Uint8 b);
void setpixel(int x, int y, Uint8 r, Uint8 g, Uint8 b);



//Arrays to keep the info
double gravDepth1   [ROWS] [COLS];
double gravDepth2   [ROWS] [COLS];
double gravDepthSum [ROWS] [COLS];

//SDL stuff
SDL_Surface *screen;
SDL_Event event;

int main(int argc, char *argv[]) {
//Initialize SDL
if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0 ) {
 fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
 exit(1);
}
atexit(SDL_Quit);


screen = SDL_SetVideoMode(ROWS, COLS, 16, SDL_SWSURFACE);
if ( screen == NULL ) {
 fprintf(stderr, "Unable to set 640x480 video: %s\n", SDL_GetError());
 exit(1);
}

//Create some data!
printf ("Testing with the radius of the earth: %f \n", grav_calc (6371000,0,5974000000000000000000000.0));
int x;
int y;
for (x = 0; x < ROWS; x++) {
 for (y = 0; y < COLS; y++) {
 	gravDepth1 [x] [y] = grav_calc (grav_UnitConv(x - Xcenter), grav_UnitConv(y - Ycenter), MASS1);
 	printf ("Depth in (%d,%d):%f - colour: %d\n",x,y,gravDepth1 [x] [y], grav_colorConvR(gravDepth1 [x] [y]));
 	setpixel (x , y, grav_colorConvR(gravDepth1 [x] [y]),0, 0);
 	//setpixel (x, y, 255, 255, 255);
 	//drawrect (x,y,x+10,y+10,255,255,255);
 	//break;
 }
 SDL_Flip(screen);
 //break;
}

//Draw the data!


//Wait for input
while(SDL_WaitEvent(&event)) {
 switch(event.type) {
 	case SDL_QUIT:
   printf ("QUIT!!\n");
   return (0);
 	break;
 	
 	/*
 	case SDL_KEYDOWN:
   switch (event.key.keysym.sym)
   	case SDLK_SPACE:
     //drawrect (50,50,200,200,255,255,255);
     printf ("SPACE!!\n");
     break;
   	//Why isn't this working? (i get a whole lot of error
   	//messages at compile time)
   	//I do not want to handle every key i don't use...
   	default:
     printf ("DEFAULT!!\n");
     break;
 	*/
 }
 SDL_Flip(screen);
}

return (0);
}

double grav_calc (double dx, double dy, double mass) {
return ((GAMMA * mass) / (dy*dy + dx*dx));
}

double grav_UnitConv (int grav_PixelValue) {
return (METERPRPIXEL * grav_PixelValue);
}

//Convert gravity depth value to a sane colour value
Uint8 grav_colorConvR (double value) {
return ((value / 20) * 255);
}
Uint8 grav_colorConvG (double value) {
return 0;
}
Uint8 grav_colorConvB (double value) {
return 0;
}

//**************************************************************************
//********************** SDL DRAWING FUNCTIONS *****************************
//**************************************************************************
void lock()
{
/* Lock the screen, if needed */
if(SDL_MUSTLOCK(screen)) 
{
if(SDL_LockSurface(screen) < 0) 
return;
}
}

void unlock()
{
/* Unlock the screen if needed */
if(SDL_MUSTLOCK(screen)) {
SDL_UnlockSurface(screen);
}
}


void drawrect(int x1, int y1, int x2, int y2, Uint8 r, Uint8 g, Uint8 b)	{
Uint32 color;
color = SDL_MapRGB (screen->format, r, g, b);

SDL_Rect rect;
rect.w = x2;
rect.h = y2;
rect.x = x1;
rect.y = y1;
lock();
SDL_FillRect (screen, &rect, color);
unlock();
}



void setpixel(int x, int y, Uint8 r, Uint8 g, Uint8 b) {
Uint8  *ubuff8;
Uint16 *ubuff16;
Uint32 *ubuff32;
Uint32 color;
char c1, c2, c3;

lock();
/* Get the color */
color = SDL_MapRGB( screen->format, r, g, b );

/* How we draw the pixel depends on the bitdepth */
switch(screen->format->BytesPerPixel) 
{
case 1: 
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y * screen->pitch) + x; 
*ubuff8 = (Uint8) color;
break;

case 2:
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y * screen->pitch) + (x*2);
ubuff16 = (Uint16*) ubuff8;
*ubuff16 = (Uint16) color; 
break;  

case 3:
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y * screen->pitch) + (x*3);


if(SDL_BYTEORDER == SDL_LIL_ENDIAN) 
{
c1 = (color & 0xFF0000) >> 16;
c2 = (color & 0x00FF00) >> 8;
c3 = (color & 0x0000FF);
} else 
{
c3 = (color & 0xFF0000) >> 16;
c2 = (color & 0x00FF00) >> 8;
c1 = (color & 0x0000FF);	
}

ubuff8[0] = c3;
ubuff8[1] = c2;
ubuff8[2] = c1;
break;

case 4:
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y*screen->pitch) + (x*4);
ubuff32 = (Uint32*)ubuff8;
*ubuff32 = color;
break;

default:
fprintf(stderr, "Error: Unknown bitdepth!\n");
}

unlock();
}

[kyrsjo]

Peker forøvrig på

http://forum.hardware.no/index.php?showtopic=400842

som er den matematiske siden av saken.

[Klette]

er det ikke en liten feil i kalkuleringen din? eller er det jeg som tenker feil? Formelen for feltstyrke er vel g = (y*M)/r^2 y=6.67*10^11 M = massen til jorda = 5.974*10^24 og r= avstand fra jorda/radius fra jorda.

 

Og i og med at vi jobber med et radielt felt, så er vel x avstanden og y avstanden den samme?

 

Blir det da ikke

float grav_calc (float dist, float mass) { 
return ((GAMMA * mass) / (dist*dist));
}

 

Mulig jeg surrer veldig da...

[kyrsjo]

Vel:

 

F = ma

F = GAMMA * M * m / r^2

 

ma = GAMMA * M * m / r^2

a = GAMMA * M / r^2

 

r = sqrt (dx^2 + dy^2)

a = GAMMA * M / (sqrt (dx^2 + dy^2))^2

a = GAMMA * M / (dx^2 + dy^2)

 

som er det vi har.

 

Om du fortsatt tviler, så kan du titte på denne kodestumpen:

 

//testprog.c

#include <stdlib.h>
#include <stdio.h>

#define GAMMA 0.0000000000667

int main () {


double dy = 0;
double dx = 6371000;
double mass = 5974000000000000000000000.0;

printf ("%d\n", (int)sizeof (double));
double result;
result = (GAMMA * mass) / (dy*dy + dx*dx);
printf ("%f\n", result);
return 0;
}	

(kompileres ganske enkelt med "gcc -Wall test.c .o test")

 

Brukte den til å teste formelen min - den har hardkodet radius og masse til jorda, og gir ganske riktig 9,81.

 

Den var forøvrig nesten-skyldig i komma-spørsmålet, ettersom jeg hadde husket å fikse #define GAMMA i denne fila, men ikke i hovedprosjektet

[Klette]

Min funker jo like greit da

 

Hva er dy for no egentlig? ser ikke helt poenget med den

Endret 5. april 2005 av Klette

[kyrsjo]

delta y og delta x

 

nei den er ikke noe poeng i test.c, men i det "ekte" programmet så plotter jeg inn i en 2d-matrise. Det er sååå mye lettere å finne avstander i rette linjer (og så pytagoras), enn det er å gjette seg fram til den ellers

 

gravDepth1 [x] [y] = grav_calc (grav_UnitConv(x - Xcenter), grav_UnitConv(y - Ycenter), MASS1);

og

double grav_calc (double dx, double dy, double mass) {
return ((GAMMA * mass) / (dy*dy + dx*dx));
}

er her aktuelle. Jeg regner ut delta Y og delta X (ut ifra senter som er definert vha #define's - se toppen av koden), og forer det til grav_calc.

[Klette]

I det formål ja.. Da ser jeg at det kan forenkle endel. du kunne ikke ha slengt opp en svn eller no på den da ? =) Hadde vært spennede å laget noen saker til denne (bergening av kreftene fra de andre planetene også i beregningene.. bare for skøy. Dog det krever å finne posisjonene til planetene på det aktuelle tidspunkt det skal utregnes for... jaja, mye morro man kan lage med dette =) 3d versjon med opengl f.eks =)

[kyrsjo]

Planen er å få inn:

- Månen

- Input på posisjon og masse på de to legemene

- Zoom

 

Problemet er:

- Skalere output-verdiene til farger så de faktisk er synlige. Se mattetråden for dette, dette er programmeringstråden.

- Knuse vektorer... senere. Trodde en stund jeg kunne regne ut akserelasjonen deres *uavhengig* av hverandre, og så summere (derfor jeg har 3 arrays)

- Hastighet. Dette er treigt

 

Når det gjelder SVN/CVS, så:

- jeg kan ikke cvs

- Serveren min hjemme står på ca. når jeg gidder høre på bråket/noen ringer meg og ber meg skru den på (en gammel 160 mhz med 64 MB shabby RAM og Debian Sarge. Men, den virker...)

- hmm.. Sourceforge?

 

mailingliste burde la seg ordne.

 

Forøvrig er lisensen selvsagt GPL.

Nyeste kode:

#include <stdlib.h>
#include <SDL.h>
#include <math.h>

//Resolution. Shold be autodetected...
#define ROWS 640
#define COLS 480

//Plotting stuff. Should eventually become dynamical...
// 6*10^8 / 640
#define METERPRPIXEL 937500
// 640 / 5
#define Xcenter 128
// 480 / 2
#define Ycenter 240

//Input values. MUST get dynamical ASAP, those here are just for testing!
//Object 1 (Earth) - 5,974*10^24
#define MASS1 5974000000000000000000000.0

//Natural constants
//Gravitational constant, 6,67*10^-11
#define GAMMA 0.0000000000667

//Functions
double grav_calc (double dx, double dy, double mass);
double grav_UnitConv (int grav_PixelValue);

Uint8 grav_colorConvR (double value);
Uint8 grav_colorConvG (double value);
Uint8 grav_colorConvB (double value);

void lock();
void unlock();
void drawrect(int x1, int y1, int x2, int y2, Uint8 r, Uint8 g, Uint8 b);
void setpixel(int x, int y, Uint8 r, Uint8 g, Uint8 b);



//Arrays to keep the info
double gravDepth1   [ROWS] [COLS];
double gravDepth2   [ROWS] [COLS];
double gravDepthSum [ROWS] [COLS];

//SDL stuff
SDL_Surface *screen;
SDL_Event event;

int main(int argc, char *argv[]) {
//Initialize SDL
if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0 ) {
 fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
 exit(1);
}
atexit(SDL_Quit);


screen = SDL_SetVideoMode(ROWS, COLS, 16, SDL_SWSURFACE);
if ( screen == NULL ) {
 fprintf(stderr, "Unable to set 640x480 video: %s\n", SDL_GetError());
 exit(1);
}

//Create some data!
printf ("Testing with the radius of the earth: %f \n", grav_calc (6371000,0,5974000000000000000000000.0));
int x;
int y;
for (x = 0; x < ROWS; x++) {
 for (y = 0; y < COLS; y++) {
 	gravDepth1 [x] [y] = grav_calc (grav_UnitConv(x - Xcenter), grav_UnitConv(y - Ycenter), MASS1);
 	printf ("Depth in (%d,%d):%f - colour: %d\n",x,y,gravDepth1 [x] [y], grav_colorConvR(gravDepth1 [x] [y]));
 	setpixel (x , y, grav_colorConvR(gravDepth1 [x] [y]),0, 0);
 	//setpixel (x, y, 255, 255, 255);
 	//drawrect (x,y,x+10,y+10,255,255,255);
 	//break;
 }
 SDL_Flip(screen);
 //break;
}


//Wait for input
while(SDL_WaitEvent(&event)) {
 switch(event.type) {
 	case SDL_QUIT:
   printf ("QUIT!!\n");
   return (0);
 	break;
 	
 	/*
 	case SDL_KEYDOWN:
   switch (event.key.keysym.sym)
   	case SDLK_SPACE:
     //drawrect (50,50,200,200,255,255,255);
     printf ("SPACE!!\n");
     break;
   	//Why isn't this working? (i get a whole lot of error
   	//messages at compile time)
   	//I do not want to handle every key i don't use...
   	default:
     printf ("DEFAULT!!\n");
     break;
 	*/
 }
 SDL_Flip(screen);
}

return (0);
}

double grav_calc (double dx, double dy, double mass) {
return ((GAMMA * mass) / (dy*dy + dx*dx));
}

double grav_UnitConv (int grav_PixelValue) {
return (METERPRPIXEL * grav_PixelValue);
}

//Convert gravity depth value to a sane colour value
Uint8 grav_colorConvR (double value) {
//return (value * 255);
return (log(value+1) * 1024);
//return (pow (value + 1, 0.5));
}
Uint8 grav_colorConvG (double value) {
return 0;
}
Uint8 grav_colorConvB (double value) {
return 0;
}

//**************************************************************************
//********************** SDL DRAWING FUNCTIONS *****************************
//**************************************************************************
void lock()
{
/* Lock the screen, if needed */
if(SDL_MUSTLOCK(screen)) 
{
if(SDL_LockSurface(screen) < 0) 
return;
}
}

void unlock()
{
/* Unlock the screen if needed */
if(SDL_MUSTLOCK(screen)) {
SDL_UnlockSurface(screen);
}
}


void drawrect(int x1, int y1, int x2, int y2, Uint8 r, Uint8 g, Uint8 b)	{
Uint32 color;
color = SDL_MapRGB (screen->format, r, g, b);

SDL_Rect rect;
rect.w = x2;
rect.h = y2;
rect.x = x1;
rect.y = y1;
lock();
SDL_FillRect (screen, &rect, color);
unlock();
}



void setpixel(int x, int y, Uint8 r, Uint8 g, Uint8 b) {
Uint8  *ubuff8;
Uint16 *ubuff16;
Uint32 *ubuff32;
Uint32 color;
char c1, c2, c3;

lock();
/* Get the color */
color = SDL_MapRGB( screen->format, r, g, b );

/* How we draw the pixel depends on the bitdepth */
switch(screen->format->BytesPerPixel) 
{
case 1: 
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y * screen->pitch) + x; 
*ubuff8 = (Uint8) color;
break;

case 2:
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y * screen->pitch) + (x*2);
ubuff16 = (Uint16*) ubuff8;
*ubuff16 = (Uint16) color; 
break;  

case 3:
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y * screen->pitch) + (x*3);


if(SDL_BYTEORDER == SDL_LIL_ENDIAN) 
{
c1 = (color & 0xFF0000) >> 16;
c2 = (color & 0x00FF00) >> 8;
c3 = (color & 0x0000FF);
} else 
{
c3 = (color & 0xFF0000) >> 16;
c2 = (color & 0x00FF00) >> 8;
c1 = (color & 0x0000FF);	
}

ubuff8[0] = c3;
ubuff8[1] = c2;
ubuff8[2] = c1;
break;

case 4:
ubuff8 = (Uint8*) screen->pixels;
ubuff8 += (y*screen->pitch) + (x*4);
ubuff32 = (Uint32*)ubuff8;
*ubuff32 = color;
break;

default:
fprintf(stderr, "Error: Unknown bitdepth!\n");
}

unlock();
}

 

Om du ønsker å hacke på den, så vær så god. Kommer ikke til å gjøre noe mer i kveld uansett, historieprøve... Bare vær snill å kommentere skikkelig (det burde jeg også gjøre...)

 

OpenGL kan jeg ikke.

Kompilere:

gcc -Wall `sdl-config --cflags --libs` main.c -o gravitymap

 

Blir litt Einstein gravitasjonsteori vist grafisk over det hele...