/// // 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 ); }
void Tile::render(Camera *camera){ //if(interceptRect(camera->getRect())){ mat4x4_mul(*camera->getViewProjectionMatrix(), *camera->getProjectionMatrix(), *camera->getViewMatrix()); mat4x4_translate(model_matrix, (float)x, (float)y, (float)z); //mat4x4_translate_in_place(model_matrix, camX, camY, camZ); mat4x4_mul(model_view_projection_matrix, *camera->getViewProjectionMatrix(), model_matrix); glUniformMatrix4fv(_modelViewUniform, 1, 0, (GLfloat*)model_view_projection_matrix); glVertexAttribPointer(_positionSlot, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0); glVertexAttribPointer(_texCoordSlot, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*) (sizeof(float) * 3)); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); glUniform1i(_textureUniform, 0); glDrawElements(GL_TRIANGLES, sizeof(Indices)/sizeof(Indices[0]), GL_UNSIGNED_BYTE, 0); //}else{ //} }
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 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); }
int main(int argc, char** argv) { unsigned long frame_count = 0; double last_time, current_time; GLFWwindow* window; GLuint vertex_buffer, vertex_shader, fragment_shader, program; GLint mvp_location, vpos_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, "Tearing detector", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); gladLoadGL(glfwGetProcAddress); set_swap_interval(window, 0); last_time = glfwGetTime(); frame_rate = 0.0; swap_tear = (glfwExtensionSupported("WGL_EXT_swap_control_tear") || glfwExtensionSupported("GLX_EXT_swap_control_tear")); glfwSetKeyCallback(window, key_callback); 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"); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(vertices[0]), (void*) 0); while (!glfwWindowShouldClose(window)) { int width, height; mat4x4 m, p, mvp; float position = cosf((float) glfwGetTime() * 4.f) * 0.75f; glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT); mat4x4_ortho(p, -1.f, 1.f, -1.f, 1.f, 0.f, 1.f); mat4x4_translate(m, position, 0.f, 0.f); 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(); frame_count++; current_time = glfwGetTime(); if (current_time - last_time > 1.0) { frame_rate = frame_count / (current_time - last_time); frame_count = 0; last_time = current_time; update_window_title(window); } } glfwTerminate(); exit(EXIT_SUCCESS); }
void G_Tick() { BufferTextInput(); if (G_ContainsHeightMap(*((heightmap*)((object*)G_staticMeshes.first->value)->shape), G_camPos)) printf("\rYes\n"); vec3 dir = {0, 0, 0}; float moveSpeed = G_moveSpeed * (SYS_deltaMillis / 1000.0); float rotSpeed = G_rotSpeed * (SYS_deltaMillis / 1000.0); if (IN_IsKeyPressed(IN_W)) dir[2] -= moveSpeed; if (IN_IsKeyPressed(IN_A)) dir[0] -= moveSpeed; if (IN_IsKeyPressed(IN_S)) dir[2] += moveSpeed; if (IN_IsKeyPressed(IN_D)) dir[0] += moveSpeed; if (IN_IsKeyPressed(IN_UP)) dir[1] += moveSpeed; if (IN_IsKeyPressed(IN_DOWN)) dir[1] -= moveSpeed; if (IN_IsKeyPressed(IN_RIGHT)) G_camRot[1] += rotSpeed; if (IN_IsKeyPressed(IN_LEFT)) G_camRot[1] -= rotSpeed; if (IN_IsKeyPressed(IN_PITCH_UP)) G_camRot[0] += rotSpeed; if (IN_IsKeyPressed(IN_PITCH_DOWN)) G_camRot[0] -= rotSpeed; if (IN_IsKeyPressed(IN_ACTION)) { if (!actionHeld) { Shoot(); actionHeld = true; } }else actionHeld = false; if (IN_IsKeyPressed(IN_TOGGLE)) { if (!toggleHeld) { ads = ads ? false : true; lastAdsTime = SYS_TimeMillis() / 1000.0; toggleHeld = true; } }else toggleHeld = false; if (IN_IsKeyPressed(IN_CHAT)) { if (!chatHeld) { IN_StartTextInput(); C_console.inputActive = true; chatHeld = true; } }else chatHeld = false; if (IN_IsKeyPressed(IN_RELOAD)) { ReloadLevel(); } if (G_camRot[0] > PITCH_LIMIT) G_camRot[0] = PITCH_LIMIT; else if (G_camRot[0] < -PITCH_LIMIT) G_camRot[0] = -PITCH_LIMIT; float c = cos(G_camRot[1]); float s = sin(G_camRot[1]); G_camPos[0] += -dir[2] * s + dir[0] * c; G_camPos[2] += dir[2] * c + dir[0] * s; G_camPos[1] += dir[1]; mat4x4_translate(G_gunMat, G_camPos[0], G_camPos[1], G_camPos[2]); mat4x4_rotate_Y(G_gunMat, G_gunMat, G_camRot[1] + M_PI); mat4x4_rotate_X(G_gunMat, G_gunMat, -G_camRot[0]); double d, f; { termf terms[2] = {{2, 2}, {-1, 4}}; d = G_Valuef((function) {0, 1, 2, terms}, (SYS_TimeMillis() / 1000.0 - lastAdsTime) * 5); if (ads) d = 1 - d; } { termf terms[2] = {{1, 0.3}, {-1, 1}}; f = G_Valuef((function) {0, 1, 2, terms}, (SYS_TimeMillis() / 1000.0 - lastShootTime) * 5); } V_SetProj(fov->value * d + adsFov->value * (1 - d)); vec3 resultant = {0, 0, 0}; for (int i = 0; i < 3; i++) { resultant[i] += defGunPos[i]; resultant[i] += hipGunPos[i] * d; resultant[i] += fireGunPos[i] * f; resultant[i] += hipFireGunPos[i] * d * f; } resultant[0] += d * 0.01 * cos(SYS_TimeMillis() / 2000.0); resultant[1] += d * 0.005 * cos(SYS_TimeMillis() / 1500.0); mat4x4_translate_in_place(G_gunMat, resultant[0], resultant[1], resultant[2]); HandleSmoke(); if (IN_IsKeyPressed(IN_RELOAD)) V_reloadShaders = true; }
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); }
int main(int argc, char** argv) { int ch, samples = 4; GLFWwindow* window; GLuint vertex_buffer, vertex_shader, fragment_shader, program; GLint mvp_location, vpos_location; while ((ch = getopt(argc, argv, "hs:")) != -1) { switch (ch) { case 'h': usage(); exit(EXIT_SUCCESS); case 's': samples = atoi(optarg); break; default: usage(); exit(EXIT_FAILURE); } } glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); if (samples) printf("Requesting MSAA with %i samples\n", samples); else printf("Requesting that MSAA not be available\n"); glfwWindowHint(GLFW_SAMPLES, samples); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); window = glfwCreateWindow(800, 400, "Aliasing Detector", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); glfwSwapInterval(1); glGetIntegerv(GL_SAMPLES, &samples); if (samples) printf("Context reports MSAA is available with %i samples\n", samples); else printf("Context reports MSAA is unavailable\n"); 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"); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(vertices[0]), (void*) 0); while (!glfwWindowShouldClose(window)) { float ratio; int width, height; mat4x4 m, p, mvp; const double angle = glfwGetTime() * M_PI / 180.0; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float) height; glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(program); mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 0.f, 1.f); mat4x4_translate(m, -1.f, 0.f, 0.f); mat4x4_rotate_Z(m, m, (float) angle); mat4x4_mul(mvp, p, m); glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp); glDisable(GL_MULTISAMPLE); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); mat4x4_translate(m, 1.f, 0.f, 0.f); mat4x4_rotate_Z(m, m, (float) angle); mat4x4_mul(mvp, p, m); glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp); glEnable(GL_MULTISAMPLE); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
/// // 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 ); }