NAMA : Rosyidah Wildania

NRP : 2210141041
DOSEN : Moch Mobed Bachtiar
TANGGAL : 3 April 2017
 Obyek Grafik 2D

I. Tujuan
Mahasiswa dapat menggambar objek dan mentransformasikan objek tersebut.
Mahasiswa bisa membuat objek bergerak

II. Dasar Teori

1. Struktur Titik dan Vektor
Struktur data dari titik 2D pada opengl adalah

Struktur data dari vektor 2D

Perubahan titik dan vektor

2. Fungsi point2vector
Fungsi ini digunakan untuk memindahkan tipe data titik menjadi tipe data
vektor. Hal ini sangat berguna untuk operasional matrik yang digunakan dalam
melakukan transformasi dan pengolahan matrik pada grafika komputer.
 3. Fungsi vector2point
Fungsi ini digunakan untuk memindahkan tipe data vektor menjadi tipe data titik.
Hal ini sangat berguna untuk penyajian grafis setelah proses pengolahan matrik yang
dikenakan pada obyek 2D.

III. Alat dan Bahan

1. PC atau Laptop
2. Visual Studio dengan OpenGL library

IV. Hasil
Tugas 1 : Menggambar Orbit Bumi dan bulan saat mengelilingi Matahari
Tugas 2 : Menggambar Sinyal Osiloskop
#include <glut.h>
#include <math.h>

typedef struct {
float x;
float y;
} point2D_t;

typedef struct {
float r;
float g;
float b;
} color_t;

typedef struct {
float v[3];
} vector2D_t;

typedef struct {
float m[3][3];
} matrix2D_t;

void setColor(color_t col) {

glColor3f(col.r , col.g , col.b);
}

void setColor(float r, float g, float b) {

glColor3f(r, g, b);
}

vector2D_t point2vector (point2D_t pnt){

vector2D_t vec;
vec.v[0]=pnt.x;
vec.v[1]=pnt.y;
vec.v[2]=1.;
return vec;
}

point2D_t vector2point (vector2D_t vec){

point2D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
return pnt;
}

matrix2D_t createIdentity(void) {
matrix2D_t u;
int i, j;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++) u.m[i][j]=0;
u.m[i][i]=1.;
}
return u;
}
matrix2D_t operator*(matrix2D_t a, matrix2D_t b) {
matrix2D_t c; // c=a*b
int i, j, k;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
c.m[i][j]=0;
for (int k= 0; k < 3; k++) {
c.m[i][j]+=a.m[i][k]*b.m[k][j];
}
}
}
return c;
}

vector2D_t operator*(matrix2D_t a, vector2D_t b) {

vector2D_t c; // c=a*b
int i, j;
for (int i = 0; i < 3; i++) {
c.v[i]=0;
for (int j = 0; j < 3; j++) {
c.v[i]+=a.m[i][j]*b.v[j];
}
}
return c;
}

matrix2D_t translation(float dx, float dy){

matrix2D_t trans = createIdentity();
trans.m[0][2]=dx;
trans.m[1][2]=dy;
return trans;
}

matrix2D_t scallingMTX (float mx, float my){

matrix2D_t scale = createIdentity();
scale.m[0][0]=mx;
scale.m[1][1]=my;
return scale;
}

matrix2D_t rotation (float theta) {

matrix2D_t rotate= createIdentity();
float cs = cos(theta);
float sn = sin(theta);
rotate.m[0][0]=cs;
rotate.m[0][1]=-sn;
rotate.m[1][0]=sn;
rotate.m[1][1]=cs;
return rotate;
}
matrix2D_t rotation1(float theta, point2D_t p1){
matrix2D_t rotate= createIdentity();
float cs = cos(theta);
float sn = sin(theta);
rotate.m[0][0]=cs*p1.x;
rotate.m[0][1]=-sn*p1.y;
rotate.m[1][0]=sn*p1.x;
rotate.m[1][1]=cs*p1.y;
return rotate;
}
void transform2D (point2D_t p[], matrix2D_t mat, int n){
vector2D_t vec;
for (int i = 0; i < n; i++) {
vec = point2vector (p[i]);
vec = mat*vec;
p[i]=vector2point(vec);
}
}

void drawPolyline (point2D_t p[], int n) {

int i;
glBegin(GL_LINE_STRIP);
for (int i = 0; i < n; i++)
{
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void drawPolygon(point2D_t p[],int n){

int i;
glBegin(GL_LINE_LOOP);
for(i=0;i<n;i++)
{
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void fillPolygon(point2D_t p[],int n, color_t col){

int i;
glBegin(GL_POLYGON);
setColor(col);
for(i=0;i<n;i++)
{
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void gradatePolygon(point2D_t p[],int n, color_t col[]){

int i;
glBegin(GL_POLYGON);
for(int i=0;i<n;i++)
{
setColor(col[i]);
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void drawcircle (point2D_t p[], float r, int n){

float a=6.28/n;
for (int i = 0; i < n; i++)
{
p[i].x=r*(float)cos((float)i*a);
p[i].y=r*(float)sin((float)i*a);
}
drawPolygon(p,n);
}
void drawcircle1 (point2D_t p[], point2D_t p0, float r, int n){
float a=6.28/n;
for (int i = 0; i < n; i++)
{
p[i].x=p0.x + r*(float)cos((float)i*a);
p[i].y=p0.y + r*(float)sin((float)i*a);
}
drawPolygon(p,n);
}

void drawEllipse (point2D_t p[], float r1, float r2, int n){
float a=6.28/n;
for (int i = 0; i < n; i++)
{
p[i].x=r1*(float)cos((float)i*a);
p[i].y=r2*(float)sin((float)i*a);
}
drawPolygon(p,n);
}

void centerPolygon(point2D_t p[],point2D_t pc,color_t col,color_t colp,int

n){
float a=6.28/n;
for(int i=0;i<n;i++)
{
glBegin(GL_LINE_LOOP);
setColor(colp);
glVertex2f(pc.x,pc.y);
p[i].x = pc.x + 50*(float)cos((float)i*a);
p[i].y = pc.y + 50*(float)sin((float)i*a);
setColor(col);
glVertex2f(p[i].x,p[i].y);
glEnd();
}
}

void userdraw(){
static float tick, tick1, tick2;
matrix2D_t mat, mat1, mat2;
color_t war={0,0,1};
color_t war1={0,1,1};

point2D_t lingkaran1[360], lingkaran2[360], lingkaran3[360],

lingkaran4[360];
point2D_t pusling1={300,0}, pusling2={200,0}, pusling3={250,0};
point2D_t kotak[4]={{-100,0}, {-150,0}, {-150,-30}, {-100,-30}};
point2D_t b[3]={{-20,60}, {0,120}, {20,60}};
point2D_t c[3]={{-20,-60}, {0,-120}, {20,-60}};
point2D_t d[3]={{60,20}, {120,0}, {60,-20}};
point2D_t e[3]={{-60,20}, {-120,0}, {-60,-20}};

drawcircle(lingkaran2,200,360); // garis revolusi

drawcircle1(lingkaran3, pusling2, 30,360); // bumi
drawcircle1(lingkaran4, pusling3, 15,360); // bulan

mat = rotation (0+tick);

transform2D (b,mat,3);
transform2D (c,mat,3);
transform2D (d,mat,3);
transform2D (e,mat,3);
 drawcircle (lingkaran1, 50,360); // matahari
drawPolygon (b,3);
drawPolygon (c,3);
drawPolygon (d,3);
drawPolygon (e,3);

mat1 = rotation (0+tick1);

transform2D (lingkaran3, mat1, 360);

mat2 = rotation (0+tick2);

transform2D(lingkaran4, mat2, 360);

fillPolygon (lingkaran3, 360, war);

fillPolygon (lingkaran4,360, war1);

tick+=0.01;
tick1+=0.001;
tick2+=0.001;
}

void putarbulan(){
static float tick, tick1, tick2;
matrix2D_t mat, mat1, mat2;
color_t war={0,0,1};
color_t war1={0,1,1};

point2D_t lingkaran1[360], lingkaran2[360], lingkaran3[360],

lingkaran4[360];
point2D_t pusling1={300,0}, pusling2={200,0}, pusling3={250,0};
drawcircle1(lingkaran3, pusling2, 50,360); // bumi

void sinyal() {
static int a=0;
point2D_t p[360];
for(int i=0;i<360;i++){
float s=(i+a)/57.3;
p[i].x=i;
p[i].y=sin(16*s)*(1+0.5*sin(2*s));
}
setColor(1,1,1);
drawPolyline(p,360);
a++;
}
 void Display(){
glClear(GL_COLOR_BUFFER_BIT);
//userdraw();
//putarbulan();
sinyal();
glutSwapBuffers();
}

int main(int argc, char **argv){

glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
glutCreateWindow("Teknik Komputer - TRANSFORMASI ORBIT");
glClearColor(0.0,0.0,0.0,1.0);
//glClearColor(1.0,1.0,1.0,0.0); // ORBIT
//gluOrtho2D(-320.,320.,-240.,240.); // bunga ros
gluOrtho2D (0,360,-2,2); // sinyal sinus
//gluOrtho2D(-1.,1.,-1.,1.);
//gluOrtho2D(0.,640.,0.,480.); /// ASLI
//gluOrtho2D(-1,1,-1,1);
//gluOrtho2D(-360.,360.,-240.,240.); //center polygon
glutIdleFunc(Display);
glutDisplayFunc(Display);
glutMainLoop();
return 0;
}

V. ANALISA
Dari percobaan yang telah dilakukan, diketahui bahwa untuk membuat sebuah
gambar yang bergerak, digunakan fungsi tick. Kemudian, jika kita ingin membuat
gambar tersebut berputar dapat menggunakan fungsi transformasi seperti pada
contoh diatas. Selain itu, terdapat fungsi baru yang digunakan pada praktikum ini,
antara lain matrix2d, vector2d. dari fungsi matrix dan vector maka dapat dibentuk
sebuah tranformasi 2D.
Untuk membuat sebuah sinyal sinus, rumus fungsi utamanya yaitu
p[i].y=sin(16*s)*(1+0.5*sin(2*s));

Ortho pada pembentukan orbit berbeda dengan sinyal sinus. Pada sinyal sinus,
menggunakan ortho gluOrtho2D (0,360,-2,2);

VI. KESIMPULAN
Dari percobaan yang telah dilakukan dapat disimpulkan bahwa :
Untuk membuat transformasi2D , digunakan fungsi matrix dan vector
Untuk membuat sebuah sinyal sinus, rumus fungsinya yaitu
p[i].y=sin(16*s)*(1+0.5*sin(2*s));