static void ogl_set_projection(ALLEGRO_DISPLAY *d)
{
if (d->flags & ALLEGRO_USE_PROGRAMMABLE_PIPELINE) {
#ifndef ALLEGRO_CFG_NO_GLES2
GLuint program_object = d->ogl_extras->program_object;
GLint handle;
// FIXME: In al_create_display we have no shader yet
if (program_object == 0)
return;
handle = glGetUniformLocation(program_object, "projview_matrix");
if (handle >= 0) {
ALLEGRO_TRANSFORM t;
al_copy_transform(&t, &d->view_transform);
al_compose_transform(&t, &d->proj_transform);
glUniformMatrix4fv(handle, 1, false, (float *)t.m);
}
#endif
}
else {
glMatrixMode(GL_PROJECTION);
glLoadMatrixf((float *)d->proj_transform.m);
glMatrixMode(GL_MODELVIEW);
}
}
static void ogl_update_transformation(ALLEGRO_DISPLAY* disp,
ALLEGRO_BITMAP *target)
{
if (disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
#ifdef ALLEGRO_CFG_SHADER_GLSL
GLint loc = disp->ogl_extras->varlocs.projview_matrix_loc;
ALLEGRO_TRANSFORM projview;
al_copy_transform(&projview, &target->transform);
al_compose_transform(&projview, &target->proj_transform);
al_copy_transform(&disp->projview_transform, &projview);
if (disp->ogl_extras->program_object > 0 && loc >= 0) {
_al_glsl_set_projview_matrix(loc, &disp->projview_transform);
}
#endif
} else {
glMatrixMode(GL_PROJECTION);
glLoadMatrixf((float *)target->proj_transform.m);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf((float *)target->transform.m);
}
if (target->parent) {
ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_extra = target->parent->extra;
/* glViewport requires the bottom-left coordinate of the corner. */
glViewport(target->xofs, ogl_extra->true_h - (target->yofs + target->h), target->w, target->h);
} else {
glViewport(0, 0, target->w, target->h);
}
}
static void _draw_tinted_rotated_scaled_bitmap_region(ALLEGRO_BITMAP *bitmap,
ALLEGRO_COLOR tint, float cx, float cy, float angle,
float xscale, float yscale,
float sx, float sy, float sw, float sh, float dx, float dy,
int flags)
{
ALLEGRO_TRANSFORM backup;
ALLEGRO_TRANSFORM t;
ALLEGRO_BITMAP *parent = bitmap;
float const orig_sw = sw;
float const orig_sh = sh;
ASSERT(bitmap);
al_copy_transform(&backup, al_get_current_transform());
al_identity_transform(&t);
if (bitmap->parent) {
parent = bitmap->parent;
sx += bitmap->xofs;
sy += bitmap->yofs;
}
if (sx < 0) {
sw += sx;
al_translate_transform(&t, -sx, 0);
sx = 0;
}
if (sy < 0) {
sh += sy;
al_translate_transform(&t, 0, -sy);
sy = 0;
}
if (sx + sw > parent->w)
sw = parent->w - sx;
if (sy + sh > parent->h)
sh = parent->h - sy;
if (flags & ALLEGRO_FLIP_HORIZONTAL) {
al_scale_transform(&t, -1, 1);
al_translate_transform(&t, orig_sw, 0);
flags &= ~ALLEGRO_FLIP_HORIZONTAL;
}
if (flags & ALLEGRO_FLIP_VERTICAL) {
al_scale_transform(&t, 1, -1);
al_translate_transform(&t, 0, orig_sh);
flags &= ~ALLEGRO_FLIP_VERTICAL;
}
al_translate_transform(&t, -cx, -cy);
al_scale_transform(&t, xscale, yscale);
al_rotate_transform(&t, angle);
al_translate_transform(&t, dx, dy);
al_compose_transform(&t, &backup);
al_use_transform(&t);
_bitmap_drawer(parent, tint, sx, sy, sw, sh, flags);
al_use_transform(&backup);
}
void Renderer::draw()
{
//int dw = al_get_display_width(dpy_);
//int dh = al_get_display_height(dpy_);
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_compose_transform(&trans, &camera_transform_);
al_rotate_transform_3d(&trans, 1.0, 0.0, 0.0, rx_look);
setupProjection(&trans);
al_identity_transform(&trans);
al_use_transform(&trans);
getWorldPos(camera_pos_);
al_copy_transform(&cur3d_transform_, al_get_current_transform());
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glEnable(GL_ALPHA_TEST);
if(!setShader(SHADER_DEFAULT))
{
NBT_Debug("failed to set default shader");
}
glBindVertexArray(vao_);
resManager_->setAtlasUniforms();
for(auto &it: chunkData_)
{
ChunkData *cd = it.second;
ALLEGRO_TRANSFORM ctrans;
al_identity_transform(&ctrans);
al_translate_transform_3d(&ctrans, cd->x()*15.0, 0.0, cd->z()*15.0);
al_use_transform(&ctrans);
cd->draw(&ctrans);
}
glBindVertexArray(0);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
//drawSelection();
resManager_->unsetAtlasUniforms();
}
static void _al_draw_transformed_scaled_bitmap_memory(
ALLEGRO_BITMAP *src, ALLEGRO_COLOR tint,
int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, int flags)
{
ALLEGRO_TRANSFORM local_trans;
al_identity_transform(&local_trans);
al_translate_transform(&local_trans, dx, dy);
al_compose_transform(&local_trans, al_get_current_transform());
_al_draw_transformed_bitmap_memory(src, tint, sx, sy, sw, sh, dw, dh,
&local_trans, flags);
}
static void ogl_update_transformation(ALLEGRO_DISPLAY* disp,
ALLEGRO_BITMAP *target)
{
ALLEGRO_TRANSFORM tmp;
al_copy_transform(&tmp, &target->transform);
if (target->parent) {
/* Sub-bitmaps have an additional offset. */
al_translate_transform(&tmp, target->xofs, target->yofs);
}
if (disp->flags & ALLEGRO_USE_PROGRAMMABLE_PIPELINE) {
#ifndef ALLEGRO_CFG_NO_GLES2
GLuint program_object = disp->ogl_extras->program_object;
GLint handle;
// FIXME: In al_create_display we have no shader yet
if (program_object == 0)
return;
al_copy_transform(&disp->view_transform, &tmp);
al_compose_transform(&tmp, &disp->proj_transform);
handle = glGetUniformLocation(program_object, "projview_matrix");
if (handle >= 0) {
glUniformMatrix4fv(handle, 1, GL_FALSE, (float *)tmp.m);
}
#endif
}
else {
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf((float *)tmp.m);
}
}
VALUE rbal_compose_transform(VALUE r_, VALUE rtrans, VALUE rother) {
ALLEGRO_TRANSFORM * trans = rbal_transform_unwrap(rtrans);
ALLEGRO_TRANSFORM * other = rbal_transform_unwrap(rother);
al_compose_transform(trans, other);
return rtrans;
}
