├── 2D Bezier Curves
    ├── Bezier1.PNG
    ├── BezierFormula.png
    └── Source.cpp
├── 3D Solar System
    ├── SolarSystem
    │   └── SolarSystem
    │   │   ├── a.bmp
    │   │   ├── b.bmp
    │   │   ├── c.bmp
    │   │   ├── d.bmp
    │   │   ├── e.bmp
    │   │   ├── f.bmp
    │   │   ├── g.bmp
    │   │   ├── glut32.dll
    │   │   ├── h.bmp
    │   │   ├── i.bmp
    │   │   ├── im.bmp
    │   │   ├── rocket.bmp
    │   │   └── text.bmp
    └── main.cpp
└── README.md


/2D Bezier Curves/Bezier1.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/2D Bezier Curves/Bezier1.PNG


--------------------------------------------------------------------------------
/2D Bezier Curves/BezierFormula.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/2D Bezier Curves/BezierFormula.png


--------------------------------------------------------------------------------
/2D Bezier Curves/Source.cpp:
--------------------------------------------------------------------------------
  1 | #pragma warning(disable : 4996) 
  2 | #include <iostream>
  3 | #include <glut.h>
  4 | #include <math.h>
  5 | #include <vector>
  6 | #include <utility>
  7 | #include <time.h>
  8 | #include <string>
  9 | #include <algorithm>
 10 | #include <conio.h>
 11 | 
 12 | using namespace std;
 13 | #define Frac_Circ 360  // Cien fracciones de circulo 
 14 | #define PI 3.1415926535897932 
 15 | 
 16 | 
 17 | typedef pair<float, float> pff;
 18 | int SCREEN_HEIGHT = 480;
 19 | vector<pff> PC(4);
 20 | vector<pff> PB, PR[3];
 21 | pff nuevo;
 22 | float mouseX, mouseY;
 23 | bool mouseleft;
 24 | 
 25 | float t_ = 1.0;
 26 | const int maxi = 100;
 27 | int dp[maxi][maxi], dx = 1, t = 0, id = 0, apreto = 0, id_cambio = -1;
 28 | float color1, color2, color3;
 29 | 
 30 | void init() {
 31 | 	glClearColor(1.0, 1.0, 1.0, 1.0);
 32 | 	glColor3f(1.0, 0.0, 0.0);
 33 | 	glPointSize(4.0);
 34 | 	glMatrixMode(GL_PROJECTION);
 35 | 	glLoadIdentity();
 36 | 	gluOrtho2D(0.0, 640.0, 0.0, 480.0);
 37 | }
 38 | 
 39 | 
 40 | void DibujaPunto(int x, int y)
 41 | {
 42 | 	glPointSize(9);
 43 | 	glBegin(GL_POINTS);
 44 | 	glVertex2i(x, y);
 45 | 	glEnd();
 46 | }
 47 | 
 48 | void DibujarPuntoCircular(int x, int y) {
 49 | 	glBegin(GL_POLYGON);
 50 | 	for (int i = 0; i < Frac_Circ + 1; i++) {  // +1 para cerrar 
 51 | 		glVertex2f(x + 5 * cos(2.0 * PI * i / Frac_Circ),
 52 | 			y + 5 * sin(2.0 * PI * i / Frac_Circ));
 53 | 	}
 54 | 	glEnd();
 55 | 	glColor3f(0.0f, 0.0f, 0.0f);
 56 | 	glLineWidth(1.0);
 57 | 	glBegin(GL_LINES);
 58 | 	for (int i = 0; i < Frac_Circ + 1; i++) {  // +1 para cerrar 
 59 | 		glVertex2f(x + 5 * cos(2.0 * PI * i / Frac_Circ),
 60 | 			y + 5 * sin(2.0 * PI * i / Frac_Circ));
 61 | 	}
 62 | 	glEnd();
 63 | }
 64 | 
 65 | void DibujarPuntoCircularDelgado(int x, int y) {
 66 | 	glBegin(GL_POLYGON);
 67 | 	for (int i = 0; i < Frac_Circ + 1; i++) {  // +1 para cerrar 
 68 | 		glVertex2f(x + 3 * cos(2.0 * PI * i / Frac_Circ),
 69 | 			y + 3 * sin(2.0 * PI * i / Frac_Circ));
 70 | 	}
 71 | 	glEnd();
 72 | 	glColor3f(0.0f, 0.0f, 0.0f);
 73 | 	glLineWidth(1.0);
 74 | 	glBegin(GL_LINES);
 75 | 	for (int i = 0; i < Frac_Circ + 1; i++) {  // +1 para cerrar 
 76 | 		glVertex2f(x + 3 * cos(2.0 * PI * i / Frac_Circ),
 77 | 			y + 3 * sin(2.0 * PI * i / Frac_Circ));
 78 | 	}
 79 | 	glEnd();
 80 | }
 81 | 
 82 | void DibujaLinea(pff p1, pff p2)
 83 | {
 84 | 	glLineWidth(1.0);
 85 | 	glBegin(GL_LINES);
 86 | 	glVertex3f(p1.first, p1.second, 0);
 87 | 	glVertex3f(p2.first, p2.second, 0);
 88 | 	glEnd();
 89 | }
 90 | 
 91 | void DibujaLineaGruesa(pff p1, pff p2)
 92 | {
 93 | 	glLineWidth(2.5);
 94 | 	glBegin(GL_LINES);
 95 | 	glVertex3f(p1.first, p1.second, 0);
 96 | 	glVertex3f(p2.first, p2.second, 0);
 97 | 	glEnd();
 98 | }
 99 | 
100 | pff DibujaBezier(double t)
101 | {
102 | 	pff P = { 0.0, 0.0 };
103 | 	int n = PC.size() - 1;
104 | 	for (int i = 0; i < PC.size(); i++)
105 | 	{
106 | 		P.first += 1.0 * dp[n][i] * (PC[i].first) * (pow((1 - t), n - i)) * (pow(t, i));
107 | 		P.second += 1.0 * dp[n][i] * (PC[i].second) * (pow((1 - t), n - i)) * (pow(t, i));
108 | 	}
109 | 	return P;
110 | }
111 | pff puntoRecta(double t, pff p1, pff p2) {
112 | 	return { p1.first * t + (1 - t) * p2.first , p1.second * t + (1 - t) * p2.second };
113 | }
114 | 
115 | void DrawLineaPunteada(pff p1, pff p2) {
116 | 	float dist = sqrt(pow((p2.first - p1.first), 2) + pow((p2.second - p1.second), 2));
117 | 	float inters = dist / 10;
118 | 	float aumento = 1.0 / inters;
119 | 	for (float t = 0; t < 1.0; t = t + aumento) {
120 | 		float x1 = (p2.first - p1.first) * t + p1.first;
121 | 		float y1 = (p2.second - p1.second) * t + p1.second;
122 | 		float x2 = (p2.first - p1.first) * (t + (aumento * 0.6)) + p1.first;
123 | 		float y2 = (p2.second - p1.second) * (t + (aumento * 0.6)) + p1.second;
124 | 		glBegin(GL_LINES);
125 | 		glVertex3f(x1, y1, 0);
126 | 		glVertex3f(x2, y2, 0);
127 | 		glEnd();
128 | 	}
129 | }
130 | 
131 | void draw()
132 | {
133 | 	glClear(GL_COLOR_BUFFER_BIT);
134 | 	glClearColor(1.0, 1.0, 1.0, 1.0);
135 | 	glPointSize(5);
136 | 	for (int i = 0; i < 4; i++) {
137 | 		if (i == 1 || i == 2) {
138 | 			glColor3f(0.0, 0.0, 1.0);
139 | 			DibujaPunto(PC[i].first, PC[i].second);
140 | 		}
141 | 		else {
142 | 			glColor3f(1.0, 0.0, 0.0);
143 | 			DibujarPuntoCircular(PC[i].first, PC[i].second);
144 | 		}
145 | 	}
146 | 
147 | 	glColor3f(1.0, 0.0, 0.0);
148 | 	for (int i = 0; i < PB.size() - 1; i++) DibujaLineaGruesa(PB[i], PB[i + 1]);
149 | 
150 | 	for (int i = 0; i < 3; i++) {
151 | 		if (i == 1) {
152 | 			glColor3f(0.33, 0.33, 0.33);
153 | 			DrawLineaPunteada(PC[i], PC[i + 1]);
154 | 		}
155 | 		else {
156 | 			glColor3f(0.0, 1.0, 0.0);
157 | 			DibujaLinea(PC[i], PC[i + 1]);
158 | 		}
159 | 	}
160 | 	glColor3f(1.0, 0.0, 0.0);
161 | 	DibujarPuntoCircularDelgado(PB[id].first, PB[id].second);
162 | 
163 | 	for (int i = 0; i < 3; i++) {
164 | 		glColor3f(0.0, 0.5, 0.5);
165 | 		DibujarPuntoCircularDelgado(PR[i][id].first, PR[i][id].second);
166 | 		if (i < 2) {
167 | 			if (i == 0) glColor3f(color1, color3, color2); else if (i == 1) glColor3f(color2, color3, color1);
168 | 			DrawLineaPunteada(PR[i][id], PR[i + 1][id]);
169 | 		}
170 | 	}
171 | 
172 | 	pff pc1 = puntoRecta(t_, PR[0][id], PR[1][id]);
173 | 	pff pc2 = puntoRecta(t_, PR[1][id], PR[2][id]);
174 | 
175 | 	glColor3f(1.0, 0.3, 1.0);
176 | 	DibujarPuntoCircularDelgado(pc1.first, pc1.second);
177 | 	DibujarPuntoCircularDelgado(pc2.first, pc2.second);
178 | 
179 | 	glColor3f(color3, color2, color1);
180 | 	DrawLineaPunteada(pc1, PB[id]);
181 | 	DrawLineaPunteada(PB[id], pc2);
182 | 
183 | 	glColor3f(0, 0, 0);
184 | 	for (char letra = 'A'; letra < 'E'; letra++) {
185 | 		glRasterPos2i(PC[letra - 'A'].first + 10, PC[letra - 'A'].second + 10);
186 | 		glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, letra);
187 | 	}
188 | 	glutSwapBuffers();
189 | 
190 | }
191 | void trianguloPascal() {
192 | 	for (int line = 0; line < maxi; line++)
193 | 	{
194 | 		for (int i = 0; i <= line; i++) {
195 | 			if (line == i || i == 0) dp[line][i] = 1;
196 | 			else dp[line][i] = dp[line - 1][i - 1] + dp[line - 1][i];
197 | 		}
198 | 	}
199 | }
200 | void puntos() {
201 | 	pff POld = PC[0];
202 | 	for (double t = 0.0; t <= 1.0; t += 0.005) {
203 | 		pff P = DibujaBezier(t);
204 | 		PB.push_back(P);
205 | 		POld = P;
206 | 	}
207 | 	for (int i = 0; i < 3; i++) {
208 | 		for (double t = 0.0; t <= 1.0; t += 0.005)
209 | 			PR[i].push_back(puntoRecta(t, PC[i], PC[i + 1]));
210 | 		reverse(PR[i].begin(), PR[i].end());
211 | 	}
212 | }
213 | void idle(void) {
214 | 	t++;
215 | 	if (t == 2e6) {
216 | 		if (id + dx >= PB.size() || id + dx < 0) dx *= -1;
217 | 		t_ += (dx < 0 ? 0.005 : -0.005);
218 | 		id += dx, t = 0;
219 | 		glutPostRedisplay();
220 | 	}
221 | }
222 | void mouseCB(int button, int state, int x, int y) {
223 | 	mouseX = x;
224 | 	mouseY = y;
225 | 	if (button == GLUT_LEFT_BUTTON)
226 | 	{
227 | 		if (state == GLUT_DOWN) {
228 | 			mouseleft = true;
229 | 		}
230 | 		if (state == GLUT_UP && apreto)
231 | 		{
232 | 			mouseleft = false;
233 | 		}
234 | 	}
235 | }
236 | 
237 | 
238 | void mouseMotionCB(int x, int y) {
239 | 	if (mouseleft) {
240 | 		apreto = 1;
241 | 		for (int i = 0; i < 4; i++) {
242 | 			nuevo = { x,480 - y };
243 | 			if (abs(PC[i].first - nuevo.first) < 5 && abs(PC[i].second - nuevo.second) < 5) {
244 | 				id_cambio = i;
245 | 				break;
246 | 			}
247 | 		}
248 | 		nuevo = { x,480 - y };
249 | 		apreto = 0;
250 | 		if (id_cambio == -1) return;
251 | 		PC[id_cambio] = nuevo;
252 | 		id_cambio = -1;
253 | 		PB.clear();
254 | 		for (int i = 0; i < 3; i++)
255 | 			PR[i].clear();
256 | 		puntos();
257 | 	}
258 | }
259 | 
260 | int main() {
261 | 
262 | 	time_t now = time(0);
263 | 	tm* time = localtime(&now);
264 | 	srand(time->tm_sec);
265 | 	trianguloPascal();
266 | 	color1 = (rand() % 100) * 0.01; color2 = (rand() % 100) * 0.01; color3 = (rand() % 100) * 0.01;
267 | 	for (int i = 0; i < 4; i++)	PC[i] = { rand() % 600 + 20, rand() % 440 + 20 };
268 | 	puntos();
269 | 
270 | 	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
271 | 	glutInitWindowSize(640, 480);
272 | 	glutInitWindowPosition(0, 0);
273 | 	glutCreateWindow("Bezier Curves Animation");
274 | 	init();
275 | 	glutDisplayFunc(draw);
276 | 	glutPostRedisplay();
277 | 	glutIdleFunc(idle);
278 | 	glutMouseFunc(mouseCB);
279 | 	glutMotionFunc(mouseMotionCB);
280 | 	glutMainLoop();
281 | 	return 0;
282 | }
283 | 


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/a.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/a.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/b.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/b.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/c.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/c.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/d.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/d.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/e.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/e.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/f.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/f.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/g.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/g.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/glut32.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/glut32.dll


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/h.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/h.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/i.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/i.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/im.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/im.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/rocket.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/rocket.bmp


--------------------------------------------------------------------------------
/3D Solar System/SolarSystem/SolarSystem/text.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lafifii/Computer_Graphics_Projects/ac67f5f70e5006d7f7ad29ddb75640c9a999b93c/3D Solar System/SolarSystem/SolarSystem/text.bmp


--------------------------------------------------------------------------------
/3D Solar System/main.cpp:
--------------------------------------------------------------------------------
  1 | #pragma warning(disable:4996) 
  2 | #pragma once
  3 | #include <Windows.h>
  4 | #include <stdio.h>
  5 | #include <iostream>
  6 | #include <stdlib.h>
  7 | #include <vector>
  8 | #include <time.h>
  9 | #include <stdio.h>
 10 | #include <cmath>
 11 | #include <GL/glew.h>
 12 | #include <glut.h>
 13 | double  velocidad_cohete = 1;
 14 | bool stop = 1;
 15 | struct Point {
 16 | 	float x, y, z;
 17 | 	void setxyz(float xa, float ya, float za) {
 18 | 		x = xa, y = ya, z = za;
 19 | 	}
 20 | };
 21 | struct BMP {
 22 | 	int w, h;
 23 | 	BYTE* data;
 24 | 	static unsigned int textura;
 25 | };
 26 | 
 27 | 
 28 | struct Particula {
 29 | 	Point punto;
 30 | 	float lifespan, tiempovivo, velocidad;
 31 | 	Particula(Point p) {
 32 | 		punto.setxyz(p.x, 9 + rand() % 3, p.z);
 33 | 		tiempovivo = 0;
 34 | 		lifespan = (rand() % 101) / 100.0;
 35 | 		velocidad = velocidad_cohete;
 36 | 	}
 37 | 	void mover() {
 38 | 		tiempovivo += 0.03;
 39 | 	}
 40 | 	void recal(Point p) {
 41 | 		punto.setxyz(p.x, (90 + rand() % 30) / 10.0, p.z);
 42 | 		tiempovivo = 0;
 43 | 		lifespan = (rand() % 100) / 100.0;
 44 | 		velocidad = velocidad_cohete;
 45 | 	}
 46 | };
 47 | 
 48 | using namespace std;
 49 | unsigned int texture[11];
 50 | int actual[7];
 51 | bool debe[3] = { 0 };
 52 | Point punto_cohete;
 53 | float radios[8] = { 1.5,1.8,2,1.2,2.5, 1.6,2.1,2.1 };
 54 | 
 55 | float t_ = 0, dxt = 0.005;
 56 | GLfloat girax = 15, giray = 0, zoom[3] = { 0,0,-60 }, rx = 0, ry = 0, rz = 0;
 57 | const int maxi = 40;
 58 | vector<float> Asteroides;
 59 | vector<Point> PuntosEstrellas, PC(4), PC2(4);
 60 | vector<Point> PCE[5];
 61 | vector<Point> PO[7];
 62 | vector<BMP> Texturas;
 63 | vector<Particula> SistemaParticulas;
 64 | 
 65 | int dp[maxi][maxi];
 66 | float j_cohete = 0;
 67 | void trianguloPascal() {
 68 | 	for (int line = 0; line < maxi; line++)
 69 | 	{
 70 | 		for (int i = 0; i <= line; i++) {
 71 | 			if (line == i || i == 0) dp[line][i] = 1;
 72 | 			else dp[line][i] = dp[line - 1][i - 1] + dp[line - 1][i];
 73 | 		}
 74 | 	}
 75 | }
 76 | void mover(void) {
 77 | 	glMatrixMode(GL_MODELVIEW);
 78 | 	glLoadIdentity();
 79 | 	glTranslated(zoom[0], zoom[1], zoom[2]);
 80 | 	glRotated(girax, 1.0, 0.0, 0.0);
 81 | 	glRotated(giray, 0.0, 1.0, 0.0);
 82 | 	glRotated(40, 0, 0, 1);
 83 | }
 84 | 
 85 | void cohete_cub() {
 86 | 	glPushMatrix();
 87 | 	glEnable(GL_TEXTURE_2D);
 88 | 	glBindTexture(GL_TEXTURE_2D, texture[10]);
 89 | 	int xx = ((int)j_cohete + 1) % 301;
 90 | 	double ang = 2.0 * 3.14 * xx / 300.0;
 91 | 	float ult[3] = { cos(ang) * 30, 11.5, sin(ang) * 30 };
 92 | 	punto_cohete.y += 2.5;
 93 | 
 94 | 	glTranslatef(ult[0], ult[1], ult[2]);
 95 | 	glBegin(GL_QUADS);
 96 | 	// Front Face
 97 | 	glTexCoord2f(0.0f, 1.0f);
 98 | 	glVertex3f(-1.0f, 1.0f, 1.0f);
 99 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f);
100 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f);
101 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
102 | 
103 | 	// Back Face
104 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f);
105 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f);
106 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
107 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
108 | 
109 | 	// Top Face
110 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f);
111 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 1.0f);
112 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
113 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
114 | 
115 | 	// Bottom Face
116 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
117 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f);
118 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, -1.0f, -1.0f);
119 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
120 | 
121 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f);
122 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f);
123 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f);
124 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f);
125 | 
126 | 
127 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
128 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
129 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
130 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
131 | 
132 | 	glEnd();
133 | 
134 | 	glTranslatef(0,0,0);
135 | 	punto_cohete.y -= 2.5;
136 | 	glPopMatrix();
137 | 	glDisable(GL_TEXTURE_2D);
138 | }
139 | 
140 | void LoadTextures(const char* nombre) {
141 | 	int width, height;
142 | 	BYTE* data;
143 | 	FILE* file;
144 | 	// open texture data
145 | 	file = fopen(nombre, "rb");
146 | 	// allocate buffer
147 | 	BYTE header[54];
148 | 	fread(header, 1, 54, file);
149 | 	size_t dataPos = *(int*) & (header[0x0A]);
150 | 	size_t imageSize = *(int*) & (header[0x22]);
151 | 	width = *(int*) & (header[0x12]);
152 | 	height = *(int*) & (header[0x16]);
153 | 
154 | 	if (imageSize == 0)    imageSize = width * height * 3;
155 | 	if (dataPos == 0)      dataPos = 54;
156 | 	data = new unsigned char[imageSize];
157 | 	fread(data, 1, imageSize, file);
158 | 	fclose(file);
159 | 	BMP aux;
160 | 	aux.w = width, aux.h = height, aux.data = data;
161 | 	Texturas.push_back(aux);
162 | }
163 | void nueva_textura(int idx) {
164 | 	glBindTexture(GL_TEXTURE_2D, texture[idx]);
165 | 	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
166 | 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
167 | 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
168 | 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
169 | 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
170 | 	gluBuild2DMipmaps(GL_TEXTURE_2D, 3, Texturas[idx].w, Texturas[idx].h, GL_BGR, GL_UNSIGNED_BYTE, Texturas[idx].data);
171 | 	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
172 | }
173 | void cube() {
174 | 	glEnable(GL_TEXTURE_2D);
175 | 	glBindTexture(GL_TEXTURE_2D, texture[0]);
176 | 	glEnable(GL_LIGHTING);
177 | 	glBegin(GL_QUADS);
178 | 	// Front Face
179 | 	glTexCoord2f(0.0f, 1.0f);
180 | 	glVertex3f(-60.0f, 60.0f, 60.0f);
181 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(60.0f, 60.0f, 60.0f);
182 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(60.0f, -60.0f, 60.0f);
183 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(-60.0f, -60.0f, 60.0f);
184 | 
185 | 	// Back Face
186 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(60.0f, -60.0f, -60.0f);
187 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(60.0f, 60.0f, -60.0f);
188 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(-60.0f, 60.0f, -60.0f);
189 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(-60.0f, -60.0f, -60.0f);
190 | 
191 | 	// Top Face
192 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(60.0f, 60.0f, -60.0f);
193 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(60.0f, 60.0f, 60.0f);
194 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(-60.0f, 60.0f, 60.0f);
195 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(-60.0f, 60.0f, -60.0f);
196 | 
197 | 	// Bottom Face
198 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(-60.0f, -60.0f, 60.0f);
199 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(60.0f, -60.0f, 60.0f);
200 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(60.0f, -60.0f, -60.0f);
201 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(-60.0f, -60.0f, -60.0f);
202 | 
203 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(60.0f, -60.0f, 60.0f);
204 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(60.0f, 60.0f, 60.0f);
205 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(60.0f, 60.0f, -60.0f);
206 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(60.0f, -60.0f, -60.0f);
207 | 
208 | 
209 | 	glTexCoord2f(0.0f, 1.0f); glVertex3f(-60.0f, 60.0f, -60.0f);
210 | 	glTexCoord2f(1.0f, 1.0f); glVertex3f(-60.0f, 60.0f, 60.0f);
211 | 	glTexCoord2f(1.0f, 0.0f); glVertex3f(-60.0f, -60.0f, 60.0f);
212 | 	glTexCoord2f(0.0f, 0.0f); glVertex3f(-60.0f, -60.0f, -60.0f);
213 | 
214 | 	glEnd();
215 | 	glDisable(GL_TEXTURE_2D);
216 | }
217 | void estrella(Point p, int tipo) {
218 | 	glTranslatef(p.x, p.y, p.z);
219 | 	glBegin(GL_LINE_LOOP);
220 | 	glVertex3f(0.0 * tipo, 0.2 * tipo, 0.0);
221 | 	glVertex3f(0.1 * tipo, 0.1 * tipo, 0.0);
222 | 	glVertex3f(0.2 * tipo, 0.05 * tipo, 0.0);
223 | 	glVertex3f(0.1 * tipo, 0.0 * tipo, 0.0);
224 | 	glVertex3f(0.2 * tipo, -0.1 * tipo, 0.0);
225 | 	glVertex3f(0.0 * tipo, 0.0 * tipo, 0.0);
226 | 	glVertex3f(-0.2 * tipo, -0.1 * tipo, 0.0);
227 | 	glVertex3f(-0.1 * tipo, 0.0 * tipo, 0.0);
228 | 	glVertex3f(-0.2 * tipo, 0.05 * tipo, 0.0);
229 | 	glVertex3f(-0.1 * tipo, 0.1 * tipo, 0.0);
230 | 	glEnd();
231 | }
232 | void planeta(float radio, float x, float y, float z, int idx) {
233 | 	glPushMatrix();
234 | 	glTranslatef(x, y, z);
235 | 	GLUquadric* qobj = gluNewQuadric();
236 | 	gluQuadricTexture(qobj, GL_TRUE);
237 | 	glEnable(GL_TEXTURE_2D);
238 | 	glBindTexture(GL_TEXTURE_2D, texture[idx]);
239 | 	gluSphere(qobj, radio, 50, 50);
240 | 	gluDeleteQuadric(qobj);
241 | 	glDisable(GL_TEXTURE_2D);
242 | 	glPopMatrix();
243 | }
244 | void drawAsteroides() {
245 | 	for (int i = 0, j = 0; i < Asteroides.size() && j <= 300; i++, j += 6) {
246 | 		double angle = 2 * 3.14 * j / 300;
247 | 		planeta(Asteroides[i], cos(angle) * 28, (i & 2 ? -1 : 1), sin(angle) * 28, 9);
248 | 		planeta(Asteroides[i], cos(angle) * 30, (j & 1 ? 1 : 1), sin(angle) * 30, 9);
249 | 	}
250 | }
251 | Point DibujaBezier(double t, vector<Point> & PCA)
252 | {
253 | 	Point P; P.setxyz(0, 0, 0);
254 | 	int n = PCA.size() - 1;
255 | 	for (int i = 0; i < PCA.size(); i++)
256 | 	{
257 | 		P.x += 1.0 * dp[n][i] * (PCA[i].x) * (pow((1 - t), n - i)) * (pow(t, i));
258 | 		P.y += 1.0 * dp[n][i] * (PCA[i].y) * (pow((1 - t), n - i)) * (pow(t, i));
259 | 		P.z += 1.0 * dp[n][i] * (PCA[i].z) * (pow((1 - t), n - i)) * (pow(t, i));
260 | 	}
261 | 	return P;
262 | }
263 | void orbitas_planetas(vector<Point> puntos, int idx) {
264 | 	glPushMatrix();
265 | 	glTranslatef(PO[idx][actual[idx]].x, PO[idx][actual[idx]].y, PO[idx][actual[idx]].z);
266 | 	glRotatef(rx, 1, 0, 0);
267 | 	glRotatef(ry, 0, 1, 0);
268 | 	glRotatef(rz, 0, 0, 1);
269 | 	glTranslatef(-PO[idx][actual[idx]].x, -PO[idx][actual[idx]].y, -PO[idx][actual[idx]].z);
270 | 	glLineWidth(1.5);
271 | 	glBegin(GL_LINES);
272 | 	vector<Point> vpa;
273 | 	vpa.push_back(puntos[0]);
274 | 	vpa.push_back(puntos[1]);
275 | 	vpa.push_back(puntos[2]);
276 | 	Point p1 = DibujaBezier(0, vpa);
277 | 	for (double t = 0.005; t <= 1; t += 0.005)
278 | 	{
279 | 		Point p2 = DibujaBezier(t, vpa);
280 | 		glVertex3f(p1.x, p1.y, p1.z);
281 | 		glVertex3f(p2.x, p2.y, p2.z);
282 | 		p1 = p2;
283 | 	}
284 | 	vpa.clear();
285 | 	vpa.push_back(puntos[2]);
286 | 	vpa.push_back(puntos[3]);
287 | 	vpa.push_back(puntos[0]);
288 | 
289 | 	p1 = DibujaBezier(0, vpa);
290 | 	for (double t = 0.005; t <= 1; t += 0.005)
291 | 	{
292 | 		Point p2 = DibujaBezier(t, vpa);
293 | 		glVertex3f(p1.x, p1.y, p1.z);
294 | 		glVertex3f(p2.x, p2.y, p2.z);
295 | 		p1 = p2;
296 | 	}
297 | 	glEnd();
298 | 	glPopMatrix();
299 | }
300 | void display() {
301 | 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
302 | 
303 | 	GLfloat mat_ambient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
304 | 	GLfloat mat_diffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f };
305 | 	GLfloat mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
306 | 	GLfloat high_shininess[] = { 100.0f };
307 | 	GLfloat emission[] = { 0.0, 0.0, 0.0, 1.0 };
308 | 	GLfloat emission2[] = { 1.0, 1.0, 1.0, 1.0 };
309 | 
310 | 	GLfloat light_ambient[] = { 0.5f, 0.5f, 0.5f, 1.0f };
311 | 	GLfloat light_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
312 | 	GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
313 | 	GLfloat light_pos[] = { 0.0, 0.0, 0.0, 1.0 };
314 | 
315 | 
316 | 	glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
317 | 	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
318 | 	glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
319 | 
320 | 	glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
321 | 	glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
322 | 	glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_specular);
323 | 	glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
324 | 	glMaterialfv(GL_FRONT, GL_EMISSION, emission2);
325 | 
326 | 	glEnable(GL_LIGHTING);
327 | 	glEnable(GL_LIGHT0);
328 | 
329 | 	mover();
330 | 	glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
331 | 	planeta(4, 0, 0, 0, 1);
332 | 	glMaterialfv(GL_FRONT, GL_EMISSION, emission);
333 | 	for (int i = 0; i < 7; i++)
334 | 		planeta(radios[i], PO[i][actual[i]].x, PO[i][actual[i]].y, PO[i][actual[i]].z, i + 2);
335 | 	glPushMatrix();
336 | 	glDisable(GL_LIGHTING);
337 | 	glPopMatrix();
338 | 	glPushMatrix();
339 | 
340 | 
341 | 	glPointSize(1 + (rand() % 20) / 10.0);
342 | 	glColor3f(1, 1, 1);
343 | 	glBegin(GL_POINTS);
344 | 	for (int i = 0; i < 100; i++) {
345 | 		glVertex3f(SistemaParticulas[i].punto.x, SistemaParticulas[i].punto.y, SistemaParticulas[i].punto.z);
346 | 		SistemaParticulas[i].mover();
347 | 		if (SistemaParticulas[i].tiempovivo > SistemaParticulas[i].lifespan)
348 | 			SistemaParticulas[i].recal(punto_cohete);
349 | 	}
350 | 	glEnd();
351 | 	glColor3f(0, 0, 0.15);
352 | 	for (int i = 0; i < 7; i++) {
353 | 		glBegin(GL_LINE_LOOP);
354 | 		for (int j = 0; j < PO[i].size(); j++)
355 | 			glVertex3f(PO[i][j].x, PO[i][j].y, PO[i][j].z);
356 | 		glEnd();
357 | 	}
358 | 	glPopMatrix();
359 | 	glColor3f(0.2, 0.1, 0.2);
360 | 	orbitas_planetas(PC, 4);
361 | 	vector<Point> auxP = PC;
362 | 	for (int i = 0; i < 5; i++) {
363 | 
364 | 		PC[0].x += (radios[4] * 1.4 + i * 0.2), PC[0].z += (radios[4] * 1.4 + i * 0.2);
365 | 		PC[3].x += (radios[4] * 1.4 + i * 0.2), PC[3].z -= (radios[4] * 1.4 + i * 0.2);
366 | 		PC[1].x -= (radios[4] * 1.4 + i * 0.2), PC[1].z += (radios[4] * 1.4 + i * 0.2);
367 | 		PC[2].x -= (radios[4] * 1.4 + i * 0.2), PC[2].z -= (radios[4] * 1.4 + i * 0.2);
368 | 		orbitas_planetas(PC, 4);
369 | 		PC = auxP;
370 | 	}
371 | 	glColor3f(0, 0.5, 0.5);
372 | 	orbitas_planetas(PC2, 5);
373 | 	PC2[0].x += (radios[5] * 1.5), PC2[0].z += (radios[5] * 1.5);
374 | 	PC2[3].x += (radios[5] * 1.5), PC2[3].z -= (radios[5] * 1.5);
375 | 	PC2[1].x -= (radios[5] * 1.5), PC2[1].z += (radios[5] * 1.5);
376 | 	PC2[2].x -= (radios[5] * 1.5), PC2[2].z -= (radios[5] * 1.5);
377 | 	orbitas_planetas(PC2, 5);
378 | 
379 | 	glEnable(GL_LIGHTING);
380 | 	drawAsteroides();
381 | 	cohete_cub();
382 | 	glDisable(GL_LIGHTING);
383 | 
384 | 	glColor3f(1, 0, 0);
385 | 	for (int i = 0; i < 5; i++) {
386 | 		glPushMatrix();
387 | 		Point p2 = DibujaBezier(t_, PCE[i]);
388 | 		glColor3f(0.97, 0.95, 0.17);
389 | 		estrella(p2, 2);
390 | 		glPopMatrix();
391 | 	}
392 | 	for (int j = 0; j < PuntosEstrellas.size(); j++) {
393 | 		float r = (rand() % 255) / 255.0, g = (rand() % 255) / 255.0, b = (rand() % 255) / 255.0;
394 | 		glPushMatrix();
395 | 		glColor3f(r, g, b);
396 | 		estrella(PuntosEstrellas[j], 1);
397 | 		glPopMatrix();
398 | 	}
399 | 	for (int i = 0; i < 5; i++) {
400 | 		glColor3f(1, 1, 1);
401 | 		glPushMatrix();
402 | 		glBegin(GL_POINTS);
403 | 		double tt_ = t_;
404 | 		for (int iter = 0; iter < 15; iter++) {
405 | 			tt_ -= dxt;
406 | 			if (tt_ < 0 || tt_ > 1) continue;
407 | 			Point p2 = DibujaBezier(tt_, PCE[i]);
408 | 			glVertex3f(p2.x, p2.y, p2.z);
409 | 		}
410 | 		glEnd();
411 | 		glPopMatrix();
412 | 	}
413 | 	glPushMatrix();
414 | 	cube();
415 | 	glPopMatrix();
416 | 	glutSwapBuffers();
417 | }
418 | void specialKeyInput(int key, int x, int y) {
419 | 	switch (key) {
420 | 	case GLUT_KEY_LEFT:  giray -= 5; break;
421 | 	case GLUT_KEY_RIGHT: giray += 5; break;
422 | 	case GLUT_KEY_UP:    girax -= 5; break;
423 | 	case GLUT_KEY_DOWN:  girax += 5; break;
424 | 	case GLUT_KEY_F1: debe[0] = !debe[0]; break;
425 | 	case GLUT_KEY_F2: debe[1] = !debe[1]; break;
426 | 	case GLUT_KEY_F3: debe[2] = !debe[2]; break;
427 | 	case GLUT_KEY_F4: stop = !stop; break;
428 | 	default: break;
429 | 	}
430 | 	glutPostRedisplay();
431 | }
432 | void reshape(int ancho, int alto) {
433 | 	glClearColor(0, 0, 0, 0.0); //black	
434 | 	glMatrixMode(GL_MODELVIEW);
435 | 	glLoadIdentity();
436 | 	glEnable(GL_DEPTH_TEST);
437 | 	glViewport(0, 0, ancho, alto);
438 | 	glMatrixMode(GL_PROJECTION);
439 | 	glLoadIdentity();
440 | 
441 | 	gluPerspective(90, 1, 12, 3000);
442 | }
443 | void calcular() {
444 | 	double angle = 2 * 3.14 * actual[4] / 300.0;
445 | 	for (int i = 0; i < 4; i++)
446 | 		PC[i].setxyz(cos(angle) * 35, 0, sin(angle) * 35);
447 | 	angle = 2 * 3.14 * actual[5] / 300.0;
448 | 	for (int i = 0; i < 4; i++)
449 | 		PC2[i].setxyz(cos(angle) * 40, 0, sin(angle) * 40);
450 | }
451 | void idle(void) {
452 | 	if (stop)giray += 0.5;
453 | 	if (t_ + dxt < 0 || t_ + dxt > 1) dxt *= -1;
454 | 	t_ += dxt;
455 | 	for (int j = 0; j < 7; j++) actual[j] = (actual[j] + 1) % 301;
456 | 	calcular();
457 | 	if (debe[0]) rx += 2.5;
458 | 	if (debe[1]) ry += 2.5;
459 | 	if (debe[2]) rz += 2.5;
460 | 	double angle = 2 * 3.14 * j_cohete / 300.0;
461 | 	punto_cohete.setxyz(cos(angle) * 30, 8, sin(angle) * 30);
462 | 	j_cohete += velocidad_cohete;
463 | 	glutPostRedisplay();
464 | }
465 | void iniciar() {
466 | 	double angle = 2 * 3.14 * j_cohete / 300.0;
467 | 	punto_cohete.setxyz(cos(angle) * 30, 8, sin(angle) * 30);
468 | 	j_cohete++;
469 | 	glGenTextures(12, texture);
470 | 	for(char i = 'a'; i <= 'i'; i++) 
471 | 		LoadTextures(i + ".bmp");
472 | 	LoadTextures("rocket.bmp");
473 | 	
474 | 	for (int i = 0; i < 11; i++) nueva_textura(i);
475 | 	for (int i = 0; i < 100; i++) {
476 | 		Particula pa(punto_cohete);
477 | 		SistemaParticulas.push_back(pa);
478 | 	}
479 | 	for (int i = 0; i < 50; i++) Asteroides.push_back((3 + rand() % 20) / 50.0);
480 | 	for (int i = 0; i < 500; i++) {
481 | 		Point aux;
482 | 		float x_ = (rand() % 100) * (rand() % 2 ? 1 : -1);
483 | 		float y_ = (rand() % 100) * (rand() % 2 ? 1 : -1);
484 | 		float z_ = (rand() % 100) * (rand() % 2 ? 1 : -1);
485 | 		aux.setxyz(x_, y_, z_);
486 | 		PuntosEstrellas.push_back(aux);
487 | 	}
488 | 
489 | 	for (int i = 0, orb = 10; i < 7; i++, orb += 5) {
490 | 		actual[i] = rand() % 100;
491 | 		if (orb == 30) orb += 5;
492 | 		for (int j = 0; j <= 300; j++) {
493 | 			double angle = 2 * 3.14 * j / 300.0;
494 | 			Point auxp; auxp.setxyz(cos(angle) * orb, 0, sin(angle) * orb);
495 | 			PO[i].push_back(auxp);
496 | 		}
497 | 	}
498 | 	calcular();
499 | }
500 | void tecla(unsigned char c, int x, int y) {
501 | 	c = toupper(c);
502 | 	if (c == '+') zoom[2]++;
503 | 	else if (c == '-') zoom[2]--;
504 | 	else if (c == 'A') zoom[0]++;
505 | 	else if (c == 'D') zoom[0]--;
506 | 	else if (c == 'W') zoom[1]--;
507 | 	else if (c == 'S') zoom[1]++;
508 | 	else if (c == 'V') velocidad_cohete += 0.2;
509 | 	else if (c == 'B') velocidad_cohete -= 0.2;
510 | 	glutPostRedisplay();
511 | }
512 | int main(int argc, char** argv) {
513 | 
514 | 	srand(time(NULL));
515 | 	for (int j = 0; j < 5; j++)
516 | 		for (int i = 0; i < 4; i++) {
517 | 			Point aux;
518 | 			aux.setxyz(rand() % 50 * (rand() % 2 ? 1 : -1), rand() % 50 * (rand() % 2 ? 1 : -1), rand() % 50 * (rand() % 2 ? 1 : -1));
519 | 			PCE[j].push_back(aux);
520 | 		}
521 | 	trianguloPascal();
522 | 	glutInit(&argc, argv);
523 | 	glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
524 | 	glutInitWindowPosition(100, 0);
525 | 	glutInitWindowSize(900, 700);
526 | 
527 | 	glutCreateWindow(".:: Space ::.");
528 | 
529 | 	glutReshapeFunc(reshape);
530 | 	glutDisplayFunc(display);
531 | 	glutIdleFunc(idle);
532 | 	glutSpecialFunc(specialKeyInput);
533 | 	glutKeyboardFunc(tecla);
534 | 
535 | 	iniciar();
536 | 	glutMainLoop();
537 | 	return 0;
538 | }
539 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Partial Project: Bezier-Curves
 2 | Bezier Curves animation using 4 movable control points in OpenGL 
 3 | 
 4 | A Bézier curve is a parametric curve used in computer graphics and related fields. The curve, which is related to the Bernstein polynomial, is named after Pierre Bézier, who used it in the 1960s for designing curves for the bodywork of Renault cars. Other uses include the design of computer fonts and animation. Bézier curves can be combined to form a Bézier spline, or generalized to higher dimensions to form Bézier surfaces. 
 5 | 
 6 | <p align="center">
 7 |    <img width="349" height="219" src="https://github.com/lafifii/Computer_Graphics_Projects/blob/master/2D%20Bezier%20Curves/BezierFormula.png">
 8 | </p>
 9 | 
10 | <p align="center">
11 |   <a href="https://imgflip.com/gif/33pvma"><img src="https://i.imgflip.com/33pvma.gif" title="made at imgflip.com"/></a>
12 | </p>
13 | 
14 | # Final Project: Solar System 3D
15 | 3D Animation Solar System using OpenGL 
16 | 
17 | **Topics:**
18 | * Textures
19 | * Lighting
20 | * 3D and perspective Projection
21 | * Bezier Curves 
22 | * 3D Transformation Matrix 
23 | * Particles system
24 | 
25 | <p align="center">
26 |  <a href="https://imgflip.com/gif/34be63"><img src="https://i.imgflip.com/34be63.gif" title="made at imgflip.com"/></a>
27 | </p>  
28 | 
29 | 
30 | ## Instructions:
31 | * Directional keys for moving system on x y and z axis
32 | * F1, F2, and F3 for rotating Saturn orbit around the planet in x y and z axis respectively
33 | * Zoom in and out + and -
34 | * Move camera left right with A and D respectively and up and down with W and S 
35 | * V to increase rocket's speed and B to decrease it
36 | 
37 | 


--------------------------------------------------------------------------------