public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
//
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl.glPushMatrix();
gl.glRotatef(20.0f, 1.0f, 0.0f, 0.0f);
gl.glPushMatrix();
gl.glTranslatef(-0.75f, 0.5f, 0.0f);
gl.glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
glut.glutSolidTorus(0.275f, 0.85f, 20, 20);
gl.glPopMatrix();
gl.glPushMatrix();
gl.glTranslatef(-0.75f, -0.5f, 0.0f);
gl.glRotatef(270.0f, 1.0f, 0.0f, 0.0f);
glut.glutSolidCone(1.0f, 2.0f, 20, 20);
gl.glPopMatrix();
gl.glPushMatrix();
gl.glTranslatef(0.75f, 0.0f, -1.0f);
glut.glutSolidSphere(1.0f, 20, 20);
gl.glPopMatrix();
gl.glPopMatrix();
gl.glFlush();
}
/*
* Initialize z-buffer, projection matrix, light source, and lighting model.
* Do not specify a material property here.
*/
public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
glut = new GLUT();
//
float position[] = {0.0f, 3.0f, 3.0f, 0.0f};
float local_view[] = {0.0f};
gl.glEnable(GL.GL_DEPTH_TEST);
gl.glDepthFunc(GL.GL_LESS);
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, position, 0);
gl.glLightModelfv(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, local_view, 0);
gl.glFrontFace(GL.GL_CW);
gl.glEnable(GL2.GL_LIGHTING);
gl.glEnable(GL2.GL_LIGHT0);
gl.glEnable(GL2.GL_AUTO_NORMAL);
gl.glEnable(GL2.GL_NORMALIZE);
gl.glEnable(GL2.GL_FOG);
{
float fogColor[] = {0.5f, 0.5f, 0.5f, 1.0f};
fogMode = GL2.GL_EXP;
gl.glFogi(GL2.GL_FOG_MODE, fogMode);
gl.glFogfv(GL2.GL_FOG_COLOR, fogColor, 0);
gl.glFogf(GL2.GL_FOG_DENSITY, 0.35f);
gl.glHint(GL2.GL_FOG_HINT, GL.GL_DONT_CARE);
gl.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
}
}
public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
GL2 gl = drawable.getGL().getGL2();
//
gl.glViewport(0, 0, w, h);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
if (w <= (h * 3))
gl.glOrtho(
-6.0,
6.0,
-2.0 * ((float) h * 3) / (float) w,
2.0 * ((float) h * 3) / (float) w,
0.0,
10.0);
else
gl.glOrtho(
-6.0 * (float) w / ((float) h * 3), //
6.0 * (float) w / ((float) h * 3),
-2.0,
2.0,
0.0,
10.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
GL gl = drawable.getGL();
gl.glViewport(0, 0, w, h);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
gl.glOrtho(0, w, 0, h, -1.0, 1.0);
gl.glMatrixMode(GL.GL_MODELVIEW);
}
public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
GL2 gl = drawable.getGL().getGL2();
//
gl.glViewport(0, 0, w, h);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
if (w <= h)
gl.glOrtho(-2.5, 2.5, -2.5 * (float) h / (float) w, 2.5 * (float) h / (float) w, -10.0, 10.0);
else
gl.glOrtho(-2.5 * (float) w / (float) h, 2.5 * (float) w / (float) h, -2.5, 2.5, -10.0, 10.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
}
/**
* Called back immediately after the OpenGL context is initialized. Can be used to perform
* one-time initialization. Run only once.
*/
@Override
public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2(); // get the OpenGL graphics context
glu = new GLU(); // get GL Utilities
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set background (clear) color
gl.glClearDepth(1.0f); // set clear depth value to farthest
// Do not enable depth test
// gl.glEnable(GL_DEPTH_TEST); // enables depth testing
// gl.glDepthFunc(GL_LEQUAL); // the type of depth test to do
gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // best perspective correction
gl.glShadeModel(GL_SMOOTH); // blends colors nicely, and smoothes out lighting
// Load the texture image
try {
// Use URL so that can read from JAR and disk file.
BufferedImage image = ImageIO.read(this.getClass().getResource(textureFileName));
// Create a OpenGL Texture object
texture = AWTTextureIO.newTexture(GLProfile.getDefault(), image, false);
// Use linear filter if image is larger than the original texture
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Use linear filter if image is smaller than the original texture
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} catch (GLException | IOException e) {
e.printStackTrace();
}
// Texture image flips vertically. Shall use TextureCoords class to retrieve
// the top, bottom, left and right coordinates, instead of using 0.0f and 1.0f.
TextureCoords textureCoords = texture.getImageTexCoords();
textureCoordTop = textureCoords.top();
textureCoordBottom = textureCoords.bottom();
textureCoordLeft = textureCoords.left();
textureCoordRight = textureCoords.right();
// Enable the texture
texture.enable(gl);
texture.bind(gl);
// gl.glEnable(GL_TEXTURE_2D);
// Enable blending
gl.glEnable(GL_BLEND);
gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE);
// Allocate the stars
for (int i = 0; i < stars.length; i++) {
stars[i] = new Star();
// Linearly distributed according to the star number
stars[i].distance = ((float) i / numStars) * 5.0f;
}
}
@Override
public void display(GLAutoDrawable glAutoDrawable) {
gl = glAutoDrawable.getGL().getGL2();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
// Fonts draw selves at the current raster position
gl.glRasterPos2f(right - (right + 2.0f), bottom + 1);
caption = "Please wait... drawing frames";
glut.glutBitmapString(GLUT.BITMAP_HELVETICA_18, caption);
drawByLevel();
gl.glFlush();
}
public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glRasterPos2i(1, 1);
gl.glDrawPixels(
dim.width,
dim.height, //
GL.GL_RGB,
GL.GL_UNSIGNED_BYTE,
pixels);
gl.glFlush();
}
/*
* display() draws 5 teapots at different z positions.
*/
public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
//
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
//
if (fogMode == GL2.GL_EXP2) {
gl.glFogf(GL2.GL_FOG_START, 1.0f);
gl.glFogf(GL2.GL_FOG_END, 5.0f);
}
gl.glFogi(GL2.GL_FOG_MODE, fogMode);
renderRedTeapot(gl, -4.0f, -0.5f, -1.0f);
renderRedTeapot(gl, -2.0f, -0.5f, -2.0f);
renderRedTeapot(gl, 0.0f, -0.5f, -3.0f);
renderRedTeapot(gl, 2.0f, -0.5f, -4.0f);
renderRedTeapot(gl, 4.0f, -0.5f, -5.0f);
gl.glFlush();
}
/**
* Call-back handler for window re-size event. Also called when the drawable is first set to
* visible.
*/
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
GL2 gl = drawable.getGL().getGL2(); // get the OpenGL 2 graphics context
if (height == 0) height = 1; // prevent divide by zero
float aspect = (float) width / height;
// Set the view port (display area) to cover the entire window
gl.glViewport(0, 0, width, height);
// Setup perspective projection, with aspect ratio matches viewport
gl.glMatrixMode(GL_PROJECTION); // choose projection matrix
gl.glLoadIdentity(); // reset projection matrix
glu.gluPerspective(45.0, aspect, 0.1, 100.0); // fovy, aspect, zNear, zFar
// Enable the model-view transform
gl.glMatrixMode(GL_MODELVIEW);
gl.glLoadIdentity(); // reset
}
/*
* Initialize material property and light source.
*/
public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
//
float light_ambient[] = {0.0f, 0.0f, 0.0f, 1.0f};
float light_diffuse[] = {1.0f, 0.0f, 1.0f, 1.0f};
float light_specular[] = {1.0f, 0.0f, 1.0f, 1.0f};
/* light_position is NOT default value */
float light_position[] = {1.0f, 1.0f, 1.0f, 0.0f};
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, light_ambient, 0);
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, light_diffuse, 0);
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, light_specular, 0);
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, light_position, 0);
gl.glEnable(GL2.GL_LIGHTING);
gl.glEnable(GL2.GL_LIGHT0);
gl.glDepthFunc(GL.GL_LESS);
gl.glEnable(GL.GL_DEPTH_TEST);
}
public void init(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
float m[] = {
0.0f, 1.0f, 0.0f, 0.0f, //
0.0f, 0.0f, 1.0f, 0.0f, //
1.0f, 0.0f, 0.0f, 0.0f, //
0.0f, 0.0f, 0.0f, 1.0f
};
pixels = readImage("Data/leeds.bin", dim);
System.out.println(pixels.toString());
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.glMatrixMode(GL.GL_COLOR);
gl.glLoadMatrixf(m, 0);
gl.glMatrixMode(GL.GL_MODELVIEW);
}
@Override
public void init(GLAutoDrawable glAutoDrawable) {
gl = glAutoDrawable.getGL().getGL2();
glu = new GLU();
glut = new GLUT();
gl.glClearColor(0.549f, 0.675f, 0.227f, 0.0f);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluOrtho2D(left, right, bottom, top);
gl.glViewport((int) bottom, (int) left, (int) top, (int) right);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glColor3f(.357f, .184f, .478f);
maxFrames = 50 * ifsFiles.size() + 1000;
base = gl.glGenLists(maxFrames);
currentDrawList = base;
ifsfile = "CS371/assignments/assignment02/tri.ifs";
loadifs();
}
/** Called back by the animator to perform rendering. */
@Override
public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2(); // get the OpenGL 2 graphics context
gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear color and depth buffers
for (int i = 0; i < stars.length; i++) {
// Reset the view (x, y, z axes back to normal)
gl.glLoadIdentity();
gl.glTranslatef(0.0f, 0.0f, z);
// The stars are texture quad square drawn on x-y plane and
// distributed on on x-z plane around the y-axis
// Initial 90 degree tile in the x-axis, y-axis pointing out of screen
gl.glRotatef(tilt, 1.0f, 0.0f, 0.0f);
// Rotate about y-axis (pointing out of screen), initial angle is 0
gl.glRotatef(stars[i].angle, 0.0f, 1.0f, 0.0f);
// Translate about the x-axis (pointing right) to its current distance
gl.glTranslatef(stars[i].distance, 0.0f, 0.0f);
// The stars have initial angle of 0, and initial distance linearly
// distributed between 0 and 5.0f
// Rotate the axes back, so that z-axis is again facing us, to ensure that
// the quad (with texture) on x-y plane is facing us
gl.glRotatef(-stars[i].angle, 0.0f, 1.0f, 0.0f);
gl.glRotatef(-tilt, 1.0f, 0.0f, 0.0f);
// Take note that without the two rotations and undo, there is only one
// translation along the x-axis
// Matrix operation is non-commutative. That is, AB != BA.
// Hence, ABCB'A' != C
// Draw the star, which spins on the z axis (pointing out of the screen)
gl.glRotatef(starSpinAngle, 0.0f, 0.0f, 1.0f);
// Set the star's color using bytes (why bytes? not float or int?)
gl.glColor4ub(stars[i].r, stars[i].g, stars[i].b, (byte) 255);
gl.glBegin(GL_QUADS);
// draw a square on x-y plane
gl.glTexCoord2f(textureCoordLeft, textureCoordBottom);
gl.glVertex3f(-1.0f, -1.0f, 0.0f);
gl.glTexCoord2f(textureCoordRight, textureCoordBottom);
gl.glVertex3f(1.0f, -1.0f, 0.0f);
gl.glTexCoord2f(textureCoordRight, textureCoordTop);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glTexCoord2f(textureCoordLeft, textureCoordTop);
gl.glVertex3f(-1.0f, 1.0f, 0.0f);
gl.glEnd();
// If twinkling, overlay with another drawing of an arbitrary color
if (twinkleOn) {
// Assign a color using bytes
gl.glColor4ub(
stars[(numStars - i) - 1].r,
stars[(numStars - i) - 1].g,
stars[(numStars - i) - 1].b,
(byte) 255);
gl.glBegin(GL_QUADS);
// draw a square on x-y plane
gl.glTexCoord2f(textureCoordLeft, textureCoordBottom);
gl.glVertex3f(-1.0f, -1.0f, 0.0f);
gl.glTexCoord2f(textureCoordRight, textureCoordBottom);
gl.glVertex3f(1.0f, -1.0f, 0.0f);
gl.glTexCoord2f(textureCoordRight, textureCoordTop);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glTexCoord2f(textureCoordLeft, textureCoordTop);
gl.glVertex3f(-1.0f, 1.0f, 0.0f);
gl.glEnd();
}
// Update for the next refresh
// The star spins about the z-axis (pointing out of the screen), and spiral
// inwards and collapse towards the center, by increasing the angle on x-y
// plane and reducing the distance.
starSpinAngle += 0.01f; // used to spin the stars about the z-axis
// spiral pattern
stars[i].angle += (float) i / numStars; // changes the angle of a star
// collapsing the star to the center
stars[i].distance -= 0.01f; // changes the distance of a star
// re-bone at the edge
if (stars[i].distance < 0.0f) { // Is the star collapsed to the center?
stars[i].distance += 5.0f; // move to the outer ring
stars[i].setRandomRGB(); // choose a random color for the star
}
}
}
public void init(GLAutoDrawable glAutoDrawable) {
StringBuilder sb = new StringBuilder();
sb.append(gov.nasa.worldwind.Version.getVersion() + "\n");
sb.append("\nSystem Properties\n");
sb.append("Processors: " + Runtime.getRuntime().availableProcessors() + "\n");
sb.append("Free memory: " + Runtime.getRuntime().freeMemory() + " bytes\n");
sb.append("Max memory: " + Runtime.getRuntime().maxMemory() + " bytes\n");
sb.append("Total memory: " + Runtime.getRuntime().totalMemory() + " bytes\n");
for (Map.Entry prop : System.getProperties().entrySet()) {
sb.append(prop.getKey() + " = " + prop.getValue() + "\n");
}
GL gl = glAutoDrawable.getGL();
sb.append("\nOpenGL Values\n");
String oglVersion = gl.glGetString(GL.GL_VERSION);
sb.append("OpenGL version: " + oglVersion + "\n");
String oglVendor = gl.glGetString(GL.GL_VENDOR);
sb.append("OpenGL vendor: " + oglVendor + "\n");
String oglRenderer = gl.glGetString(GL.GL_RENDERER);
sb.append("OpenGL renderer: " + oglRenderer + "\n");
int[] intVals = new int[2];
for (Attr attr : attrs) {
sb.append(attr.name).append(": ");
if (attr.attr instanceof Integer) {
gl.glGetIntegerv((Integer) attr.attr, intVals, 0);
sb.append(intVals[0]).append(intVals[1] > 0 ? ", " + intVals[1] : "");
}
sb.append("\n");
}
String extensionString = gl.glGetString(GL.GL_EXTENSIONS);
String[] extensions = extensionString.split(" ");
sb.append("Extensions\n");
for (String ext : extensions) {
sb.append(" " + ext + "\n");
}
sb.append("\nJOGL Values\n");
String pkgName = "javax.media.opengl";
try {
getClass().getClassLoader().loadClass(pkgName + ".GL");
Package p = Package.getPackage(pkgName);
if (p == null) {
sb.append("WARNING: Package.getPackage(" + pkgName + ") is null\n");
} else {
sb.append(p + "\n");
sb.append("Specification Title = " + p.getSpecificationTitle() + "\n");
sb.append("Specification Vendor = " + p.getSpecificationVendor() + "\n");
sb.append("Specification Version = " + p.getSpecificationVersion() + "\n");
sb.append("Implementation Vendor = " + p.getImplementationVendor() + "\n");
sb.append("Implementation Version = " + p.getImplementationVersion() + "\n");
}
} catch (ClassNotFoundException e) {
sb.append("Unable to load " + pkgName + "\n");
}
this.outputArea.setText(sb.toString());
}
public void display(GLAutoDrawable glAutoDrawable) {
glAutoDrawable.getGL().glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
}
