bab 9 project pilihan - universitas brawijaya · 2016. 12. 31. · bab 9 project pilihan 9.1 random...

558

BAB 9 Project Pilihan

9.1 Random Maze

9.1.1 Konsep

Random Maze merupakan permainan yang mengedepankan strategi untuk mencari jalan keluar dengan cepat, tanpa tersesat pada jalan yang buntu. Pertama ketika aplikasi dijalankan, maka map dari daerah pencarian akan dirandom dengan ukuran tertentu. Pada kondisi awal, letak dari agen berada di posisi start, dan tujuan akhirnya adalah posisi goal. Untuk menggerakkan agen (yang berbentuk segitiga), tombol control dibagian kanan bawah dapat digunakan untuk melakukan hal tersebut.

9.1.2 Tampilan Implementasi

Aplikasi ini mengimplementasikan primitive object, texture map-ping, pencahayaan dengan tampilan objek garis, segitiga, segiempat, bola, counter pantulan bola, serta dengan tombol control yang diberikan texture tertentu untuk memindahkan objek (agen) dalam mencari solusi pencarian jalan keluar. Berikut ini beberapa visualisasi dari permainan Random Maze, mulai dari adanya background (gambar, fractal), tombol control, animasi objek bergerak, efek pencahayaan, sampai pada log posisi track sentuhan tangan pada layar.

Gambar 9.1 Random Maze dengan Background Hitam

559

Gambar 9.2 Random Maze dengan Background Abu-Abu

Gambar 9.3 Random Maze Background Gambar

Gambar 9.4 Random Maze Background Gambar, Control Objek

560

9.1.3 Source Code

Source Code 9.1 Code Random Maze

ESRender.java

package com.fractalbackground;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.opengl.GLSurfaceView.Renderer;

public class ESRender implements Renderer {

private ESText glText;

private PrimitivesObject primobbg;

private PrimitivesObject primobflappy;

private PrimitivesObject primobground;

private PrimitivesObject primob1;

private PrimitivesObject primob3;

private ObjectBall objectball2;

//private ObjectBall objectball3;

private ObjectBall objectballstick;

//private ObjectBall objectballstickdua;

private ObjectBall objectballbgstick;

private PrimitivesObject primob;

//private PrimitivesObject primob2;

private TransObject transobject;

private final MySphere mEarth,mEarth2,mEarth3;

Context context;

int Run_Mode=0;

float CurrentAngle = 0.0f; //

Angle in degrees

float CurrentAngle2 = 0.0f; //

Angle in degrees

float AnimateStep = 2.0f; //

Rotation step per update

float AnimateStep2 = 0.2f; //

Rotation step per update

float ScaleStep = 1.0f;

private float move_left_right1 =0.f;

private float move_left_right2 =0.f;

private float kecepatan_ground = 5.0f;

private int faktor_naik_turun=0;

private int flag_naik=1;

private long startTime;

private long fpsStartTime;

private long numFrames;

private float fps_temp;

561

private long fpsElapsed_temp;

private long numFrames_temp;

private boolean startTimeInit=true;

private long fpsStartTime2;

private long numFrames2;

private int numIDFrame=0;

float CurrentScale =1.0f;

float radius = 50.0f; // Ball's radius

float x = radius; // Ball's center (x,y)

float y = radius;

float speedX = 0.5f; // Ball's speed (x,y)

float speedY = 0.3f;

int xMin, xMax, yMin, yMax;

private int mywidth = 0;

private int myheight = 0;

private int jumlah_pantulan=0;

private float x_player = 0;

private float y_player = 0;

private float x_player_end = 0;

private float y_player_end = 0;

private int Navigate = 0;

private int positionRow = 0;

private int positionCol = 0;

//private int hori[][] = new

int[2*primob.numberRow*primob.numberCol][2*primob.num

berRow*primob.numberCol];

//private int verti[][] = new

int[2*primob.numberRow*primob.numberCol][2*primob.num

berRow*primob.numberCol];

private int hori[][] = new int[1000][1000];

private int verti[][] = new int[1000][1000];

private int numberCol =0;

private int numberRow =0;

private float WidthObject =0;

private float x_anim_stick = 0;

private float y_anim_stick = 0;

private float x_touch = 0;

private float y_touch = 0;

private float x_pointer = 0;

private float y_pointer = 0;

private float x_pointer_awal = 0;

private float y_pointer_awal = 0;

private float x_lebar_layar = 0;

private float y_tinggi_layar = 0;

private float sudut_pointer = 0;

562

private float jarak_center = 0;

private String arah_joystick="";

boolean get_size_screen=true;

private float x_graf = 0;

private float y_graf = 0;

int[] textures_indek = new int[1];

float black[] = new float[] { 0.0f, 0.0f, 0.0f,

1.0f };

float yellow[] = new float[] { 1.0f, 1.0f, 0.0f,

1.0f };

float cyan[] = new float[] { 0.0f, 1.0f, 1.0f,

1.0f };

float white[] = new float[] { 1.0f, 1.0f, 1.0f,

1.0f };

float diffuseMaterial[] = new float[] { 0.73f,

0.13f, 0.86f, 1.0f }; // set cahaya warna ungu

float diffuseMaterial2[] = new float[] { 0.5f,

0.5f, 0.5f, 1.0f }; // set cahaya warna ungu

float lightAmbient[] = new float[] { 0.2f, 0.3f,

0.6f, 1.0f };

float mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f

};

float light_position[] = { 0.0f, 0.0f, 1.0f, 0.0f

};

float light_position2[] = { 0.0f, 0.0f, 1.0f,

0.0f };

/** Constructor to set the handed over context */

public ESRender(Context context) {

// super();

this.context = context;

this.primobbg = new PrimitivesObject();

this.primobflappy = new

PrimitivesObject();

this.primobground = new

PrimitivesObject();

this.primob1 = new PrimitivesObject();

this.primob3 = new PrimitivesObject();

this.objectball2 = new ObjectBall();

//this.objectball3 = new ObjectBall();

this.objectballstick = new ObjectBall();

this.objectballbgstick = new

ObjectBall();

this.primob = new PrimitivesObject();

//this.primob2 = new PrimitivesObject();

this.mEarth = new MySphere(5, 3);

this.mEarth2 = new MySphere(5, 3);

this.mEarth3 = new MySphere(5, 3);

this.transobject = new TransObject();

//mengambil nilai xyx (posisi awal)

labirin player

563

this.x_player = primob.x_player;

this.y_player = primob.y_player;

this.x_player_end = primob.x_player_end;

this.y_player_end = primob.y_player_end;

this.positionRow = primob.positionRow;

this.positionCol = primob.positionCol;

this.hori = primob.hori;

this.verti = primob.verti;

this.numberCol = primob.numberCol;

this.numberRow = primob.numberRow;

this.WidthObject = primob.WidthObject;

}

@Override

public void onDrawFrame(GL10 gl) {

// menangkap ukuran layar

if(get_size_screen){

this.x_lebar_layar = mywidth;

this.y_tinggi_layar = myheight;

get_size_screen=false;

}

// Draw background color

gl.glClear(GL10.GL_COLOR_BUFFER_BIT |

GL10.GL_DEPTH_BUFFER_BIT);

// gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

gl.glEnable(GL10.GL_DEPTH_TEST);

gl.glEnable(GL10.GL_NORMALIZE);

//gl.glLoadIdentity();

//gl.glMaterialfv(GL10.GL_FRONT,

GL10.GL_AMBIENT_AND_DIFFUSE, makeFloatBuffer(cyan));


GL10.GL_SPECULAR, white,0);


GL10.GL_SHININESS, white,0);


GL10.GL_DIFFUSE, white,0);

// multi light

/*float light1_ambient[] = { 0.2f, 0.2f,

0.2f, 1.0f };

float light1_diffuse[] = { 1.0f, 1.0f,

1.0f, 1.0f };

float light1_specular[] = { 1.0f, 1.0f,

1.0f, 1.0f };

float light1_position[] = { -2.0f, 2.0f,

1.0f, 1.0f };

float spot_direction[] = { -1.0f, -1.0f,

0.0f };

*/

/*gl.glLightfv(GL10.GL_LIGHT1,

564

GL10.GL_AMBIENT, light1_ambient,0);

gl.glLightfv(GL10.GL_LIGHT1,

GL10.GL_DIFFUSE, light1_diffuse,0);


GL10.GL_SPECULAR, light1_specular,0);


GL10.GL_POSITION, light1_position,0);

gl.glLightf(GL10.GL_LIGHT1,

GL10.GL_CONSTANT_ATTENUATION, 1.5f);


GL10.GL_LINEAR_ATTENUATION, 0.5f);


GL10.GL_QUADRATIC_ATTENUATION, 0.2f);


GL10.GL_SPOT_CUTOFF, 45.0f);


GL10.GL_SPOT_DIRECTION, spot_direction,0);


GL10.GL_SPOT_EXPONENT, 2.0f);

gl.glEnable(GL10.GL_LIGHT1);*/

//end multi light

//

//membuat background

gl.glPushMatrix();

gl.glDisable(GL10.GL_LIGHTING);

gl.glScalef(x_lebar_layar,

y_tinggi_layar, 1.0f);

primobbg.draw_background(gl);

gl.glEnable(GL10.GL_LIGHTING);

gl.glPopMatrix();

int x_lebar_layar_temp=(int)

(Math.ceil(x_lebar_layar/kecepatan_ground)*kecepatan_

ground);

//membuat ground 1 flappy

gl.glPushMatrix();


gl.glTranslatef(move_left_right1, 0.f, 0.f);

gl.glTranslatef(0, -50.f,

0.f);

gl.glScalef(x_lebar_layar_temp,

1.5f*y_tinggi_layar/10, 1.0f);

primobground.draw_background(gl);


gl.glPopMatrix();

move_left_right1-=kecepatan_ground;

if(-move_left_right1==x_lebar_layar_temp){

move_left_right1=x_lebar_layar_temp;

565

}

//membuat ground 2 flappy

gl.glPushMatrix();


gl.glTranslatef(move_left_right2,

0.f, 0.f);

gl.glTranslatef(x_lebar_layar_temp, 0.f, 0.f);

gl.glTranslatef(0, -50.f, 0.f);

gl.glScalef(x_lebar_layar_temp,

1.5f*y_tinggi_layar/10, 1.0f);

primobground.draw_background(gl);


gl.glPopMatrix();

move_left_right2-=kecepatan_ground;

if(-move_left_right2==2*x_lebar_layar_temp){

move_left_right2=0;

}

//membuat flappy bird

// Keep track of number of frames drawn

numFrames2++;

long fpsElapsed2 = System.currentTimeMillis() -

fpsStartTime2;

if (fpsElapsed2 > 0.09 * 1000) { // every 5

seconds

float fps2 = (numFrames2 * 1000.0F) /

fpsElapsed2;

//glText.draw( "Frames per second : "+

fps + " (" + numFrames + " frames in " + fpsElapsed +

" ms)",150, 30); // Draw Test String

fpsStartTime2 =

System.currentTimeMillis();

numFrames2 = 0;

gl.glPushMatrix();


gl.glBlendFunc(GL10.GL_SRC_ALPHA,

GL10.GL_ONE_MINUS_SRC_ALPHA);

gl.glEnable(GL10.GL_BLEND);

// mengatur naik turun

gl.glTranslatef(0,

faktor_naik_turun, 0.0f);

gl.glTranslatef(x_lebar_layar/2,

y_tinggi_layar/2, 0.0f);

gl.glScalef(x_lebar_layar/10, y_tinggi_layar/10,

566

1.0f);

primobflappy.loadBallTexture2(gl, context,

numIDFrame);

//gl.glColor4f(1.0f, 1.0f,

1.0f, 1.0f);

primobflappy.draw_background(gl);

gl.glDisable(GL10.GL_BLEND);


gl.glPopMatrix();

numIDFrame++;

if(flag_naik==1){

faktor_naik_turun+=2;

}else if(flag_naik==-1){

faktor_naik_turun-=2;

}

if(faktor_naik_turun%20==0){

flag_naik*=-1;

}

if(numIDFrame%8==0){

numIDFrame=0;

}

}else{

gl.glPushMatrix();




gl.glEnable(GL10.GL_BLEND);

// mengatur naik turun

gl.glTranslatef(0,

faktor_naik_turun, 0.0f);

gl.glTranslatef(x_lebar_layar/2,

y_tinggi_layar/2, 0.0f);

gl.glScalef(x_lebar_layar/10, y_tinggi_layar/10,

1.0f);

primobflappy.loadBallTexture2(gl, context,

numIDFrame);

//gl.glColor4f(1.0f, 1.0f,

1.0f, 1.0f);

primobflappy.draw_background(gl);

567

gl.glDisable(GL10.GL_BLEND);


gl.glPopMatrix();

}

//fractal mandelbrot

/*gl.glPushMatrix();

gl.glDisable (GL10.GL_LIGHTING);

gl.glTranslatef(550.0f,

200.0f, 0.0f);

//gl.glScalef(CurrentScale*5.0f,

CurrentScale*5.0f, 1.0f);

gl.glScalef(60.0f, 60.0f,

1.0f);

//gl.glRotatef(CurrentAngle2,

0, 0, 1);

//

primob2.draw_fractal_mandelbrot(gl);

gl.glEnable (GL10.GL_LIGHTING);

gl.glPopMatrix();*/

//fractal julia




200.0f, 0.0f);



gl.glScalef(100.0f,

100.0f, 1.0f);

gl.glRotatef(CurrentAngle2, 0,

0, 1);

//primob2.draw_fractal_julia(gl);


gl.glPopMatrix();*/

//fractal julia_m



gl.glTranslatef(550.0f, 200.0f,

0.0f);



gl.glScalef(50.0f, 50.0f, 1.0f);

//gl.glRotatef(CurrentAngle2, 0, 0,

1);

gl.glEnable(GL10.GL_POINT_SMOOTH);

gl.glPointSize(1);

primob2.draw_fractal_julia_m(gl);


gl.glPopMatrix();

*/

568

// bola 1




200.0f, 0.0f);


25.0f);

gl.glRotatef(CurrentAngle, 0,

1, 0);

mEarth.draw(gl);


gl.glPopMatrix();*/

// menampilkan object bola2 + lighting

/*gl.glPushMatrix ();

gl.glTranslatef(600.0f, 200.0f, 0.0f);

gl.glScalef(25.0f, 25.0f, 25.0f);

gl.glTranslatef (0.0f, 0.0f, -

5.0f);

gl.glPushMatrix ();

gl.glRotatef (CurrentAngle,

1.0f, 0.0f, 0.0f);

gl.glMaterialf(GL10.GL_FRONT,

GL10.GL_SHININESS, 100.0f);


GL10.GL_POSITION, light_position,0);

gl.glLightfv (GL10.GL_LIGHT0,

GL10.GL_DIFFUSE, white,0);


GL10.GL_AMBIENT, lightAmbient, 0);


GL10.GL_SPECULAR, white, 0);

gl.glTranslatef (0.0f, 0.0f,

3.5f);

gl.glDisable

(GL10.GL_LIGHTING);

gl.glScalef(0.3f,

0.3f, 0.3f);

transobject.draw_kubus(gl);


gl.glPopMatrix ();

gl.glRotatef(CurrentAngle, 0, 1, 0);

mEarth2.draw(gl);

gl.glPopMatrix ();

*/

// menampilkan object bola3 + lighting


gl.glTranslatef(mywidth-2*radius,

myheight-4f*radius, 0.0f);

gl.glScalef(25.0f, 25.0f, 25.0f);


569

5.0f);

gl.glPushMatrix ();

gl.glRotatef (CurrentAngle,

0.0f, 1.0f, 0.0f);


3.5f);








GL10.GL_DIFFUSE, white, 0);



gl.glDisable

(GL10.GL_LIGHTING);

gl.glScalef(0.3f,

0.3f, 0.3f);



gl.glPopMatrix ();

gl.glPushMatrix ();

gl.glRotatef (-CurrentAngle,

0.0f, 1.0f, 0.0f);


3.5f);








GL10.GL_DIFFUSE, white, 0);



gl.glDisable

(GL10.GL_LIGHTING);

gl.glScalef(0.3f,

0.3f, 0.3f);



gl.glEnable(GL10.GL_LIGHT0);


gl.glPopMatrix ();

gl.glRotatef(CurrentAngle, 1, 0, 0);

570

mEarth3.draw(gl);

gl.glPopMatrix ();

gl.glLoadIdentity();

*/

// cahaya bola ungu


gl.glTranslatef(mywidth-2*radius,

myheight-1.2f*radius, 0.0f);

gl.glScalef(15.0f, 15.0f, 15.0f);


5.0f);

gl.glPushMatrix ();

gl.glRotatef

(CurrentAngle, 1.0f, 0.0f, 0.0f);

gl.glMaterialf(GL10.GL_FRONT, GL10.GL_SHININESS,

100.0f);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION,

light_position,0);

gl.glLightfv

(GL10.GL_LIGHT0, GL10.GL_DIFFUSE,

diffuseMaterial,0);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT,

lightAmbient, 0);

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPECULAR, white,

0);

gl.glTranslatef (0.0f,

0.0f, 3.5f);

gl.glDisable

(GL10.GL_LIGHTING);



gl.glEnable

(GL10.GL_LIGHTING);


gl.glDisable(GL10.GL_LIGHT1);

gl.glPopMatrix ();

mEarth2.draw(gl);

gl.glPopMatrix ();

*/

// menampilkan persegi dengan gradasi

warna


gl.glTranslatef(0.0f, 1.0f, 0.0f);

571

gl.glTranslatef(0.0f, 0.0f, -5.0f);

// objectarena.draw_kotak(gl);

gl.glPopMatrix();*/

// menampilkan lingkaran dengan tepian

berwarna



// gl.glScalef(150.0f,

150.0f, 150.0f);

// gl.glTranslatef(150.0f,

150.0f, -5.0f);

gl.glLineWidth(1.0f);

gl.glEnable(GL10.GL_LINE_SMOOTH);

objectball.draw_circle(gl);


gl.glPopMatrix();

*/

// menampilkan bola bumi



//gl.glLineWidth(1.0f);

//gl.glEnable(GL10.GL_LINE_SMOOTH);

// bounds.set(x - radius,

y - radius, x + radius, y + radius);

gl.glTranslatef(-x, -y,

0.0f);

gl.glTranslatef(mywidth-

radius, myheight-radius, 0.0f);

gl.glScalef(50.0f/3.0f,50.0f/3.0f,50.0f/3.0f);

gl.glRotatef(CurrentAngle,

0, 1, 0);

mEarth.draw(gl);


gl.glPopMatrix();

*/

// menampilkan bola putar dengan gradasi

warna (3D)





// bounds.set(x - radius,

y - radius, x + radius, y + radius);

//gl.glTranslatef(x, y,

0.0f);


50.0f, 0.0f);


572

//objectball2.draw_circle_color(gl);

gl.glRotatef(CurrentAngle,

0, 1, 0);

//mEarth3.draw(gl);


gl.glPopMatrix();

*/

// menampilkan bola pantul dengan gradasi

warna (3D)

gl.glPushMatrix();




// bounds.set(x - radius, y -

radius, x + radius, y + radius);

gl.glTranslatef(x, y, 0.0f);


0.0f);


//objectball2.draw_circle_color(gl);

gl.glRotatef(CurrentAngle, 0, 1,

0);

mEarth3.draw(gl);


gl.glPopMatrix();

// segitiga merah



//GLU.gluLookAt(gl, 0, 0,

0.01f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

gl.glColor4f(1.0f, 0.0f,

0.0f, 0.5f);


60.0f, 0.0f);


0.0f);

gl.glRotatef(180, 1.0f,

0.0f, 0.0f);

//gl.glRotatef(mAngle,

0.0f, 1.0f, 0.0f);

gl.glTranslatef(-0.5f, -

0.5f, 0.0f);

objectball.draw_segitiga(gl);


gl.glPopMatrix();

*/

// segitiga hijau



573

//GLU.gluLookAt(gl, 0, 0,

0.01f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

gl.glColor4f(0.0f, 0.0f,

1.0f, 0.5f);


60.0f, 0.0f);


0.0f);

gl.glRotatef(180, 1.0f,

0.0f, 0.0f);

//gl.glRotatef(mAngle,

0.0f, 1.0f, 0.0f);

gl.glTranslatef(-0.5f, -

0.5f, 0.0f);

objectball.draw_segitiga(gl);


gl.glPopMatrix();

*/

// menampilkan lingkaran dengan warna

merah + blending



gl.glEnable(GL10.GL_BLEND); // Turn blending on

(NEW)

gl.glDisable(GL10.GL_DEPTH_TEST); // Turn depth

testing off (NEW)





gl.glTranslatef(100, 150, 0.0f);

objectball3.draw_circle_color(gl,1.0f,0.f,0.f,0.5

f);

gl.glDisable(

GL10.GL_BLEND ); // Disable Alpha

Blend


gl.glPopMatrix();


hijau + blending

gl.glPushMatrix();



(NEW)

574


testing off (NEW)





gl.glTranslatef(70,100, 0.0f);


f);

gl.glDisable(


Blend


gl.glPopMatrix();


biru + blending

gl.glPushMatrix();



(NEW)


testing off (NEW)





gl.glTranslatef(130,100, 0.0f);


f);

gl.glDisable(


Blend


gl.glPopMatrix();

*/

// update

moveWithCollisionDetection(this);

575

set((int)-radius, (int)-radius, mywidth,

myheight);

// Log.i("Test get width : ", "" +

mywidth);

// Log.i("Test get height : ", "" +

myheight);

// render text

gl.glPushMatrix();


// gl.glScalef(10.0f,

10.0f, 10.0f);

// enable texture + alpha

blending

// NOTE: this is required

for text rendering! we could incorporate it

// into

// the GLText class, but

then it would be called multiple times (which

// impacts performance).

gl.glEnable(GL10.GL_TEXTURE_2D); // Enable

Texture Mapping

gl.glEnable(GL10.GL_BLEND); // Enable Alpha Blend


testing off (NEW)


GL10.GL_ONE_MINUS_SRC_ALPHA); // Set

// Alpha

// Blend

// Function

glText.begin(1.0f, 1.0f,

1.0f, 1.0f); // Begin Text Rendering (Set Color

// WHITE)

glText.draw("Jumlah

Pantulan : (" + jumlah_pantulan + ")", 450, 2); //

Draw

// Test

// String

//

textview.setText(String.valueOf(x));

// glText.draw( "Line 1",

-2, 2 ); // Draw Test String


576

0, 0 ); // Draw Test String

glText.end(); // End Text

Rendering




//

WHITE)

glText.draw("Posisi Bola :

(" + x + "," + y + ")", 50, 2); // Draw

// Test

// String

//







Rendering




//

WHITE)

glText.draw("Posisi Touch

: (" + x_touch + "," + y_touch + ")", 450, 400); //

Draw

// Test

// String

//







Rendering




577

//

WHITE)

glText.draw("Posisi Player

: (" + ((400*x_player)+50) + "," +

((400*y_player)+50) + ")", 50, 400); // Draw

// Test

// String

//







Rendering




//

WHITE)

glText.draw("Ukuran Layar

: (" + x_lebar_layar + "," + y_tinggi_layar + ")",

50, 380); // Draw

// Test

// String

//







Rendering




//

WHITE)

glText.draw("Posisi Tujuan

Player : (" + ((400*x_player_end)+50) + "," +

((400*y_player_end)+50) + ")", 450, 380); // Draw

// Test

578

// String

//







Rendering

if(

(x_player>=(x_player_end-(WidthObject/2))) &&

(x_player=(y_player_end-(WidthObject/2))) &&

(y_player

579

}

}


//glText.begin(0.0f, 0.0f,


// Keep track of number of

frames drawn

//numFrames++;

//long fpsElapsed =

System.currentTimeMillis() - fpsStartTime;

//float fps = (numFrames *

1000.0F) / fpsElapsed;

//if (fpsElapsed > 5 * 1000) { //

every 5 seconds

//float fps = (numFrames *

1000.0F) / fpsElapsed;

// glText.draw( "Frames per

second : "+ fps + " (" + numFrames + " frames in " +

fpsElapsed + " ms)",470, 30); // Draw Test

String

//temp nilai fps dan

fpsElapsed terakhir

// fps_temp=fps;

// numFrames_temp=numFrames;

//

fpsElapsed_temp=fpsElapsed;

// fpsStartTime =

System.currentTimeMillis();

// numFrames = 0;

// startTimeInit=false;

/*}else{

if(startTimeInit){

//glText.draw(

"Frames per second : "+ fps + " (" + numFrames + "

frames in " + fpsElapsed + " ms)",450, 30);

// Draw Test String

}else{

glText.draw(

"Frames per second : "+ fps_temp + " (" +

numFrames_temp + " frames in " + fpsElapsed_temp + "

ms)",470, 30); // Draw Test String

}

}*/

//glText.end(); // End Text

Rendering


580



//

WHITE)

glText.draw("Arah : (" +

arah_joystick + ")", 450, 460); // Draw

// Test

// String

//







Rendering




//

WHITE)

glText.draw("Nilai Jarak

ke Center : (" + jarak_center + ")", 450, 440); //

Draw

// Test

// String

//







Rendering


glText.begin(.0f, 1.0f,


//

WHITE)

glText.draw("Posisi

xy_anim_stick : (" + x_anim_stick + "," +

y_anim_stick + ")", 450, 420); // Draw

581

// Test

// String

//







Rendering




//

WHITE)

glText.draw("Sudut Pointer

: (" + sudut_pointer + ")", 50, 460); // Draw

// Test

// String

//







Rendering




//

WHITE)

glText.draw("Posisi

xy_pointer : (" + x_pointer + "," + y_pointer + ")",

50, 440); // Draw

// Test

// String

//





582



Rendering




//

WHITE)

glText.draw("Posisi

xy_pointer awal : (" + x_pointer_awal + "," +

y_pointer_awal + ")", 50, 420); // Draw

// Test

// String

//







Rendering

/*gl.glLoadIdentity();

glText.begin( 1.0f, 1.0f,

0.0f, 1.0f ); // Begin Text Rendering


0.5f);

glText.draw( "Grafika

Komputer", 40.0f, 140); //

// Draw Test String


Rendering

*/


glText.begin( 0.0f, 0.0f,

1.0f, 0.5f ); // Begin Text Rendering

//gl.glTranslatef(x_graf, y_graf, 0.f);

//Log.v("nilai

x_graf :", ""+x_graf);

//Log.v("nilai

y_graf :", ""+y_graf);

gl.glTranslatef(345.f, 200.f, 0.f);

//gl.glRotatef(-30,

0.0f, 0.0f, 1.0f);

583

gl.glScalef(1.5f,

1.5f, 1.5f);

gl.glTranslatef(5.f, 140.f, 0.f);

gl.glRotatef(CurrentAngle, 0.1f, 1.0f, 0.2f); //

Rotate

gl.glTranslatef(-

50.f, 0.f, 0.f);

glText.draw(

"Grafika Komputer", 0.0f, 0.0f); //

// Draw Test String


Rendering


// disable texture + alpha

gl.glDisable(GL10.GL_BLEND); //

Disable Alpha Blend

gl.glDisable(GL10.GL_TEXTURE_2D);

// Disable Texture Mapping

gl.glPopMatrix();

// membuat background joystick dari

lingkaran dengan texture

gl.glPushMatrix();




//gl.glTranslatef(-x, -y,

0.0f);


(2*radius)-radius, 0.0f+radius, 0.0f);

objectballbgstick.draw_circle_color(gl);


gl.glPopMatrix();

// membuat joystick dari lingkaran dengan

texture

gl.glPushMatrix();




gl.glTranslatef(x_anim_stick, y_anim_stick,

0.0f);

//gl.glTranslatef(mywidth-

2*radius, 0.5f*radius, 0.0f);

//canvas.drawBitmap(_joystick.get_joystick(),

//_controls._touchingPoint.x - 26,

_controls._touchingPoint.y - 26, null);

584


(1.5f*radius)-radius, (0.5f*radius)+radius, 0.0f);


1.5f*radius, 0.5f*radius, 0.0f);

//gl.glTranslatef(1013.0f,

500.0f, 0.0f);


1.0f);

objectballstick.draw_circle_color(gl);


gl.glPopMatrix();

// membuat joystick dari lingkaran dengan

texture 2





gl.glTranslatef(x_anim_stick, y_anim_stick,

0.0f);


2*radius, 0.5f*radius, 0.0f);

gl.glTranslatef(-

5*radius,0.0f,0.0f);

//canvas.drawBitmap(_joystick.get_joystick(),

//_controls._touchingPoint.x - 26,

_controls._touchingPoint.y - 26, null);


(1.5f*radius)-radius, (0.5f*radius)+radius, 0.0f);


1.5f*radius, 0.5f*radius, 0.0f);


500.0f, 0.0f);


1.0f);

objectballstickdua.draw_circle_color(gl);


gl.glPopMatrix();*/

//Log.v("mywidth: ", "" + mywidth);

//Log.v("myheight: ", "" + myheight);

//Log.v("radius: ", "" + radius);

// membuat jaring-jaring labirin

gl.glPushMatrix();


585

//gl.glDisable(GL10.GL_DEPTH_TEST); // Turn depth

testing off (NEW)


400.0f, 0.0f);


0.0f);

//gl.glScalef(25.0f,

25.0f, 25.0f);

gl.glScalef(400.0f,

400.0f, 1.0f);


0.0f, -5.0f);



primob.draw_line_maze_horiverti(gl);


gl.glPopMatrix();


// segitiga dengan texture sebagai player

labirin



//GLU.gluLookAt(gl, 0, 0, 0.01f,

0f, 0f, 0f, 0f, 1.0f, 0.0f);


0.0f);


gl.glRotatef(180, 1.0f, 0.0f,

0.0f);

gl.glTranslatef(-0.5f, -0.5f,

0.0f);

objectball.draw_segitiga_texture(gl);


gl.glPopMatrix();*/

// membuat player untuk labirin

gl.glPushMatrix();



50.0f, 0.0f);

gl.glScalef(400.0f,

400.0f, 1.0f);


0.0f, -5.0f);

// start me-manage

pergerakan player

if(Navigate == 1)

//Navigate right

{

586

gl.glTranslatef(x_player, y_player, 0.0f);

gl.glRotatef(-90.0f,

0.0f, 0.0f, 1.0f);

gl.glTranslatef(-

x_player, -y_player, 0.0f);

}

else if(Navigate == 2)

//Navigate bottom

{


gl.glRotatef(-180.0f,

0.0f, 0.0f, 1.0f);

gl.glTranslatef(-


}

else if(Navigate == 3)

//Navigate left

{


gl.glRotatef(90.0f,

0.0f, 0.0f, 1.0f);

gl.glTranslatef(-


}

// end me-manage

pergerakan player

primob.draw_segitiga_labirin_player(gl,positionCo

l,positionRow);

//primob.draw_segitiga_labirin_player(gl);

//primob1.draw_segitiga_texture(gl,positionCol,po

sitionRow);


gl.glPopMatrix();

// membuat player untuk labirin as bot

/*int min = 1;

int max = 3;

Random init_random = new Random();

int my_random = init_random.nextInt(max -

min + 1) + min;

Navigate=my_random;

Log.v("my_random =",""+my_random);

*/

// Update the rotational angle after each

refresh

// re-Calculate animation

parameters

CurrentAngle += AnimateStep;

if (CurrentAngle > 360.0) {

587

//CurrentAngle -=

360.0*Math.floor(CurrentAngle/360.0);

CurrentAngle=0.0f;

CurrentAngle +=

AnimateStep;

}

CurrentAngle2 += AnimateStep2;

if (CurrentAngle2 > 360.0) {

//CurrentAngle -=

360.0*Math.floor(CurrentAngle/360.0);

CurrentAngle2=0.0f;

CurrentAngle2 +=

AnimateStep2;

}

// pengkondisian penghitungan

pantulan mulai dari nol

/*if(Run_ModeScale==0){

this.CurrentScale-

=ScaleStep;

this.Run_ModeScale=1;

}*/

CurrentScale += ScaleStep;

if (CurrentScale % 10.0f==0) {

ScaleStep = -1*ScaleStep;

}

//gl.glFlush();

}

public float getX_graf() {

return x_graf;

}

public void setX_graf(float x_graf) {

this.x_graf = x_graf;

}

public float getY_graf() {

return y_graf;

}

public void setY_graf(float y_graf) {

this.y_graf = y_graf;

}

public float getX_touch() {

return x_touch;

}

588

public void setX_touch(float x_touch) {

this.x_touch = x_touch;

}

public float getY_touch() {

return y_touch;

}

public void setY_touch(float y_touch) {

this.y_touch = y_touch;

}

public String getArah_joystick() {

return arah_joystick;

}

public void setArah_joystick(String

arah_joystick) {

this.arah_joystick = arah_joystick;

}

public float getJarak_center() {

return jarak_center;

}

public void setJarak_center(float jarak_center) {

this.jarak_center = jarak_center;

}

public float getSudut_pointer() {

return sudut_pointer;

}

public void setSudut_pointer(float sudut_pointer)

{

this.sudut_pointer = sudut_pointer;

}

public float getX_lebar_layar() {

return x_lebar_layar;

}

public void setX_lebar_layar(float x_lebar_layar)

{

this.x_lebar_layar = x_lebar_layar;

}

public float getY_tinggi_layar() {

return y_tinggi_layar;

}

589

public void setY_tinggi_layar(float

y_tinggi_layar) {

this.y_tinggi_layar = y_tinggi_layar;

}

public float getX_pointer_awal() {

return x_pointer_awal;

}

public void setX_pointer_awal(float

x_pointer_awal) {

this.x_pointer_awal = x_pointer_awal;

}

public float getY_pointer_awal() {

return y_pointer_awal;

}

public void setY_pointer_awal(float

y_pointer_awal) {

this.y_pointer_awal = y_pointer_awal;

}

public float getX_pointer() {

return x_pointer;

}

public void setX_pointer(float x_pointer) {

this.x_pointer = x_pointer;

}

public float getY_pointer() {

return y_pointer;

}

public void setY_pointer(float y_pointer) {

this.y_pointer = y_pointer;

}

public float getX_anim_stick() {

return x_anim_stick;

}

public void setX_anim_stick(float x_anim_stick) {

this.x_anim_stick = x_anim_stick;

}

public float getY_anim_stick() {

return y_anim_stick;

590

}

public void setY_anim_stick(float y_anim_stick) {

this.y_anim_stick = y_anim_stick;

}

public float getRadius() {

return radius;

}

public void setRadius(float radius) {

this.radius = radius;

}

public int getMywidth() {

return mywidth;

}

public void setMywidth(int mywidth) {

this.mywidth = mywidth;

}

public int getMyheight() {

return myheight;

}

public void setMyheight(int myheight) {

this.myheight = myheight;

}

public int getNumberRow() {

return numberRow;

}

public void setNumberRow(int numberRow) {

this.numberRow = numberRow;

}

public float getWidthObject() {

return WidthObject;

}

public void setWidthObject(float widthObject) {

WidthObject = widthObject;

}

public float getX_player() {

return x_player;

}

public void setX_player(float x_player) {

this.x_player = x_player;

591

}

public float getY_player() {

return y_player;

}

public void setY_player(float y_player) {

this.y_player = y_player;

}

public int getNavigate() {

return Navigate;

}

public void setNavigate(int navigate) {

Navigate = navigate;

}

public boolean goForward()

{

if(Navigate == 0 && positionRow > 0 &&

hori[positionRow][positionCol] == 0) return true;

if(Navigate == 1 && positionCol <

(numberCol-1) && verti[positionRow][positionCol+1] ==

0) return true;

if(Navigate == 2 && positionRow <

(numberRow-1) && hori[positionRow+1][positionCol] ==

0) return true;

if(Navigate == 3 && positionCol > 0 &&

verti[positionRow][positionCol] == 0) return true;

return false;

}

public int getPositionRow() {

return positionRow;

}

public void setPositionRow(int positionRow) {

this.positionRow = positionRow;

}

public int getPositionCol() {

return positionCol;

}

public void setPositionCol(int positionCol) {

this.positionCol = positionCol;

}

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig

config) {

//gl.glClearColor(0.5f, 0.5f, 0.5f,

1.0f); // Set color's clear-value to

//gl.glClearColor(1.0f, 1.0f, 1.0f,

1.0f); // Set color's clear-value to

// black

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

592

// Set color's clear-value to

gl.glClearDepthf(1.0f); // Set depth's

clear-value to farthest

gl.glEnable(GL10.GL_DEPTH_TEST); //

Enables depth-buffer for hidden

// surface removal

gl.glDepthFunc(GL10.GL_LEQUAL); // The

type of depth testing to do

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,

GL10.GL_NICEST); // nice

// perspective

// view

gl.glShadeModel(GL10.GL_SMOOTH); //

Enable smooth shading of color

gl.glDisable(GL10.GL_DITHER); // Disable

dithering for better

// performance



//gl.glEnable(GL10.GL_LIGHT1);

// Create the GLText

glText = new ESText(gl,

context.getAssets());

// Load the font from file (set size +

padding), creates the texture

// NOTE: after a successful call to this

the font is ready for

// rendering!

glText.load("Roboto-Regular.ttf", 14, 2,

2); // Create Font (Height: 14

//

Pixels / X+Y Padding

// 2

Pixels)

// gl.glDisable(GL10.GL_DITHER); //

Disable dithering for better

// performance

// Setup Blending (NEW)

gl.glColor4f(1.0f, 1.0f, 1.0f, 0.5f); //

Full brightness, 50% alpha (NEW)


GL10.GL_ONE); // Select blending function (NEW)

// Setup Texture, each time the surface

is created (NEW)

primob3.loadBallTexture(gl, context,1);

primob1.loadBallTexture(gl, context,4);

objectball2.loadBallTexture(gl, context);

objectballstick.loadBallTexture(gl,

context,2);

593

objectballbgstick.loadBallTexture(gl,

context,3);

mEarth.loadGLTexture(gl, context,2);

//mEarth2.loadGLTexture(gl, context,6);

mEarth3.loadGLTexture(gl, context,4);

primobbg.loadBallTexture(gl, context, 5);

primobflappy.loadBallTexture2(gl,

context, 0);

primobground.loadBallTexture(gl, context,

6);

gl.glEnable(GL10.GL_TEXTURE_2D); //

Enable texture (NEW)

}

@Override

public void onSurfaceChanged(GL10 gl, int width,

int height) {

mywidth = width;

myheight = height;

gl.glViewport(0, 0, width, height);

// Setup orthographic projection

gl.glMatrixMode(GL10.GL_PROJECTION); //

Activate Projection Matrix

gl.glLoadIdentity(); // Load Identity

Matrix

gl.glOrthof( // Set Ortho Projection

(Left,Right,Bottom,Top,Front,Back)

0, width, 0, height,

500.0f, -500.0f);

// Save width and height

// this.width = width; // Save Current

Width

// this.height = height; // Save Current

Height

gl.glMatrixMode(GL10.GL_MODELVIEW); //

Select model-view matrix

gl.glLoadIdentity(); // Reset

/*float[] vertices_quad = { // Vertices

for the square

-1.0f, -1.0f, 0.0f, // 0.

left-bottom

1.0f, -1.0f, 0.0f, // 1.

right-bottom

-1.0f, 1.0f, 0.0f, // 2.

left-top

1.0f, 1.0f, 0.0f // 3.

right-top

};

// set background

Bitmap bitmap =

BitmapFactory.decodeStream(context.getResources()

594

.openRawResource(R.drawable.splash));

float tex_quad[] = {

-100, -100, 0,

100, -100, 0,

-100, 100, 0,

100, 100, 0

};

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

gl.glVertexPointer(3, GL10.GL_FLOAT, 0,

makeFloatBuffer(tex_quad));

gl.glTexCoordPointer(3, GL10.GL_FLOAT, 0,

makeFloatBuffer(vertices_quad)); // 5

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRA

Y);

//gl.glVertexPointer(2, GL_FLOAT,

sizeof(GLfloat)*4, &tex_quad[0]);

//glTexCoordPointer(2, GL_FLOAT,

sizeof(GLfloat)*4, &tex_quad[2]);

gl.glDisable(GL10.GL_DEPTH_TEST);

gl.glDepthMask(false);

gl.glEnable(GL10.GL_TEXTURE_2D);

//gl.glGenTextures(1, textures_indek, 0);

gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);

gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0,

4);

//glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

//glEnable(GL_DEPTH_TEST);

gl.glEnable(GL10.GL_DEPTH_TEST);

gl.glDepthMask(true);

gl.glDisable( GL10.GL_TEXTURE_2D );

// Disable Texture Mapping

*/

}

public float getxMax() {

return xMax;

}

public void setxMax(int xmax) {

xMax = xmax;

}

public float getxMin() {

return xMin;

}

595

public void setxMin(int xmin) {

xMin = xmin;

}

public float getyMax() {

return yMax;

}

public void setyMax(int ymax) {

yMax = ymax;

}

public float getyMin() {

return yMin;

}

public void setyMin(int ymin) {

yMin = ymin;

}

public float getspeedX() {

return speedX;

}

public void setspeedX(float speedX_) {

speedX = speedX_;

}

public float getspeedY() {

return speedY;

}

public void setspeedY(float speedY_) {

speedY = speedY_;

}

public void moveWithCollisionDetection(ESRender

esRender) {

// Get new (x,y) position

x += speedX;

y += speedY;

// Detect collision and react

if (x + radius > esRender.getxMax()) {

speedX = -speedX;

x = esRender.getxMax() - radius;

this.jumlah_pantulan+=1;

} else if (x - radius <

esRender.getxMin()) {

speedX = -speedX;

x = esRender.getxMin() + radius;


}

if (y + radius > esRender.getyMax()) {

speedY = -speedY;

y = esRender.getyMax() - radius;


} else if (y - radius <

esRender.getyMin()) {

596

speedY = -speedY;

y = esRender.getyMin() + radius;


}

// pengkondisian penghitungan pantulan

mulai dari nol

if(Run_Mode==0){

this.jumlah_pantulan-=4;

this.Run_Mode=1;

}

}

public void set(int x, int y, int width, int

height) {

xMin = x;

// xMax = x + width - 1;

xMax = x + width;

yMin = y;

// yMax = y + height - 1;

yMax = y + height;

}

}

ESSurfaceView.java


import android.content.Context;

//import android.graphics.PixelFormat;

import android.graphics.Point;

import android.opengl.GLSurfaceView;

import android.util.Log;

import android.view.KeyEvent;

import android.view.MotionEvent;

/**

* A view container where OpenGL ES graphics can be

drawn on screen. This view

* can also be used to capture touch events, such as

a user interacting with

* drawn objects.

*/

public class ESSurfaceView extends GLSurfaceView {

private final ESRender esRender;

private float previousX;

private float previousY;

/*

* public float initx_stick = 425; public float

inity_stick = 267; public

* Point _touchingPoint = new Point(425,267);

597

public Point _pointerPosition

* = new Point(220,150);

*/

public float initx_stick = 1013;

public float inity_stick = 500;

public Point _touchingPoint = new Point(1013,

500);

public Point _pointerPosition = new Point(220,

150);

private Boolean _dragging = false;

private int flag_first = 0;

private float mypointer_awal_x = 0;

private float mypointer_awal_y = 0;

public ESSurfaceView(Context context) {

super(context);

// Set the Renderer for drawing on the

GLSurfaceView

esRender = new ESRender(context);

setRenderer(esRender);

// To enable keypad

this.setFocusable(true);

this.requestFocus();

// To enable touch mode

this.setFocusableInTouchMode(true);

// Render the view only when there is a

change in the drawing data

// merender hanya ketika ada perubahan/

event

//

setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

//set background

//glSurfaceView = ...

/*glSurfaceView.setEGLConfigChooser(8, 8,

8, 8, 16, 0);

glSurfaceView.getHolder().setFormat(PixelFormat.T

RANSLUCENT);

glSurfaceView.setBackgroundResource(R.drawable.my

_background);

glSurfaceView.setZOrderOnTop(true);

glSurfaceView.setRenderer(...);

glSurfaceView.setRenderMode(...);*/

//this.setEGLConfigChooser(8, 8, 8, 8,

16, 0);

//this.getHolder().setFormat(PixelFormat.TRANSLUC

ENT);

598

//this.setBackgroundResource(R.drawable.splash);

//this.setZOrderOnTop(true);

//glSurfaceView.setRenderer(...);

//glSurfaceView.setRenderMode(...);

}

@Override

public boolean onTouchEvent(MotionEvent v) {

// MotionEvent reports input details from

the touch screen

// and other input controls. In this

case, we are only

// interested in events where the touch

position changed.

/*

* initx_stick =

esRender.getWidthObject()-esRender.getRadius();

* inity_stick = 0.0f; _touchingPoint.x =

(int) initx_stick;

* _touchingPoint.y= (int) inity_stick;

*

* _pointerPosition.x = (int)

initx_stick; _pointerPosition.y= (int)

* inity_stick;

*/

update(v);

float currentX = v.getX();

float currentY = v.getY();

float deltaX, deltaY;

// float scalingFactor = 0.50f /

((esRender.xMax > esRender.yMax) ?

// esRender.yMax

// : esRender.xMax);

switch (v.getAction()) {

case MotionEvent.ACTION_DOWN:

//Log.v("Test Action Down",

"action down working");

// esRender.setX_anim_stick(-

esRender.getRadius());

// esRender.setY_anim_stick(0.0f);

// membuat animasi pergerakan

tombol joystick

// bound to a box disekitar

joystick

/*

* if( currentX >=

_touchingPoint.x-esRender.getRadius() && currentX

*

599

_touchingPoint.x+esRender.getRadius()){

*

* if( currentY >=

_touchingPoint.y-esRender.getRadius() && currentY

* =

_touchingPoint.x-esRender.getRadius() && currentX

* =

_touchingPoint.y-esRender.getRadius() && currentY

*

600

"action working");

// esRender.setX_anim_stick(0.0f);

// esRender.setY_anim_stick(-

esRender.getRadius());

// requestRender();

// case MotionEvent.ACTION_MOVE:

// Log.v("Test Action

ACTION_POINTER_DOWN", "action working");

// requestRender();

// case MotionEvent.ACTION_UP:

// Log.v("Test Action Up", "action

up working");

// requestRender();

case MotionEvent.ACTION_MOVE:

// Modify rotational angles

according to movement

/*deltaX = currentX - previousX;

deltaY = currentY - previousY;

//

esRender.setspeedX(esRender.getspeedX()+

(deltaX/getWidth()));

//

esRender.setspeedY(esRender.getspeedY()+

(deltaY/getHeight()));

esRender.setspeedX(esRender.getspeedX() + deltaX

/ 100);

esRender.setspeedY(esRender.getspeedY() + deltaY

/ 100);

*/

//requestRender();

}

// Save current x, y

previousX = currentX;

previousY = currentY;

return true; // Event handled

// break;

}

private MotionEvent lastEvent;

public void update(MotionEvent event) {

// initx_stick = 1066.0f-

1.5f*esRender.getRadius();

// inity_stick

=0.5f*esRender.getRadius();

if (event == null && lastEvent == null) {

return;

} else if (event == null && lastEvent !=

null) {

event = lastEvent;

} else {

601

lastEvent = event;

}

// drag drop

if (event.getAction() ==

MotionEvent.ACTION_DOWN) {

_dragging = true;

flag_first = 0;

} else if (event.getAction() ==

MotionEvent.ACTION_UP) {

_dragging = false;

}

// penanda untuk menyimpan koordinat yang

pertama kali diklik

if (_dragging) {

// get the pos

_touchingPoint.x = (int)

event.getX();

_touchingPoint.y = (int)

event.getY();

esRender.setX_touch(_touchingPoint.x);

esRender.setY_touch(esRender.getMyheight() -

_touchingPoint.y);

esRender.setJarak_center((float)

((Math.pow(_touchingPoint.x

-

(esRender.getMywidth() - 2 * esRender.getRadius()),

2)) + (Math

.pow(esRender.getMyheight() - _touchingPoint.y -

2

*

esRender.getRadius(), 2))));

if(esRender.getJarak_center()=

(esRender.getMywidth() - 200)

&& _touchingPoint.y

>= (esRender.getMyheight() - 200)

&& (((Math.pow(

602

_touchingPoint.x

- (esRender.getMywidth() - 2 * esRender

.getRadius()), 2)) +

(Math.pow(

esRender.getMyheight() - _touchingPoint.y - 2

* esRender.getRadius(), 2))) > Math.pow(

0.5

* esRender.getRadius(), 2))) {

Music.playOnce(esRender.context, R.raw.fb);

// membuat penanda untuk

mendapatkan point awal touch

if (flag_first == 0) {

esRender.setX_pointer_awal(_touchingPoint.x);

mypointer_awal_x =

esRender.getX_pointer_awal();

esRender.setY_pointer_awal(_touchingPoint.y);

mypointer_awal_y =

esRender.getY_pointer_awal();

flag_first = 1;

}

// kodisi jika titik awal

sama dengan titik pointer

if ((mypointer_awal_x ==

_touchingPoint.x)

&&

(mypointer_awal_y == _touchingPoint.y)) {

mypointer_awal_x =

esRender.getMywidth() - 100;

mypointer_awal_y =

esRender.getMyheight() - 100;

}

esRender.setX_pointer(_touchingPoint.x);

esRender.setY_pointer(_touchingPoint.y);

esRender.setX_lebar_layar(esRender.getMywidth());

esRender.setY_tinggi_layar(esRender.getMyheight()

);

// get the angle

double myangle = -Math

.atan2(_touchingPoint.y - mypointer_awal_y,

603

_touchingPoint.x - mypointer_awal_x)

/ (Math.PI

/ 180);

esRender.setSudut_pointer((float) myangle);

esRender.setX_anim_stick((float) (26.0f *

Math.cos(myangle

* (Math.PI

/ 180))));

esRender.setY_anim_stick((float) (26.0f *

Math.sin(myangle

* (Math.PI

/ 180))));

// set arah joystick

if ((float) myangle >= 45

&& (float) myangle

604

+

(esRender.getWidthObject() / 2));

esRender.setY_player(((esRender.getNumberRow()

-

esRender.getPositionRow() - 1) * esRender

.getWidthObject())

+

(esRender.getWidthObject() / 2));

} else if (((float)

myangle >= 0 && (float) myangle < 45)

|| ((float)

myangle >= -44 && (float) myangle

605

*

esRender.setY_anim_stick(_touchingPoint.y);

*/

// bound to a box

if (_touchingPoint.x < 400) {

_touchingPoint.x = 400;

}

if (_touchingPoint.x > 450) {

_touchingPoint.x = 450;

}

if (_touchingPoint.y < 240) {

_touchingPoint.y = 240;

}

if (_touchingPoint.y > 290) {

_touchingPoint.y = 290;

}

// get the angle

double angle =

Math.atan2(_touchingPoint.y - inity_stick,

_touchingPoint.x -

initx_stick) / (Math.PI / 180);

// Move the beetle in proportion

to how far

// the joystick is dragged from

its center

_pointerPosition.y +=

Math.sin(angle * (Math.PI / 180))

* (_touchingPoint.x

/ 70);

_pointerPosition.x +=

Math.cos(angle * (Math.PI / 180))

* (_touchingPoint.x

/ 70);

//

esRender.setX_anim_stick(_touchingPoint.x);

//

esRender.setY_anim_stick(_touchingPoint.y);

// make the pointer go thru

if (_pointerPosition.x > 480) {

_pointerPosition.x = 0;

}

if (_pointerPosition.x < 0) {

_pointerPosition.x = 480;

}

if (_pointerPosition.y > 320) {

_pointerPosition.y = 0;

}

if (_pointerPosition.y < 0) {

_pointerPosition.y = 320;

}

} else if (!_dragging) {

606

flag_first = 0;

// Snap back to center when the

joystick is released

_touchingPoint.x = (int)

initx_stick;

_touchingPoint.y = (int)

inity_stick;

esRender.setX_anim_stick(0.0f);

esRender.setY_anim_stick(0.0f);

// shaft.alpha = 0;

}

}

// Key-up event handler

@Override

public boolean onKeyUp(int keyCode, KeyEvent

event) {

switch (keyCode) {

case KeyEvent.KEYCODE_A: // mengurangi

kecepatan object

if ((esRender.getspeedX() - 0.05f

> 0)) {

esRender.setspeedX(esRender.getspeedX() - 0.05f);

}

if ((esRender.getspeedX() - 0.05f

< 0)) {

esRender.setspeedX(0.0f);

}

if ((esRender.getspeedY() - 0.05f

>= 0)) {

esRender.setspeedY(esRender.getspeedY() - 0.05f);

}

if ((esRender.getspeedY() - 0.05f

< 0)) {

esRender.setspeedY(0.0f);

}

Log.v("Test Action KEYCODE_A",

"action working");

break;

case KeyEvent.KEYCODE_T: // up

if (esRender.getNavigate() == 0 &&

esRender.goForward())

esRender.setPositionRow(esRender.getPositionRow()

- 1);

else if (esRender.getNavigate() ==

1 && esRender.goForward())

esRender.setPositionCol(esRender.getPositionCol()

+ 1);



607

esRender.setPositionRow(esRender.getPositionRow()

+ 1);



esRender.setPositionCol(esRender.getPositionCol()

- 1);

Log.v("Test Action KEYCODE_T",

"action working");

esRender.setX_player((esRender.getPositionCol() *

esRender

.getWidthObject())

+ (esRender.getWidthObject() / 2));

esRender.setY_player(((esRender.getNumberRow()

-

esRender.getPositionRow() - 1) * esRender

.getWidthObject()) + (esRender.getWidthObject() /

2));

break;

case KeyEvent.KEYCODE_G:

Log.v("Test Action KEYCODE_G",

"action working");

break;

case KeyEvent.KEYCODE_H: // right

esRender.setNavigate(esRender.getNavigate() + 1);

Log.v("Test Action KEYCODE_H",

"action working");

break;

case KeyEvent.KEYCODE_F: // left

esRender.setNavigate(esRender.getNavigate() - 1);

Log.v("Test Action KEYCODE_F",

"action working");

break;

}

if (esRender.getNavigate() < 0)

esRender.setNavigate(3);

esRender.setNavigate(esRender.getNavigate() % 4);

return true; // Event handled

}

}

ESText.java

608

// This is a OpenGL ES 1.0 dynamic font rendering

system. It loads actual font

// files, generates a font map (texture) from them,

and allows rendering of

// text strings.

//

// NOTE: the rendering portions of this class uses a

sprite batcher in order

// provide decent speed rendering. Also, rendering

assumes a BOTTOM-LEFT

// origin, and the (x,y) positions are relative to

that, as well as the

// bottom-left of the string to render.


import javax.microedition.khronos.opengles.GL10;

import android.content.res.AssetManager;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Typeface;

import android.opengl.GLUtils;

public class ESText {

//--Constants--//

public final static int CHAR_START = 32;

// First Character (ASCII Code)

public final static int CHAR_END = 126;

// Last Character (ASCII Code)

public final static int CHAR_CNT = ( ( ( CHAR_END

- CHAR_START ) + 1 ) + 1 ); // Character Count

(Including Character to use for Unknown)

public final static int CHAR_NONE = 32;

// Character to Use for Unknown (ASCII Code)

public final static int CHAR_UNKNOWN = ( CHAR_CNT

- 1 ); // Index of the Unknown Character

public final static int FONT_SIZE_MIN = 6;

// Minumum Font Size (Pixels)

public final static int FONT_SIZE_MAX = 180;

// Maximum Font Size (Pixels)

public final static int CHAR_BATCH_SIZE = 100;

// Number of Characters to Render Per Batch

//--Members--//

GL10 gl;

// GL10 Instance

AssetManager assets;

// Asset Manager

SpriteBatch batch;

// Batch Renderer

int fontPadX, fontPadY;

609

// Font Padding (Pixels; On Each Side, ie. Doubled on

Both X+Y Axis)

float fontHeight;

// Font Height (Actual; Pixels)

float fontAscent;

// Font Ascent (Above Baseline; Pixels)

float fontDescent;

// Font Descent (Below Baseline; Pixels)

int textureId;

// Font Texture ID [NOTE: Public for Testing Purposes

Only!]

int textureSize;

// Texture Size for Font (Square) [NOTE: Public for

Testing Purposes Only!]

TextureRegion textureRgn;

// Full Texture Region

float charWidthMax;

// Character Width (Maximum; Pixels)

float charHeight;

// Character Height (Maximum; Pixels)

final float[] charWidths;

// Width of Each Character (Actual; Pixels)

TextureRegion[] charRgn;

// Region of Each Character (Texture Coordinates)

int cellWidth, cellHeight;

// Character Cell Width/Height

int rowCnt, colCnt;

// Number of Rows/Columns

float scaleX, scaleY;

// Font Scale (X,Y Axis)

float spaceX;

// Additional (X,Y Axis) Spacing (Unscaled)

//--Constructor--//

// D: save GL instance + asset manager, create

arrays, and initialize the members

// A: gl - OpenGL ES 10 Instance

public ESText(GL10 gl, AssetManager assets) {

this.gl = gl;

// Save the GL10 Instance

this.assets = assets;

// Save the Asset Manager Instance

batch = new SpriteBatch( gl, CHAR_BATCH_SIZE );

// Create Sprite Batch (with Defined Size)

charWidths = new float[CHAR_CNT];

// Create the Array of Character Widths

charRgn = new TextureRegion[CHAR_CNT];

// Create the Array of Character Regions

// initialize remaining members

fontPadX = 0;

fontPadY = 0;

610

fontHeight = 0.0f;

fontAscent = 0.0f;

fontDescent = 0.0f;

textureId = -1;

textureSize = 0;

charWidthMax = 0;

charHeight = 0;

cellWidth = 0;

cellHeight = 0;

rowCnt = 0;

colCnt = 0;

scaleX = 1.0f;

// Default Scale = 1 (Unscaled)

scaleY = 1.0f;

// Default Scale = 1 (Unscaled)

spaceX = 0.0f;

}

//--Load Font--//

// description

// this will load the specified font file,

create a texture for the defined

// character range, and setup all required

values used to render with it.

// arguments:

// file - Filename of the font (.ttf, .otf) to

use. In 'Assets' folder.

// size - Requested pixel size of font (height)

// padX, padY - Extra padding per character

(X+Y Axis); to prevent overlapping characters.

public boolean load(String file, int size, int

padX, int padY) {

// setup requested values

fontPadX = padX;

// Set Requested X Axis Padding

fontPadY = padY;

// Set Requested Y Axis Padding

// load the font and setup paint instance for

drawing

Typeface tf = Typeface.createFromAsset( assets,

file ); // Create the Typeface from Font File

Paint paint = new Paint();

// Create Android Paint Instance

paint.setAntiAlias( true );

// Enable Anti Alias

paint.setTextSize( size );

// Set Text Size

paint.setColor( 0xffffffff );

// Set ARGB (White, Opaque)

paint.setTypeface( tf );

// Set Typeface

611

// get font metrics

Paint.FontMetrics fm = paint.getFontMetrics();

// Get Font Metrics

fontHeight = (float)Math.ceil( Math.abs(

fm.bottom ) + Math.abs( fm.top ) ); // Calculate

Font Height

fontAscent = (float)Math.ceil( Math.abs(

fm.ascent ) ); // Save Font Ascent

fontDescent = (float)Math.ceil( Math.abs(

fm.descent ) ); // Save Font Descent

// determine the width of each character

(including unknown character)

// also determine the maximum character width

char[] s = new char[2];

// Create Character Array

charWidthMax = charHeight = 0;

// Reset Character Width/Height Maximums

float[] w = new float[2];

// Working Width Value

int cnt = 0;

// Array Counter

for ( char c = CHAR_START; c charWidthMax )

// IF Width Larger Than Max Width

charWidthMax = charWidths[cnt];

// Save New Max Width

cnt++;

// Advance Array Counter

}

s[0] = CHAR_NONE;

// Set Unknown Character

paint.getTextWidths( s, 0, 1, w );

// Get Character Bounds

charWidths[cnt] = w[0];

// Get Width

if ( charWidths[cnt] > charWidthMax )

// IF Width Larger Than Max Width

charWidthMax = charWidths[cnt];

// Save New Max Width

cnt++;

// Advance Array Counter

// set character height to font height

charHeight = fontHeight;

// Set Character Height

// find the maximum size, validate, and setup

cell sizes

cellWidth = (int)charWidthMax + ( 2 * fontPadX

); // Set Cell Width

cellHeight = (int)charHeight + ( 2 * fontPadY

612

); // Set Cell Height

int maxSize = cellWidth > cellHeight ?

cellWidth : cellHeight; // Save Max Size

(Width/Height)

if ( maxSize < FONT_SIZE_MIN || maxSize >

FONT_SIZE_MAX ) // IF Maximum Size Outside Valid

Bounds

return false;

// Return Error

// set texture size based on max font size

(width or height)

// NOTE: these values are fixed, based on the

defined characters. when

// changing start/end characters

(CHAR_START/CHAR_END) this will need adjustment too!

if ( maxSize

613

s[0] = c;

// Set Character to Draw

canvas.drawText( s, 0, 1, x, y, paint );

// Draw Character

x += cellWidth;

// Move to Next Character

if ( ( x + cellWidth - fontPadX ) >

textureSize ) { // IF End of Line Reached

x = fontPadX;

// Set X for New Row

y += cellHeight;

// Move Down a Row

}

}

s[0] = CHAR_NONE;

// Set Character to Use for NONE

canvas.drawText( s, 0, 1, x, y, paint );

// Draw Character

// generate a new texture

int[] textureIds = new int[1];

// Array to Get Texture Id

gl.glGenTextures( 1, textureIds, 0 );

// Generate New Texture

textureId = textureIds[0];

// Save Texture Id

// setup filters for texture

gl.glBindTexture( GL10.GL_TEXTURE_2D, textureId

); // Bind Texture

gl.glTexParameterf( GL10.GL_TEXTURE_2D,

GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST ); //

Set Minification Filter


GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR ); // Set

Magnification Filter


GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE ); //

Set U Wrapping


GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE ); //

Set V Wrapping

// load the generated bitmap onto the texture

GLUtils.texImage2D( GL10.GL_TEXTURE_2D, 0,

bitmap, 0 ); // Load Bitmap to Texture

gl.glBindTexture( GL10.GL_TEXTURE_2D, 0 );

// Unbind Texture

// release the bitmap

bitmap.recycle();

// Release the Bitmap

// setup the array of character texture regions

x = 0;

// Initialize X

y = 0;

// Initialize Y

for ( int c = 0; c < CHAR_CNT; c++ ) {

614

// FOR Each Character (On Texture)

charRgn[c] = new TextureRegion( textureSize,

textureSize, x, y, cellWidth-1, cellHeight-1 ); //

Create Region for Character

x += cellWidth;

// Move to Next Char (Cell)

if ( x + cellWidth > textureSize ) {

x = 0;

// Reset X Position to Start

y += cellHeight;

// Move to Next Row (Cell)

}

}

// create full texture region

textureRgn = new TextureRegion( textureSize,

textureSize, 0, 0, textureSize, textureSize ); //

Create Full Texture Region

// return success

return true;

// Return Success

}

//--Begin/End Text Drawing--//

// D: call these methods before/after

(respectively all draw() calls using a text instance

// NOTE: color is set on a per-batch basis, and

fonts should be 8-bit alpha only!!!

// A: red, green, blue - RGB values for font

(default = 1.0)

// alpha - optional alpha value for font

(default = 1.0)

// R: [none]

public void begin() {

begin( 1.0f, 1.0f, 1.0f, 1.0f );

// Begin with White Opaque

}

public void begin(float alpha) {

begin( 1.0f, 1.0f, 1.0f, alpha );

// Begin with White (Explicit Alpha)

}

public void begin(float red, float green, float

blue, float alpha) {

gl.glColor4f( red, green, blue, alpha );

// Set Color+Alpha

gl.glBindTexture( GL10.GL_TEXTURE_2D, textureId

); // Bind the Texture

batch.beginBatch();

// Begin Batch

}

public void end() {

batch.endBatch();

// End Batch

gl.glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );

// Restore Default Color/Alpha

}

//--Draw Text--//

615

// D: draw text at the specified x,y position

// A: text - the string to draw

// x, y - the x,y position to draw text at

(bottom left of text; including descent)

// R: [none]

public void draw(String text, float x, float y) {

float chrHeight = cellHeight * scaleY;

// Calculate Scaled Character Height

float chrWidth = cellWidth * scaleX;

// Calculate Scaled Character Width

int len = text.length();

// Get String Length

x += ( chrWidth / 2.0f ) - ( fontPadX * scaleX

); // Adjust Start X

y += ( chrHeight / 2.0f ) - ( fontPadY * scaleY

); // Adjust Start Y

for ( int i = 0; i < len; i++ ) {

// FOR Each Character in String

int c = (int)text.charAt( i ) - CHAR_START;

// Calculate Character Index (Offset by First Char in

Font)

if ( c < 0 || c >= CHAR_CNT )

// IF Character Not In Font

c = CHAR_UNKNOWN;

// Set to Unknown Character Index

batch.drawSprite( x, y, chrWidth, chrHeight,

charRgn[c] ); // Draw the Character

x += ( charWidths[c] + spaceX ) * scaleX;

// Advance X Position by Scaled Character Width

}

}

//--Draw Text Centered--//

// D: draw text CENTERED at the specified x,y

position

// A: text - the string to draw

// x, y - the x,y position to draw text at

(bottom left of text)

// R: the total width of the text that was drawn

public float drawC(String text, float x, float y)

{

float len = getLength( text );

// Get Text Length

draw( text, x - ( len / 2.0f ), y - (

getCharHeight() / 2.0f ) ); // Draw Text Centered

return len;

// Return Length

}

public float drawCX(String text, float x, float y)

{

float len = getLength( text );

// Get Text Length

draw( text, x - ( len / 2.0f ), y );

// Draw Text Centered (X-Axis Only)

return len;

// Return Length

}

public void drawCY(String text, float x, float y)

{

616

draw( text, x, y - ( getCharHeight() / 2.0f )

); // Draw Text Centered (Y-Axis Only)

}

//--Set Scale--//

// D: set the scaling to use for the font

// A: scale - uniform scale for both x and y axis

scaling

// sx, sy - separate x and y axis scaling

factors

// R: [none]

public void setScale(float scale) {

scaleX = scaleY = scale;

// Set Uniform Scale

}

public void setScale(float sx, float sy) {

scaleX = sx;

// Set X Scale

scaleY = sy;

// Set Y Scale

}

//--Get Scale--//

// D: get the current scaling used for the font

// A: [none]

// R: the x/y scale currently used for scale

public float getScaleX() {

return scaleX;

// Return X Scale

}

public float getScaleY() {

return scaleY;

// Return Y Scale

}

//--Set Space--//

// D: set the spacing (unscaled; ie. pixel size)

to use for the font

// A: space - space for x axis spacing

// R: [none]

public void setSpace(float space) {

spaceX = space;

// Set Space

}

//--Get Space--//

// D: get the current spacing used for the font

// A: [none]

// R: the x/y space currently used for scale

public float getSpace() {

return spaceX;

// Return X Space

}

//--Get Length of a String--//

// D: return the length of the specified string if

rendered using current settings

// A: text - the string to get length for

// R: the length of the specified string (pixels)

617

public float getLength(String text) {

bab 9 project pilihan - universitas brawijaya · 2016. 12. 31. · bab 9 project pilihan 9.1 random...

Documents