Initial revision

1 files changed, 781 insertions, 0 deletions

diff --git a/demos/GLLandScape/GLLandScape1w1.java b/demos/GLLandScape/GLLandScape1w1.java
new file mode 100644
index 0000000..9f6f1a3
--- /dev/null
+++ b/demos/GLLandScape/GLLandScape1w1.java
@@ -0,0 +1,781 @@
+/**
+ * @(#) GLLandScape1w1.java
+ */
+import gl4java.GLContext;
+import gl4java.awt.GLAnimCanvas;
+import java.awt.*;
+import java.awt.event.*;
+import java.lang.*;
+import java.util.*;
+
+/**
+ * This is meant as an skellekton for porting/writing
+ * OpenGL to gl4java
+ *
+ * If you are interessting in further Documentation and/or
+ * the history of gl4java follow the following link.
+ *
+ * <pre>
+   <a href="gl4java.html#_top_">The gl4java Documentation</a>
+ * </pre>
+ * <p>
+ *
+ * This NEW dummy code uses repaint(),
+ * the std. java thread, and sleep to suspend with a given
+ * Frames per secounds value !!
+ * (of course - sDisplay is still avaiable,
+ *  but i guess it is not that reliable ... comments welcome )
+ *
+ *
+ * @see WinDataAccess
+ * @version 	1.1, 3. MAI 1999
+ * @author      Sven Goethel
+ *
+ */
+class GLLandScape1w1 extends GLAnimCanvas 
+{
+   /**
+    * Variables for the LandScape
+    */
+   class COLOUR 
+   {
+      public float r, g, b;
+
+      public COLOUR()
+      {
+         r = 0.0f;
+         g = 0.0f;
+         b = 0.0f;
+      }
+
+   }
+
+   /* The constant MAP is used throughout the program and represents the MAP of
+      the matrix/landscape. */
+   static final int MAP = 256;
+
+   /* This is the holding space for the landscape. */
+   float y[/*MAP+2*/][/*MAP+2*/];
+
+   char object[/*MAP+1*/][/*MAP+1*/];
+
+   /* This is the holding space for the landscape colours. */
+   COLOUR c[/*MAP+1*/][/*MAP+1*/];
+
+   public static final int FORWARD = 1;
+
+   public static final int UP = 2;
+
+   public static final int TURNLEFT = 3;
+
+   public static final int STRAFELEFT = 4;
+
+   public static final int LOOKUP = 5;
+
+   public static final int LOOKSET = 6;
+
+   static final int TRUE = 1;
+
+   static final int FALSE = 0;
+
+   static final int WIDTH = 32;
+
+   /* The width of the texture map. */
+   byte texImg[/*WIDTH * WIDTH * 4*/];
+
+   int texName[/*1*/] = {0};
+
+   short comp = 32;
+
+   /* Scale modifier. */
+   short temp, texture_mapping = FALSE, land_fogging = TRUE, 
+         flat_shading = FALSE;
+
+   /* Initial eye position and vector of sight. */
+   float posx, posy, posz;
+
+   float lookx, looky, lookz;
+
+   float mySpeed = 0;
+
+   int myDir = FORWARD;
+
+   // the display list for the land ..
+   int theLand;
+
+   
+   final int MAX_PLANES = 15;
+   GlutPlaneObj planes[] = null;
+   Random random = null;
+
+
+   public GLLandScape1w1(int w, int h)
+   {
+      super(w,h);
+   }
+
+   public void init_pos()
+   {
+      posx = 4500.0f;
+      posy = 256.0f;
+      posz = 4500.0f;
+      lookx = 4096.0f;
+      looky = 0.0f;
+      lookz = 4096.0f;
+      mySpeed = 0;
+      System.out.println("init_pos");
+   }
+
+   public void init()
+   {
+      int i, j;
+      /* here we should add and initialize our JAVA components */
+      texImg = new byte[WIDTH * WIDTH * 4];
+      y = new float[MAP + 2][MAP + 2];
+      object = new char[MAP + 1][MAP + 1];
+      c = new COLOUR[MAP + 1][MAP + 1];
+      for(i = 0;i <= MAP;i++)
+      {
+         for(j = 0;j <= MAP;j++)
+         {
+            c[i][j] = new COLOUR();
+         }
+      }
+      float fogColor[] = {0.75f, 0.75f, 1.0f, 1.0f};
+      init_pos();
+      // srand(224);
+
+      create_fractal();
+      genLand();
+
+      random = new Random(System.currentTimeMillis());
+      planes = new GlutPlaneObj[MAX_PLANES];
+      for (i = 0; i < MAX_PLANES; i++)
+	planes[i] = new GlutPlaneObj(gl, glu);
+
+      // srand((unsigned)time(NULL));
+      makeTexture();
+      /* ... and furthet OpenGL init's - like you want to */
+      gl.glPixelStorei(GL_UNPACK_ALIGNMENT,1);
+      if(texture_mapping == TRUE)
+         gl.glEnable(GL_TEXTURE_2D);
+      gl.glGenTextures(1,texName);
+      gl.glBindTexture(GL_TEXTURE_2D,texName[0]);
+      gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
+      gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
+      gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+      gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+      gl.glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,WIDTH,WIDTH,0,GL_RGBA,GL_UNSIGNED_BYTE,texImg);
+      gl.glEnable(GL_DEPTH_TEST);
+      if(flat_shading == FALSE)
+         gl.glShadeModel(GL_SMOOTH);
+      else
+         gl.glShadeModel(GL_FLAT);
+      if(land_fogging == TRUE)
+         gl.glEnable(GL_FOG);
+      else
+         gl.glDisable(GL_FOG);
+      gl.glFogi(GL_FOG_MODE,GL_LINEAR);
+      gl.glFogfv(GL_FOG_COLOR,fogColor);
+      gl.glFogf(GL_FOG_DENSITY,0.4f);
+      gl.glFogf(GL_FOG_START,800.0f);
+      gl.glFogf(GL_FOG_END,1000.0f);
+      gl.glClearColor(0.75f,0.75f,1.0f,1.0f);
+      // FreeConsole();
+      glj.gljCheckGL();
+
+
+      Dimension dim = getSize();
+      reshape(dim.width,dim.height);
+      myMove(FORWARD,mySpeed,true,false);
+      check_height();
+      repaint();
+      /* and start our working thread ... */
+      start();
+   }
+
+   public void display()
+   {
+      int i;
+      /* Standard gl4java Init */
+      if(!cvsIsInit() || glj.gljMakeCurrent() == false)
+      {
+         System.out.println("problem in use() method");
+         return;
+      }
+      // ... just render it
+
+      gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+      gl.glCallList(theLand);
+
+      gl.glShadeModel(GL_FLAT);
+      for (i = 0; i < MAX_PLANES; i++)
+      {
+	planes[i].display();
+      }
+      if(flat_shading == FALSE)
+         gl.glShadeModel(GL_SMOOTH);
+
+      myMove(FORWARD,mySpeed,true,false);
+      check_height();
+
+
+      /* For your animation dutys ;-) */
+      glj.gljSwap();
+      glj.gljCheckGL();
+      glj.gljFree();
+   }
+
+   public void addPlane()
+   {
+	    for (int i = 0; i < MAX_PLANES; i++)
+	    {
+		if (planes[i].speed == 0.0f)
+		{
+		    int c = random.nextInt() & 0x07;
+		    while (c == 0) c = random.nextInt() & 0x07;
+		    float r = (float)((c >> 2) & 0x01);
+		    float g = (float)((c >> 1) & 0x01);
+		    float b = (float)(c & 0x01);
+			// Blue fades into the background; lighten it up.
+		    if (c == 0x01) r = g = 0.4f;
+		    planes[i].setColor(r,g,b);
+		    planes[i].speed =
+			((float)(random.nextInt() % 20)) * 0.001f + 0.02f;
+		    if ((random.nextInt() & 0x01) != 0)
+			planes[i].speed *= -1.0f;
+		    planes[i].theta =
+			((float)(random.nextInt() % 257))*0.1111f;
+		    planes[i].tick();
+		    if (isSuspended()) repaint();
+		    System.out.println("plane added");
+		    return;
+		}
+	    }
+   }
+
+   public void removePlane()
+   {
+	    for (int i = MAX_PLANES - 1; i >= 0; i--)
+	    {
+		if (planes[i].speed != 0.0f)
+		{
+		    planes[i].speed = 0.0f;
+		    if (isSuspended()) repaint();
+		    System.out.println("plane removed");
+		    return;
+		}
+	    }
+   }
+
+   /*************************************************************/
+   /*************************************************************/
+   /*************************************************************/
+   /*************************************************************/
+   /*************************************************************/
+   /*************************************************************/
+   void create_fractal()
+   {
+      int bsize, csize;
+      int x, z, i;
+      int r = 256;
+      /* The maximum random value. */
+      float gradient, shadow = 0.5f, n;
+      /* Make the matrix flat. */
+      for(x = 0;x < MAP + 2;x++)
+         for(z = 0;z < MAP + 2;z++)
+            y[x][z] = 0L;
+      bsize = MAP;
+      for(i = 0;i < 8;i++)
+      {
+         for(x = 0;x < MAP;x += bsize)
+            for(z = 0;z < MAP;z += bsize)
+               y[x][z] += (Math.random() * r - r / 2);
+         if(i > 4)
+            r = r / 2;
+         csize = bsize / 2;
+         if(csize > 0)
+         {
+            for(x = 0;x < MAP;x += bsize)
+               for(z = 0;z < MAP;z += bsize)
+               {
+                  if(x < MAP)
+                     y[x + csize][z] = (y[x + bsize][z] + y[x][z]) / 2;
+                  if(z < MAP)
+                     y[x][z + csize] = (y[x][z + bsize] + y[x][z]) / 2;
+                  if(x < MAP && z < MAP)
+                     y[x + csize][z + csize] = (y[x][z] + y[x + bsize][z] + y[x][z + bsize] + y[x + bsize][z + bsize]) / 4;
+               }
+         }
+         bsize = csize;
+      }
+      for(x = 0;x < MAP;x++)
+      {
+         for(z = 0;z < MAP;z++)
+         {
+            y[x][z] = y[x][z] + y[x + 1][z] + y[x + 1][z + 1] + y[x][z + 1];
+            y[x][z] /= 4.0f;
+         }
+      }
+      for(x = MAP;x > 0;x--)
+      {
+         for(z = 0;z < MAP;z++)
+         {
+            y[x][z] = y[x][z] + y[x - 1][z] + y[x - 1][z + 1] + y[x][z + 1];
+            y[x][z] /= 4.0f;
+         }
+      }
+      /* put trees in various places on grassland. */
+      for(x = 0;x < MAP;x++)
+      {
+         for(z = 0;z < MAP;z++)
+         {
+            if(((int)(Math.random() * 256.0f)) % 8 == 0 && y[x][z] > 0 && y[x][z] < 64)
+            {
+               object[x][z] = 't';
+            }
+            else
+            {
+               object[x][z] = 'n';
+            }
+         }
+      }
+      for(x = 0;x < MAP;x++)
+         for(z = 0;z < MAP;z++)
+            if(y[x][z] > 8)
+            {
+               n = y[x][z];
+               y[x][z] *= n;
+               y[x][z] /= 256.0f;
+            }
+      for(x = 0;x <= MAP;x++)
+      {
+         for(z = 0;z <= MAP;z++)
+         {
+            gradient = ((float)(y[x][z] - y[x + 1][z])) / 100.0f;
+            if(y[x][z] > 64)
+            {
+               if((y[x][z] - y[x][z + 1]) < 8 && (y[x][z] - y[x][z + 1]) > -8 && (y[x][z] - y[x + 1][z]) < 8 && (y[x][z] - y[x + 1][z]) > -8)
+               {
+                  c[x][z].g = gradient + 0.75f;
+                  c[x][z].r = c[x][z].g;
+                  c[x][z].b = c[x][z].g;
+               }
+               else
+               {
+                  c[x][z].r = gradient + 0.75f;
+                  c[x][z].g = c[x][z].r * 0.8f;
+                  c[x][z].b = c[x][z].r * 0.5f;
+               }
+            }
+            else
+               if(y[x][z] > 0)
+               {
+                  c[x][z].g = gradient + 0.75f;
+                  c[x][z].r = c[x][z].g * 0.6f;
+                  c[x][z].b = 0.0f;
+               }
+               else
+               {
+                  c[x][z].r = gradient + 1.0f;
+                  c[x][z].g = c[x][z].r * 0.75f;
+                  c[x][z].b = c[x][z].r * 0.5f;
+               }
+         }
+      }
+      for(x = 0;x <= MAP;x++)
+         for(z = 0;z <= MAP;z++)
+         {
+            if(y[x][z] < 0)
+               y[x][z] /= 4.0f;
+         }
+
+   }
+
+   void makeTexture()
+   {
+      int i, j, h, c;
+      for(i = 0;i < WIDTH;i++)
+      {
+         for(j = 0;j < WIDTH;j++)
+         {
+            c = (int)(Math.random() * 15 + 240);
+            h = i * WIDTH * 4 + j * 4;
+            texImg[h + 0] = (byte)c;
+            texImg[h + 1] = (byte)c;
+            texImg[h + 2] = (byte)c;
+            texImg[h + 3] = (byte)255;
+         }
+      }
+   }
+
+   void check_height()
+   {
+      float x0, x1, lx, lz, x, z, midpoint;
+      int fx, fz;
+      x = (posx / (comp * 1.0f));
+      z = (posz / (comp * 1.0f));
+      fx = (int)(x);
+      fz = (int)(z);
+      lx = x - fx;
+      lz = z - fz;
+      if(fx >= MAP + 2 || fz >= MAP + 2 || fx < 0 || fz < 0)
+      {
+         init_pos();
+         return;
+      }
+      x0 = y[fx][fz] + (y[fx][fz + 1] - y[fx][fz]) * lz;
+      x1 = y[fx + 1][fz] + (y[fx + 1][fz + 1] - y[fx + 1][fz]) * lz;
+      midpoint = x0 + (x1 - x0) * lx;
+      posy = midpoint + 16.0f;
+   }
+
+   /* Function that moves the eye / turns the angle of sight. */
+   /* Updates scene if update. */
+   void myMove(int dir, float amount, boolean update, boolean fetchGLContext)
+   {
+      float diff = (float)Math.sqrt(lookx * lookx + lookz * lookz);
+      /*
+         float alpha = (float)
+         Math.atan(Math.abs(lookz)/Math.abs(lookx));
+         if(lookx<0&&lookz>=0)
+         alpha+=(float)(Math.PI/2.0);
+         else if(lookx>=0&&lookz>=0)
+         alpha+=0;
+         else if(lookx<0&&lookz<0)
+         alpha+=(float)Math.PI;
+         else if(lookx>=0&&lookz<0)
+         alpha+=(float)((3.0*Math.PI)/2.0);
+         float _alpha = (float) (alpha*180f/Math.PI );
+       */
+      boolean do_repaint = false;
+      lookx /= diff;
+      lookz /= diff;
+      //myDir=dir;
+      switch(dir)
+      {
+         case FORWARD:
+            posx += lookx * amount;
+            posz += lookz * amount;
+            break;
+         case TURNLEFT:
+            lookx = lookx * (float)Math.cos(amount) + lookz * (float)Math.sin(amount);
+            lookz = lookz * (float)Math.cos(amount) - lookx * (float)Math.sin(amount);
+            // lookx^2 + lookz^2 != 1 for some reason. Fix.
+            lookx /= diff;
+            lookz /= diff;
+            do_repaint = true;
+            break;
+         case STRAFELEFT:
+            posx += lookz * amount;
+            posz -= lookx * amount;
+            break;
+         case UP:
+            posy += amount;
+            do_repaint = true;
+            break;
+         case LOOKUP:
+            looky += amount;
+            do_repaint = true;
+            break;
+         case LOOKSET:
+            looky = amount;
+            do_repaint = true;
+            break;
+      }
+      int x = (int)(posx / (comp * 1.0f));
+      int z = (int)(posz / (comp * 1.0f));
+      if(x > MAP)
+         posx = 0;
+      if(z > MAP)
+         posz = 0;
+      if(posx < 0)
+         posx = MAP * comp;
+      if(posz < 0)
+         posz = MAP * comp;
+      if (update)
+      {
+	      if(fetchGLContext && glj.gljMakeCurrent() == false)
+	      {
+		 System.out.println("problem in use() method");
+		 return;
+	      }
+	      gl.glMatrixMode(GL_MODELVIEW); gl.glLoadIdentity();
+              glu.gluLookAt(posx,posy,posz,
+			    posx+lookx, posy+looky,
+			    posz+lookz, 0.0f,1.0f,0.0f);
+
+	      if(fetchGLContext)
+		      glj.gljFree();
+
+	      if( do_repaint )
+		      repaint();
+      }
+   }
+
+   void draw_tree(int x, int z)
+   {
+      int x1, y1, z1;
+      y1 = (int)y[x][z];
+      x1 = x * comp;
+      z1 = z * comp;
+      gl.glBegin(GL_POLYGON);
+      gl.glColor3f(0.6f,0.4f,0.0f);
+      gl.glVertex3f(x1 - 2,y1 + 5,z1);
+      gl.glVertex3f(x1 + 2,y1 + 5,z1);
+      gl.glVertex3f(x1 + 2,y1,z1);
+      gl.glVertex3f(x1 - 2,y1,z1);
+      gl.glEnd();
+      gl.glBegin(GL_POLYGON);
+      gl.glVertex3f(x1,y1 + 5,z1 - 2);
+      gl.glVertex3f(x1,y1 + 5,z1 + 2);
+      gl.glVertex3f(x1,y1,z1 + 2);
+      gl.glVertex3f(x1,y1,z1 - 2);
+      gl.glEnd();
+      gl.glBegin(GL_POLYGON);
+      gl.glColor3f(0.35f,0.7f,0.0f);
+      gl.glTexCoord2f(0.0f,0.0f);
+      gl.glVertex3f(x1 - 10,y1 + 5,z1);
+      gl.glTexCoord2f(0.5f,1.0f);
+      gl.glVertex3f(x1,y1 + 25,z1);
+      gl.glTexCoord2f(1.0f,0.0f);
+      gl.glVertex3f(x1 + 10,y1 + 5,z1);
+      gl.glEnd();
+      gl.glBegin(GL_POLYGON);
+      gl.glColor3f(0.4f,0.8f,0.0f);
+      gl.glTexCoord2f(0.0f,0.0f);
+      gl.glVertex3f(x1,y1 + 5,z1 - 10);
+      gl.glTexCoord2f(0.5f,1.0f);
+      gl.glVertex3f(x1,y1 + 25,z1);
+      gl.glTexCoord2f(1.0f,0.0f);
+      gl.glVertex3f(x1,y1 + 5,z1 + 10);
+      gl.glEnd();
+   }
+
+   void genLand()
+   {
+      int x, z, position_x, position_z;
+      float x1, x2, z1, z2;
+
+      theLand = gl.glGenLists(1);
+      gl.glNewList(theLand, GL_COMPILE);
+
+      position_x = (int)(posx / comp);
+      position_z = (int)(posz / comp);
+      for(x = position_x - 16;x < position_x + 17;x++)
+         for(z = position_z - 16;z < position_z + 17;z++)
+         {
+            if(x > 0 && x < MAP && z > 0 && z < MAP)
+            {
+               x1 = x * comp;
+               x2 = x * comp + comp;
+               z1 = z * comp;
+               z2 = z * comp + comp;
+               gl.glBegin(GL_POLYGON);
+               gl.glColor3f(c[x][z].r,c[x][z].g,c[x][z].b);
+               gl.glTexCoord2f(0.0f,0.0f);
+               gl.glVertex3f(x1,y[x][z],z1);
+               gl.glColor3f(c[x + 1][z].r,c[x + 1][z].g,c[x + 1][z].b);
+               gl.glTexCoord2f(1.0f,0.0f);
+               gl.glVertex3f(x2,y[x + 1][z],z1);
+               gl.glColor3f(c[x][z + 1].r,c[x][z + 1].g,c[x][z + 1].b);
+               gl.glTexCoord2f(0.0f,1.0f);
+               gl.glVertex3f(x1,y[x][z + 1],z2);
+               gl.glEnd();
+               gl.glBegin(GL_POLYGON);
+               gl.glColor3f(c[x + 1][z + 1].r,c[x + 1][z + 1].g,c[x + 1][z + 1].b);
+               gl.glTexCoord2f(1.0f,1.0f);
+               gl.glVertex3f(x2,y[x + 1][z + 1],z2);
+               gl.glColor3f(c[x][z + 1].r,c[x][z + 1].g,c[x][z + 1].b);
+               gl.glTexCoord2f(0.0f,1.0f);
+               gl.glVertex3f(x1,y[x][z + 1],z2);
+               gl.glColor3f(c[x + 1][z].r,c[x + 1][z].g,c[x + 1][z].b);
+               gl.glTexCoord2f(1.0f,0.0f);
+               gl.glVertex3f(x2,y[x + 1][z],z1);
+               gl.glEnd();
+               if(object[x][z] == 't')
+                  draw_tree(x,z);
+            }
+         }
+      gl.glEndList();
+      glj.gljCheckGL();
+   }
+
+   public void reshape(int w, int h)
+   {
+      glj.gljResize(w,h);
+      gl.glViewport(0,0,w,h);
+      gl.glMatrixMode(GL_PROJECTION);
+      gl.glLoadIdentity();
+      glu.gluPerspective(60.0,(double)w / (double)h,1.0,1000.0);
+      gl.glMatrixMode(GL_MODELVIEW);
+      gl.glLoadIdentity();
+      glu.gluLookAt(posx,posy,posz,posx + lookx,posy + looky,posz + lookz,0.0,1.0,0.0);
+   }
+
+   public float getMySpeed()
+   {
+      return mySpeed;
+   }
+
+   public void setMySpeed(float s)
+   {
+      mySpeed = s;
+   }
+
+   public boolean getTextureState()
+   {
+      return texture_mapping == TRUE;
+   }
+
+   public void setTexture(boolean t)
+   {
+      if(t)
+      {
+         if(texture_mapping == FALSE)
+         {
+            if(glj!=null)
+	    {
+		    if(glj.gljMakeCurrent() == false)
+		    {
+		       System.out.println("problem in use() method");
+		       return;
+		    }
+		    gl.glEnable(GL_TEXTURE_2D);
+		    texture_mapping = TRUE;
+		    glj.gljCheckGL();
+		    repaint();
+	    }
+         }
+      }
+      else
+      {
+         if(texture_mapping == TRUE)
+         {
+            if(glj!=null)
+	    {
+		    if(glj.gljMakeCurrent() == false)
+		    {
+		       System.out.println("problem in use() method");
+		       return;
+		    }
+		    gl.glDisable(GL_TEXTURE_2D);
+		    texture_mapping = FALSE;
+		    glj.gljCheckGL();
+		    repaint();
+	    }
+         }
+      }
+      setSuspended(false);
+   }
+
+   public boolean getFogState()
+   {
+      return land_fogging == TRUE;
+   }
+
+   public void setFog(boolean t)
+   {
+      if(t)
+      {
+         if(land_fogging == FALSE)
+         {
+            if(glj!=null)
+	    {
+		    if(glj.gljMakeCurrent() == false)
+		    {
+		       System.out.println("problem in use() method");
+		       return;
+		    }
+		    gl.glEnable(GL_FOG);
+		    land_fogging = TRUE;
+		    glj.gljCheckGL();
+		    repaint();
+            }
+         }
+      }
+      else
+      {
+         if(land_fogging == TRUE)
+         {
+            if(glj!=null)
+	    {
+		    if(glj.gljMakeCurrent() == false)
+		    {
+		       System.out.println("problem in use() method");
+		       return;
+		    }
+		    gl.glDisable(GL_FOG);
+		    land_fogging = FALSE;
+		    glj.gljCheckGL();
+		    repaint();
+            }
+         }
+      }
+      setSuspended(false);
+   }
+
+   public boolean getFlatShadeState()
+   {
+      return flat_shading == TRUE;
+   }
+
+   public void setFlatShading(boolean t)
+   {
+      if(t)
+      {
+         if(flat_shading == FALSE)
+         {
+            if(glj!=null)
+	    {
+		    if(glj.gljMakeCurrent() == false)
+		    {
+		       System.out.println("problem in use() method");
+		       return;
+		    }
+		    gl.glShadeModel(GL_FLAT);
+		    flat_shading = TRUE;
+		    glj.gljCheckGL();
+		    repaint();
+            }
+         }
+      }
+      else
+      {
+         if(flat_shading == TRUE)
+         {
+            if(glj!=null)
+	    {
+		    if(glj.gljMakeCurrent() == false)
+		    {
+		       System.out.println("problem in use() method");
+		       return;
+		    }
+		    gl.glShadeModel(GL_SMOOTH);
+		    flat_shading = FALSE;
+		    glj.gljCheckGL();
+		    repaint();
+            }
+         }
+      }
+      setSuspended(false);
+   }
+
+   public void newFractal()
+   {
+      create_fractal();
+      if(!cvsIsInit() || glj.gljMakeCurrent() == false)
+      {
+         System.out.println("problem in use() method");
+         return;
+      }
+      gl.glFinish();
+      gl.glDeleteLists(theLand, 1);
+      genLand();
+      check_height();
+      repaint();
+      setSuspended(false);
+   }
+
+}
+