static GLboolean
framebuffer_srgb_fbo(void)
{
GLboolean pass = GL_TRUE;
int fbo_width = FBO_SIZE;
int fbo_height = FBO_SIZE;
GLuint fbo;
fbo = make_fbo(fbo_width, fbo_height);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo);
glViewport(0, 0, fbo_width, fbo_height);
piglit_ortho_projection(fbo_width, fbo_height, GL_FALSE);
pass = test_srgb();
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
draw_fbo(0, 0);
piglit_present_results();
glDeleteFramebuffersEXT(1, &fbo);
return pass;
}
static GLboolean
run_test(void)
{
GLboolean pass = GL_TRUE;
GLuint fbo;
int fbo_width = FBO_SIZE;
int fbo_height = FBO_SIZE;
int x0 = PAD;
int y0 = PAD;
int y1 = PAD * 2 + SIZE;
int y2 = PAD * 3 + SIZE * 2;
GLint win_depth_bits, fbo_depth_bits, win_stencil_bits, fbo_stencil_bits;
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glDepthMask(GL_TRUE);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClearDepth(0.12345);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
/* Draw the color rect in the window system window */
draw_depth_rect(x0, y0, SIZE, SIZE);
fbo = make_fbo(fbo_width, fbo_height);
/* query depth/stencil sizes */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glGetIntegerv(GL_DEPTH_BITS, &win_depth_bits);
glGetIntegerv(GL_STENCIL_BITS, &win_stencil_bits);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glGetIntegerv(GL_DEPTH_BITS, &fbo_depth_bits);
glGetIntegerv(GL_STENCIL_BITS, &fbo_stencil_bits);
if (win_depth_bits != fbo_depth_bits ||
win_stencil_bits != fbo_stencil_bits) {
/* The spec doesn't allow blitting between depth/blitting surfaces
* of different formats.
*/
piglit_report_result(PIGLIT_SKIP);
}
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glViewport(0, 0, fbo_width, fbo_height);
piglit_ortho_projection(fbo_width, fbo_height, GL_FALSE);
glClearDepth(0.54321);
glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
/* Draw the color rect in the FBO */
draw_depth_rect(x0, y0, SIZE, SIZE);
/* Now that we have correct samples, blit things around.
* FBO(bottom) -> WIN(middle)
*
* Also blit with stencil to exercise this path.
* Not that we need it for this test.
*/
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo);
copy(x0, y0, x0 + SIZE, y0 + SIZE,
x0, y1, x0 + SIZE, y1 + SIZE,
GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
/* WIN(bottom) -> FBO(middle) */
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, piglit_winsys_fbo);
copy(x0, y0, x0 + SIZE, y0 + SIZE,
x0, y1, x0 + SIZE, y1 + SIZE,
GL_DEPTH_BUFFER_BIT);
/* FBO(middle) -> WIN(top) back to verify WIN -> FBO */
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo);
copy(x0, y1, x0 + SIZE, y1 + SIZE,
x0, y2, x0 + SIZE, y2 + SIZE,
GL_DEPTH_BUFFER_BIT);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
assert(glGetError() == 0);
printf("Verify 1\n");
pass = verify_depth_rect(PAD, y0, SIZE, SIZE) && pass;
printf("Verify 2\n");
pass = verify_depth_rect(PAD, y1, SIZE, SIZE) && pass;
printf("Verify 3\n");
pass = verify_depth_rect(PAD, y2, SIZE, SIZE) && pass;
printf("Verify 4 (FBO)\n");
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
pass = verify_depth_rect(PAD, y0, SIZE, SIZE) && pass;
printf("Verify 5 (FBO)\n");
pass = verify_depth_rect(PAD, y1, SIZE, SIZE) && pass;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
assert(glGetError() == 0);
piglit_present_results();
return pass;
}
PlayState(Game* game) : m_game(game) {
window_sub = Window::currentContext()->onResize.subscribe([=](const gecom::window_size_event &e) {
if (e.size.w > 0 && e.size.h > 0) {
make_fbo(e.size);
}
return false;
});
make_fbo(Window::currentContext()->size());
m_scene = new Scene2D();
last_update = gecom::really_high_resolution_clock().now();
gecom::image img_bg(gecom::image::type_png(), "./res/textures/bg.png", true);
glGenTextures(1, &m_tex_bg);
glBindTexture(GL_TEXTURE_2D, m_tex_bg);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, img_bg.width(), img_bg.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, img_bg.data());
glGenerateMipmap(GL_TEXTURE_2D);
world = game->getGCM().get<Box2DGameComponent>()->addWorld(i3d::vec3d(0.0, -20.0, 0.0));
player = std::make_shared<PlayerEntity>(world);
m_scene->add(player);
player->setPosition(player->getPosition() + i3d::vec3d::j() * 64);
auto drone = std::make_shared<DroneEntity>(world, player);
m_scene->add(drone);
//box = std::make_shared<Entity>();
//box->setPosition(i3d::vec3d(5, 50, 0));
//box->addComponent<DrawableComponent>(std::make_shared<ProtagonistDrawable>(box));
//box->addComponent<DrawableComponent>(std::make_shared<UnitSquare>(box, 1, 1.5));
//player_phs = std::make_shared<B2PhysicsComponent>(box);
//player_phs->registerWithWorld(world);
//box->addComponent<B2PhysicsComponent>(player_phs);
/*auto ground = std::make_shared<Entity>(world);
ground->setPosition(i3d::vec3d(0, -20, 0));
auto gphs = std::make_shared<B2PhysicsStatic>(ground, 200, 1);
gphs->registerWithWorld(world);
ground->addComponent<B2PhysicsComponent>(gphs);
m_scene->add(ground);*/
//shared_ptr<SteadyFocusCamera> cameraEntity(make_shared<SteadyFocusCamera>(player));
auto cameraEntity = std::make_shared<SteadyFocusCamera>(world, player);
m_scene->add(cameraEntity);
auto camera = std::make_shared<Camera>(cameraEntity);
//shared_ptr<Camera> camera(make_shared<Camera>(cameraEntity));
m_scene->setCamera(camera);
pxljm::LevelGenerator lg;
auto level = lg.getTestLevel(world);
level->load(*m_scene, world);
}
static GLboolean
run_test(void)
{
GLboolean pass = GL_TRUE;
GLuint fbo;
int fbo_width = FBO_SIZE;
int fbo_height = FBO_SIZE;
int x0 = PAD;
int y0 = PAD;
int y1 = PAD * 2 + SIZE;
int y2 = PAD * 3 + SIZE * 2;
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
/* Draw the color rect in the window system window */
draw_color_rect(x0, y0, SIZE, SIZE);
fbo = make_fbo(fbo_width, fbo_height);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
glViewport(0, 0, fbo_width, fbo_height);
piglit_ortho_projection(fbo_width, fbo_height, GL_FALSE);
glClearColor(1.0, 0.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Draw the color rect in the FBO */
draw_color_rect(x0, y0, SIZE, SIZE);
/* Now that we have correct samples, blit things around.
* FBO(bottom) -> WIN(middle)
*/
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo);
copy(x0, y0, x0 + SIZE, y0 + SIZE,
x0, y1, x0 + SIZE, y1 + SIZE);
/* WIN(bottom) -> FBO(middle) */
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
copy(x0, y0, x0 + SIZE, y0 + SIZE,
x0, y1, x0 + SIZE, y1 + SIZE);
/* FBO(middle) -> WIN(top) back to verify WIN -> FBO */
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo);
copy(x0, y1, x0 + SIZE, y1 + SIZE,
x0, y2, x0 + SIZE, y2 + SIZE);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
pass = verify_color_rect(PAD, y0, SIZE, SIZE) && pass;
pass = verify_color_rect(PAD, y1, SIZE, SIZE) && pass;
pass = verify_color_rect(PAD, y2, SIZE, SIZE) && pass;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
pass = verify_color_rect(PAD, y0, SIZE, SIZE) && pass;
pass = verify_color_rect(PAD, y1, SIZE, SIZE) && pass;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glutSwapBuffers();
return pass;
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint fbo, tex, pbo;
uint32_t *addr;
make_fbo(&fbo, &tex);
glClear(GL_COLOR_BUFFER_BIT);
glGenBuffersARB(1, &pbo);
glBindBufferARB(GL_PIXEL_PACK_BUFFER, pbo);
glBufferDataARB(GL_PIXEL_PACK_BUFFER, 4 * 4, NULL, GL_STREAM_DRAW_ARB);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glViewport(0, 0, 2, 2);
piglit_ortho_projection(2, 2, GL_FALSE);
/* bottom: green. top: blue. */
glColor4f(0.0, 1.0, 0.0, 0.0);
piglit_draw_rect(0, 0, 2, 1);
glColor4f(0.0, 0.0, 1.0, 0.0);
piglit_draw_rect(0, 1, 2, 1);
/* Read the whole buffer. */
glReadPixels(0, 0, 2, 2,
GL_BGRA, GL_UNSIGNED_BYTE, (void *)(uintptr_t)0);
addr = glMapBufferARB(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY_ARB);
pass &= probe(0, 0, 0x0000ff00, addr[0]);
pass &= probe(1, 0, 0x0000ff00, addr[1]);
pass &= probe(0, 1, 0x000000ff, addr[2]);
pass &= probe(1, 1, 0x000000ff, addr[3]);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER);
/* Read with an offset. */
glReadPixels(1, 0, 1, 1,
GL_BGRA, GL_UNSIGNED_BYTE, (void *)(uintptr_t)4);
addr = glMapBufferARB(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY_ARB);
pass &= probe(1, 0, 0x0000ff00, addr[1]);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER);
/* Read with an offset. */
glReadPixels(1, 1, 1, 1,
GL_BGRA, GL_UNSIGNED_BYTE, (void *)(uintptr_t)4);
addr = glMapBufferARB(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY_ARB);
pass &= probe(1, 1, 0x000000ff, addr[1]);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER);
glDeleteBuffersARB(1, &pbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindTexture(GL_TEXTURE_2D, tex);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_draw_rect_tex(0, 0, piglit_width, piglit_height,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteFramebuffersEXT(1, &fbo);
glDeleteTextures(1, &tex);
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
