void gfxBlitTexture(uint32 tex, float x, float y, float w, float h, float wnd_w, float wnd_h)
{
mat4x4 ortho;
mat4x4_ortho(ortho, 0.f, wnd_w, wnd_h, 0.f, 0.f, 100.f);
gfxBindTextures2D(&tex, &s_blitQuadTEX.texLocation, 1, s_blitQuadTEX.rp.fsh);
ssquadResize(&s_blitQuadTEX.rp, ortho, x, y, w, h);
ssquadDraw(&s_blitQuadTEX.rp);
}
static inline void _calc_zoom(game *g, int dir) {
g->d.zoom_level += dir;
g->d.zoom = pow(g->d.zoom_amount, g->d.zoom_level - (g->d.ortho ? 0 : 6));
_update_translations(g);
float zoom = 1 / g->d.zoom;
if (g->d.ortho) {
mat4x4_ortho(g->d.proj, -g->aspect * zoom, g->aspect * zoom, -1 * zoom, 1 * zoom, 1, 1000);
} else {
vec3 temp;
memcpy(&g->d.eye_zoom, &g->d.eye, sizeof(g->d.eye_zoom));
vec3_scale(temp, g->d.view_f, zoom);
vec3_sub(g->d.eye_zoom, g->d.center, temp);
}
}
static inline void _setup_camera(game *g) {
if (g->d.ortho) {
mat4x4_ortho(g->d.proj, -g->aspect, g->aspect, -1, 1, 0.001, 1000);
} else {
mat4x4_perspective(g->d.proj, 45.0, g->aspect, 0.001, 1000.0);
}
vec3_sub(g->d.view_f, g->d.center, g->d.eye);
vec3_norm(g->d.view_f, g->d.view_f);
vec3_mul_cross(g->d.view_r, g->d.view_f, g->d.up);
vec3_norm(g->d.view_r, g->d.view_r);
vec3_mul_cross(g->d.view_u, g->d.view_r, g->d.view_f);
_calc_zoom(g, 0); // Update zoom for this view type
}
int init_context(void)
{
int depth = config.board_width+config.board_height;
glewExperimental = GL_TRUE;
glewInit();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/* Load shaders and make them active */
if (!load_shaders())
goto err_shaders;
init_players_rendering();
mat4x4_ortho(projection, 0, config.screen_width, config.screen_height, 0, -depth, 0);
return 1;
err_shaders:
return 0;
}
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(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);
}
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;
}
int main(int argc, char** argv)
{
int ch;
GLFWwindow* windows[2];
GLuint texture, program, vertex_buffer;
GLint mvp_location, vpos_location, color_location, texture_location;
srand((unsigned int) time(NULL));
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "d")) != -1)
{
switch (ch)
{
case 'd':
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
break;
}
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
windows[0] = glfwCreateWindow(400, 400, "First", NULL, NULL);
if (!windows[0])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetKeyCallback(windows[0], key_callback);
glfwMakeContextCurrent(windows[0]);
// Only enable vsync for the first of the windows to be swapped to
// avoid waiting out the interval for each window
glfwSwapInterval(1);
// The contexts are created with the same APIs so the function
// pointers should be re-usable between them
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
if (GLAD_GL_KHR_debug)
{
glDebugMessageCallback(debug_callback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
}
// Create the OpenGL objects inside the first context, created above
// All objects will be shared with the second context, created below
{
int x, y;
char pixels[16 * 16];
GLuint vertex_shader, fragment_shader;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
for (y = 0; y < 16; y++)
{
for (x = 0; x < 16; x++)
pixels[y * 16 + x] = rand() % 256;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 16, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
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");
color_location = glGetUniformLocation(program, "color");
texture_location = glGetUniformLocation(program, "texture");
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);
}
glUseProgram(program);
glUniform1i(texture_location, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof(vertices[0]), (void*) 0);
windows[1] = glfwCreateWindow(400, 400, "Second", NULL, windows[0]);
if (!windows[1])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
// Place the second window to the right of the first
{
int xpos, ypos, left, right, width;
glfwGetWindowSize(windows[0], &width, NULL);
glfwGetWindowFrameSize(windows[0], &left, NULL, &right, NULL);
glfwGetWindowPos(windows[0], &xpos, &ypos);
glfwSetWindowPos(windows[1], xpos + width + left + right, ypos);
}
glfwSetKeyCallback(windows[1], key_callback);
glfwMakeContextCurrent(windows[1]);
// While objects are shared, the global context state is not and will
// need to be set up for each context
glUseProgram(program);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof(vertices[0]), (void*) 0);
while (!glfwWindowShouldClose(windows[0]) &&
!glfwWindowShouldClose(windows[1]))
{
int i;
const vec3 colors[2] =
{
{ 0.3f, 0.4f, 1.f },
{ 0.8f, 0.4f, 1.f }
};
for (i = 0; i < 2; i++)
{
int width, height;
mat4x4 mvp;
glfwGetFramebufferSize(windows[i], &width, &height);
glfwMakeContextCurrent(windows[i]);
glViewport(0, 0, width, height);
mat4x4_ortho(mvp, 0.f, 1.f, 0.f, 1.f, 0.f, 1.f);
glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp);
glUniform3fv(color_location, 1, colors[i]);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glfwSwapBuffers(windows[i]);
}
glfwWaitEvents();
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
static void _init_overlay(game *g) {
overlay *o = &g->o;
// Texture values
o->tex_format = GL_RGBA;
o->int_format = GL_RGBA8;
o->tex_type = GL_UNSIGNED_INT_8_8_8_8;
o->alignment = 4;
// Font values
o->update_text_max = 8;
o->label_text_max = 32;
o->text_pad = 0.5;
o->font_spacing = 1.2;
// Surface values
Uint32 rmask = 0xff000000;
Uint32 gmask = 0x00ff0000;
Uint32 bmask = 0x0000ff00;
Uint32 amask = 0x000000ff;
// Overlay stuff
o->size = 0.4;
o->mvp = malloc(sizeof(mat4x4));
mat4x4_ortho(*o->mvp, -g->aspect, g->aspect, -1.0, 1.0, 0, 10);
int win_width, win_height, overlay_width, overlay_height;
SDL_GetWindowSize(g->win, &win_width, &win_height);
overlay_width = win_width * o->size;
overlay_height = win_height * o->size;
float overlay_triangles[8] = {
-g->aspect*o->size, o->size, // Top left
-g->aspect*o->size, -o->size, // Bottom left
g->aspect*o->size, -o->size, // Bottom right
g->aspect*o->size, o->size, // Top right
};
GLubyte overlay_elements[6] = {
0, 1, 2,
0, 2, 3
};
float overlay_tex_coords[8] = {
0.0, 0.0, // Top left
0.0, 1.0, // Bottom left
1.0, 1.0, // Bottom right
1.0, 0.0, // Top right
};
o->matrix_id = glGetUniformLocation(g->overlay_shader, "MVP");
o->tex_coords_id = glGetAttribLocation(g->overlay_shader, "tex_coord");
glUseProgram(g->overlay_shader);
glUniformMatrix4fv(o->matrix_id, 1, GL_FALSE, (GLfloat *) o->mvp);
glUseProgram(0);
glGenBuffers(1, &o->vert_buf);
glBindBuffer(GL_ARRAY_BUFFER, o->vert_buf);
glBufferData(GL_ARRAY_BUFFER, sizeof(overlay_triangles), &overlay_triangles, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &o->tex_coord_buf);
glBindBuffer(GL_ARRAY_BUFFER, o->tex_coord_buf);
glBufferData(GL_ARRAY_BUFFER, sizeof(overlay_tex_coords), &overlay_tex_coords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &o->el_buf);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, o->el_buf);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(overlay_elements), &overlay_elements, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
// Set up font things
char *res_path = get_res_path(""),
*font_path = join_path(res_path, "DejaVuSansMono.ttf");
o->font = TTF_OpenFont(font_path, 14);
free(res_path);
free(font_path);
o->font_text = calloc(o->update_text_max+1, sizeof(char));
o->bg = SDL_CreateRGBSurface(
0, overlay_width, overlay_height, 32, rmask, gmask, bmask, amask
);
if (o->bg == NULL) {
printf("BLARGH: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
o->font_text[0] = 'W';
SDL_Surface *temp_surf;
temp_surf = TTF_RenderText_Solid(o->font, o->font_text, o->font_col);
int font_w = temp_surf->w;
int font_h = temp_surf->h;
SDL_free(temp_surf);
o->font_surf = SDL_CreateRGBSurface(
0, font_w * o->update_text_max + 1, font_h, 32, rmask, gmask, bmask, amask
);
// Render static text
_update_colors(g, g->color_scheme);
glGenTextures(1, &o->tex);
glBindTexture(GL_TEXTURE_2D, o->tex);
glPixelStorei(GL_UNPACK_ALIGNMENT, o->alignment);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, o->int_format, o->bg->w, o->bg->h, 0, o->tex_format, o->tex_type, o->bg->pixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
}
void crop_rotate::toolbar(PapayaMemory* mem)
{
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(3, 0));
if (ImGui::Button("-90")) { mem->crop_rotate.base_rotation--; }
ImGui::SameLine();
if (ImGui::Button("+90")) { mem->crop_rotate.base_rotation++; }
ImGui::SameLine();
ImGui::PopStyleVar();
ImGui::PushItemWidth(85);
ImGui::SliderAngle("Rotate", &mem->crop_rotate.slider_angle, -45.0f, 45.0f);
ImGui::PopItemWidth();
ImGui::SameLine(ImGui::GetWindowWidth() - 94); // TODO: Magic number alert
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2, 0));
if (ImGui::Button("Apply")) {
bool size_changed = (mem->crop_rotate.base_rotation % 2 != 0);
// Swap render texture and document texture handles
if (size_changed) {
int32 temp = mem->doc.width;
mem->doc.width = mem->doc.height;
mem->doc.height = temp;
mat4x4_ortho(mem->doc.proj_mtx,
0.f, (float)mem->doc.width,
0.f, (float)mem->doc.height,
-1.f, 1.f);
mem->doc.inverse_aspect = (float)mem->doc.height /
(float)mem->doc.width;
GLCHK( glDeleteTextures(1, &mem->misc.fbo_sample_tex) );
mem->misc.fbo_sample_tex = gl::allocate_tex(mem->doc.width,
mem->doc.height);
}
GLCHK( glDisable(GL_BLEND) );
GLCHK( glViewport(0, 0, mem->doc.width, mem->doc.height) );
// Bind and clear the frame buffer
GLCHK( glBindFramebuffer(GL_FRAMEBUFFER, mem->misc.fbo) );
GLCHK( glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, mem->misc.fbo_sample_tex, 0) );
GLCHK( glClearColor(0.0f, 0.0f, 0.0f, 0.0f) );
GLCHK( glClear(GL_COLOR_BUFFER_BIT) );
mat4x4 m, r;
// Rotate around center
{
Vec2 offset = Vec2(mem->doc.width * 0.5f,
mem->doc.height * 0.5f);
mat4x4_dup(m, mem->doc.proj_mtx);
mat4x4_translate_in_place(m, offset.x, offset.y, 0.f);
// mat4x4_rotate_Z(r, m, math::to_radians(-90));
mat4x4_rotate_Z(r, m, mem->crop_rotate.slider_angle +
math::to_radians(90.0f * mem->crop_rotate.base_rotation));
if (size_changed) {
mat4x4_translate_in_place(r, -offset.y, -offset.x, 0.f);
} else {
mat4x4_translate_in_place(r, -offset.x, -offset.y, 0.f);
}
}
// Draw the image onto the frame buffer
GLCHK( glBindBuffer(GL_ARRAY_BUFFER, mem->meshes[PapayaMesh_RTTAdd].vbo_handle) );
GLCHK( glUseProgram(mem->shaders[PapayaShader_DeMultiplyAlpha].handle) );
GLCHK( glUniformMatrix4fv(mem->shaders[PapayaShader_ImGui].uniforms[0],
1, GL_FALSE, (GLfloat*)r) );
gl::set_vertex_attribs(mem->shaders[PapayaShader_DeMultiplyAlpha]);
GLCHK( glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)mem->doc.texture_id) );
GLCHK( glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) );
GLCHK( glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) );
GLCHK( glDrawArrays (GL_TRIANGLES, 0, 6) );
uint32 temp = mem->misc.fbo_sample_tex;
mem->misc.fbo_sample_tex = mem->doc.texture_id;
mem->doc.texture_id = temp;
if (size_changed) {
core::resize_doc(mem, mem->doc.width, mem->doc.height);
// Reposition canvas to maintain apparent position
int32 delta = math::round_to_int((mem->doc.height - mem->doc.width)
* 0.5f * mem->doc.canvas_zoom);
mem->doc.canvas_pos.x += delta;
mem->doc.canvas_pos.y -= delta;
}
// Reset stuff
GLCHK( glBindFramebuffer(GL_FRAMEBUFFER, 0) );
GLCHK( glViewport(0, 0, (int32)ImGui::GetIO().DisplaySize.x, (int32)ImGui::GetIO().DisplaySize.y) );
mem->crop_rotate.slider_angle = 0.f;
mem->crop_rotate.base_rotation = 0;
}
ImGui::SameLine();
if (ImGui::Button("Cancel")) {
mem->crop_rotate.slider_angle = 0.f;
mem->crop_rotate.base_rotation = 0;
}
ImGui::PopStyleVar();
}
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);
}
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();
}
