protected void drawToolTip(
DrawContext dc,
java.awt.Rectangle viewport,
String text,
int x,
int y,
ToolTipAttributes attributes) {
java.awt.geom.Rectangle2D textBounds = this.computeTextBounds(dc, text, attributes.getFont());
java.awt.geom.Rectangle2D bgBounds =
this.computeBackgroundBounds(
dc, textBounds.getWidth(), textBounds.getHeight(), attributes.getInsets());
java.awt.Point screenPoint = this.adjustDrawPointToViewport(x, y, bgBounds, viewport);
java.awt.geom.Point2D textTranslation =
this.computeTextTranslation(dc, textBounds, attributes.getInsets());
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
OGLStackHandler stackHandler = new OGLStackHandler();
stackHandler.pushModelview(gl);
try {
gl.glTranslated(
screenPoint.getX() + bgBounds.getX(), screenPoint.getY() + bgBounds.getY(), 0);
this.drawToolTipInterior(dc, bgBounds.getWidth(), bgBounds.getHeight(), attributes);
this.drawToolTipOutline(dc, bgBounds.getWidth(), bgBounds.getHeight(), attributes);
gl.glTranslated(textTranslation.getX(), textTranslation.getY(), 0);
this.drawToolTipText(dc, text, 0, 0, attributes);
} finally {
stackHandler.pop(gl);
}
}
protected void drawToolTipInterior(
DrawContext dc, double width, double height, ToolTipAttributes attributes) {
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
this.applyColor(dc, attributes.getInteriorColor(), attributes.getInteriorOpacity());
// Draw a filled rectangle with the background dimensions.
gl.glRectd(0, 0, width, height);
}
@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 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();
}
/**
* 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;
}
}
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);
}
private void recursiveDraw(
int level, double x1, double y1, double x2, double y2, double x3, double y3) {
if (level < 1) {
return;
}
gl.glBegin(GL2.GL_LINE_LOOP);
gl.glVertex2d(x1, y1);
gl.glVertex2d(x2, y2);
gl.glVertex2d(x3, y3);
gl.glEnd();
for (int i = 0; i < transitions; i += 1) {
x1 = rotate_scale_xx[i] * x1 + rotate_scale_xy[i] * y1 + trans_x[i];
y1 = rotate_scale_yx[i] * x1 + rotate_scale_yy[i] * y1 + trans_y[i];
x2 = rotate_scale_xx[i] * x2 + rotate_scale_xy[i] * y2 + trans_x[i];
y2 = rotate_scale_yx[i] * x2 + rotate_scale_yy[i] * y2 + trans_y[i];
x3 = rotate_scale_xx[i] * x3 + rotate_scale_xy[i] * y3 + trans_x[i];
y3 = rotate_scale_yx[i] * x3 + rotate_scale_yy[i] * y3 + trans_y[i];
recursiveDraw(level - 1, x1, y1, x2, y2, x3, y3);
}
}
protected void drawToolTipOutline(
DrawContext dc, double width, double height, ToolTipAttributes attributes) {
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
this.applyColor(dc, attributes.getOutlineColor(), attributes.getOutlineOpacity());
gl.glLineWidth((float) getOutlineWidth());
// Draw a line loop around the background rectangle. Inset the lines slightly to compensate for
// OpenGL's line
// rasterization algorithm. We want the line to straddle the rectangle pixels.
double inset = 0.5;
gl.glBegin(GL2.GL_LINE_LOOP);
gl.glVertex2d(inset, inset);
gl.glVertex2d(width - inset, inset);
gl.glVertex2d(width - inset, height - inset);
gl.glVertex2d(inset, height - inset);
gl.glEnd();
}
/*
* 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);
}
protected void beginRendering(DrawContext dc, OGLStackHandler stackHandler) {
if (dc == null) {
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().fine(message);
throw new IllegalArgumentException(message);
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
int attribMask =
GL2.GL_COLOR_BUFFER_BIT // for alpha test func and ref, blend func
| GL2.GL_CURRENT_BIT // for current color
| GL2.GL_ENABLE_BIT // for enable/disable
| GL2.GL_LINE_BIT // for line width
| GL2.GL_TRANSFORM_BIT; // for matrix mode
stackHandler.pushAttrib(gl, attribMask);
stackHandler.pushTextureIdentity(gl);
stackHandler.pushProjectionIdentity(gl);
java.awt.Rectangle viewport = dc.getView().getViewport();
gl.glOrtho(
viewport.x, viewport.x + viewport.width, viewport.y, viewport.y + viewport.height, -1, 1);
stackHandler.pushModelviewIdentity(gl);
// Enable the alpha test.
gl.glEnable(GL2.GL_ALPHA_TEST);
gl.glAlphaFunc(GL2.GL_GREATER, 0.0f);
// Enable blending in premultiplied color mode.
gl.glEnable(GL.GL_BLEND);
OGLUtil.applyBlending(gl, true);
gl.glDisable(GL.GL_CULL_FACE);
gl.glDisable(GL.GL_DEPTH_TEST);
gl.glDisable(GL2.GL_LIGHTING);
gl.glDisable(GL.GL_TEXTURE_2D);
}
@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();
}
/*
* 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();
}
private void renderRedTeapot(GL2 gl, float x, float y, float z) {
float mat[] = new float[4];
gl.glPushMatrix();
gl.glTranslatef(x, y, z);
mat[0] = 0.1745f;
mat[1] = 0.01175f;
mat[2] = 0.01175f;
mat[3] = 1.0f;
gl.glMaterialfv(GL.GL_FRONT, GL2.GL_SPECULAR, mat, 0);
mat[0] = 0.61424f;
mat[1] = 0.04136f;
mat[2] = 0.04136f;
gl.glMaterialfv(GL.GL_FRONT, GL2.GL_DIFFUSE, mat, 0);
mat[0] = 0.727811f;
mat[1] = 0.626959f;
mat[2] = 0.626959f;
gl.glMaterialfv(GL.GL_FRONT, GL2.GL_SPECULAR, mat, 0);
gl.glMaterialf(GL.GL_FRONT, GL2.GL_SHININESS, 0.6f * 128.0f);
glut.glutSolidTeapot(1.0);
gl.glPopMatrix();
}
/**
* 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 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);
}
}
/** 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 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();
}
