/// // Draw triangles using the shader pair created in Init() // void gl_rect_draw(GL_STATE_T *p_state) { RectInstanceData *userData = p_state->user_data; GLShapeInstanceData *shapeData = &userData->shape; GLRectDisplayData *displayData = p_state->rectDisplayData; mat4x4 projection; mat4x4 modelView; mat4x4 projection_scaled; mat4x4 translation; mat4x4 projection_final; GLfloat vVertices[] = { 0.0f, 0.0f, 0.0f, // Position 0 0.0f, 1.0f, 0.0f, // Position 1 1.0f, 1.0f, 0.0f, // Position 2 1.0f, 0.0f, 0.0f, // Position 3 }; GLushort indices[] = { 0, 1, 2, 0, 2, 3 }; //GLushort indices[] = {1, 0, 3, 0, 2, 0, 1 }; // Use the program object glUseProgram ( displayData->programObject ); // Load the vertex position glVertexAttribPointer ( displayData->positionLoc, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), vVertices ); glEnableVertexAttribArray ( displayData->positionLoc ); mat4x4_identity(projection); mat4x4_scale_aniso(projection_scaled, projection, 2.0/p_state->width, -2.0/p_state->height, 1.0); mat4x4_translate(translation, -1, 1, 0); mat4x4_mul(projection_final, translation, projection_scaled); mat4x4_translate(translation, shapeData->objectX, shapeData->objectY, 0.0); mat4x4_identity(projection); mat4x4_scale_aniso(projection_scaled, projection, shapeData->objectWidth, shapeData->objectHeight, 1.0); mat4x4_mul(modelView, translation, projection_scaled); glUniformMatrix4fv ( displayData->projectionLoc, 1, GL_FALSE, (GLfloat *)projection_final); glUniformMatrix4fv ( displayData->modelViewLoc, 1, GL_FALSE, (GLfloat *)modelView); glUniform3f ( displayData->colorLoc, userData->red, userData->green, userData->blue ); glDrawElements ( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices ); //glDrawElements ( GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, indices ); }
static inline void mvp_matrix(mat4x4 model_view_projection_matrix, Params params, mat4x4 view_projection_matrix) { mat4x4 model_matrix; mat4x4_identity(model_matrix); mat4x4 id; mat4x4_identity(id); mat4x4_translate(model_matrix, -params.anchor.x, -params.anchor.y, params.anchor.z); mat4x4 scaled; mat4x4_identity(scaled); mat4x4_scale_aniso(scaled, scaled, params.scale.x, -params.scale.y, params.scale.z); mat4x4 tmp; mat4x4_dup(tmp, model_matrix); mat4x4_mul(model_matrix, scaled, tmp); mat4x4 rotate; mat4x4_dup(rotate, id); mat4x4_rotate_Z2(rotate, id, deg_to_radf(-params.rotation)); mat4x4_dup(tmp, model_matrix); mat4x4_mul(model_matrix, rotate, tmp); mat4x4_translate_independed(model_matrix, params.position.x, -params.position.y, params.position.z); mat4x4 model_matrix3; mat4x4_identity(model_matrix3); mat4x4 mm; mat4x4_mul(mm, model_matrix3, view_projection_matrix); mat4x4_mul(model_view_projection_matrix, mm, model_matrix); mat4x4_translate_independed(model_view_projection_matrix, 0, -y_offset/view_projection_matrix[3][3], 0); }
void lndr_gen_jet_mv_matrix(Lander *lander) { if(lander->jetState == JS_OFF) return; float scale = 0; if(lander->jetState == JS_INCREASING || lander->jetState == JS_DECREASING) scale = lander->jetFrames / FLAME_GROW_RATE; else if(lander->jetState == JS_ON) { if(lander->jetFrames < 10) return; lander->jetFrames = 0; int rnd = rand() % 6 - 3; scale = 1.0 + (0.07 * rnd); } mat4x4 ident, temp; mat4x4_identity(ident); mat4x4_translate_in_place(ident, 0, -0.3529412, 0); mat4x4_scale_aniso(temp, ident, 1.0, scale, 1.0); mat4x4_translate_in_place(temp, 0, 0.3529412, 0); mat4x4_transpose(lander->jetMatrix, temp); }
void Camera_view_projection(Camera* const camera, mat4x4 matrix) { mat4x4 position_matrix, orientation_matrix, scale_matrix; mat4x4_translate( position_matrix, -camera->transform.position[0], -camera->transform.position[1], -camera->transform.position[2] ); quat q; quat_conj(q, camera->transform.orientation); mat4x4_from_quat(orientation_matrix, q); vec3 v = { 1.0f / camera->transform.scale[0], 1.0f / camera->transform.scale[1], 1.0f / camera->transform.scale[2] }; mat4x4 m; mat4x4_identity(m); mat4x4_scale_aniso(scale_matrix, m, v[0], v[1], v[2]); mat4x4_mul(matrix, scale_matrix, orientation_matrix); mat4x4_mul(matrix, matrix, position_matrix); mat4x4_mul(matrix, camera->projection, matrix); }
void lndr_gen_mv_matrix(Lander *lander) { mat4x4 ident, temp, trans; mat4x4_identity(ident); /* float glx = 2 / glob_game.ppw; float gly = 2 / glob_game.pph; */ /* glx *= lander->x; gly *= lander->y; glx--; gly--; */ float glx = lander->x; float gly = lander->y; mat4x4_scale_aniso(temp, ident, DEFAULT_SCALE, DEFAULT_SCALE, DEFAULT_SCALE); mat4x4_rotate_Z(temp, temp, lander->rotation); mat4x4_translate(trans, glx, gly, 0); mat4x4_mul(ident, trans, temp); mat4x4_transpose(lander->mvMatrix, ident); }
static void recalculate_matrices(struct ball *b) { mat4x4_identity(b->model_matrix); mat4x4_translate_in_place(b->model_matrix, b->x, b->y, b->z); mat4x4_scale_aniso(b->model_matrix, b->model_matrix, SCALE_FACTOR, SCALE_FACTOR, SCALE_FACTOR); mat4x4_invert(b->normal_matrix, b->model_matrix); mat4x4_transpose(b->normal_matrix, b->normal_matrix); }
static void wolf_frame(struct point2 *position, struct vector2 *direction, float angle) { glClearColor(0,0,0,0); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); mat4x4 project; mat4x4_identity(project); mat4x4_perspective(project, degrees_to_radians(FOV), 640.0/480.0, 0.1f, 64.0f); mat4x4_identity(model_view); vec3 eye; eye[0] = position->x; eye[1] = 0.3; eye[2] = position->y; vec3 center; center[0] = position->x+direction->x; center[1] = 0.3; center[2] = position->y+direction->y; vec3 up; up[0] = 0.0; up[1] = 1.0; up[2] = 0.0; mat4x4_look_at(model_view, eye, center, up); glMatrixMode(GL_PROJECTION); glLoadMatrixf((const GLfloat*) project); glMatrixMode(GL_MODELVIEW); glLoadMatrixf((const GLfloat*) model_view); glEnable(GL_DEPTH_TEST); wolf_draw_floor(); wolf_raycast(position, angle, wolf_draw_wall); }
void mat4x4_translate_independed(mat4x4 m, float x, float y, float z) { mat4x4 tr; mat4x4_identity(tr); mat4x4_translate_in_place(tr, x, y, z); //mat4x4 model_matrix2_tr; //mat4x4_mul(model_matrix2_tr, tr, m); mat4x4 m_dup; mat4x4_dup(m_dup, m); mat4x4_mul(m, tr, m_dup ); }
Primitive* createPrimitive(unsigned int primitiveCount) { Primitive *tmp; int i; unsigned int len = sizeof(*tmp)*primitiveCount; assert(primitiveCount > 0); tmp = malloc(len); memset(tmp, 0, len); for (i = 0; i < primitiveCount; ++i) mat4x4_identity(tmp[i].transf); return tmp; }
void rtt_draw() { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, rtt_tex); mat4x4 id; mat4x4_identity(id); glUseProgram(fx); glUniform1i(glGetUniformLocation(fx, "tex"), 0); glUniform1f(glGetUniformLocation(fx, "time"), glfwGetTime()); glUniform1i(glGetUniformLocation(fx, "effect"), rtt_effect); glBindVertexArray(rtt_vao); glBindBuffer(GL_ARRAY_BUFFER, rtt_vbo); glDrawArrays(GL_QUADS, 0, 4); }
void cubeUpdate(CubeRenderPacket* cube, vec3 rot, float angle, float x, float y, float z, float* view, float* proj) { static mat4x4 temp; memcpy(cube->transforms.view, view, 16 * sizeof(float)); memcpy(cube->transforms.proj, proj, 16 * sizeof(float)); vec3_norm(rot, rot); mat4x4_identity(cube->transforms.world); mat4x4_translate_in_place(cube->transforms.world, x, y, z); mat4x4_rotate(cube->transforms.world, cube->transforms.world, rot[0], rot[1], rot[2], angle); mat4x4_mul(temp, cube->transforms.view, cube->transforms.world); mat4x4_mul(cube->transforms.proj_view_world, cube->transforms.proj, temp); gfxBindUniformBuffer(cube->ubo, &cube->transforms, sizeof(struct Transforms), 0); }
int main(void) { // set error callback glfwSetErrorCallback(error_callback); // init environment glfwInit(); // check GLFW and GLES version // glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); // create window context GLFWwindow *window = glfwCreateWindow(640, 480, "untitled_1", NULL, NULL); glfwSetFramebufferSizeCallback(window, reshape_callback); glfwMakeContextCurrent(window); glfwSwapInterval(1); // load dynamic gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); // show current OpenGL variables printf("GL_VERSION : %s\n", glGetString(GL_VERSION)); printf("GL_RENDERER : %s\n", glGetString(GL_RENDERER)); // shader GLuint vertex_shader = create_shader(GL_VERTEX_SHADER, vertex_shader_text); GLuint fragment_shader = create_shader(GL_FRAGMENT_SHADER, fragment_shader_text); GLuint program = link_program(vertex_shader, fragment_shader); // load data from application to gpu GLuint vertex_buffer; glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GLint mvp_location = glGetUniformLocation(program, "MVP"); GLint vpos_location = glGetAttribLocation(program, "vPosition"); GLint vcol_location = glGetAttribLocation(program, "vColor"); glEnableVertexAttribArray((GLuint) vpos_location); glVertexAttribPointer((GLuint) vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void *) 0); glEnableVertexAttribArray((GLuint) vcol_location); glVertexAttribPointer((GLuint) vcol_location, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void *) (sizeof(float) * 2)); // uint32_t counter = 0; float angle = 0; // main loop, keep running while (!glfwWindowShouldClose(window)) { int width, height; glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT); float ratio = (float) width / height; // mat4x4 m, p, mvp; mat4x4_identity(m); mat4x4_rotate_Z(m, m, angle); // 构建旋转矩阵 counter += 1; if (counter < 100) { angle += 0.01; } else if ((counter < 200)) { angle -= 0.02; } else { counter = 0; } // mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f); // 处理缩放 mat4x4_mul(mvp, p, m); // 组合旋转+缩放 // apply shader glUseProgram(program); // Specify the value of a uniform variable for the current program object glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat *) mvp); // draw glDrawArrays(GL_TRIANGLES, 0, 3); // window has two buffers, one for display, another for render // after render, we need to swap them to display glfwSwapBuffers(window); // process events glfwPollEvents(); } // destroy glfwDestroyWindow(window); glfwTerminate(); return 0; }
void initFace(Faces *face) { assert(NULL != face); memset(face, 0, sizeof(*face)); mat4x4_identity(face->transf); }
/// // Draw triangles using the shader pair created in Init() // void gl_image_draw(GL_STATE_T *p_state) { ImageInstanceData *userData = p_state->user_data; GLShapeInstanceData *shapeData = &userData->shape; GLImageDisplayData *displayData = p_state->imageDisplayData; mat4x4 projection; mat4x4 modelView; mat4x4 projection_scaled; mat4x4 translation; mat4x4 projection_final; GLfloat vVertices[] = { 0.0f, 0.0f, 0.0f, // Position 0 0.0f, 0.0f, // TexCoord 0 0.0f, 1.0f, 0.0f, // Position 1 0.0f, 1.0f, // TexCoord 1 1.0f, 1.0f, 0.0f, // Position 2 1.0f, 1.0f, // TexCoord 2 1.0f, 0.0f, 0.0f, // Position 3 1.0f, 0.0f // TexCoord 3 }; GLfloat texCoords[8]; TexCoordsForRotation(shapeData->orientation, texCoords); vVertices[3] = texCoords[0]; vVertices[4] = texCoords[1]; vVertices[8] = texCoords[2]; vVertices[9] = texCoords[3]; vVertices[13] = texCoords[4]; vVertices[14] = texCoords[5]; vVertices[18] = texCoords[6]; vVertices[19] = texCoords[7]; GLushort indices[] = { 0, 1, 2, 0, 2, 3 }; //GLushort indices[] = {1, 0, 3, 0, 2, 0, 1 }; // Use the program object glUseProgram ( displayData->programObject ); // Load the vertex position glVertexAttribPointer ( displayData->positionLoc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vVertices ); // Load the texture coordinate glVertexAttribPointer ( displayData->texCoordLoc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &vVertices[3] ); glEnableVertexAttribArray ( displayData->positionLoc ); glEnableVertexAttribArray ( displayData->texCoordLoc ); // Bind the texture glActiveTexture ( GL_TEXTURE0 ); glBindTexture ( GL_TEXTURE_2D, userData->textureId ); // Set the sampler texture unit to 0 glUniform1i ( displayData->samplerLoc, 0 ); mat4x4_identity(projection); mat4x4_scale_aniso(projection_scaled, projection, 2.0/p_state->width, -2.0/p_state->height, 1.0); mat4x4_translate(translation, -1, 1, 0); mat4x4_mul(projection_final, translation, projection_scaled); mat4x4_translate(translation, shapeData->objectX, shapeData->objectY, 0.0); mat4x4_identity(projection); mat4x4_scale_aniso(projection_scaled, projection, shapeData->objectWidth, shapeData->objectHeight, 1.0); mat4x4_mul(modelView, translation, projection_scaled); glUniformMatrix4fv ( displayData->projectionLoc, 1, GL_FALSE, (GLfloat *)projection_final); glUniformMatrix4fv ( displayData->modelViewLoc, 1, GL_FALSE, (GLfloat *)modelView); glDrawElements ( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices ); //glDrawElements ( GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, indices ); }
int main(int argc, char** argv) { int count = 0; double base; GLFWwindow* window; srand((unsigned int) time(NULL)); glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); for (;;) { int width, height; GLFWmonitor* monitor = NULL; GLuint vertex_shader, fragment_shader, program, vertex_buffer; GLint mvp_location, vpos_location; if (count & 1) { int monitorCount; GLFWmonitor** monitors = glfwGetMonitors(&monitorCount); monitor = monitors[rand() % monitorCount]; } if (monitor) { const GLFWvidmode* mode = glfwGetVideoMode(monitor); width = mode->width; height = mode->height; } else { width = 640; height = 480; } base = glfwGetTime(); window = glfwCreateWindow(width, height, "Window Re-opener", monitor, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } if (monitor) { printf("Opening full screen window on monitor %s took %0.3f seconds\n", glfwGetMonitorName(monitor), glfwGetTime() - base); } else { printf("Opening regular window took %0.3f seconds\n", glfwGetTime() - base); } glfwSetWindowCloseCallback(window, window_close_callback); glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); glfwSwapInterval(1); vertex_shader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL); glCompileShader(vertex_shader); fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL); glCompileShader(fragment_shader); program = glCreateProgram(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glLinkProgram(program); mvp_location = glGetUniformLocation(program, "MVP"); vpos_location = glGetAttribLocation(program, "vPos"); glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(vertices[0]), (void*) 0); glfwSetTime(0.0); while (glfwGetTime() < 5.0) { float ratio; int width, height; mat4x4 m, p, mvp; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float) height; glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT); mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 0.f, 1.f); mat4x4_identity(m); mat4x4_rotate_Z(m, m, (float) glfwGetTime()); mat4x4_mul(mvp, p, m); glUseProgram(program); glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glfwSwapBuffers(window); glfwPollEvents(); if (glfwWindowShouldClose(window)) { close_window(window); printf("User closed window\n"); glfwTerminate(); exit(EXIT_SUCCESS); } } printf("Closing window\n"); close_window(window); count++; } glfwTerminate(); }
int main(void) { glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); GLFWmonitor *monitor = glfwGetPrimaryMonitor(); const GLFWvidmode *mode = glfwGetVideoMode(monitor); printf("monitor mode: %d, %d\n", mode->width, mode->height); // if DEBUG { // glfw.WindowHint(glfw.OpenGLDebugContext, gl.TRUE) // } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 1); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); GLFWwindow *window = glfwCreateWindow(mode->width, mode->height, "Hialin", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); glfwSwapInterval(0); p_glBindFragDataLocation = (glBindFragDataLocation_t)glfwGetProcAddress("glBindFragDataLocation"); if (!p_glBindFragDataLocation) { printf("\n failed glBindFragDataLocation"); glfwTerminate(); exit(EXIT_FAILURE); } p_glGenVertexArrays = (glGenVertexArrays_t)glfwGetProcAddress("glGenVertexArrays"); if (!p_glGenVertexArrays) { printf("\n failed glGenVertexArrays"); glfwTerminate(); exit(EXIT_FAILURE); } p_glBindVertexArray = (glBindVertexArray_t)glfwGetProcAddress("glBindVertexArray"); if (!p_glBindVertexArray) { printf("\n failed glBindVertexArray"); glfwTerminate(); exit(EXIT_FAILURE); } GLuint vsh = glCreateShader(GL_VERTEX_SHADER); { glShaderSource(vsh, 1, &vertex_shader_text, NULL); glCompileShader(vsh); int result; glGetShaderiv(vsh, GL_COMPILE_STATUS, &result ); if (result == GL_FALSE) { int logLength; glGetShaderiv(vsh, GL_INFO_LOG_LENGTH, &logLength); char log[10*1024] = {0}; glGetShaderInfoLog(vsh, logLength, NULL, log); printf("\nvertex shader compile: %s", log); glfwTerminate(); exit(EXIT_FAILURE); } } glCheck(); GLuint fsh = glCreateShader(GL_FRAGMENT_SHADER); { glShaderSource(fsh, 1, &fragment_shader_text, NULL); glCompileShader(fsh); int result; glGetShaderiv(fsh, GL_COMPILE_STATUS, &result); if (result == GL_FALSE) { int logLength; glGetShaderiv(fsh, GL_INFO_LOG_LENGTH, &logLength); char log[10*1024] = {0}; glGetShaderInfoLog(fsh, logLength, NULL, log); printf("\nfragment shader compile: %s", log); glfwTerminate(); exit(EXIT_FAILURE); } } glCheck(); GLuint program = glCreateProgram(); { glAttachShader(program, vsh); glAttachShader(program, fsh); glLinkProgram(program); int result; glGetProgramiv(program, GL_LINK_STATUS, &result); if (result == GL_FALSE) { int logLength; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength); char log[10*1024] = {0}; glGetProgramInfoLog(program, logLength, NULL, log); printf("\nprogram link: \n%s", log); glfwTerminate(); exit(EXIT_FAILURE); } } glCheck(); glUseProgram(program); glCheck(); GLint projectionU = glGetUniformLocation(program, "projection"); mat4x4 camera; vec3 eye = {3, 3, 3}, center = {0, 0, 0}, up = {0, 1, 0}; mat4x4_look_at(camera, eye, center, up); GLint cameraU = glGetUniformLocation(program, "camera"); glUniformMatrix4fv(cameraU, 1, GL_FALSE, (const float*)camera); glCheck(); mat4x4 model; mat4x4_identity(model); GLint modelU = glGetUniformLocation(program, "model"); glUniformMatrix4fv(modelU, 1, GL_FALSE, (const float*)model); glCheck(); GLint texU = glGetUniformLocation(program, "tex"); glUniform1i(texU, 0); p_glBindFragDataLocation(program, 0, "outputColor"); glCheck(); // Load the texture // char *texturePath = "./Resources/code.png" // GLuint texture = MakeTexture(0, texturePath); GLuint texture = MakeTexture(0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); glCheck(); // Configure the vertex data GLuint vao; p_glGenVertexArrays(1, &vao); p_glBindVertexArray(vao); glCheck(); GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW); glCheck(); GLuint val = glGetAttribLocation(program, "vert"); glEnableVertexAttribArray(val); glVertexAttribPointer(val, 3, GL_FLOAT, GL_FALSE, 5*4, (const void *)(0*4)); glCheck(); GLuint valTC = glGetAttribLocation(program, "vertTexCoord"); glEnableVertexAttribArray(valTC); glVertexAttribPointer(valTC, 2, GL_FLOAT, GL_FALSE, 5*4, (const void *)(3*4)); glCheck(); // Configure global settings glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glClearColor(0.0, 0.0, 0.0, 1.0); glCheck(); long time0 = tick(); float angle = 0.01; int width = 0, height = 0; int i = 0; while (!glfwWindowShouldClose(window)) { int w, h; glfwGetFramebufferSize(window, &w, &h); if (w != width || h != height) { width = w; height = h; glViewport(0, 0, width, height); printf("buffer size: %d %d\n", w, h); } float ratio = width/(float)height; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); mat4x4_rotate_Y(model, model, angle); mat4x4 projection; mat4x4_perspective(projection, 0.785, ratio, 0.1, 10.0); // 45 degrees == 0.785 radians glUniformMatrix4fv(projectionU, 1, GL_FALSE, (const float*)projection); glUniformMatrix4fv(modelU, 1, GL_FALSE, (const float*)model); for (int i = 0; i < 1*1000; i++) { glDrawArrays(GL_TRIANGLES, 0, 6*2*3); // 12 triangles } i++; if (i == 100) { printf("time for 100 frames: %ld\n", tick()-time0); } else if (i == 1000) { printf("time for 1000 frames: %ld\n", tick()-time0); break; } glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { GLFWwindow* window; GLuint vertex_buffer, vertex_shader, fragment_shader, program; GLint mvp_location, vpos_location, vcol_location; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); glfwSwapInterval(1); // NOTE: OpenGL error checks have been omitted for brevity glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); vertex_shader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL); glCompileShader(vertex_shader); fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL); glCompileShader(fragment_shader); program = glCreateProgram(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glLinkProgram(program); mvp_location = glGetUniformLocation(program, "MVP"); vpos_location = glGetAttribLocation(program, "vPos"); vcol_location = glGetAttribLocation(program, "vCol"); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*) 0); glEnableVertexAttribArray(vcol_location); glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*) (sizeof(float) * 2)); while (!glfwWindowShouldClose(window)) { float ratio; int width, height; mat4x4 m, p, mvp; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float) height; glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT); mat4x4_identity(m); mat4x4_rotate_Z(m, m, (float) glfwGetTime()); mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f); mat4x4_mul(mvp, p, m); glUseProgram(program); glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp); glDrawArrays(GL_TRIANGLES, 0, 3); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { Primative *edits[] = { primative_create(CUBE, ADDITIVE), primative_create(SPHERE, ADDITIVE), primative_create(SPHERE, SUBTRACTIVE), primative_create(SPHERE, ADDITIVE) }; primative_scale(edits[0], 0.4, 1.0, 1.5); primative_translate(edits[1], 0.2, 0, 0); primative_translate(edits[2], -0.3, 0, 0); primative_translate(edits[3], -0.5, 0, 0); primative_scale(edits[3], 0.5, 0.5, 0.5); edits[1]->blend = 0.2; sdf_args.edits = edits; sdf_args.num_edits = 4; vec3 origin = {0, 0, 0}; vec3 halfDim = {1, 1, 1}; OctTree *tree = octTree_create(origin, halfDim); octTree_populate(tree, distance); int num_verticies = octTree_count(tree); size_t vert_size = sizeof(Point); fprintf(stdout, "num verts %d\n", num_verticies); int vi = 0; Point *verticies = malloc(num_verticies * vert_size); octTree_get_points(tree, verticies, &vi); GLFWwindow* window; mat4x4 ident; mat4x4_identity(ident); glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); window = glfwCreateWindow(640, 480, "speed dream", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); glfwSwapInterval(1); glEnable(GL_PROGRAM_POINT_SIZE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glfwSetKeyCallback(window, key_callback); mat4x4 proj; mat4x4 view; mat4x4 matrix; mat4x4_identity(view); mat4x4_identity(matrix); vec3_set(camera.pos, 0.0f, 0.0f, 0.0f); // Create Vertex Array Object GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); // Create a Vertex Buffer Object and copy the vertex data to it GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, num_verticies * vert_size, verticies, GL_STATIC_DRAW); // Create and compile the shaders GLuint vertexShader = loadShader(GL_VERTEX_SHADER, DREAM_VERT); GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, DREAM_FRAG); // Link the vertex and fragment shader into a shader program GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glBindFragDataLocation(shaderProgram, 0, "outColor"); glLinkProgram(shaderProgram); glUseProgram(shaderProgram); // Specify the layout of the vertex data GLint posAttrib = glGetAttribLocation(shaderProgram, "position"); glEnableVertexAttribArray(posAttrib); glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, vert_size, 0); GLint normAttrib = glGetAttribLocation(shaderProgram, "normal"); glEnableVertexAttribArray(normAttrib); glVertexAttribPointer(normAttrib, 3, GL_FLOAT, GL_FALSE, vert_size, (void*)(3 * sizeof(GLfloat))); GLint colorAttrib = glGetAttribLocation(shaderProgram, "color"); glEnableVertexAttribArray(colorAttrib); glVertexAttribPointer(colorAttrib, 3, GL_FLOAT, GL_FALSE, vert_size, (void*)(6 * sizeof(GLfloat))); GLint uniModel = glGetUniformLocation(shaderProgram, "model"); GLint uniView = glGetUniformLocation(shaderProgram, "view"); GLint uniProj = glGetUniformLocation(shaderProgram, "proj"); vec3 lightPos = {3.f, 0.f, 3.f}; GLint uniLightPos = glGetUniformLocation(shaderProgram, "lightPos"); glUniform3fv(uniLightPos, 1, (const GLfloat *)&lightPos); while (!glfwWindowShouldClose(window)) { float ratio; int width, height; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float) height; glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); vec4 movement = {0, 0, 0, 1}; if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS) movement[0] -= 0.1; if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS) movement[0] += 0.1; if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS) movement[2] += 0.1; if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS) movement[2] -= 0.1; if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) camera.pitch -= 0.05; if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) camera.pitch += 0.05; if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) camera.yaw += 0.05; if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) camera.yaw -= 0.05; mat4x4 pitch_mat; mat4x4_identity(pitch_mat); mat4x4_rotate_X(pitch_mat, pitch_mat, camera.pitch); mat4x4 yaw_mat; mat4x4_identity(yaw_mat); mat4x4_rotate_Y(yaw_mat, yaw_mat, camera.yaw); mat4x4 inv_yaw_mat; mat4x4_invert(inv_yaw_mat, yaw_mat); vec4 rotated_movement; mat4x4_mul_vec4(rotated_movement, inv_yaw_mat, movement); camera.pos[0] += rotated_movement[0]; camera.pos[1] += rotated_movement[1]; camera.pos[2] += rotated_movement[2]; mat4x4 translation_mat; mat4x4_translate(translation_mat, camera.pos[0], camera.pos[1], camera.pos[2]); mat4x4_mul(view, pitch_mat, yaw_mat); mat4x4_mul(view, view, translation_mat); glUniformMatrix4fv(uniView, 1, GL_FALSE, (const GLfloat *)&view); mat4x4_perspective(proj, 60 * M_PI / 180, ratio, 0.1f, 10.0f); glUniformMatrix4fv(uniProj, 1, GL_FALSE, (const GLfloat *)&proj); glUniformMatrix4fv(uniModel, 1, GL_FALSE, (const GLfloat *)&matrix); glDrawArrays(GL_POINTS, 0, num_verticies); glfwSwapBuffers(window); glfwPollEvents(); } glDeleteProgram(shaderProgram); glDeleteShader(fragmentShader); glDeleteShader(vertexShader); glDeleteBuffers(1, &vbo); glDeleteVertexArrays(1, &vao); glfwDestroyWindow(window); free(verticies); glfwTerminate(); exit(EXIT_SUCCESS); }