home *** CD-ROM | disk | FTP | other *** search
/ Gambler 19 / GAMBLERCD19.BIN / UTILS / RIVA128 / Uzytki / ssystem-1.2 / SOURCE / INIT.C next >
C/C++ Source or Header  |  1998-05-01  |  35KB  |  1,055 lines
  1. /*
  2.   Initialization routines:
  3.   
  4.       - Read texture images
  5.       - Initialize planets' data
  6.       - Create display lists
  7.       - Other initialization routines
  8.   
  9.   Major code reorganization since 1.02
  10.   
  11.   Satellites' textures (except Moon) are 128x128 so we don't reach the 2MB 
  12.   limit in many Voodoo Graphics cards. May change in the future, since all 
  13.   Voodoo2 cards come with a minimum of 4MB on board.
  14.   
  15. */
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <math.h>
  20. #include <malloc.h>
  21. #include <time.h>
  22. #include "jpeglib.h"
  23. #include <setjmp.h>
  24. #include <GL/glut.h>
  25. #include "planets.h"
  26.  
  27. char * filenames[NUMBODIES]=    {"sun.jpg",
  28.             "mercury.jpg",
  29.             "venus.jpg",
  30.             "earth.jpg",
  31.             "mars.jpg",
  32.             "jupiter.jpg",
  33.             "saturn.jpg",
  34.             "uranus.jpg",
  35.             "neptune.jpg",
  36.             "pluto.jpg",
  37.             "moon.jpg",
  38.             "io.jpg",
  39.             "europa.jpg",
  40.             "ganymede.jpg",
  41.             "callisto.jpg",
  42.             "tethys.jpg",
  43.             "dione.jpg",
  44.             "rhea.jpg",
  45.             "titan.jpg",
  46.             "triton.jpg",
  47.             "charon.jpg",
  48.             "satrings.jpg"};
  49.  
  50. GLfloat LightPos[4] = {0.0, 0.0, 0.0, 1.0};
  51. GLfloat ambient[4] = {0.6, 0.6, 0.6, 1.0};
  52. GLfloat White[4] = {1.0, 1.0, 1.0, 1.0};
  53. GLfloat Black[4] = {0.0, 0.0, 0.0, 1.0};
  54. GLuint texName[NUMBODIES],texture=1,smodel=GL_SMOOTH,lighting=1,drawstars=1;
  55. GLuint Stars,red,polaris;
  56. int ImgWidth, ImgHeight;
  57. GLenum ImgFormat;
  58. planetdata planets[NUMBODIES];
  59. GLfloat stars[NUMSTARS][4];
  60. double days,timefactor=1/(24.0*60.0); /* iterarion = 1 minute */
  61. int SLICES=12,STACKS=12;
  62. char texturepath[100]=".";
  63. static void InitSun(void),InitMercury(void),InitVenus(void),InitEarth(void),
  64.     InitMars(void),InitJupiter(void),InitSaturn(void),InitUranus(void),
  65.     InitNeptune(void),InitPluto(void),InitStars(void);
  66.  
  67. GLubyte *read_JPEG_file (char *);
  68.  
  69. void Init( void )
  70. {
  71.    time_t t;
  72.    
  73.    glEnable(GL_LIGHTING);
  74.    glEnable(GL_LIGHT0);
  75.    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
  76.    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
  77.  
  78.    t=time(NULL);
  79.    srand(t);
  80.    days=t/3600.0/24.0-10093.0;
  81.    glEnable(GL_DEPTH_TEST);
  82.    glEnable(GL_CULL_FACE);
  83.    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  84.    glGenTextures(NUMBODIES, texName);
  85.    InitSun();      
  86.    InitMercury();   
  87.    InitVenus();
  88.    InitEarth();
  89.    InitMars();
  90.    InitJupiter(); 
  91.    InitSaturn();   
  92.    InitUranus();   
  93.    InitNeptune();   
  94.    InitPluto();   
  95.    InitStars();
  96.    glEnable(GL_TEXTURE_2D);
  97.    glShadeModel(GL_SMOOTH);
  98.    glBlendFunc(GL_DST_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  99. }
  100.  
  101.  
  102. static void InitSun(void)
  103. { 
  104.    static int i,j;
  105.    static char *localimage;
  106.    
  107.    planets[SUN].Radius=2.0; /*Real Radius is 109.6*/
  108.    planets[SUN].Degrees=0.0;
  109.    planets[SUN].DeltaRotation=0.0;
  110.    planets[SUN].Rotation=360.0/28.0;
  111.    planets[SUN].Sat=0;
  112.    planets[SUN].posx=planets[SUN].posy=planets[SUN].posz=0.0;
  113.    sprintf(planets[SUN].Name,"Sun");
  114.  
  115.    planets[SUN].Object = gluNewQuadric();
  116.    gluQuadricTexture( planets[SUN].Object, GL_FALSE );   
  117.    planets[SUN].Sphere= glGenLists(1);
  118.    glNewList( planets[SUN].Sphere, GL_COMPILE );
  119.    gluSphere( planets[SUN].Object,RADIUSSCALE(planets[SUN].Radius), SLICES, STACKS );
  120.    glEndList();
  121.  
  122.    planets[SUN].Image = read_JPEG_file(filenames[SUN]);
  123.    if (!planets[SUN].Image) {
  124.       printf("Couldn't read image\n");
  125.       exit(0);
  126.    }
  127.  
  128.    localimage=malloc(128*128*4);
  129.    for (i=0;i<(128*128);i++) {
  130.     localimage[i*4]=planets[SUN].Image[i*3];
  131.     localimage[i*4+1]=planets[SUN].Image[i*3+1];
  132.     localimage[i*4+2]=planets[SUN].Image[i*3+2];
  133.     j=planets[SUN].Image[i*3]*2;
  134.     localimage[i*4+3]=j>255?255:j;
  135.    }
  136.  
  137.    glBindTexture(GL_TEXTURE_2D, texName[SUN]);
  138.    glTexImage2D( GL_TEXTURE_2D,
  139.                  0,
  140.                  4,
  141.                  128, 128,
  142.                  0,
  143.                  GL_RGBA, GL_UNSIGNED_BYTE,
  144.                  localimage );
  145.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  146.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  147.    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);                 
  148.    free(planets[SUN].Image);
  149.    free(localimage);
  150. } 
  151.  
  152.  
  153. static void InitMercury(void)
  154. {
  155.    planets[MERCURY].Radius=0.382;
  156.    planets[MERCURY].Degrees=0.0;
  157.    planets[MERCURY].DeltaRotation=0.0;
  158.    planets[MERCURY].Rotation=360.0/58.6462;
  159.    planets[MERCURY].Inclination=DEG2RAD(7.00507);
  160.    planets[MERCURY].AscendingNode=DEG2RAD(48.3339);
  161.    planets[MERCURY].Perihelion=DEG2RAD(77.45399999999999);
  162.    planets[MERCURY].MeanDistance=DISTCORRECTION(0.3870978);
  163.    planets[MERCURY].DailyMotion=DEG2RAD(4.092353);
  164.    planets[MERCURY].Eccentricity=0.2056324;
  165.    planets[MERCURY].MeanLongitude=DEG2RAD(314.42369);
  166.    planets[MERCURY].Sat=0;
  167.    sprintf(planets[MERCURY].Name,"Mercury");
  168.  
  169.    planets[MERCURY].Image = read_JPEG_file(filenames[MERCURY]);
  170.    if (!planets[MERCURY].Image) {
  171.       printf("Couldn't read image\n");
  172.       exit(0);
  173.    }
  174.  
  175.    glBindTexture(GL_TEXTURE_2D, texName[MERCURY]);
  176.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  177.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  178.    glTexImage2D( GL_TEXTURE_2D,
  179.                  0,
  180.                  3,
  181.                  256, 256,
  182.                  0,
  183.                  GL_RGB, GL_UNSIGNED_BYTE,
  184.                  planets[MERCURY].Image );
  185.    free(planets[MERCURY].Image);
  186.    planets[MERCURY].Object = gluNewQuadric();
  187.    gluQuadricTexture( planets[MERCURY].Object, GL_TRUE );   
  188.    planets[MERCURY].Sphere= glGenLists(1);
  189.    glNewList( planets[MERCURY].Sphere, GL_COMPILE );
  190.    gluSphere( planets[MERCURY].Object,RADIUSSCALE(planets[MERCURY].Radius), SLICES, STACKS );
  191.    glEndList();
  192.  
  193. } 
  194.  
  195.  
  196. static void InitVenus(void)
  197. {
  198.    planets[VENUS].Radius=0.95;
  199.    planets[VENUS].Degrees=177.3;
  200.    planets[VENUS].DeltaRotation=0.0;
  201.    planets[VENUS].Rotation=360.0/243.0187;
  202.    planets[VENUS].Inclination=DEG2RAD(3.39472);
  203.    planets[VENUS].AscendingNode=DEG2RAD(76.6889);
  204.    planets[VENUS].Perihelion=DEG2RAD(131.761);
  205.    planets[VENUS].MeanDistance=DISTCORRECTION(0.7233238);
  206.    planets[VENUS].DailyMotion=DEG2RAD(1.602158);
  207.    planets[VENUS].Eccentricity=0.0067933;
  208.    planets[VENUS].MeanLongitude=DEG2RAD(236.94045);
  209.    planets[VENUS].Sat=0;
  210.    sprintf(planets[VENUS].Name,"Venus");
  211.    
  212.  
  213.    planets[VENUS].Image = read_JPEG_file(filenames[VENUS]);
  214.    if (!planets[VENUS].Image) {
  215.       printf("Couldn't read image\n");
  216.       exit(0);
  217.    }
  218.  
  219.    glBindTexture(GL_TEXTURE_2D, texName[VENUS]);
  220.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  221.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  222.    glTexImage2D( GL_TEXTURE_2D,
  223.                  0,
  224.                  3,
  225.                  128, 128,
  226.                  0,
  227.                  GL_RGB, GL_UNSIGNED_BYTE,
  228.                  planets[VENUS].Image );
  229.    free(planets[VENUS].Image);
  230.    planets[VENUS].Object = gluNewQuadric();
  231.    gluQuadricTexture( planets[VENUS].Object, GL_TRUE );   
  232.    planets[VENUS].Sphere= glGenLists(1);
  233.    glNewList( planets[VENUS].Sphere, GL_COMPILE );
  234.    gluSphere( planets[VENUS].Object,RADIUSSCALE(planets[VENUS].Radius), SLICES, STACKS );
  235.    glEndList();
  236.  
  237.  
  238. } 
  239.  
  240.  
  241. static void InitEarth(void)
  242. {
  243.    planets[EARTH].Radius=1.0;
  244.    planets[EARTH].Degrees=23.45;
  245.    planets[EARTH].DeltaRotation=0.0;
  246.    planets[EARTH].Rotation=360.0/(365.0/365.256);
  247.    planets[EARTH].Inclination=DEG2RAD(0.00041);
  248.    planets[EARTH].AscendingNode=DEG2RAD(349.2);
  249.    planets[EARTH].Perihelion=DEG2RAD(102.8517);
  250.    planets[EARTH].MeanDistance=DISTCORRECTION(1.00002);
  251.    planets[EARTH].DailyMotion=DEG2RAD(0.9855796);
  252.    planets[EARTH].Eccentricity=0.0166967;
  253.    planets[EARTH].MeanLongitude=DEG2RAD(328.40353);
  254.    planets[EARTH].Sat=0;
  255.    sprintf(planets[EARTH].Name,"Earth");
  256.  
  257.    planets[MOON].Radius=0.2724;
  258.    planets[MOON].Degrees=5.1454;
  259.    planets[MOON].DeltaRotation=0.0;
  260.    planets[MOON].Rotation=360.0/27.32166;
  261.    planets[MOON].Inclination=DEG2RAD(5.1454);
  262.    planets[MOON].AscendingNode=DEG2RAD(125.1228);
  263.    planets[MOON].Perihelion=DEG2RAD(83.1862);
  264.    planets[MOON].MeanDistance=RADIUSSCALE(60.2666)/4.0;
  265.    planets[MOON].DailyMotion=DEG2RAD(13.0649929509);
  266.    planets[MOON].Eccentricity=0.054900;
  267.    planets[MOON].MeanLongitude=DEG2RAD(328.40353);
  268.    planets[MOON].Sat=EARTH;
  269.    sprintf(planets[MOON].Name,"Moon");
  270.  
  271.  
  272.    planets[EARTH].Image = read_JPEG_file(filenames[EARTH]);
  273.    if (!planets[EARTH].Image) {
  274.       printf("Couldn't read image\n");
  275.       exit(0);
  276.    }
  277.  
  278.    glBindTexture(GL_TEXTURE_2D, texName[EARTH]);
  279.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  280.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  281.    glTexImage2D( GL_TEXTURE_2D,
  282.                  0,
  283.                  3,
  284.                  256, 256,
  285.                  0,
  286.                  GL_RGB, GL_UNSIGNED_BYTE,
  287.                  planets[EARTH].Image );
  288.    free(planets[EARTH].Image);
  289.    planets[EARTH].Object = gluNewQuadric();
  290.    gluQuadricTexture( planets[EARTH].Object, GL_TRUE );   
  291.    planets[EARTH].Sphere= glGenLists(1);
  292.    glNewList( planets[EARTH].Sphere, GL_COMPILE );
  293.    gluSphere( planets[EARTH].Object,RADIUSSCALE(planets[EARTH].Radius), SLICES, STACKS );
  294.    glEndList();
  295.  
  296.  
  297.    planets[MOON].Image = read_JPEG_file(filenames[MOON]);
  298.    if (!planets[MOON].Image) {
  299.       printf("Couldn't read image\n");
  300.       exit(0);
  301.    }
  302.  
  303.    glBindTexture(GL_TEXTURE_2D, texName[MOON]);
  304.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  305.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  306.    glTexImage2D( GL_TEXTURE_2D,
  307.                  0,
  308.                  3,
  309.                  256, 256,
  310.                  0,
  311.                  GL_RGB, GL_UNSIGNED_BYTE,
  312.                  planets[MOON].Image );
  313.    free(planets[MOON].Image);
  314.    planets[MOON].Object = gluNewQuadric();
  315.    gluQuadricTexture( planets[MOON].Object, GL_TRUE );   
  316.    planets[MOON].Sphere= glGenLists(1);
  317.    glNewList( planets[MOON].Sphere, GL_COMPILE );
  318.    gluSphere( planets[MOON].Object,RADIUSSCALE(planets[MOON].Radius), SLICES, STACKS );
  319.    glEndList();
  320.  
  321. } 
  322.  
  323.  
  324. static void InitMars(void)
  325. {
  326.    planets[MARS].Radius=0.532;
  327.    planets[MARS].Degrees=25.19;
  328.    planets[MARS].DeltaRotation=0.0;
  329.    planets[MARS].Rotation=360.0/1.025957;
  330.    planets[MARS].Inclination=DEG2RAD(1.84992);
  331.    planets[MARS].AscendingNode=DEG2RAD(49.5664);
  332.    planets[MARS].Perihelion=DEG2RAD(336.0882);
  333.    planets[MARS].MeanDistance=DISTCORRECTION(1.5236365);
  334.    planets[MARS].DailyMotion=DEG2RAD(0.5240613);
  335.    planets[MARS].Eccentricity=0.0934231;
  336.    planets[MARS].MeanLongitude=DEG2RAD(262.42784);
  337.    planets[MARS].Sat=0;
  338.    sprintf(planets[MARS].Name,"Mars");
  339.  
  340.    planets[MARS].Image = read_JPEG_file(filenames[MARS]);
  341.    if (!planets[MARS].Image) {
  342.       printf("Couldn't read image\n");
  343.       exit(0);
  344.    }
  345.  
  346.    glBindTexture(GL_TEXTURE_2D, texName[MARS]);
  347.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  348.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  349.    glTexImage2D( GL_TEXTURE_2D,
  350.                  0,
  351.                  3,
  352.                  256, 256,
  353.                  0,
  354.                  GL_RGB, GL_UNSIGNED_BYTE,
  355.                  planets[MARS].Image );
  356.    free(planets[MARS].Image);
  357.    planets[MARS].Object = gluNewQuadric();
  358.    gluQuadricTexture( planets[MARS].Object, GL_TRUE );   
  359.    planets[MARS].Sphere= glGenLists(1);
  360.    glNewList( planets[MARS].Sphere, GL_COMPILE );
  361.    gluSphere( planets[MARS].Object,RADIUSSCALE(planets[MARS].Radius), SLICES, STACKS );
  362.    glEndList();
  363.  
  364.     
  365.            
  366. } 
  367.  
  368.  
  369. static void InitJupiter(void)
  370. {
  371.    int i;
  372.    
  373.    planets[JUPITER].Radius=11.27;
  374.    planets[JUPITER].Degrees=3.12;
  375.    planets[JUPITER].DeltaRotation=0.0;
  376.    planets[JUPITER].Rotation=360.0/0.41354;
  377.    planets[JUPITER].Inclination=DEG2RAD(1.30463);
  378.    planets[JUPITER].AscendingNode=DEG2RAD(100.4713);
  379.    planets[JUPITER].Perihelion=DEG2RAD(15.6978);
  380.    planets[JUPITER].MeanDistance=DISTCORRECTION(5.202597);
  381.    planets[JUPITER].DailyMotion=DEG2RAD(8.309618000000001E-02);
  382.    planets[JUPITER].Eccentricity=0.0484646;
  383.    planets[JUPITER].MeanLongitude=DEG2RAD(322.55983);
  384.    planets[JUPITER].Sat=0;
  385.    sprintf(planets[JUPITER].Name,"Jupiter");
  386.  
  387.  
  388.    planets[IO].Radius=1820.0/6378.0;
  389.    planets[IO].Degrees=0.0;
  390.    planets[IO].DeltaRotation=360.0/1.769138;
  391.    planets[IO].Rotation=0.0;
  392.    planets[IO].Inclination=0.0;
  393.    planets[IO].Sat=JUPITER;
  394.    sprintf(planets[IO].Name,"Io");
  395.  
  396.    planets[EUROPA].Radius=1565.0/6378.0;
  397.    planets[EUROPA].Degrees=0.0;
  398.    planets[EUROPA].DeltaRotation=0.0;
  399.    planets[EUROPA].Rotation=360.0/3.551181;
  400.    planets[EUROPA].Inclination=0.0;
  401.    planets[EUROPA].Sat=JUPITER;
  402.    sprintf(planets[EUROPA].Name,"Europa");
  403.  
  404.    planets[GANYMEDE].Radius=2635.0/6378.0;
  405.    planets[GANYMEDE].Degrees=0.0;
  406.    planets[GANYMEDE].DeltaRotation=0.0;
  407.    planets[GANYMEDE].Rotation=360.0/7.154553;
  408.    planets[GANYMEDE].Inclination=0.0;   
  409.    planets[GANYMEDE].Sat=JUPITER;
  410.    sprintf(planets[GANYMEDE].Name,"Ganymede");
  411.    
  412.    planets[CALLISTO].Radius=2420.0/6378.0;
  413.    planets[CALLISTO].Degrees=0.0;
  414.    planets[CALLISTO].DeltaRotation=0.0;
  415.    planets[CALLISTO].Rotation=360.0/16.68902;
  416.    planets[CALLISTO].Inclination=0.0;   
  417.    planets[CALLISTO].Sat=JUPITER;
  418.    sprintf(planets[CALLISTO].Name,"Callisto");
  419.  
  420.  
  421.  
  422.    planets[JUPITER].Image = read_JPEG_file(filenames[JUPITER]);
  423.    if (!planets[JUPITER].Image) {
  424.       printf("Couldn't read image\n");
  425.       exit(0);
  426.    }
  427.  
  428.    glBindTexture(GL_TEXTURE_2D, texName[JUPITER]);
  429.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  430.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  431.    glTexImage2D( GL_TEXTURE_2D,
  432.                  0,
  433.                  3,
  434.                  256,256,
  435.                  0,
  436.                  GL_RGB, GL_UNSIGNED_BYTE,
  437.                  planets[JUPITER].Image );
  438.    free(planets[JUPITER].Image);
  439.    planets[JUPITER].Object = gluNewQuadric();
  440.    gluQuadricTexture( planets[JUPITER].Object, GL_TRUE );   
  441.    planets[JUPITER].Sphere= glGenLists(1);
  442.    glNewList( planets[JUPITER].Sphere, GL_COMPILE );
  443.    gluSphere( planets[JUPITER].Object,RADIUSSCALE(planets[JUPITER].Radius), SLICES, STACKS );
  444.    glEndList();
  445.  
  446.  
  447.    for (i=IO;i<=CALLISTO;i++) {
  448.        planets[i].Image = read_JPEG_file(filenames[i]);
  449.        if (!planets[i].Image) {
  450.           printf("Couldn't read image\n");
  451.           exit(0);
  452.        }
  453.  
  454.        glBindTexture(GL_TEXTURE_2D, texName[i]);
  455.        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  456.        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  457.        glTexImage2D( GL_TEXTURE_2D,
  458.                      0,
  459.                      3,
  460.                      128, 128,
  461.                      0,
  462.                      GL_RGB, GL_UNSIGNED_BYTE,
  463.                      planets[i].Image );
  464.        free(planets[i].Image);
  465.        planets[i].Object = gluNewQuadric();
  466.        gluQuadricTexture( planets[i].Object, GL_TRUE );   
  467.        planets[i].Sphere= glGenLists(1);
  468.        glNewList( planets[i].Sphere, GL_COMPILE );
  469.        gluSphere( planets[i].Object,RADIUSSCALE(planets[i].Radius), SLICES, STACKS );
  470.        glEndList();
  471.    }
  472.     
  473. } 
  474.  
  475.  
  476. static void InitSaturn(void)
  477. {
  478.    int i;
  479.    unsigned char *localimage;
  480.    
  481.    planets[SATURN].Radius=9.5;
  482.    planets[SATURN].Degrees=26.73;
  483.    planets[SATURN].DeltaRotation=0.0;
  484.    planets[SATURN].Rotation=360.0/0.44401;
  485.    planets[SATURN].Inclination=DEG2RAD(2.48524);
  486.    planets[SATURN].AscendingNode=DEG2RAD(113.6358);
  487.    planets[SATURN].Perihelion=DEG2RAD(88.863);
  488.    planets[SATURN].MeanDistance=DISTCORRECTION(9.571899999999999);
  489.    planets[SATURN].DailyMotion=DEG2RAD(0.03328656);
  490.    planets[SATURN].Eccentricity=0.0531651;
  491.    planets[SATURN].MeanLongitude=DEG2RAD(20.95759);
  492.    planets[SATURN].Sat=0;
  493.    sprintf(planets[SATURN].Name,"Saturn");
  494.  
  495.    planets[TETHYS].Radius=525.0/6378.0;
  496.    planets[TETHYS].Degrees=0.0;
  497.    planets[TETHYS].DeltaRotation=0.0;
  498.    planets[TETHYS].Rotation=360.0/1.8880926;
  499.    planets[TETHYS].Inclination=0.0;
  500.    planets[TETHYS].Sat=SATURN;
  501.    sprintf(planets[TETHYS].Name,"Tethys");
  502.  
  503.    planets[DIONE].Radius=560.0/6378.0;
  504.    planets[DIONE].Degrees=0.0;
  505.    planets[DIONE].DeltaRotation=0.0;
  506.    planets[DIONE].Rotation=360.0/2.7375218;
  507.    planets[DIONE].Inclination=0.0;
  508.    planets[DIONE].Sat=SATURN;
  509.    sprintf(planets[DIONE].Name,"Dione");
  510.  
  511.    planets[RHEA].Radius=765.0/6378.0;
  512.    planets[RHEA].Degrees=0.0;
  513.    planets[RHEA].DeltaRotation=0.0;
  514.    planets[RHEA].Rotation=360.0/4.5191631;
  515.    planets[RHEA].Inclination=0.0;
  516.    planets[RHEA].Sat=SATURN;
  517.    sprintf(planets[RHEA].Name,"Rhea");
  518.  
  519.    planets[TITAN].Radius=2575.0/6378.0;
  520.    planets[TITAN].Degrees=0.0;
  521.    planets[TITAN].DeltaRotation=0.0;
  522.    planets[TITAN].Rotation=360.0/15.9669028;
  523.    planets[TITAN].Inclination=0.0;
  524.    planets[TITAN].Sat=SATURN;
  525.    sprintf(planets[TITAN].Name,"Titan");
  526.  
  527.    planets[SATURN].Image = read_JPEG_file(filenames[SATURN]);
  528.    if (!planets[SATURN].Image) {
  529.       printf("Couldn't read image\n");
  530.       exit(0);
  531.    }
  532.  
  533.    glBindTexture(GL_TEXTURE_2D, texName[SATURN]);
  534.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  535.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  536.    glTexImage2D( GL_TEXTURE_2D,
  537.                  0,
  538.                  3,
  539.                  128, 128,
  540.                  0,
  541.                  GL_RGB, GL_UNSIGNED_BYTE,
  542.                  planets[SATURN].Image );
  543.    free(planets[SATURN].Image);
  544.  
  545.    planets[SATURN].Image = read_JPEG_file(filenames[RINGS]);
  546.    if (!planets[SATURN].Image) {
  547.       printf("Couldn't read image\n");
  548.       exit(0);
  549.    }
  550.    
  551.    localimage=malloc(256*256*4);
  552.    for (i=0;i<(256*256);i++) {
  553.     localimage[i*4]=planets[SATURN].Image[i*3];
  554.     localimage[i*4+1]=planets[SATURN].Image[i*3+1];
  555.     localimage[i*4+2]=planets[SATURN].Image[i*3+2];
  556.     localimage[i*4+3]=planets[SATURN].Image[i*3]>10?255:0;
  557.    }
  558.    glBindTexture(GL_TEXTURE_2D, texName[RINGS]);
  559.    glTexImage2D( GL_TEXTURE_2D,
  560.                  0,
  561.                  4,
  562.                  256, 256,
  563.                  0,
  564.                  GL_RGBA, GL_UNSIGNED_BYTE,
  565.                  localimage );
  566.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  567.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  568.    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
  569.    free(planets[SATURN].Image);
  570.    free(localimage);
  571.  
  572.  
  573.  
  574.    planets[SATURN].Object = gluNewQuadric();
  575.    gluQuadricTexture( planets[SATURN].Object, GL_TRUE );   
  576.    planets[SATURN].Sphere= glGenLists(1);
  577.    glNewList( planets[SATURN].Sphere, GL_COMPILE );
  578.    gluSphere( planets[SATURN].Object,RADIUSSCALE(planets[SATURN].Radius), SLICES, STACKS );
  579.    glBindTexture(GL_TEXTURE_2D, texName[RINGS]);
  580.    glDisable(GL_CULL_FACE);
  581.    glDisable(GL_LIGHTING);
  582.    glEnable(GL_BLEND);
  583.    gluDisk(planets[SATURN].Object,
  584.            1.5*RADIUSSCALE(planets[SATURN].Radius),
  585.            1.9*RADIUSSCALE(planets[SATURN].Radius),
  586.            SLICES*2,1);
  587.    gluDisk(planets[SATURN].Object,
  588.            2.0*RADIUSSCALE(planets[SATURN].Radius),
  589.            2.2*RADIUSSCALE(planets[SATURN].Radius),
  590.            SLICES*2,1);
  591.    glDisable(GL_BLEND);        
  592.    glEnable(GL_LIGHTING);
  593.    glEnable(GL_CULL_FACE);
  594.    glEndList();
  595.  
  596.    for (i=TETHYS;i<=TITAN;i++) {
  597.        planets[i].Image = read_JPEG_file(filenames[i]);
  598.        if (!planets[i].Image) {
  599.           printf("Couldn't read image\n");
  600.           exit(0);
  601.        }
  602.  
  603.        glBindTexture(GL_TEXTURE_2D, texName[i]);
  604.        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  605.        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  606.        glTexImage2D( GL_TEXTURE_2D,
  607.                      0,
  608.                      3,
  609.                      128, 128,
  610.                      0,
  611.                      GL_RGB, GL_UNSIGNED_BYTE,
  612.                      planets[i].Image );
  613.        free(planets[i].Image);
  614.        planets[i].Object = gluNewQuadric();
  615.        gluQuadricTexture( planets[i].Object, GL_TRUE );   
  616.        planets[i].Sphere= glGenLists(1);
  617.        glNewList( planets[i].Sphere, GL_COMPILE );
  618.        gluSphere( planets[i].Object,RADIUSSCALE(planets[i].Radius), SLICES, STACKS );
  619.        glEndList();
  620.    }
  621. } 
  622.  
  623.  
  624. static void InitUranus(void)
  625. {
  626.    planets[URANUS].Radius=3.9;
  627.    planets[URANUS].Degrees=97.86;
  628.    planets[URANUS].DeltaRotation=0.0;
  629.    planets[URANUS].Rotation=360.0/0.71833;
  630.    planets[URANUS].Inclination=DEG2RAD(0.77343);
  631.    planets[URANUS].AscendingNode=DEG2RAD(74.0954);
  632.    planets[URANUS].Perihelion=DEG2RAD(175.6807);
  633.    planets[URANUS].MeanDistance=DISTCORRECTION(19.30181);
  634.    planets[URANUS].DailyMotion=DEG2RAD(0.01162295);
  635.    planets[URANUS].Eccentricity=0.0428959;
  636.    planets[URANUS].MeanLongitude=DEG2RAD(303.18967);
  637.    planets[URANUS].Sat=0;
  638.    sprintf(planets[URANUS].Name,"Uranus");
  639.  
  640.  
  641.    planets[URANUS].Image = read_JPEG_file(filenames[URANUS]);
  642.    if (!planets[URANUS].Image) {
  643.       printf("Couldn't read image\n");
  644.       exit(0);
  645.    }
  646.  
  647.    glBindTexture(GL_TEXTURE_2D, texName[URANUS]);
  648.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  649.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  650.    glTexImage2D( GL_TEXTURE_2D,
  651.                  0,
  652.                  3,
  653.                  128, 128,
  654.                  0,
  655.                  GL_RGB, GL_UNSIGNED_BYTE,
  656.                  planets[URANUS].Image );
  657.    free(planets[URANUS].Image);
  658.    planets[URANUS].Object = gluNewQuadric();
  659.    gluQuadricTexture( planets[URANUS].Object, GL_TRUE );   
  660.    planets[URANUS].Sphere= glGenLists(1);
  661.    glNewList( planets[URANUS].Sphere, GL_COMPILE );
  662.    gluSphere( planets[URANUS].Object,RADIUSSCALE(planets[URANUS].Radius), SLICES, STACKS );
  663.    glEndList();
  664.  
  665.     
  666. } 
  667.  
  668.  
  669. static void InitNeptune(void)
  670. {
  671.    planets[NEPTUNE].Radius=4.0;
  672.    planets[NEPTUNE].Degrees=29.0;
  673.    planets[NEPTUNE].DeltaRotation=0.0;
  674.    planets[NEPTUNE].Rotation=360.0/0.67125;
  675.    planets[NEPTUNE].Inclination=DEG2RAD(1.7681);
  676.    planets[NEPTUNE].AscendingNode=DEG2RAD(131.7925);
  677.    planets[NEPTUNE].Perihelion=DEG2RAD(7.206);
  678.    planets[NEPTUNE].MeanDistance=DISTCORRECTION(30.26664);
  679.    planets[NEPTUNE].DailyMotion=DEG2RAD(0.005919282);
  680.    planets[NEPTUNE].Eccentricity=0.0102981;
  681.    planets[NEPTUNE].MeanLongitude=DEG2RAD(299.8641);
  682.    planets[NEPTUNE].Sat=0;
  683.    sprintf(planets[NEPTUNE].Name,"Neptune");
  684.  
  685.    planets[TRITON].Radius=1353.0/6378.0;
  686.    planets[TRITON].Degrees=0.0;
  687.    planets[TRITON].DeltaRotation=0.0;
  688.    planets[TRITON].Rotation=360.0/5.876854;
  689.    planets[TRITON].Inclination=DEG2RAD(157.0);
  690.    planets[TRITON].Sat=NEPTUNE;
  691.    sprintf(planets[TRITON].Name,"Triton");
  692.  
  693.  
  694.  
  695.    planets[NEPTUNE].Image = read_JPEG_file(filenames[NEPTUNE]);
  696.    if (!planets[NEPTUNE].Image) {
  697.       printf("Couldn't read image\n");
  698.       exit(0);
  699.    }
  700.  
  701.    glBindTexture(GL_TEXTURE_2D, texName[NEPTUNE]);
  702.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  703.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  704.    glTexImage2D( GL_TEXTURE_2D,
  705.                  0,
  706.                  3,
  707.                  128, 128,
  708.                  0,
  709.                  GL_RGB, GL_UNSIGNED_BYTE,
  710.                  planets[NEPTUNE].Image );
  711.    free(planets[NEPTUNE].Image);
  712.    planets[NEPTUNE].Object = gluNewQuadric();
  713.    gluQuadricTexture( planets[NEPTUNE].Object, GL_TRUE );   
  714.    planets[NEPTUNE].Sphere= glGenLists(1);
  715.    glNewList( planets[NEPTUNE].Sphere, GL_COMPILE );
  716.    gluSphere( planets[NEPTUNE].Object,RADIUSSCALE(planets[NEPTUNE].Radius), SLICES, STACKS );
  717.    glEndList();
  718.  
  719.  
  720.    planets[TRITON].Image = read_JPEG_file(filenames[TRITON]);
  721.    if (!planets[TRITON].Image) {
  722.       printf("Couldn't read image\n");
  723.       exit(0);
  724.    }
  725.  
  726.    glBindTexture(GL_TEXTURE_2D, texName[TRITON]);
  727.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  728.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  729.    glTexImage2D( GL_TEXTURE_2D,
  730.                  0,
  731.                  3,
  732.                  128, 128,
  733.                  0,
  734.                  GL_RGB, GL_UNSIGNED_BYTE,
  735.                  planets[TRITON].Image );
  736.    free(planets[TRITON].Image);
  737.    planets[TRITON].Object = gluNewQuadric();
  738.    gluQuadricTexture( planets[TRITON].Object, GL_TRUE );   
  739.    planets[TRITON].Sphere= glGenLists(1);
  740.    glNewList( planets[TRITON].Sphere, GL_COMPILE );
  741.    gluSphere( planets[TRITON].Object,RADIUSSCALE(planets[TRITON].Radius), SLICES, STACKS );
  742.    glEndList();
  743.  
  744.  
  745.     
  746. } 
  747.  
  748.  
  749. static void InitPluto(void)
  750. {
  751.    planets[PLUTO].Radius=0.45;
  752.    planets[PLUTO].Degrees=118.0;
  753.    planets[PLUTO].DeltaRotation=0.0;
  754.    planets[PLUTO].Rotation=360.0/6.3872;
  755.    planets[PLUTO].Inclination=DEG2RAD(17.12137);
  756.    planets[PLUTO].AscendingNode=DEG2RAD(110.3833);
  757.    planets[PLUTO].Perihelion=DEG2RAD(224.8025);
  758.    planets[PLUTO].MeanDistance=DISTCORRECTION(39.5804);
  759.    planets[PLUTO].DailyMotion=DEG2RAD(0.003958072);
  760.    planets[PLUTO].Eccentricity=0.2501272;
  761.    planets[PLUTO].MeanLongitude=DEG2RAD(235.7656);
  762.    planets[PLUTO].Sat=0;
  763.    sprintf(planets[PLUTO].Name,"Pluto");
  764.  
  765.    planets[CHARON].Radius=593.0/6378.0;
  766.    planets[CHARON].Degrees=0.0;
  767.    planets[CHARON].DeltaRotation=0.0;
  768.    planets[CHARON].Rotation=360.0/6.38725;
  769.    planets[CHARON].Inclination=DEG2RAD(99.0);   
  770.    planets[CHARON].Sat=PLUTO;
  771.    sprintf(planets[CHARON].Name,"Charon");
  772.  
  773.  
  774.    planets[PLUTO].Image = read_JPEG_file(filenames[PLUTO]);
  775.    if (!planets[PLUTO].Image) {
  776.       printf("Couldn't read image\n");
  777.       exit(0);
  778.    }
  779.  
  780.    glBindTexture(GL_TEXTURE_2D, texName[PLUTO]);
  781.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  782.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  783.    glTexImage2D( GL_TEXTURE_2D,
  784.                  0,
  785.                  3,
  786.                  128, 128,
  787.                  0,
  788.                  GL_RGB, GL_UNSIGNED_BYTE,
  789.                  planets[PLUTO].Image );
  790.    free(planets[PLUTO].Image);
  791.    planets[PLUTO].Object = gluNewQuadric();
  792.    gluQuadricTexture( planets[PLUTO].Object, GL_TRUE );   
  793.    planets[PLUTO].Sphere= glGenLists(1);
  794.    glNewList( planets[PLUTO].Sphere, GL_COMPILE );
  795.    gluSphere( planets[PLUTO].Object,RADIUSSCALE(planets[PLUTO].Radius), SLICES, STACKS );
  796.    glEndList();
  797.  
  798.  
  799.    planets[CHARON].Image = read_JPEG_file(filenames[CHARON]);
  800.    if (!planets[CHARON].Image) {
  801.       printf("Couldn't read image\n");
  802.       exit(0);
  803.    }
  804.  
  805.    glBindTexture(GL_TEXTURE_2D, texName[CHARON]);
  806.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  807.    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  808.    glTexImage2D( GL_TEXTURE_2D,
  809.                  0,
  810.                  3,
  811.                  128, 128,
  812.                  0,
  813.                  GL_RGB, GL_UNSIGNED_BYTE,
  814.                  planets[CHARON].Image );
  815.    free(planets[CHARON].Image);
  816.    planets[CHARON].Object = gluNewQuadric();
  817.    gluQuadricTexture( planets[CHARON].Object, GL_TRUE );   
  818.    planets[CHARON].Sphere= glGenLists(1);
  819.    glNewList( planets[CHARON].Sphere, GL_COMPILE );
  820.    gluSphere( planets[CHARON].Object,RADIUSSCALE(planets[CHARON].Radius), SLICES, STACKS );
  821.    glEndList();
  822.     
  823. } 
  824.  
  825.  
  826.  
  827. static void InitStars(void)
  828. { 
  829.    static char line[100],*tmp;
  830.    FILE *f;
  831.    static float ascention,declination,magnitude;
  832.    int i;
  833.    
  834.    f=fopen("Stars.dat","rt");
  835.    for (i=0;i<NUMSTARS;i++) {
  836.     fgets(line,100,f);
  837.     if (feof(f)) break;
  838.     while (line[0]=='#') fgets(line,100,f);
  839.     tmp=line;
  840.     while (tmp[0]!=',') tmp++;
  841.     *tmp='\0';
  842.     tmp++;
  843.     red=0;
  844.     /* Print some stars in red color for testing */
  845.     if (!strcmp(line,"Polaris")) { red=1; polaris=i; }
  846.     if (!strcmp(line,"Dubhe")) red=1;
  847.     if (!strcmp(line,"Merak")) red=1;
  848.     if (!strcmp(line,"Phecda")) red=1;
  849.     if (!strcmp(line,"Megrez")) red=1;
  850.     if (!strcmp(line,"Alioth")) red=1;
  851.     if (!strcmp(line,"Mizar")) red=1;
  852.     sscanf(tmp,"%f,%f,%f\n",&ascention,&declination,&magnitude);
  853.     stars[i][0]=DISTCORRECTION(500.0)*cos(-ascention)*cos(declination);
  854.     stars[i][1]=DISTCORRECTION(500.0)*sin(declination);
  855.     stars[i][2]=DISTCORRECTION(500.0)*sin(-ascention)*cos(declination);
  856.     magnitude=sqrt(1.0/(1.46+magnitude));
  857.     if (red) magnitude=-magnitude;
  858.     stars[i][3]=magnitude;
  859.    }
  860.    fclose(f);
  861.  
  862.    Stars = glGenLists(1);
  863.    glNewList( Stars, GL_COMPILE );
  864.    glBegin(GL_POINTS);
  865.    magnitude=1.0;
  866.    for (i=0;i<NUMSTARS;i++) {
  867.        /* Since star catalog is sorted by magnitude and there are many stars
  868.           with the same magnitude this will avoid extra calls to glColor */
  869.     if (magnitude!=stars[i][3]) {
  870.         glColor3f(stars[i][3],stars[i][3],stars[i][3]);
  871.         magnitude=stars[i][3];
  872.     }
  873.     if (stars[i][3]<0) glColor3f(1.0,0.0,0.0);
  874.     glVertex3f(stars[i][0],stars[i][1],stars[i][2]);
  875.    }
  876.    glEnd();
  877.    glEndList();
  878. }
  879.  
  880.  
  881. /***************************************************************/
  882. /* JPEG DECOMPRESSION CODE TAKEN FROM JPEG LIBRARY SAMPLE CODE */
  883. /***************************************************************/
  884. struct my_error_mgr {
  885.   struct jpeg_error_mgr pub;    /* "public" fields */
  886.  
  887.   jmp_buf setjmp_buffer;    /* for return to caller */
  888. };
  889.  
  890. typedef struct my_error_mgr * my_error_ptr;
  891.  
  892. /*
  893.  * Here's the routine that will replace the standard error_exit method:
  894.  */
  895.  
  896. METHODDEF(void)
  897. my_error_exit (j_common_ptr cinfo)
  898. {
  899.   /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
  900.   my_error_ptr myerr = (my_error_ptr) cinfo->err;
  901.  
  902.   /* Always display the message. */
  903.   /* We could postpone this until after returning, if we chose. */
  904.   (*cinfo->err->output_message) (cinfo);
  905.  
  906.   /* Return control to the setjmp point */
  907.   longjmp(myerr->setjmp_buffer, 1);
  908. }
  909.  
  910.  
  911. /*
  912.  * Sample routine for JPEG decompression.  We assume that the source file name
  913.  * is passed in.  We want to return 1 on success, 0 on error.
  914.  */
  915.  
  916.  
  917. GLubyte *read_JPEG_file (char * fname)
  918. {
  919.   /* This struct contains the JPEG decompression parameters and pointers to
  920.    * working space (which is allocated as needed by the JPEG library).
  921.    */
  922.   struct jpeg_decompress_struct cinfo;
  923.   /* We use our private extension JPEG error handler.
  924.    * Note that this struct must live as long as the main JPEG parameter
  925.    * struct, to avoid dangling-pointer problems.
  926.    */
  927.   struct my_error_mgr jerr;
  928.   /* More stuff */
  929.   FILE * infile;        /* source file */
  930.   JSAMPARRAY buffer;        /* Output row buffer */
  931.   int row_stride;        /* physical row width in output buffer */
  932.   long cont;
  933.   JSAMPLE *image_buffer;
  934.   char filename[128];
  935.   
  936.   /* In this example we want to open the input file before doing anything else,
  937.    * so that the setjmp() error recovery below can assume the file is open.
  938.    * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
  939.    * requires it in order to read binary files.
  940.    */
  941.  
  942.   sprintf(filename,"%s/%s",texturepath,fname);
  943.   if ((infile = fopen(filename, "rb")) == NULL) {
  944.     fprintf(stderr, "can't open %s\n", filename);
  945.     return NULL;
  946.   }
  947.  
  948.   /* Step 1: allocate and initialize JPEG decompression object */
  949.  
  950.   /* We set up the normal JPEG error routines, then override error_exit. */
  951.   cinfo.err = jpeg_std_error(&jerr.pub);
  952.   jerr.pub.error_exit = my_error_exit;
  953.   /* Establish the setjmp return context for my_error_exit to use. */
  954.   if (setjmp(jerr.setjmp_buffer)) {
  955.     /* If we get here, the JPEG code has signaled an error.
  956.      * We need to clean up the JPEG object, close the input file, and return.
  957.      */
  958.     jpeg_destroy_decompress(&cinfo);
  959.     fclose(infile);
  960.     return NULL;
  961.   }
  962.   /* Now we can initialize the JPEG decompression object. */
  963.   jpeg_create_decompress(&cinfo);
  964.  
  965.   /* Step 2: specify data source (eg, a file) */
  966.  
  967.   jpeg_stdio_src(&cinfo, infile);
  968.  
  969.   /* Step 3: read file parameters with jpeg_read_header() */
  970.  
  971.   (void) jpeg_read_header(&cinfo, TRUE);
  972.   /* We can ignore the return value from jpeg_read_header since
  973.    *   (a) suspension is not possible with the stdio data source, and
  974.    *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
  975.    * See libjpeg.doc for more info.
  976.    */
  977.  
  978.   /* Step 4: set parameters for decompression */
  979.  
  980.   /* In this example, we don't need to change any of the defaults set by
  981.    * jpeg_read_header(), so we do nothing here.
  982.    */
  983.  
  984.   /* Step 5: Start decompressor */
  985.  
  986.   (void) jpeg_start_decompress(&cinfo);
  987.   /* We can ignore the return value since suspension is not possible
  988.    * with the stdio data source.
  989.    */
  990.  
  991.   /* We may need to do some setup of our own at this point before reading
  992.    * the data.  After jpeg_start_decompress() we have the correct scaled
  993.    * output image dimensions available, as well as the output colormap
  994.    * if we asked for color quantization.
  995.    * In this example, we need to make an output work buffer of the right size.
  996.    */ 
  997.   /* JSAMPLEs per row in output buffer */
  998.   row_stride = cinfo.output_width * cinfo.output_components;
  999.   /* Make a one-row-high sample array that will go away when done with image */
  1000.   buffer = (*cinfo.mem->alloc_sarray)
  1001.         ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
  1002.  
  1003.   /* Step 6: while (scan lines remain to be read) */
  1004.   /*           jpeg_read_scanlines(...); */
  1005.  
  1006.   /* Here we use the library's state variable cinfo.output_scanline as the
  1007.    * loop counter, so that we don't have to keep track ourselves.
  1008.    */
  1009.  
  1010.  image_buffer=(JSAMPLE *) malloc(cinfo.image_width*cinfo.image_height*3);
  1011.  
  1012.  
  1013.   
  1014.   cont=cinfo.output_height-1;
  1015.   while (cinfo.output_scanline < cinfo.output_height) {
  1016.     /* jpeg_read_scanlines expects an array of pointers to scanlines.
  1017.      * Here the array is only one element long, but you could ask for
  1018.      * more than one scanline at a time if that's more convenient.
  1019.      */
  1020.     (void) jpeg_read_scanlines(&cinfo, buffer, 1);
  1021.     /* Assume put_scanline_someplace wants a pointer and sample count. */
  1022.     /* put_scanline_someplace(buffer[0], row_stride); */
  1023.     memcpy(image_buffer+cinfo.image_width*3*cont,buffer[0],row_stride);
  1024.     cont--;
  1025.   }
  1026.  
  1027.   /* Step 7: Finish decompression */
  1028.  
  1029.   (void) jpeg_finish_decompress(&cinfo);
  1030.   /* We can ignore the return value since suspension is not possible
  1031.    * with the stdio data source.
  1032.    */
  1033.  
  1034.   /* Step 8: Release JPEG decompression object */
  1035.  
  1036.   /* This is an important step since it will release a good deal of memory. */
  1037.   jpeg_destroy_decompress(&cinfo);
  1038.  
  1039.   /* After finish_decompress, we can close the input file.
  1040.    * Here we postpone it until after no more JPEG errors are possible,
  1041.    * so as to simplify the setjmp error logic above.  (Actually, I don't
  1042.    * think that jpeg_destroy can do an error exit, but why assume anything...)
  1043.    */
  1044.   fclose(infile);
  1045.  
  1046.   /* At this point you may want to check to see whether any corrupt-data
  1047.    * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
  1048.    */
  1049.  
  1050.   /* And we're done! */
  1051.   return image_buffer;
  1052. }
  1053.  
  1054.  
  1055.