API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 26th, 2017
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 29.41 KB | None | 0 0
raw download clone embed print report
  1. //=============================================================================================
  2. // Szamitogepes grafika hazi feladat keret. Ervenyes 2017-tol.
  3. // A //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. // sorokon beluli reszben celszeru garazdalkodni, mert a tobbit ugyis toroljuk.
  5. // A beadott program csak ebben a fajlban lehet, a fajl 1 byte-os ASCII karaktereket tartalmazhat.
  6. // Tilos:
  7. // - mast "beincludolni", illetve mas konyvtarat hasznalni
  8. // - faljmuveleteket vegezni a printf-et kivéve
  9. // - new operatort hivni a lefoglalt adat korrekt felszabaditasa nelkul
  10. // - felesleges programsorokat a beadott programban hagyni
  11. // - felesleges kommenteket a beadott programba irni a forrasmegjelolest kommentjeit kiveve
  12. // ---------------------------------------------------------------------------------------------
  13. // A feladatot ANSI C++ nyelvu forditoprogrammal ellenorizzuk, a Visual Studio-hoz kepesti elteresekrol
  14. // es a leggyakoribb hibakrol (pl. ideiglenes objektumot nem lehet referencia tipusnak ertekul adni)
  15. // a hazibeado portal ad egy osszefoglalot.
  16. // ---------------------------------------------------------------------------------------------
  17. // A feladatmegoldasokban csak olyan OpenGL/GLUT fuggvenyek hasznalhatok, amelyek az oran a feladatkiadasig elhangzottak
  18. //
  19. // NYILATKOZAT
  20. // ---------------------------------------------------------------------------------------------
  21. // Nev : Kovács László
  22. // Neptun : JNH1DH
  23. // ---------------------------------------------------------------------------------------------
  24. // ezennel kijelentem, hogy a feladatot magam keszitettem, es ha barmilyen segitseget igenybe vettem vagy
  25. // mas szellemi termeket felhasznaltam, akkor a forrast es az atvett reszt kommentekben egyertelmuen jeloltem.
  26. // A forrasmegjeloles kotelme vonatkozik az eloadas foliakat es a targy oktatoi, illetve a
  27. // grafhazi doktor tanacsait kiveve barmilyen csatornan (szoban, irasban, Interneten, stb.) erkezo minden egyeb
  28. // informaciora (keplet, program, algoritmus, stb.). Kijelentem, hogy a forrasmegjelolessel atvett reszeket is ertem,
  29. // azok helyessegere matematikai bizonyitast tudok adni. Tisztaban vagyok azzal, hogy az atvett reszek nem szamitanak
  30. // a sajat kontribucioba, igy a feladat elfogadasarol a tobbi resz mennyisege es minosege alapjan szuletik dontes.
  31. // Tudomasul veszem, hogy a forrasmegjeloles kotelmenek megsertese eseten a hazifeladatra adhato pontokat
  32. // negativ elojellel szamoljak el es ezzel parhuzamosan eljaras is indul velem szemben.
  33. //=============================================================================================
  34.  
  35. #define _USE_MATH_DEFINES
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <math.h>
  39.  
  40. #include <vector>
  41.  
  42. #if defined(__APPLE__)
  43. #include <GLUT/GLUT.h>
  44. #include <OpenGL/gl3.h>
  45. #include <OpenGL/glu.h>
  46. #else
  47. #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
  48. #include <windows.h>
  49. #endif
  50. #include <GL/glew.h> // must be downloaded
  51. #include <GL/freeglut.h> // must be downloaded unless you have an Apple
  52. #endif
  53.  
  54.  
  55. const unsigned int windowWidth = 600, windowHeight = 600;
  56.  
  57. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  58. // You are supposed to modify the code from here...
  59.  
  60. // OpenGL major and minor versions
  61. int majorVersion = 3, minorVersion = 3;
  62.  
  63. void getErrorInfo(unsigned int handle) {
  64. int logLen;
  65. glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &logLen);
  66. if (logLen > 0) {
  67. char * log = new char[logLen];
  68. int written;
  69. glGetShaderInfoLog(handle, logLen, &written, log);
  70. printf("Shader log:\n%s", log);
  71. delete log;
  72. }
  73. }
  74.  
  75. // check if shader could be compiled
  76. void checkShader(unsigned int shader, char * message) {
  77. int OK;
  78. glGetShaderiv(shader, GL_COMPILE_STATUS, &OK);
  79. if (!OK) {
  80. printf("%s!\n", message);
  81. getErrorInfo(shader);
  82. }
  83. }
  84.  
  85. // check if shader could be linked
  86. void checkLinking(unsigned int program) {
  87. int OK;
  88. glGetProgramiv(program, GL_LINK_STATUS, &OK);
  89. if (!OK) {
  90. printf("Failed to link shader program!\n");
  91. getErrorInfo(program);
  92. }
  93. }
  94.  
  95. // vertex shader in GLSL
  96. const char * vertexSource = R"(
  97. #version 330
  98. precision highp float;
  99.  
  100. uniform mat4 MVP; // Model-View-Projection matrix in row-major format
  101.  
  102. layout(location = 0) in vec2 vertexPosition; // Attrib Array 0
  103. layout(location = 1) in vec3 vertexColor; // Attrib Array 1
  104. out vec3 color; // output attribute
  105.  
  106. void main() {
  107. color = vertexColor; // copy color from input to output
  108. gl_Position = vec4(vertexPosition.x, vertexPosition.y, 0, 1) * MVP; // transform to clipping space
  109. }
  110. )";
  111.  
  112. // fragment shader in GLSL
  113. const char * fragmentSource = R"(
  114. #version 330
  115. precision highp float;
  116.  
  117. in vec3 color; // variable input: interpolated color of vertex shader
  118. out vec4 fragmentColor; // output that goes to the raster memory as told by glBindFragDataLocation
  119.  
  120. void main() {
  121. fragmentColor = vec4(color, 1); // extend RGB to RGBA
  122. }
  123. )";
  124.  
  125. // row-major matrix 4x4
  126. struct mat4 {
  127. float m[4][4];
  128. public:
  129. mat4() {}
  130. mat4(float m00, float m01, float m02, float m03,
  131. float m10, float m11, float m12, float m13,
  132. float m20, float m21, float m22, float m23,
  133. float m30, float m31, float m32, float m33) {
  134. m[0][0] = m00; m[0][1] = m01; m[0][2] = m02; m[0][3] = m03;
  135. m[1][0] = m10; m[1][1] = m11; m[1][2] = m12; m[1][3] = m13;
  136. m[2][0] = m20; m[2][1] = m21; m[2][2] = m22; m[2][3] = m23;
  137. m[3][0] = m30; m[3][1] = m31; m[3][2] = m32; m[3][3] = m33;
  138. }
  139.  
  140. mat4 operator*(const mat4& right) {
  141. mat4 result;
  142. for (int i = 0; i < 4; i++) {
  143. for (int j = 0; j < 4; j++) {
  144. result.m[i][j] = 0;
  145. for (int k = 0; k < 4; k++) result.m[i][j] += m[i][k] * right.m[k][j];
  146. }
  147. }
  148. return result;
  149. }
  150. operator float*() { return &m[0][0]; }
  151. };
  152.  
  153.  
  154. // 3D point in homogeneous coordinates
  155. struct vec4 {
  156. float v[4];
  157.  
  158. vec4(float x = 0, float y = 0, float z = 0, float w = 1) {
  159. v[0] = x; v[1] = y; v[2] = z; v[3] = w;
  160. }
  161.  
  162. vec4 operator*(const mat4& mat) {
  163. vec4 result;
  164. for (int j = 0; j < 4; j++) {
  165. result.v[j] = 0;
  166. for (int i = 0; i < 4; i++) result.v[j] += v[i] * mat.m[i][j];
  167. }
  168. return result;
  169. }
  170. vec4 operator*(const vec4& vec) {
  171. vec4 result;
  172. result = vec4(vec.v[0] + v[0], vec.v[1] + v[1], vec.v[2] + v[2], vec.v[3] + v[3]);
  173. return result;
  174. }
  175. };
  176.  
  177.  
  178.  
  179. // 2D camera
  180. struct Camera {
  181. float wCx, wCy; // center in world coordinates
  182. float wWx, wWy; // width and height in world coordinates
  183. public:
  184. Camera() {
  185. Animate(0);
  186. }
  187.  
  188. mat4 V() { // view matrix: translates the center to the origin
  189. return mat4(1, 0, 0, 0,
  190. 0, 1, 0, 0,
  191. 0, 0, 1, 0,
  192. -wCx, -wCy, 0, 1);
  193. }
  194.  
  195. mat4 P() { // projection matrix: scales it to be a square of edge length 2
  196. return mat4(2 / wWx, 0, 0, 0,
  197. 0, 2 / wWy, 0, 0,
  198. 0, 0, 1, 0,
  199. 0, 0, 0, 1);
  200. }
  201.  
  202. mat4 Vinv() { // inverse view matrix
  203. return mat4(1, 0, 0, 0,
  204. 0, 1, 0, 0,
  205. 0, 0, 1, 0,
  206. wCx, wCy, 0, 1);
  207. }
  208.  
  209. mat4 Pinv() { // inverse projection matrix
  210. return mat4(wWx / 2, 0, 0, 0,
  211. 0, wWy / 2, 0, 0,
  212. 0, 0, 1, 0,
  213. 0, 0, 0, 1);
  214. }
  215.  
  216. void Animate(float t) {
  217. wCx = 0; // 10 * cosf(t);
  218. wCy = 0;
  219. wWx = 20;
  220. wWy = 20;
  221. }
  222. };
  223.  
  224. // 2D camera
  225. Camera camera;
  226.  
  227. // handle of the shader program
  228. unsigned int shaderProgram;
  229. unsigned int z;
  230.  
  231. class Terepasztal {
  232. float vertexData[4800];
  233. float vertexColors[14400];
  234. unsigned int vao;
  235. float k = -10.0f;
  236. float f = -10.0f;
  237. float up = 1.0f;
  238. int change = 0;
  239. mat4 cordm[3];
  240. public:
  241.  
  242. float x(float u, float v) {
  243. float temp = 0.0f;
  244. for (int i = 0; i < 4; i++) {
  245. for (int j = 0; j < 4; j++) {
  246. temp += cordm[0].m[i][j] * B(i, u) * B(j, v);
  247. }
  248. }
  249. return temp;
  250. }
  251.  
  252. float y(float u, float v) {
  253. float temp = 0.0f;
  254. for (int i = 0; i < 4; i++) {
  255. for (int j = 0; j < 4; j++) {
  256. temp += cordm[1].m[i][j] * B(i, u) * B(j, v);
  257. }
  258. }
  259. return temp;
  260. }
  261.  
  262. float z(float u, float v) {
  263. float temp = 0.0f;
  264. for (int i = 0; i < 4; i++) {
  265. for (int j = 0; j < 4; j++) {
  266. temp += cordm[2].m[i][j] * B(i, u) * B(j, v);
  267. }
  268. }
  269. return temp;
  270. }
  271.  
  272. float B(int i, float uv) {
  273. switch (i) {
  274. case 0: return((1 - uv)*(1 - uv)*(1 - uv));
  275. break;
  276. case 1: return((3 * uv)*((1 - uv)*(1 - uv)));
  277. break;
  278. case 2: return((3 * (uv*uv))*(1 - uv));
  279. break;
  280. case 3: return(uv * uv * uv);
  281. break;
  282. }
  283. }
  284.  
  285.  
  286. void Create() {
  287. cordm[0] = mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.33f, 0.33f, 0.33f, 0.33f, 0.66f, 0.66f, 0.66f, 0.66f, 1.0f, 1.0f, 1.0f, 1.0f);
  288. cordm[1] = mat4(0.0f, 0.33f, 0.66f, 1.0f, 0.0f, 0.33f, 0.66f, 1.0f, 0.0f, 0.33f, 0.66f, 1.0f, 0.0f, 0.33f, 0.66f, 1.0f);
  289. cordm[2] = mat4(1.8f, 0.6f, 1.4f, 1.6f,
  290. 0.8f, 10.0f, 9.6f, 0.8f,
  291. 0.4f, 8.8f, 9.2f, 1.1f,
  292. 0.2f, 0.6f, 0.8f, 1.0f);
  293. for (int i = 0; i < 400; i++) {
  294. vertexData[12*i] = k;
  295. vertexData[12*i+1] = f;
  296.  
  297. vertexData[12*i+2] = k;
  298. vertexData[12*i + 3] = f + 1.0f;
  299.  
  300. vertexData[12*i + 4] = k+ 1.0f;
  301. vertexData[12*i + 5] = f;
  302.  
  303. vertexData[12*i+6] = k;
  304. vertexData[12*i + 7] = f + 1.0f;
  305.  
  306. vertexData[12*i + 8] = k + 1.0f;
  307. vertexData[12*i + 9] = f ;
  308.  
  309. vertexData[12*i + 10] = k + 1.0f;
  310. vertexData[12*i + 11] = f + 1.0f;
  311. k = k + 1.0f;
  312. change++;
  313. if (change == 20) {
  314. k = -10.0f;
  315. change = 0;
  316. f = f + up;
  317. }
  318. }
  319. change = 0;
  320. k = 0.0f;
  321. f = 0.0f;
  322. for (int i = 0; i < 800; i++) {
  323.  
  324. if (1 < (sqrt(z(k, f)*z(k, f)) / 10))
  325. vertexColors[18 * i] = 1;
  326. else
  327. vertexColors[18 * i] = sqrt(z(k, f)*z(k, f)) /10;
  328. vertexColors[18 * i + 1] = 0.21f;
  329. vertexColors[18 * i+2] = 0.32f;
  330.  
  331. if (1 < sqrt(z(k, f + 0.05263157894736842105263157894737f)*z(k, f + 0.05263157894736842105263157894737f))/10)
  332. vertexColors[18 * i + 3] = 1;
  333. else
  334. vertexColors[18 * i + 3] = sqrt(z(k, f + 0.05263157894736842105263157894737f)*z(k, f + 0.05263157894736842105263157894737f))/10;
  335. vertexColors[18 * i + 4] = 0.21f;
  336. vertexColors[18 * i + 5] = 0.32f;
  337.  
  338. if(1 < sqrt(z(k + 0.05263157894736842105263157894737f, f)*(z(k + 0.05263157894736842105263157894737f, f)))/10)
  339. vertexColors[18 * i+6] = 1;
  340. else
  341. vertexColors[18 * i + 6] = sqrt(z(k + 0.05263157894736842105263157894737f, f)*(z(k + 0.05263157894736842105263157894737f, f)))/10;
  342. vertexColors[18 * i + 7] = 0.21f;
  343. vertexColors[18 * i + 8] = 0.32f;
  344.  
  345. if(1 < sqrt(z(k, f + 0.05263157894736842105263157894737f)* z(k, f + 0.05263157894736842105263157894737f))/10)
  346. vertexColors[18 * i + 9] = 1;
  347. else
  348. vertexColors[18 * i + 9] = sqrt(z(k, f + 0.05263157894736842105263157894737f)* z(k, f + 0.05263157894736842105263157894737f))/10;
  349. vertexColors[18 * i + 10] = 0.21f;
  350. vertexColors[18 * i + 11] = 0.32f;
  351.  
  352. if(1 < sqrt(z(k + 0.05263157894736842105263157894737f, f)*z(k + 0.05263157894736842105263157894737f, f))/10)
  353. vertexColors[18 * i + 12] = 1 ;
  354. else
  355. vertexColors[18 * i + 12] = sqrt(z(k + 0.05263157894736842105263157894737f, f)*z(k + 0.05263157894736842105263157894737f, f))/10;
  356. vertexColors[18 * i + 13] = 0.21f;
  357. vertexColors[18 * i + 14] = 0.32f;
  358.  
  359. if(1 < sqrt(z(k + 0.05263157894736842105263157894737f, f + 0.05263157894736842105263157894737f)*z(k + 0.05263157894736842105263157894737f, f + 0.05263157894736842105263157894737f))/10)
  360. vertexColors[18 * i+ 15] = 1;
  361. else
  362. vertexColors[18 * i + 15] = sqrt(z(k + 0.05263157894736842105263157894737f, f + 0.05263157894736842105263157894737f)*z(k + 0.05263157894736842105263157894737f, f + 0.05263157894736842105263157894737f))/10;
  363. vertexColors[18 * i + 16] = 0.21f;
  364. vertexColors[18 * i + 17] = 0.32f;
  365.  
  366. k = k + 0.05263157894736842105263157894737f;
  367. change++;
  368. if (change == 20) {
  369. k = 0.0f;
  370. change = 0;
  371. f = f + 0.05263157894736842105263157894737f;
  372. }
  373.  
  374. }
  375.  
  376. glGenVertexArrays(1, &vao); // create 1 vertex array object
  377. glBindVertexArray(vao); // make it active
  378.  
  379. unsigned int vbo[2]; // vertex buffer objects
  380. glGenBuffers(2, &vbo[0]); // Generate 2 vertex buffer objects
  381.  
  382. // vertex coordinates: vbo[0] -> Attrib Array 0 -> vertexPosition of the vertex shader
  383. glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // make it active, it is an array
  384.  
  385. glBufferData(GL_ARRAY_BUFFER, // copy to the GPU
  386. sizeof(vertexData), // number of the vbo in bytes
  387. vertexData, // address of the data array on the CPU
  388. GL_STATIC_DRAW); // copy to that part of the memory which is not modified
  389. // Map Attribute Array 0 to the current bound vertex buffer (vbo[0])
  390. glEnableVertexAttribArray(0);
  391. // Data organization of Attribute Array 0
  392. glVertexAttribPointer(0, // Attribute Array 0
  393. 2, GL_FLOAT, // components/attribute, component type
  394. GL_FALSE, // not in fixed point format, do not normalized
  395. 0, NULL); // stride and offset: it is tightly packed
  396.  
  397. // vertex colors: vbo[1] -> Attrib Array 1 -> vertexColor of the vertex shader
  398. glBindBuffer(GL_ARRAY_BUFFER, vbo[1]); // make it active, it is an array
  399.  
  400. glBufferData(GL_ARRAY_BUFFER, sizeof(vertexColors), vertexColors, GL_STATIC_DRAW); // copy to the GPU
  401.  
  402. // Map Attribute Array 1 to the current bound vertex buffer (vbo[1])
  403. glEnableVertexAttribArray(1); // Vertex position
  404. // Data organization of Attribute Array 1
  405. glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL); // Attribute Array 1, components/attribute, component type, normalize?, tightly packed
  406. }
  407.  
  408. void Draw() {
  409. mat4 Mscale(1, 0, 0, 0,
  410. 0, 1, 0, 0,
  411. 0, 0, 0, 0,
  412. 0, 0, 0, 1); // model matrix
  413.  
  414. mat4 Mtranslate(1, 0, 0, 0,
  415. 0, 1, 0, 0,
  416. 0, 0, 0, 0,
  417. 0, 0, 0, 1); // model matrix
  418.  
  419. mat4 MVPTransform = Mscale * Mtranslate * camera.V() * camera.P();
  420.  
  421. // set GPU uniform matrix variable MVP with the content of CPU variable MVPTransform
  422. int location = glGetUniformLocation(shaderProgram, "MVP");
  423. if (location >= 0) glUniformMatrix4fv(location, 1, GL_TRUE, MVPTransform); // set uniform variable MVP to the MVPTransform
  424. else printf("uniform MVP cannot be set\n");
  425.  
  426. glBindVertexArray(vao); // make the vao and its vbos active playing the role of the data source
  427. glDrawArrays(GL_TRIANGLES, 0, 4800); // draw a single triangle with vertices defined in vao
  428. }
  429. };
  430.  
  431.  
  432. vec4 forgatas(vec4 irany, float szog) {
  433. szog *= 57.3f;
  434. printf("%f ", (cos(szog)*irany.v[0]) - (sin(szog)*irany.v[1]));
  435. return vec4(
  436. ((cos(szog)*irany.v[0]) - (sin(szog)*irany.v[1])),
  437. ((sin(szog)*irany.v[0]) + (cos(szog)*irany.v[1]))
  438. );
  439.  
  440.  
  441. }
  442.  
  443. class Triangle {
  444. GLuint vao;
  445. GLuint vbo[2]; // vertex array object id
  446. float sx, sy; // scaling
  447. float wTx, wTy; // translation
  448. float vertexColors[18] = { 0, 1, 0, 0, 1, 0, 0, 1, 0 , 0, 1, 0, 0, 1, 0, 0, 1, 0 };
  449. float vertexCoords[12] = { -2.0f, -2.0f, 0.0f, 0.0f, 0.0f, -1.0f , 0.0f , -1.0f , 0.0f,0.0f, 2.0f , -2.0f };
  450. float forgx, forgx1, forgy, forgy1;
  451. long elteltido= 0;
  452. float vertexData[10000];
  453. float vertexDatas[1000];
  454. float ellapsedtime[1000];
  455. std::vector<vec4> cps; // control points
  456. std::vector<float> ts; // parameter (knot) values
  457. public:
  458. Triangle() {
  459. //Animate(0.0f , 0.0f , 0.0f , 0.0f , 0.0f);
  460. }
  461. void AddPoint(float cX, float cY) {
  462. AddControlPoint(vec4(cX, cY, 0, 1));
  463. }
  464.  
  465. float Ld(int i, float t) {
  466. float Li = 0.0f;
  467. for (int j = 0; j < cps.size(); j++)
  468. if (j != i) Li += (1 / t - ts[j]);
  469. float Lf = 1.0f;
  470. for (int j = 0; j < cps.size(); j++)
  471. if (j != i) Lf *= ((t - ts[j]) - ts[i] / (ts[i] - ts[j]));
  472. return Li*Lf;
  473.  
  474. }
  475. vec4 rd(float t) {
  476. vec4 rr(0, 0, 0, 1);
  477. for (int i = 0; i < cps.size(); i++) {
  478. vec4 temp(cps[i].v[0] * Ld(i, t), cps[i].v[1] * Ld(i, t), 0, cps[i].v[3] * Ld(i, t));
  479. vec4 mamma = rr;
  480. rr = vec4(mamma.v[0] + temp.v[0], mamma.v[1] + temp.v[1], 0, mamma.v[3] + temp.v[3]);
  481. }
  482. return rr;
  483. }
  484.  
  485. float L(int i, float t) {
  486. float Li = 1.0f;
  487. for (int j = 0; j < cps.size(); j++)
  488. if (j != i) Li *= (t - ts[j]) / (ts[i] - ts[j]);
  489. return Li;
  490. }
  491.  
  492. void AddControlPoint(vec4 cp) {
  493. float ti = cps.size(); // or something better
  494. cps.push_back(cp); ts.push_back(ti);
  495. }
  496.  
  497. vec4 r(float t) {
  498. vec4 rr(0, 0, 0, 1);
  499. for (int i = 0; i < cps.size(); i++) {
  500. vec4 temp(cps[i].v[0] * L(i, t), cps[i].v[1] * L(i, t), 0, 1);
  501. vec4 mamma = rr;
  502. rr = vec4(mamma.v[0] + temp.v[0], mamma.v[1] + temp.v[1], 0, 1);
  503. }
  504. return rr;
  505. }
  506.  
  507. int gettime(int i) {
  508. return ellapsedtime[i + 1] - ellapsedtime[i];
  509. }
  510.  
  511.  
  512. long elteltIdo() { return elteltido; }
  513. void Create() {
  514. glGenVertexArrays(1, &vao); // create 1 vertex array object
  515. glBindVertexArray(vao); // make it active
  516.  
  517. unsigned int vbo[2]; // vertex buffer objects
  518. glGenBuffers(2, &vbo[0]); // Generate 2 vertex buffer objects
  519.  
  520. // vertex coordinates: vbo[0] -> Attrib Array 0 -> vertexPosition of the vertex shader
  521. glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // make it active, it is an array
  522.  
  523. glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // make it active, it is an array
  524. glBufferData(GL_ARRAY_BUFFER, // copy to the GPU
  525. sizeof(vertexCoords), // number of the vbo in bytes
  526. vertexCoords, // address of the data array on the CPU
  527. GL_STATIC_DRAW); // copy to that part of the memory which is not modified
  528. //printf("%f %f %f %f %f", vertexCoords[0], vertexCoords[1], vertexCoords[2], vertexCoords[3], vertexCoords[4]);
  529.  
  530. glEnableVertexAttribArray(0);
  531. // Data organization of Attribute Array 0
  532. glVertexAttribPointer(0, // Attribute Array 0
  533. 2, GL_FLOAT, // components/attribute, component type
  534. GL_FALSE, // not in fixed point format, do not normalized
  535. 0, NULL); // stride and offset: it is tightly packed
  536.  
  537. // vertex colors: vbo[1] -> Attrib Array 1 -> vertexColor of the vertex shader
  538. glBindBuffer(GL_ARRAY_BUFFER, vbo[1]); // make it active, it is an array
  539. // vertex data on the CPU
  540. glBufferData(GL_ARRAY_BUFFER, sizeof(vertexColors), vertexColors, GL_DYNAMIC_DRAW); // copy to the GPU
  541.  
  542. // Map Attribute Array 1 to the current bound vertex buffer (vbo[1])
  543. glEnableVertexAttribArray(1); // Vertex position
  544. // Data organization of Attribute Array 1
  545. glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL); // Attribute Array 1, components/attribute, component type, normalize?, tightly packed
  546.  
  547.  
  548. elteltido = glutGet(GLUT_ELAPSED_TIME);
  549. }
  550.  
  551.  
  552.  
  553.  
  554. void Animate(float t ) {
  555.  
  556. if (elteltido != 0) {
  557.  
  558. vec4 temp = r(t)* camera.Pinv() * camera.Vinv();
  559. sx = 1; // sinf(t);
  560. sy = 1; //cosf(t)
  561. wTx = temp.v[0]; // 4 * cosf(t / 2);
  562. wTy = temp.v[1]; // 4 * sinf(t / 2); // itt kell
  563.  
  564. vec4 temp1 = rd(t);
  565. for (int i = 0; i < 6; i++) {
  566.  
  567. vertexCoords[2 * i] = forgatas(vec4(vertexCoords[2 * i], vertexCoords[2 * i + 1], 0, 1), atan(temp1.v[1] / temp1.v[0])).v[0];
  568. vertexCoords[2 * i + 1] = forgatas(vec4(vertexCoords[2 * i], vertexCoords[2 * i + 1], 0, 1), atan(temp1.v[1] / temp1.v[0])).v[1];
  569.  
  570. }
  571.  
  572. }
  573.  
  574. }
  575.  
  576. void Draw() {
  577. // copy to that part of the memory which is not modified
  578. if (cps.size() > 0) {
  579. glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // make it active, it is an array
  580.  
  581. glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // make it active, it is an array
  582. glBufferData(GL_ARRAY_BUFFER, // copy to the GPU
  583. sizeof(vertexCoords), // number of the vbo in bytes
  584. vertexCoords, // address of the data array on the CPU
  585. GL_STATIC_DRAW); // copy to that part of the memory which is not modified
  586. //printf("%f %f %f %f %f", vertexCoords[0], vertexCoords[1], vertexCoords[2], vertexCoords[3], vertexCoords[4]);
  587.  
  588. mat4 Mscale(sx, 0, 0, 0,
  589. 0, sy, 0, 0,
  590. 0, 0, 0, 0,
  591. 0, 0, 0, 1); // model matrix
  592.  
  593. mat4 Mtranslate(1, 0, 0, 0,
  594. 0, 1, 0, 0,
  595. 0, 0, 0, 0,
  596. wTx, wTy, 0, 1); // model matrix
  597.  
  598.  
  599.  
  600. mat4 MVPTransform = Mscale * Mtranslate *camera.V() * camera.P();
  601.  
  602. // set GPU uniform matrix variable MVP with the content of CPU variable MVPTransform
  603. int location = glGetUniformLocation(shaderProgram, "MVP");
  604. if (location >= 0) glUniformMatrix4fv(location, 1, GL_TRUE, MVPTransform); // set uniform variable MVP to the MVPTransform
  605. else printf("uniform MVP cannot be set\n");
  606.  
  607. glBindVertexArray(vao); // make the vao and its vbos active playing the role of the data source
  608. glDrawArrays(GL_TRIANGLES, 0, 6); // draw a single triangle with vertices defined in vao
  609. }
  610. }
  611. };
  612.  
  613. class LagrangeCurve {
  614. GLuint vao, vbo; // vertex array object, vertex buffer object
  615.  
  616. int nVertices;
  617. int nVerticesl; // number of vertices
  618. std::vector<vec4> cps; // control points
  619. std::vector<float> ts; // parameter (knot) values
  620. float hossz = 0;
  621.  
  622. public:
  623. float vertexData[10000];
  624. float vertexDatas[1000];
  625. float ellapsedtime[1000];
  626.  
  627. LagrangeCurve() {
  628. nVertices = 0;
  629. }
  630. void Create() {
  631. glGenVertexArrays(1, &vao);
  632. glBindVertexArray(vao);
  633. glGenBuffers(1, &vbo); // Generate 1 vertex buffer object
  634. glBindBuffer(GL_ARRAY_BUFFER, vbo);
  635. // Enable the vertex attribute arrays
  636. glEnableVertexAttribArray(0); // attribute array 0
  637. glEnableVertexAttribArray(1); // attribute array 1
  638. // Map attribute array 0 to the vertex data of the interleaved vbo
  639. glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), reinterpret_cast<void*>(0)); // attribute array, components/attribute, component type, normalize?, stride, offset
  640. // Map attribute array 1 to the color data of the interleaved vbo
  641. glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), reinterpret_cast<void*>(2 * sizeof(float)));
  642. }
  643.  
  644. float Ld(int i, float t) {
  645. float Li = 0.0f;
  646. for (int j = 0; j < cps.size(); j++)
  647. if (j != i) Li += (1 / t - ts[j]);
  648. float Lf = 1.0f;
  649. for (int j = 0; j < cps.size(); j++)
  650. if (j != i) Lf *= ((t - ts[j]) - ts[i] / (ts[i] - ts[j]));
  651. return Li*Lf;
  652.  
  653. }
  654. vec4 rd(float t) {
  655. vec4 rr(0, 0, 0, 1);
  656. for (int i = 0; i < cps.size(); i++) {
  657. vec4 temp(cps[i].v[0] * Ld(i, t), cps[i].v[1] * Ld(i, t), 0, cps[i].v[3]*Ld(i,t));
  658. vec4 mamma = rr;
  659. rr = vec4(mamma.v[0] + temp.v[0], mamma.v[1] + temp.v[1], 0, mamma.v[3]+temp.v[3]);
  660. }
  661. return rr;
  662. }
  663.  
  664. float L(int i, float t) {
  665. float Li = 1.0f;
  666. for (int j = 0; j < cps.size(); j++)
  667. if (j != i) Li *= (t - ts[j]) / (ts[i] - ts[j]);
  668. return Li;
  669. }
  670.  
  671. void AddControlPoint(vec4 cp) {
  672. float ti = cps.size(); // or something better
  673. cps.push_back(cp); ts.push_back(ti);
  674. }
  675.  
  676. vec4 r(float t) {
  677. vec4 rr(0, 0, 0, 1);
  678. for (int i = 0; i < cps.size(); i++) {
  679. vec4 temp(cps[i].v[0] * L(i, t), cps[i].v[1] * L(i, t), 0, 1);
  680. vec4 mamma = rr;
  681. rr = vec4(mamma.v[0] + temp.v[0], mamma.v[1] + temp.v[1], 0, 1);
  682. }
  683. return rr;
  684. }
  685.  
  686. int gettime(int i) {
  687. return ellapsedtime[i + 1] - ellapsedtime[i];
  688. }
  689.  
  690. void AddPoint(float cX, float cY) {
  691.  
  692. glBindBuffer(GL_ARRAY_BUFFER, vbo);
  693. if (nVertices >= 20) return;
  694.  
  695. AddControlPoint(vec4(cX, cY, glutGet(GLUT_ELAPSED_TIME) / 100.0f, 1));
  696. ellapsedtime[nVertices] = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
  697. if(nVertices > 1)ellapsedtime[nVertices - 1] = ellapsedtime[nVertices] - ellapsedtime[nVertices - 1];
  698. nVerticesl = 0;
  699. for (float t = 0; t < (cps.size() - 0.99); t += 0.01f) {
  700. vec4 temp = r(t) * camera.Pinv() * camera.Vinv();
  701. vec4 temp1 = rd(t);
  702.  
  703. vertexDatas[2 * nVerticesl] = temp1.v[0]/temp1.v[3];
  704. vertexDatas[2 * nVerticesl+1] = temp1.v[1]/temp1.v[3];
  705. // fill interleaved data
  706. vertexData[5 * nVerticesl] = temp.v[0];
  707. vertexData[5 * nVerticesl + 1] = temp.v[1];
  708. vertexData[5 * nVerticesl + 2] = 1; // red
  709. vertexData[5 * nVerticesl + 3] = 1; // green
  710. vertexData[5 * nVerticesl + 4] = 1; // blue
  711.  
  712. //printf("%f \n ", ellapsedtime[nVerticesl]);
  713.  
  714. nVerticesl++;
  715. }
  716. nVertices++;
  717.  
  718.  
  719. if (nVertices > 1) { //hossz szamitas
  720. for (int i = 0; i < nVerticesl * 5 - 5; i = i + 5) {
  721. float temp = (sqrt(((vertexData[i] - vertexData[i + 5]) * (vertexData[i] - vertexData[i + 5])) + ((vertexData[i + 1] - vertexData[i + 6])*(vertexData[i + 1] - vertexData[i + 6]))));
  722. hossz = hossz + temp;
  723. }
  724. //printf("%f \n", hossz);
  725. }
  726.  
  727. //copy data to GPU
  728. glBufferData(GL_ARRAY_BUFFER, nVerticesl * 5 * sizeof(float), vertexData, GL_DYNAMIC_DRAW);
  729. }
  730.  
  731. void Draw() {
  732. if (nVertices > 0) {
  733.  
  734. mat4 VPTransform = camera.V() * camera.P();
  735.  
  736. int location = glGetUniformLocation(shaderProgram, "MVP");
  737. if (location >= 0) glUniformMatrix4fv(location, 1, GL_TRUE, VPTransform);
  738. else printf("uniform MVP cannot be set\n");
  739.  
  740. glBindVertexArray(vao);
  741.  
  742. glDrawArrays(GL_LINE_STRIP, 0, nVerticesl);
  743. }
  744. }
  745. };
  746.  
  747. // The virtual world: collection of two objects
  748.  
  749. LagrangeCurve lagrangeCurve;
  750. Terepasztal terepasztal;
  751. Triangle triangle;
  752.  
  753. // Initialization, create an OpenGL context
  754. void onInitialization() {
  755. glViewport(0, 0, windowWidth, windowHeight);
  756.  
  757. // Create objects by setting up their vertex data on the GPU
  758.  
  759. lagrangeCurve.Create();
  760. terepasztal.Create();
  761.  
  762.  
  763. // Create vertex shader from string
  764. unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
  765. if (!vertexShader) {
  766. printf("Error in vertex shader creation\n");
  767. exit(1);
  768. }
  769. glShaderSource(vertexShader, 1, &vertexSource, NULL);
  770. glCompileShader(vertexShader);
  771. checkShader(vertexShader, "Vertex shader error");
  772.  
  773. // Create fragment shader from string
  774. unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  775. if (!fragmentShader) {
  776. printf("Error in fragment shader creation\n");
  777. exit(1);
  778. }
  779. glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
  780. glCompileShader(fragmentShader);
  781. checkShader(fragmentShader, "Fragment shader error");
  782.  
  783. // Attach shaders to a single program
  784. shaderProgram = glCreateProgram();
  785. if (!shaderProgram) {
  786. printf("Error in shader program creation\n");
  787. exit(1);
  788. }
  789. glAttachShader(shaderProgram, vertexShader);
  790. glAttachShader(shaderProgram, fragmentShader);
  791.  
  792. // Connect the fragmentColor to the frame buffer memory
  793. glBindFragDataLocation(shaderProgram, 0, "fragmentColor"); // fragmentColor goes to the frame buffer memory
  794.  
  795. // program packaging
  796. glLinkProgram(shaderProgram);
  797. checkLinking(shaderProgram);
  798. // make this program run
  799. glUseProgram(shaderProgram);
  800. }
  801.  
  802. void onExit() {
  803. glDeleteProgram(shaderProgram);
  804. printf("exit");
  805. }
  806.  
  807. // Window has become invalid: Redraw
  808. void onDisplay() {
  809. glClearColor(0, 0, 0, 0); // background color
  810. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the screen
  811.  
  812. terepasztal.Draw();
  813. lagrangeCurve.Draw();
  814. if(triangle.elteltIdo() != 0 ) triangle.Draw();
  815.  
  816. glutSwapBuffers(); // exchange the two buffers
  817. }
  818.  
  819. // Key of ASCII code pressed
  820. void onKeyboard(unsigned char key, int pX, int pY) {
  821. if ( key == ' ')
  822. triangle.Create();
  823. if (key == 'd')
  824. glutPostRedisplay(); // if d, invalidate display, i.e. redraw
  825.  
  826. }
  827.  
  828. // Key of ASCII code released
  829. void onKeyboardUp(unsigned char key, int pX, int pY) {
  830.  
  831. }
  832.  
  833. // Mouse click event
  834. void onMouse(int button, int state, int pX, int pY) {
  835. if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) { // GLUT_LEFT_BUTTON / GLUT_RIGHT_BUTTON and GLUT_DOWN / GLUT_UP
  836. float cX = 2.0f * pX / windowWidth - 1; // flip y axis
  837. float cY = 1.0f - 2.0f * pY / windowHeight;
  838. lagrangeCurve.AddPoint(cX, cY);
  839. triangle.AddPoint(cX, cY);
  840. glutPostRedisplay(); // redraw
  841. }
  842. }
  843.  
  844. // Move mouse with key pressed
  845. void onMouseMotion(int pX, int pY) {
  846. }
  847.  
  848. // Idle event indicating that some time elapsed: do animation here
  849. void onIdle() {
  850. long time = glutGet(GLUT_ELAPSED_TIME); // elapsed time since the start of the program
  851. float sec = time/1000.0f; // convert msec to sec
  852. camera.Animate(sec);
  853.  
  854. float i = sec - triangle.elteltIdo()/1000.0f;
  855. //int a = i;
  856. //int b = lagrangeCurve.ellapsedtime[z];
  857. //if ( b == a) {
  858. triangle.Animate(i);
  859. // z++;
  860. //}
  861. //printf("%i \n", i); // animate the triangle object
  862. glutPostRedisplay();
  863. //if(time == lagrangeCurve.gettime(z))
  864. // z++;
  865. // redraw the scene
  866. }
  867.  
  868. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  869. // Do not touch the code below this line
  870.  
  871. int main(int argc, char * argv[]) {
  872. glutInit(&argc, argv);
  873. #if !defined(__APPLE__)
  874. glutInitContextVersion(majorVersion, minorVersion);
  875. #endif
  876. glutInitWindowSize(windowWidth, windowHeight); // Application window is initially of resolution 600x600
  877. glutInitWindowPosition(100, 100); // Relative location of the application window
  878. #if defined(__APPLE__)
  879. glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_3_3_CORE_PROFILE); // 8 bit R,G,B,A + double buffer + depth buffer
  880. #else
  881. glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
  882. #endif
  883. glutCreateWindow(argv[0]);
  884.  
  885. #if !defined(__APPLE__)
  886. glewExperimental = true; // magic
  887. glewInit();
  888. #endif
  889.  
  890. printf("GL Vendor : %s\n", glGetString(GL_VENDOR));
  891. printf("GL Renderer : %s\n", glGetString(GL_RENDERER));
  892. printf("GL Version (string) : %s\n", glGetString(GL_VERSION));
  893. glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
  894. glGetIntegerv(GL_MINOR_VERSION, &minorVersion);
  895. printf("GL Version (integer) : %d.%d\n", majorVersion, minorVersion);
  896. printf("GLSL Version : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
  897.  
  898. onInitialization();
  899.  
  900. glutDisplayFunc(onDisplay); // Register event handlers
  901. glutMouseFunc(onMouse);
  902. glutIdleFunc(onIdle);
  903. glutKeyboardFunc(onKeyboard);
  904. glutKeyboardUpFunc(onKeyboardUp);
  905. glutMotionFunc(onMouseMotion);
  906.  
  907. glutMainLoop();
  908. onExit();
  909. return 1;
  910. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!