Initial revision

1 files changed, 634 insertions, 0 deletions

diff --git a/demos/waveCvs.java b/demos/waveCvs.java
new file mode 100644
index 0000000..bd7afbe
--- /dev/null
+++ b/demos/waveCvs.java
@@ -0,0 +1,634 @@
+ 

+/* 

+ * @version 	1.0, 23. JUNI 1998

+ */

+

+import gl4java.GLContext;

+import gl4java.awt.GLAnimCanvas;

+import java.awt.*;

+import java.awt.event.*;

+

+

+class waveCvs extends GLAnimCanvas

+  implements MouseListener

+{

+

+    class facet {

+	public float color[];

+	public float normal[];

+

+	public facet()

+	{ color = new float[3];

+	  normal = new float[3];

+	}

+    }

+

+    class coord {

+	public float vertex[];

+	public float normal[];

+

+	public coord()

+	{ vertex = new float[3];

+	  normal = new float[3];

+	}

+    }

+

+    class mesh {

+	public int widthX, widthY;

+	public int numFacets;

+	public int numCoords;

+	public int frames;

+	coord  coords[];

+	facet  facets[];

+    }

+

+/**

+ * The thread  for  referencing Thread (Animation)

+ *

+ * @see sbin

+ */

+	boolean rgb;

+

+	int colorIndexes1[];

+	int colorIndexes2[];

+	int clearMask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;

+

+	boolean smooth = GL_TRUE;

+	boolean lighting = GL_TRUE;

+	boolean depth = GL_TRUE;

+	boolean stepMode = GL_FALSE;

+	boolean spinMode = GL_FALSE;

+	int contouring = 0;

+	int widthX, widthY;

+

+	int checkerSize;

+	float height;

+

+	int frames, curFrame = 0, nextFrame = 0;

+

+	mesh theMesh;

+

+	static final float PI =  3.14159265358979323846f;

+

+

+	byte contourTexture1[] = {

+	    (byte) 255, (byte)255, (byte) 255, (byte) 255,

+	    (byte) 255, (byte)255, (byte) 255, (byte) 255,

+	    (byte) 255, (byte)255, (byte) 255, (byte) 255,

+	    (byte) 127, (byte)127, (byte) 127, (byte) 127

+	};

+	byte contourTexture2[] = {

+	    (byte) 255, (byte) 255, (byte) 255, (byte) 255,

+	    (byte) 255, (byte) 127, (byte) 127, (byte) 127,

+	    (byte) 255, (byte) 127, (byte) 127, (byte) 127,

+	    (byte) 255, (byte) 127, (byte) 127, (byte) 127

+	};

+

+

+	public waveCvs(int w, int h, String glClass, String gluClass)

+	{

+		super( w, h, glClass, gluClass);

+	}

+

+	Frame ctrl = null;

+

+	Button ButtonCont; TextField TextCont;

+	Button ButtonShade; TextField TextShade;

+	Button ButtonLight; TextField TextLight;

+	Button ButtonDepth; TextField TextDepth;

+	Button ButtonStepMode; TextField TextStepMode;

+	Button ButtonStep; TextField TextStep;

+	Button ButtonSpinMode; TextField TextSpinMode;

+

+        public void init()

+        {

+		ctrl = new Frame ("Wave-Features");

+

+		ctrl.setLayout(new GridLayout(7,2));

+		ctrl.add ( ButtonCont=new Button("Contour") );

+		ctrl.add ( TextCont=new TextField() );

+		ctrl.add ( ButtonShade=new Button("Shade") );

+		ctrl.add ( TextShade=new TextField() );

+		ctrl.add ( ButtonLight=new Button("Light") );

+		ctrl.add ( TextLight=new TextField() );

+		ctrl.add ( ButtonDepth=new Button("Depth") );

+		ctrl.add ( TextDepth=new TextField() );

+		ctrl.add ( ButtonStepMode=new Button("StepMod") );

+		ctrl.add ( TextStepMode=new TextField() );

+		ctrl.add ( ButtonStep=new Button("Step") );

+		ctrl.add ( TextStep=new TextField() );

+		ctrl.add ( ButtonSpinMode=new Button("SpinMod") );

+		ctrl.add ( TextSpinMode=new TextField() );

+

+		TextCont.setEditable(false);

+		TextShade.setEditable(false);

+		TextLight.setEditable(false);

+		TextDepth.setEditable(false);

+		TextStepMode.setEditable(false);

+		TextStep.setEditable(false);

+		TextSpinMode.setEditable(false);

+

+		updateTextFields();

+

+		ctrl.pack();

+		ctrl.setVisible( true );

+

+		ButtonCont.addMouseListener(this);

+		ButtonShade.addMouseListener(this);

+		ButtonLight.addMouseListener(this);

+		ButtonDepth.addMouseListener(this);

+		ButtonStepMode.addMouseListener(this);

+		ButtonStep.addMouseListener(this);

+		ButtonSpinMode.addMouseListener(this);

+

+		rgb = GL_TRUE;

+		frames = 10;

+		widthX = 10;

+		widthY = 10;

+		checkerSize = 2;

+		height = 0.2f;

+

+		/* here we should add and initialize our JAVA components */

+		colorIndexes1=new int [3];

+		colorIndexes2=new int [3];

+

+		/* Standard gl4java Init */

+		if(rgb==GL_TRUE)

+			System.out.println("using rgb...");

+		else

+			System.out.println("using color index...");

+

+		gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

+

+	        gl.glShadeModel(GL_SMOOTH);

+		

+		gl.glFrontFace(GL_CW);

+

+		gl.glEnable(GL_DEPTH_TEST);

+

+		InitMaterials();

+		InitTexture();

+		InitMesh();

+

+		gl.glMatrixMode(GL_MODELVIEW);

+		gl.glTranslatef(0.0f, 0.4f, -1.8f);

+		gl.glScalef(2.0f, 2.0f, 2.0f);

+		gl.glRotatef(-35.0f, 1.0f, 0.0f, 0.0f);

+		gl.glRotatef(35.0f, 0.0f, 0.0f, 1.0f);

+		/* ... and furthet OpenGL init's - like you want to */

+                glj.gljCheckGL();

+        }

+

+	 public coord GETCOORD(int frame, int x, int y) 

+	 {

+	   return 

+	    theMesh.coords[frame*theMesh.numCoords+(x)+(y)*(theMesh.widthX+1)];

+	 }

+	 public facet GETFACET(int frame, int x, int y) 

+	 { 

+	   return 

+	    theMesh.facets[frame*theMesh.numFacets+(x)+(y)*(theMesh.widthX)];

+	 }

+

+	public void display()

+	{

+	    coord coord_;

+	    facet facet_;

+	    float lastColor[] = null;

+	    float thisColor[] = null;

+	    int i, j;

+

+	    /* Standard gl4java Init */

+	    if( glj.gljMakeCurrent() == false ) 

+	    {

+		System.out.println("wave-display: problem in use() method");

+		return;

+	    }

+

+	    gl.glClear(clearMask);

+

+	    if (nextFrame>0 || stepMode==GL_FALSE) {

+		curFrame++;

+	    }

+	    if (curFrame >= theMesh.frames) {

+		curFrame = 0;

+	    }

+

+	    if ((nextFrame>0 || stepMode==GL_FALSE) && spinMode==GL_TRUE) 

+	    {

+		gl.glRotatef(5.0f, 0.0f, 0.0f, 1.0f);

+	    }

+	    nextFrame = 0;

+

+	    for (i = 0; i < theMesh.widthX; i++) {

+		gl.glBegin(GL_QUAD_STRIP);

+		lastColor = null;

+		for (j = 0; j < theMesh.widthY; j++) {

+		    facet_ = GETFACET(curFrame, i, j);

+		    if (smooth==GL_FALSE && lighting==GL_TRUE) 

+		    {

+			gl.glNormal3fv(facet_.normal);

+		    }

+		    if (lighting==GL_TRUE) {

+			if (rgb==GL_TRUE) {

+			    thisColor = facet_.color;

+			    gl.glColor3fv(facet_.color);

+			} else {

+			    thisColor = facet_.color;

+			    gl.glMaterialfv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, 

+					 facet_.color);

+			}

+		    } else {

+			if (rgb==GL_TRUE) {

+			    thisColor = facet_.color;

+			    gl.glColor3fv(facet_.color);

+			} else {

+			    thisColor = facet_.color;

+			    gl.glIndexf(facet_.color[1]);

+			}

+		    }

+

+		    if (lastColor==null || 

+		        (thisColor[0] != lastColor[0] && smooth==GL_TRUE)

+		       ) 

+		    {

+			if (lastColor!=null) {

+			    gl.glEnd();

+			    gl.glBegin(GL_QUAD_STRIP);

+			}

+			coord_ = GETCOORD(curFrame, i, j);

+			if (smooth==GL_TRUE && lighting==GL_TRUE) 

+			{

+			    gl.glNormal3fv(coord_.normal);

+			}

+			gl.glVertex3fv(coord_.vertex);

+

+			coord_ = GETCOORD(curFrame, i+1, j);

+			if (smooth==GL_TRUE && lighting==GL_TRUE) 

+			{

+			    gl.glNormal3fv(coord_.normal);

+			}

+			gl.glVertex3fv(coord_.vertex);

+		    }

+

+		    coord_ = GETCOORD(curFrame, i, j+1);

+		    if (smooth==GL_TRUE && lighting==GL_TRUE) {

+			gl.glNormal3fv(coord_.normal);

+		    }

+		    gl.glVertex3fv(coord_.vertex);

+

+		    coord_ = GETCOORD(curFrame, i+1, j+1);

+		    if (smooth==GL_TRUE && lighting==GL_TRUE) {

+			gl.glNormal3fv(coord_.normal);

+		    }

+		    gl.glVertex3fv(coord_.vertex);

+

+		    lastColor = thisColor;

+		}

+		gl.glEnd();

+	    }

+

+	    glj.gljSwap();

+	    glj.gljCheckGL();

+	    glj.gljFree();

+	}

+

+	public void InitMesh()

+	{

+	    coord coord_;

+	    facet facet_;

+	    float dp1[], dp2[];

+	    float pt1[], pt2[], pt3[];

+	    float angle, d, x, y;

+	    int numFacets, numCoords, frameNum, i, j;

+

+            dp1=new float[3];

+            dp2=new float[3];

+

+            theMesh = new mesh();

+	    theMesh.widthX = widthX;

+	    theMesh.widthY = widthY;

+	    theMesh.frames = frames;

+

+	    numFacets = widthX * widthY;

+	    numCoords = (widthX + 1) * (widthY + 1);

+

+	    theMesh.numCoords = numCoords;

+	    theMesh.numFacets = numFacets;

+

+	    theMesh.coords = new coord[frames*numCoords];

+	    for(i=0; i<frames*numCoords; i++)

+	      theMesh.coords[i]=new coord();

+

+	    theMesh.facets = new facet[frames*numFacets];

+	    for(i=0; i<frames*numFacets; i++)

+	      theMesh.facets[i]=new facet();

+

+	    for (frameNum = 0; frameNum < frames; frameNum++) {

+		for (i = 0; i <= widthX; i++) {

+		    x = i / (float)widthX;

+		    for (j = 0; j <= widthY; j++) {

+			y = j / (float)widthY;

+

+			d = (float) Math.sqrt(x*x+y*y);

+			if (d == 0.0) {

+			    d = 0.0001f;

+			}

+			angle = 2 * (float)PI * d + 

+			        (2 * (float)PI / frames * frameNum);

+

+			coord_ = GETCOORD(frameNum, i, j);

+

+			coord_.vertex[0] = x - 0.5f;

+			coord_.vertex[1] = y - 0.5f;

+			coord_.vertex[2] = (height - height * d) * 

+			                   (float)Math.cos(angle);

+

+			coord_.normal[0] = -(height / d) * x * ((1 - d) * 2 * 

+			                   PI * (float)Math.sin(angle) + 

+					  (float)Math.cos(angle));

+			coord_.normal[1] = -(height / d) * y * ((1 - d) * 2 * 

+			                   PI * (float)Math.sin(angle) + 

+					   (float)Math.cos(angle));

+			coord_.normal[2] = -1;

+

+			d = 1.0f / 

+			    (float)Math.sqrt(coord_.normal[0]*coord_.normal[0]+

+				       coord_.normal[1]*coord_.normal[1]+1);

+			coord_.normal[0] *= d;

+			coord_.normal[1] *= d;

+			coord_.normal[2] *= d;

+		    }

+		}

+		for (i = 0; i < widthX; i++) {

+		    for (j = 0; j < widthY; j++) {

+			facet_ = GETFACET(frameNum, i, j);

+			if ( ( ( (i/checkerSize)%2 ) ^ (j/checkerSize) %2 )

+			     >0

+			   ) 

+			{

+			    if (rgb==GL_TRUE) {

+				facet_.color[0] = 1.0f;

+				facet_.color[1] = 0.2f;

+				facet_.color[2] = 0.2f;

+			    } else {

+				facet_.color[0] = colorIndexes1[0];

+				facet_.color[1] = colorIndexes1[1];

+				facet_.color[2] = colorIndexes1[2];

+			    }

+			} else {

+			    if (rgb==GL_TRUE) {

+				facet_.color[0] = 0.2f;

+				facet_.color[1] = 1.0f;

+				facet_.color[2] = 0.2f;

+			    } else {

+				facet_.color[0] = colorIndexes2[0];

+				facet_.color[1] = colorIndexes2[1];

+				facet_.color[2] = colorIndexes2[2];

+			    }

+			}

+			pt1 = GETCOORD(frameNum, i, j).vertex;

+			pt2 = GETCOORD(frameNum, i, j+1).vertex;

+			pt3 = GETCOORD(frameNum, i+1, j+1).vertex;

+

+			dp1[0] = pt2[0] - pt1[0];

+			dp1[1] = pt2[1] - pt1[1];

+			dp1[2] = pt2[2] - pt1[2];

+

+			dp2[0] = pt3[0] - pt2[0];

+			dp2[1] = pt3[1] - pt2[1];

+			dp2[2] = pt3[2] - pt2[2];

+

+			facet_.normal[0] = dp1[1] * dp2[2] - dp1[2] * dp2[1];

+			facet_.normal[1] = dp1[2] * dp2[0] - dp1[0] * dp2[2];

+			facet_.normal[2] = dp1[0] * dp2[1] - dp1[1] * dp2[0];

+

+			d = 1.0f / (float)Math.sqrt(facet_.normal[0]*facet_.normal[0]+

+				       facet_.normal[1]*facet_.normal[1]+

+				       facet_.normal[2]*facet_.normal[2]);

+

+			facet_.normal[0] *= d;

+			facet_.normal[1] *= d;

+			facet_.normal[2] *= d;

+		    }

+		}

+	    }

+	}

+

+	static float ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};

+	static float diffuse[] = {0.5f, 1.0f, 1.0f, 1.0f};

+	static float position[] = {90.0f, 90.0f, 150.0f, 0.0f};

+	static float front_mat_shininess[] = {60.0f, 0f, 0f, 0f};

+	static float front_mat_specular[] = {0.2f, 0.2f, 0.2f, 1.0f};

+	static float front_mat_diffuse[] = {0.5f, 0.28f, 0.38f, 1.0f};

+	static float back_mat_shininess[] = {60.0f, 0f, 0f, 0f};

+	static float back_mat_specular[] = {0.5f, 0.5f, 0.2f, 1.0f};

+	static float back_mat_diffuse[] = {1.0f, 1.0f, 0.2f, 1.0f};

+	static float lmodel_ambient[] = {1.0f, 1.0f, 1.0f, 1.0f};

+	static float lmodel_twoside[] = {1f, 0f, 0f, 0f};

+

+	public void InitMaterials()

+	{

+	    gl.glMatrixMode(GL_PROJECTION);

+	    glu.gluPerspective(450, 1.0, 0.5, 10.0);

+

+	    gl.glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);

+	    gl.glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);

+	    gl.glLightfv(GL_LIGHT0, GL_POSITION, position);

+	    gl.glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

+	    gl.glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);

+	    gl.glEnable(GL_LIGHTING);

+	    gl.glEnable(GL_LIGHT0);

+	    

+	    gl.glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);

+	    gl.glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);

+	    gl.glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);

+	    gl.glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);

+	    gl.glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);

+	    gl.glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);

+	    if (rgb==GL_TRUE) {

+		gl.glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);

+	    }

+

+	    if (rgb==GL_TRUE) {

+		gl.glEnable(GL_COLOR_MATERIAL);

+	    } /* else {

+		SetColorMap();

+	    } */

+	}

+

+	public void InitTexture()

+	{

+

+	    gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

+	    gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

+	    gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

+	    gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

+	    gl.glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

+	}

+

+	// Methods required for the implementation of MouseListener

+	public void mouseClicked( MouseEvent evt )

+	{

+	    Component comp = evt.getComponent();

+

+	    if( cvsIsInit()==false ) return ;

+

+	    if( glj.gljMakeCurrent() == false ) 

+	    {

+		    System.out.println("CtrlWin: problem in use() method");

+		    return;

+	    } else {

+		    gl.glFinish();

+	    }

+

+	    if(comp.equals(ButtonCont)) 

+	    {

+		contouring++;

+		if (contouring == 1) {

+		    float map[];

+		    map=new float[4];

+		    map[0]=0f;

+		    map[1]=0f;

+		    map[2]=20f;

+		    map[3]=0f;

+

+		    gl.glTexImage2D(GL_TEXTURE_2D, 0, 3, 4, 4, 0, GL_LUMINANCE,

+				 GL_UNSIGNED_BYTE, contourTexture1);

+		    gl.glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

+		    gl.glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

+		    gl.glTexGenfv(GL_S, GL_OBJECT_PLANE, map);

+		    gl.glTexGenfv(GL_T, GL_OBJECT_PLANE, map);

+		    gl.glEnable(GL_TEXTURE_2D);

+		    gl.glEnable(GL_TEXTURE_GEN_S);

+		    gl.glEnable(GL_TEXTURE_GEN_T);

+		} else if (contouring == 2) {

+		    float map[];

+		    map=new float[4];

+		    map[0]=0f;

+		    map[1]=0f;

+		    map[2]=20f;

+		    map[3]=0f;

+

+		    gl.glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);

+		    gl.glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);

+		    gl.glPushMatrix();

+		    gl.glMatrixMode(GL_MODELVIEW);

+		    gl.glLoadIdentity();

+		    gl.glTexGenfv(GL_S, GL_EYE_PLANE, map);

+		    gl.glTexGenfv(GL_T, GL_EYE_PLANE, map);

+		    gl.glPopMatrix();

+		} else {

+		    contouring = 0;

+		    gl.glDisable(GL_TEXTURE_GEN_S);

+		    gl.glDisable(GL_TEXTURE_GEN_T);

+		    gl.glDisable(GL_TEXTURE_2D);

+		}

+	    }

+	    else if(comp.equals(ButtonShade)) 

+	    {

+		smooth = (smooth==GL_TRUE)?GL_FALSE:GL_TRUE;

+		if (smooth==GL_TRUE) {

+		    gl.glShadeModel(GL_SMOOTH);

+		} else {

+		    gl.glShadeModel(GL_FLAT);

+		}

+	    }

+	    else if(comp.equals(ButtonLight)) 

+	    {

+		lighting = (lighting==GL_TRUE)?GL_FALSE:GL_TRUE;

+		if (lighting==GL_TRUE) {

+		    gl.glEnable(GL_LIGHTING);

+		    gl.glEnable(GL_LIGHT0);

+		    if (rgb==GL_TRUE) {

+			gl.glEnable(GL_COLOR_MATERIAL);

+		    }

+		} else {

+		    gl.glDisable(GL_LIGHTING);

+		    gl.glDisable(GL_LIGHT0);

+		    if (rgb==GL_TRUE) {

+			gl.glDisable(GL_COLOR_MATERIAL);

+		    }

+		}

+	    }

+	    else if(comp.equals(ButtonDepth)) 

+	    {

+		depth = (depth==GL_TRUE)?GL_FALSE:GL_TRUE;

+		if (depth==GL_TRUE) {

+		    gl.glEnable(GL_DEPTH_TEST);

+		    clearMask |= GL_DEPTH_BUFFER_BIT;

+		} else {

+		    gl.glDisable(GL_DEPTH_TEST);

+		    clearMask &= ~GL_DEPTH_BUFFER_BIT;

+		}

+	    }

+	    else if(comp.equals(ButtonStepMode)) 

+	    {

+		stepMode = (stepMode==GL_TRUE)?GL_FALSE:GL_TRUE;

+		if (stepMode==GL_TRUE) {

+		    stop();

+		} else {

+		    start();

+		}

+	    }

+	    else if(comp.equals(ButtonStep)) 

+	    {

+		if (stepMode==GL_TRUE) {

+		    nextFrame = 1;

+		}

+	    }

+	    else if(comp.equals(ButtonSpinMode)) 

+	    {

+		spinMode = (spinMode==GL_TRUE)?GL_FALSE:GL_TRUE;

+	    }

+

+	    updateTextFields();

+

+	    gl.glFinish();

+	    glj.gljFree();

+

+	    repaint();

+	}

+

+	public void updateTextFields()

+	{

+		TextCont.setText(String.valueOf(contouring));

+

+		TextShade.setText((smooth==GL_TRUE)?"ON":"OFF");

+

+		TextLight.setText((lighting==GL_TRUE)?"ON":"OFF");

+

+		TextDepth.setText((depth==GL_TRUE)?"ON":"OFF");

+

+		TextStepMode.setText((stepMode==GL_TRUE)?"ON":"OFF");

+

+		TextStep.setText((stepMode==GL_TRUE)?"ON":"OFF");

+

+		TextSpinMode.setText((spinMode==GL_TRUE)?"ON":"OFF");

+	}

+

+	public void mouseEntered( MouseEvent evt )

+	{

+	}

+

+	public void mouseExited( MouseEvent evt )

+	{

+	}

+

+	public void mousePressed( MouseEvent evt )

+	{

+	}

+

+	public void mouseReleased( MouseEvent evt )

+	{

+	}

+

+	 public void cvsDispose()

+	 {

+	 	if(ctrl!=null)

+		{

+			ctrl.dispose();

+		}

+		super.cvsDispose();

+	 }

+}