# Basic Transformations in OPENGL

• Last Updated : 02 May, 2022

Transformations play a very important role in manipulating objects on the 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 the 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 = cy + (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 on 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 are to be applied, follow the order: translate, rotate, scale

Implementation:

## C

 `// 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;``        ``}` `        ``// Drawing the point``        ``drawPoint(px, py);` `        ``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;` `         ``// Drawing the point``        ``drawPoint(fx, fy);` `        ``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``;``    ``}``}` `// Driver code``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();``}`