# Basic Transformations in OPENGL

Transformations play a very important role in manipulating objects on screen. It should be noted that here the algorithms will be implemented in code and the built-in functions will not be used to give a good understanding of how the algorithms work.
Also note that all transformations are implemented in 2D.
There are three basic kinds of Transformations in Computer Graphics:
1. Translation
2. Rotation
3. Scaling Algorithms

1. Translation : Translation refers to moving an object to a different position on screen.
```Formula:  X = x + tx
Y = y + ty
where tx and ty are translation coordinates

The OpenGL function is glTranslatef( tx, ty, tz );```
2. Rotation : Rotation refers to rotating a point.
```Formula:  X = xcosA - ysinA
Y = xsinA + ycosA,
A is the angle of rotation.
The above formula will rotate the point around the origin.
To rotate around a different point, the formula:
X = cx + (x-cx)*cosA - (y-cy)*sinA,
Y = cx + (x-cx)*sinA + (y-cy)*cosA,
cx, cy is centre coordinates,
A is the angle of rotation.

The OpenGL function is glRotatef (A, x, y, z). ```
3. Scaling : Scaling refers to zooming in and out an object in different scales across axes.
```Formula: X = x*sx
Y = y*sy,    sx, sy being scaling factors.

The OpenGL function is glScalef(float x, float y, float z)
```

Note: If combined transformations is to be applied, follow the order: translate, rotate, scale

Implementation

 `// C code to implement basic ` `// transformations in OPENGL ` `#include ` `#include ` `#include ` `#include ` ` `  `// window size ` `#define maxWD 640 ` `#define maxHT 480 ` ` `  `// rotation speed ` `#define thetaSpeed 0.05 ` ` `  `// this creates delay between two actions ` `void` `delay(unsigned ``int` `mseconds) ` `{ ` `    ``clock_t` `goal = mseconds + ``clock``(); ` `    ``while` `(goal > ``clock``()) ` `        ``; ` `} ` ` `  `// this is a basic init for the glut window ` `void` `myInit(``void``) ` `{ ` `    ``glClearColor(1.0, 1.0, 1.0, 0.0); ` `    ``glMatrixMode(GL_PROJECTION); ` `    ``glLoadIdentity(); ` `    ``gluOrtho2D(0.0, maxWD, 0.0, maxHT); ` `    ``glClear(GL_COLOR_BUFFER_BIT); ` `    ``glFlush(); ` `} ` ` `  `// this function just draws a point ` `void` `drawPoint(``int` `x, ``int` `y) ` `{ ` `    ``glPointSize(7.0); ` `    ``glColor3f(0.0f, 0.0f, 1.0f); ` `    ``glBegin(GL_POINTS); ` `    ``glVertex2i(x, y); ` `    ``glEnd(); ` `} ` ` `  `void` `rotateAroundPt(``int` `px, ``int` `py, ``int` `cx, ``int` `cy) ` `{ ` `    ``float` `theta = 0.0; ` `    ``while` `(1) { ` `        ``glClear(GL_COLOR_BUFFER_BIT); ` `        ``int` `xf, yf; ` ` `  `        ``// update theta anticlockwise rotation ` `        ``theta = theta + thetaSpeed; ` ` `  `        ``// check overflow ` `        ``if` `(theta >= (2.0 * 3.14159)) ` `            ``theta = theta - (2.0 * 3.14159); ` ` `  `        ``// actual calculations.. ` `        ``xf = cx + (``int``)((``float``)(px - cx) * ``cos``(theta)) ` `             ``- ((``float``)(py - cy) * ``sin``(theta)); ` `        ``yf = cy + (``int``)((``float``)(px - cx) * ``sin``(theta)) ` `             ``+ ((``float``)(py - cy) * ``cos``(theta)); ` ` `  `        ``// drawing the centre point ` `        ``drawPoint(cx, cy); ` ` `  `        ``// drawing the rotating point ` `        ``drawPoint(xf, yf); ` `        ``glFlush(); ` `        ``// creating a delay ` `        ``// so that the point can be noticed ` `        ``delay(10); ` `    ``} ` `} ` ` `  `// this function will translate the point ` `void` `translatePoint(``int` `px, ``int` `py, ``int` `tx, ``int` `ty) ` `{ ` `    ``int` `fx = px, fy = py; ` `    ``while` `(1) { ` `        ``glClear(GL_COLOR_BUFFER_BIT); ` ` `  `        ``// update ` `        ``px = px + tx; ` `        ``py = py + ty; ` ` `  `        ``// check overflow to keep point in screen ` `        ``if` `(px > maxWD || px < 0 || py > maxHT || py < 0) { ` `            ``px = fx; ` `            ``py = fy; ` `        ``} ` ` `  `        ``drawPoint(px, py); ``// drawing the point ` ` `  `        ``glFlush(); ` `        ``// creating a delay ` `        ``// so that the point can be noticed ` `        ``delay(10); ` `    ``} ` `} ` ` `  `// this function draws ` `void` `scalePoint(``int` `px, ``int` `py, ``int` `sx, ``int` `sy) ` `{ ` `    ``int` `fx, fy; ` `    ``while` `(1) { ` `        ``glClear(GL_COLOR_BUFFER_BIT); ` ` `  `        ``// update ` `        ``fx = px * sx; ` `        ``fy = py * sy; ` ` `  `        ``drawPoint(fx, fy); ``// drawing the point ` ` `  `        ``glFlush(); ` `        ``// creating a delay ` `        ``// so that the point can be noticed ` `        ``delay(500); ` ` `  `        ``glClear(GL_COLOR_BUFFER_BIT); ` ` `  `        ``// update ` `        ``fx = px; ` `        ``fy = py; ` ` `  `        ``// drawing the point ` `        ``drawPoint(fx, fy); ` `        ``glFlush(); ` `        ``// creating a delay ` `        ``// so that the point can be noticed ` `        ``delay(500); ` `    ``} ` `} ` ` `  `// Actual display function ` `void` `myDisplay(``void``) ` `{ ` `    ``int` `opt; ` `    ``printf``(``"\nEnter\n\t<1> for translation"` `           ``"\n\t<2> for rotation"` `           ``"\n\t<3> for scaling\n\t:"``); ` `    ``scanf``(``"%d"``, &opt); ` `    ``printf``(``"\nGo to the window..."``); ` `    ``switch` `(opt) { ` `    ``case` `1: ` `        ``translatePoint(100, 200, 1, 5); ` `        ``break``; ` `    ``case` `2: ` `        ``rotateAroundPt(200, 200, maxWD / 2, maxHT / 2); ` `        ``// point will circle around ` `        ``// the centre of the window ` `        ``break``; ` `    ``case` `3: ` `        ``scalePoint(10, 20, 2, 3); ` `        ``break``; ` `    ``} ` `} ` ` `  `void` `main(``int` `argc, ``char``** argv) ` `{ ` `    ``glutInit(&argc, argv); ` `    ``glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); ` `    ``glutInitWindowSize(maxWD, maxHT); ` `    ``glutInitWindowPosition(100, 150); ` `    ``glutCreateWindow(``"Transforming point"``); ` `    ``glutDisplayFunc(myDisplay); ` `    ``myInit(); ` `    ``glutMainLoop(); ` `} `

This article is contributed by Suprotik Dey. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.