0% found this document useful (0 votes)
219 views18 pages

Project Report Graphics

The project has been successfully completed in the computer graphics domain and this is the project report which contains the required code and guidelines for the implementation of the project.

Uploaded by

Reema Christ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
219 views18 pages

Project Report Graphics

The project has been successfully completed in the computer graphics domain and this is the project report which contains the required code and guidelines for the implementation of the project.

Uploaded by

Reema Christ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 18

PROJECT

REPORT

SUBMITTED BY
NECHIKETH SURENDRAN
1860427
&
NIRMAL RAJESH
1860434

____________________________________________________________________________________
INTRODUCTION
The development of technology has increased very rapidly and can be found in almost all
areas of human life, author can find one of them in the field of education. Nowadays,
education learning is using technology in order to perform the delivery of material will
become more interesting and easy memorable. The use of technology in education can be
implemented with a visualization on a subject of study. The study of the solar system for
example, by using the visualization of objects in the solar system would facilitate teachers
for the delivery of content. Visualization of the solar system is modified in graphic or animation
to display a collection of celestial objects that consist a large star called the sun, and all objects
that are bound by the force of gravity. The objects are eight planets that make a
revolution or rotation of the sun and remain in orbit respectively.

THEORETICAL BACKGROUND
Computer Graphics
Computer graphics is concerned with all aspects of producing pictures or images using a
computer (Angel, 2012). Computer graphics is the process of transforming a 3D model of the
object in the form of geometric shapes, position, color, texture, and lighting into 2D images.

OpenGL
OpenGL is a computer graphics rendering API or we can say that OpenGL is a library for doing
computer graphics. OpenGL is designed as a streamlined, hardware-independent interface
to be implemented on many different hardware platforms. OpenGL can used to create an
interactive applications that render high-quality color images composed of 3D geometric
objects and image

UTILITIES IN THE CURRENT PROJECT


Transformation
In addition to the position and orientation of the camera can be permuted, by naturally
objects can also switch to the position and orientation relative to the others. Modelling
transformation is used for object manipulation, such as translation, rotation and scaling.
Transformation of objects can be represented in several ways, namely:
1. using the transformation matrix (glLoadMatrix)
2. using the transformation operations (glRotate, glTranslate)

____________________________________________________________________________________
3. change the status of OpenGL projection mode with command glMatrixMode
(GL_MODELVIEW).

Material/Texture
Material of the solar system based on discussion as needed for design, there are:
1. The composition of the solar system Displays information about the sun and the order of
the planets and their orbital trajectory.
2. Various planets Displays the names of the planets in order.
3. The size of the planet Displaying diameter comparison by the actual size of the planet and
visualization.
4. Distance planet to the sun Displaying diameter comparison by the actual distance of the
planet and visualization.
5. The revolution speed of each planet Revolution speed comparison by the actual speed of
the planet and the visualization

STEPS INVOLVED IN SUCESSFUL COMPLETION OF THE PROJECT


Stages of making solar system visualization:
1. Declare all the attributes that needed for the keyboard function and rotation.
2. Set the speed of rotation of each planet, because the speed of each planet to make one
revolution is different.
3. Create the sun with a solid sphere, set the size, and position in the center point (0,0,0) so
that the sun became the center of planets that will be surrounding them.
4. Create the planets Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune with a
solid sphere, set the size of each planet, and the planet's position in accordance with the ratio
of the actual distance.
5. Set the revolution of each planet.
6. Create the orbit of each planet, with torus (ring), set torus in the center, so the
planets will move around the sun, and still remain in orbit.
7. Create Keyboard function for regulating the movement of the display.
8 . Adjust the lighting to give a 3D effect

____________________________________________________________________________________
In this visualization, user can interacts with the application to perform transformation
against planets. Users can do the translation and rotation against 3d planets, and can also
plays music to accompanying the visualization of the solar system. User can interact with
the application by keyboard function as follows:
SIDE ARROW: translate to left
SIDE ARROW : translate to right
UP ARROW : translate up
DOWN ARROW : translate down

SOURCE CODE
MAIN
package simulator;

import javax.swing.*;

import com.jogamp.opengl.GLCapabilities;
import com.jogamp.opengl.GLProfile;

import simulator.camera.Camera;

import java.awt.*;

public class Main {


public static void main(String[] args) {
final GLProfile profile = GLProfile.get (GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);

Camera camera = new Camera(900, 900, capabilities);


// the window frame
JFrame frame = new JFrame("Solar system");
frame.getContentPane().add(camera, BorderLayout.CENTER);

frame.setSize(frame.getContentPane().getPreferredSize());
frame.setResizable(true);
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.setVisible(true);
camera.requestFocus();
}
}

PLANET

____________________________________________________________________________________
package simulator;

import com.jogamp.opengl.*;
import com.jogamp.opengl.awt.GLCanvas;
import com.jogamp.opengl.glu.GLU;
import com.jogamp.opengl.glu.GLUquadric;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.opengl.util.texture.Texture;

import simulator.texture.TextureHandler;

import javax.swing.*;

public class Planet {


private GL2 gl;
private GLU glu;
private TextureHandler planetTexture;
private float angle;
private float distance;

private float rotationAngle = 0;


private float speed = 0;
private float radius;

public Planet(GL2 gl, GLU glu, TextureHandler planetTexture, float


speed, float distance, float radius) {
this.gl = gl;
this.glu = glu;
this.planetTexture = planetTexture;

this.speed = speed;
this.distance = distance;
this.radius = radius;
}

public void display() {

gl.glPushMatrix();
angle = (angle + speed) % 360f;
final float x = (float) Math.sin(Math.toRadians(angle)) * distance;
final float y = (float) Math.cos(Math.toRadians(angle)) * distance;
final float z = 0;

gl.glTranslatef(x, y, z);

draw();

gl.glPopMatrix();

private void draw() {

____________________________________________________________________________________
// Set material properties.
float[] rgba = { 1f, 1f, 1f };
gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT, rgba, 0);
gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_SPECULAR, rgba, 0);
gl.glMaterialf(GL2.GL_FRONT, GL2.GL_SHININESS, 0.6f);

// Apply texture.
planetTexture.enable(gl);
planetTexture.bind(gl);

rotationAngle = (rotationAngle + 0.1f) % 360f;

gl.glPushMatrix();
gl.glRotatef(rotationAngle, 0.2f, 0.1f, 0);

GLUquadric planet = glu.gluNewQuadric();


glu.gluQuadricTexture(planet, true);
glu.gluQuadricDrawStyle(planet, GLU.GLU_FILL);
glu.gluQuadricNormals(planet, GLU.GLU_FLAT);
glu.gluQuadricOrientation(planet, GLU.GLU_OUTSIDE);
final int slices = 16;
final int stacks = 16;
glu.gluSphere(planet, radius, slices, stacks);
glu.gluDeleteQuadric(planet);

gl.glPopMatrix();

}
SUN
package simulator;

import com.jogamp.opengl.GL2;
import com.jogamp.opengl.glu.GLU;
import com.jogamp.opengl.glu.GLUquadric;
import com.jogamp.opengl.util.texture.Texture;

import simulator.texture.TextureHandler;

public class Sun {


private GL2 gl;
private GLU glu;
private TextureHandler sunTexture;
private float angle = 0;

public Sun(GL2 gl, GLU glu, TextureHandler sunTexture) {


this.gl = gl;
this.glu = glu;

____________________________________________________________________________________
this.sunTexture = sunTexture;
}

public void display() {

// Set material properties.


float[] rgba = { 1f, 1f, 1f };
gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT, rgba, 0);
gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_SPECULAR, rgba, 0);
gl.glMaterialf(GL2.GL_FRONT, GL2.GL_SHININESS, 1f);
gl.glClear(GL2.GL_COLOR_BUFFER_BIT);
gl.glClear(GL2.GL_DEPTH_BUFFER_BIT);

// This method is used for updating the vertices.


// NOTE that it is called BEFORE rendering the quad.

// Apply texture.
sunTexture.enable(gl);
sunTexture.bind(gl);
gl.glPushName(6);
angle = (angle + 0.7f) % 360f;

gl.glPushMatrix();
gl.glRotatef(angle, 0.8f, 0.1f, 0);

//Draw sphere (possible styles: FILL, LINE, POINT).


// gl.glColor3f(0.3f, 0.5f, 1f);
GLUquadric sun = glu.gluNewQuadric();
glu.gluQuadricTexture(sun, true);
glu.gluQuadricDrawStyle(sun, GLU.GLU_FILL);
glu.gluQuadricNormals(sun, GLU.GLU_FLAT);
glu.gluQuadricOrientation(sun, GLU.GLU_OUTSIDE);
final float radius = 10f;
final int slices = 16;
final int stacks = 16;
glu.gluSphere(sun, radius, slices, stacks);
glu.gluDeleteQuadric(sun);

gl.glPopMatrix();
gl.glPopName();
}

CAMERA
package simulator.camera;

import com.jogamp.opengl.*;

____________________________________________________________________________________
import com.jogamp.opengl.awt.GLCanvas;
import com.jogamp.opengl.fixedfunc.GLPointerFunc;
import com.jogamp.opengl.glu.GLU;
import com.jogamp.opengl.glu.GLUquadric;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.opengl.util.awt.TextRenderer;
import com.jogamp.opengl.util.gl2.GLUT;
import com.jogamp.opengl.util.texture.Texture;
import com.jogamp.opengl.util.texture.TextureData;
import com.jogamp.opengl.util.texture.TextureIO;

import simulator.Planet;
import simulator.Sun;
import simulator.camera.Camera;
import simulator.texture.*;

import com.jogamp.common.nio.Buffers;
import com.jogamp.nativewindow.util.Point;

import java.awt.Font;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.io.*;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;

public class Camera extends GLCanvas implements GLEventListener,


KeyListener {

private static final float SUN_RADIUS = 12f;


private GLUT glut;
private FPSAnimator animator;
private GLU glu;
private TextureHandler earthTexture;
private TextureHandler cloudTexture;
private TextureHandler skyTexture;
private TextureHandler sunTexture;

private TextureHandler mercuryTexture;


private TextureHandler venusTexture;
private TextureHandler jupiterTexture;
private TextureHandler marsTexture;
private TextureHandler saturnTexture;
private TextureHandler uranusTexture;
private TextureHandler neptuneTexture;
private TextureHandler moonTexture;

____________________________________________________________________________________
private ArrayList<Planet> planets;

private float Angle = 0;


private float earthAngle = 0;
private float systemAngle = 0;
private Sun sun;

float cameraAzimuth = 0.0f, cameraSpeed = 0.0f, cameraElevation =


0.0f;

float cameraCoordsPosx = 0.0f, cameraCoordsPosy = 0.0f,


cameraCoordsPosz = -20.0f;

// Set camera orientation


float cameraUpx = 0.0f, cameraUpy = 1.0f, cameraUpz = 0.0f;

public Camera(int width, int height, GLCapabilities capabilities) {


super(capabilities);
setSize(width, height);
addGLEventListener(this);
}

@Override
public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
glu = new GLU();
planets = new ArrayList<>();

gl.glEnable(GL.GL_DEPTH_TEST);
gl.glDepthFunc(GL.GL_LEQUAL);
gl.glDisable(GL.GL_DEPTH_TEST);

gl.glShadeModel(GL2.GL_SMOOTH);

gl.glClearColor(0f, 0f, 0f, 0f);

gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
this.addKeyListener(this);
animator = new FPSAnimator(this, 60);
animator.start();
// adding planets

earthTexture = new TextureHandler(gl,glu,"res\\earthmap1k.jpg",true);


cloudTexture = new TextureHandler(gl,glu,"res\\\\tx_15_1.png",true);
skyTexture = new TextureHandler(gl,glu,"res\\\\starfield.png",true);
sunTexture = new TextureHandler(gl,glu,"res\\\\preview_sun.jpg",true);

____________________________________________________________________________________
mercuryTexture = new
TextureHandler(gl,glu,"res\\\\mercurymap.jpg",true);
venusTexture = new TextureHandler(gl,glu,"res\\\\venusmap.jpg",true);
jupiterTexture = new TextureHandler(gl,glu,"res\\jupiter.jpg",true);
marsTexture = new
TextureHandler(gl,glu,"res\\mars_1k_color.jpg",true);
moonTexture = new TextureHandler(gl,glu,"res\\\\tx_0_0.png",true);
saturnTexture = new TextureHandler(gl,glu,"res\\saturn.jpg",true);
uranusTexture = new
TextureHandler(gl,glu,"res\\\\uranuscyl1.jpg",true);
neptuneTexture = new
TextureHandler(gl,glu,"res\\\\neptune_current.jpg",true);

this.sun = new Sun(gl, glu, sunTexture);

Planet mercury = new Planet(gl, glu, mercuryTexture, 1.2f, SUN_RADIUS


+ 2f, 2.56f);
Planet venus = new Planet(gl, glu, venusTexture, 0.7f, SUN_RADIUS +
12f, 3.56f);
Planet Jupiter = new Planet(gl, glu, jupiterTexture, 0.25f, SUN_RADIUS
+ 65f, 8.56f);
Planet mars = new Planet(gl, glu, marsTexture, 0.3f, SUN_RADIUS + 50f,
3.56f);
Planet Saturn = new Planet(gl, glu, saturnTexture, 0.3f, SUN_RADIUS +
90f, 7.56f);
Planet Uranus = new Planet(gl, glu, uranusTexture, 0.25f, SUN_RADIUS +
105f, 6.56f);
Planet Neptune = new Planet(gl, glu, neptuneTexture, 0.275f,
SUN_RADIUS + 120f, 5.56f);

planets.add(mercury);
planets.add(venus);
planets.add(mars);
planets.add(Jupiter);
planets.add(Saturn);
planets.add(Uranus);
planets.add(Neptune);

@Override
public void dispose(GLAutoDrawable glAutoDrawable) {

@Override
public void display(GLAutoDrawable glAutoDrawable) {

if (!animator.isAnimating()) {
return;
}

____________________________________________________________________________________
final GL2 gl = glAutoDrawable.getGL().getGL2();

setCamera(gl,300);
aimCamera(gl,glu);
moveCamera();

setLights(gl);

gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
sun.display();
drawEarthAndMoon(gl);

for (Planet p : planets)


p.display();

skyTexture.bind(gl);
skyTexture.enable(gl);

// skybox
drawCube(gl);

private void drawEarthAndMoon(GL2 gl) {


gl.glPushMatrix();
systemAngle = (systemAngle + 0.4f) % 360f;

final float distance = SUN_RADIUS + 30f;


final float x = (float) Math.sin(Math.toRadians(systemAngle)) *
distance;
final float y = (float) Math.cos(Math.toRadians(systemAngle)) *
distance;
final float z = 0;
gl.glTranslatef(x, y, z);

drawEarth(gl);
drawMoon(gl);
gl.glPopMatrix();

// pamant si cer
private void drawEarth(GL2 gl) {

float[] rgba = { 1f, 1f, 1f };


gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT, rgba, 0);
gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_SPECULAR, rgba, 0);
gl.glMaterialf(GL2.GL_FRONT, GL2.GL_SHININESS, 0.5f);

____________________________________________________________________________________
gl.glPushName(4);
earthAngle = (earthAngle + 0.1f) % 360f;
cloudTexture.enable(gl);
cloudTexture.bind(gl);

gl.glPushMatrix();
gl.glRotatef(earthAngle, 0.2f, 0.1f, 0);
final float radius = 6.378f;
final int slices = 16;
final int stacks = 16;
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_COLOR, GL.GL_DST_ALPHA);

// clouds above the earth using a bigger sphere and applying blend to
it
GLUquadric clouds = glu.gluNewQuadric();
glu.gluQuadricOrientation(clouds, GLU.GLU_OUTSIDE);
glu.gluQuadricTexture(clouds, true);
glu.gluSphere(clouds, 7, slices, stacks);
earthTexture.enable(gl);
earthTexture.bind(gl);
gl.glDisable(GL.GL_BLEND);

GLUquadric earth = glu.gluNewQuadric();


glu.gluQuadricTexture(earth, true);
glu.gluQuadricDrawStyle(earth, GLU.GLU_FILL);
glu.gluQuadricNormals(earth, GLU.GLU_FLAT);
glu.gluQuadricOrientation(earth, GLU.GLU_OUTSIDE);

glu.gluSphere(earth, radius, slices, stacks);

gl.glPopName();

glu.gluDeleteQuadric(earth);
glu.gluDeleteQuadric(clouds);

gl.glPopMatrix();
}

// luna
private void drawMoon(GL2 gl) {

gl.glPushMatrix();
moonTexture.enable(gl);
moonTexture.bind(gl);
gl.glPushName(5);
Angle = (Angle + 1f) % 360f;
final float distance = 12.000f;
final float x = (float) Math.sin(Math.toRadians(Angle)) * distance;
final int y = (int) ((float) Math.cos(Math.toRadians(Angle)) *
distance);
final float z = 0;

____________________________________________________________________________________
gl.glTranslatef(x, y, z);
gl.glRotatef(Angle, 0, 0, -1);
gl.glRotatef(45f, 0, 1, 0);

final float radius = 3.378f;


final int slices = 16;
final int stacks = 16;
GLUquadric moon = glu.gluNewQuadric();
glu.gluQuadricTexture(moon, true);
glu.gluQuadricDrawStyle(moon, GLU.GLU_FILL);
glu.gluQuadricNormals(moon, GLU.GLU_FLAT);
glu.gluQuadricOrientation(moon, GLU.GLU_INSIDE);
glu.gluSphere(moon, radius, slices, stacks);

gl.glPopMatrix();
gl.glPopName();
}

private void setLights(GL2 gl) {

float SHINE_ALL_DIRECTIONS = 1;
float[] lightPos = { 0, 0, 0, SHINE_ALL_DIRECTIONS };
float[] lightColorAmbient = { 0.5f, 0.5f, 0.5f, 1f };
float[] lightColorSpecular = { 0.8f, 0.8f, 0.8f, 1f };

// Seteaza parametrii pentru lumina.


gl.glLightfv(GL2.GL_LIGHT1, GL2.GL_POSITION, lightPos, 0);
gl.glLightfv(GL2.GL_LIGHT1, GL2.GL_AMBIENT, lightColorAmbient, 0);
gl.glLightfv(GL2.GL_LIGHT1, GL2.GL_SPECULAR, lightColorSpecular, 0);

gl.glEnable(GL2.GL_LIGHT1);
gl.glEnable(GL2.GL_LIGHTING);

@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width,
int height) {
GL gl = drawable.getGL();
gl.glViewport(0, 0, width, height);
}

// metoda pentru controlarea camerei

// skybox
private void drawCube(GL gl) {

____________________________________________________________________________________
skyTexture.enable(gl);
skyTexture.bind(gl);

((GLPointerFunc) gl).glDisableClientState(GL2.GL_VERTEX_ARRAY);
final float radius = 150f;
final int slices = 16;
final int stacks = 16;
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_COLOR, GL.GL_DST_ALPHA);
GLUquadric sky = glu.gluNewQuadric();
glu.gluQuadricTexture(sky, true);
glu.gluQuadricDrawStyle(sky, GLU.GLU_FILL);
glu.gluQuadricNormals(sky, GLU.GLU_FLAT);
glu.gluQuadricOrientation(sky, GLU.GLU_INSIDE);
glu.gluSphere(sky, radius, slices, stacks);

gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_COLOR, GL.GL_DST_ALPHA);
}

public void setCamera(GL2 gl, float distance) {

gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();

float widthHeightRatio = (float) getWidth() / (float) getHeight();


glu.gluPerspective(45, widthHeightRatio, 1, 1000);
glu.gluLookAt(0, 0, distance, 0, 0, 0, 0, 1, 0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}

public void moveCamera() {


float[] tmp = polarToCartesian(cameraAzimuth, cameraSpeed,
cameraElevation);

cameraCoordsPosx += tmp[0];
cameraCoordsPosy += tmp[1];
cameraCoordsPosz += tmp[2];
}

public void aimCamera(GL2 gl, GLU glu) {


gl.glLoadIdentity();

float[] tmp = polarToCartesian(cameraAzimuth, 100.0f,


cameraElevation);

____________________________________________________________________________________
float[] camUp = polarToCartesian(cameraAzimuth, 100.0f,
cameraElevation + 90);

cameraUpx = camUp[0];
cameraUpy = camUp[1];
cameraUpz = camUp[2];

glu.gluLookAt(cameraCoordsPosx, cameraCoordsPosy, cameraCoordsPosz,


cameraCoordsPosx + tmp[0],
cameraCoordsPosy + tmp[1], cameraCoordsPosz + tmp[2], cameraUpx,
cameraUpy, cameraUpz);
}

private float[] polarToCartesian(float azimuth, float length, float


altitude) {
float[] result = new float[3];
float x, y, z;

// Do x-z calculation
float theta = (float) Math.toRadians(90 - azimuth);
float tantheta = (float) Math.tan(theta);
float radian_alt = (float) Math.toRadians(altitude);
float cospsi = (float) Math.cos(radian_alt);

x = (float) Math.sqrt((length * length) / (tantheta * tantheta + 1));


z = tantheta * x;

x = -x;

if ((azimuth >= 180.0 && azimuth <= 360.0) || azimuth == 0.0f) {


x = -x;
z = -z;
}

// Calculate y, and adjust x and z


y = (float) (Math.sqrt(z * z + x * x) * Math.sin(radian_alt));

if (length < 0) {
x = -x;
z = -z;
y = -y;
}

x = x * cospsi;
z = z * cospsi;

result[0] = x;
result[1] = y;
result[2] = z;

return result;
}

____________________________________________________________________________________
// miscarea camerei prin butoane
public void keyPressed(KeyEvent event) {
if (event.getKeyCode() == KeyEvent.VK_UP) {
cameraElevation -= 2;
}

if (event.getKeyCode() == KeyEvent.VK_DOWN) {
cameraElevation += 2;
}

if (event.getKeyCode() == KeyEvent.VK_RIGHT) {
cameraAzimuth -= 2;
}

if (event.getKeyCode() == KeyEvent.VK_LEFT) {
cameraAzimuth += 2;
}

if (event.getKeyCode() == KeyEvent.VK_I) {
cameraSpeed += 0.05;
}

if (event.getKeyCode() == KeyEvent.VK_O) {
cameraSpeed -= 0.05;
}

if (event.getKeyCode() == KeyEvent.VK_S) {
cameraSpeed = 0;
}
if (event.getKeyCode() < 250)
keys[event.getKeyCode()] = true;

if (cameraAzimuth > 359)


cameraAzimuth = 1;

if (cameraAzimuth < 1)
cameraAzimuth = 359;
}

private boolean[] keys = new boolean[250];

@Override
public void keyReleased(KeyEvent arg0) {
// TODO Auto-generated method stub

@Override
public void keyTyped(KeyEvent arg0)}}

____________________________________________________________________________________
OUTPUT

____________________________________________________________________________________
CONCLUSION
Based on the results of discussion that has been done, the authors can conclude that:
1. Animation circulation of planets around the sun interface design is the design of the visual
and interpretive models designed.
2. Application of learning visualization of the solar system was designed using API OpenGL
that can facilitate computer users to know the objects of the solar system and the solar
system information more easily

____________________________________________________________________________________

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy