/*
* Draw an image in OpenGL
*/
static void draw_image(VALUE el, int x, int y) {
struct img_data *data;
Data_Get_Struct(rb_iv_get(el, "@data"), struct img_data, data);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
SDL_GL_BindTexture(data->texture, NULL, NULL);
int w = data->surface->w;
int h = data->surface->h;
glBegin(GL_QUADS);
glColor4f(1, 1, 1, 1);
glTexCoord2f(0, 0);
glVertex2f(x, y);
glTexCoord2f(w, 0);
glVertex2f(x + w, y);
glTexCoord2f(w, h);
glVertex2f(x + w, y + h);
glTexCoord2f(0, h);
glVertex2f(x, y + h);
glEnd();
SDL_GL_UnbindTexture(data->texture);
}
void Game::render()
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//glScalef(0.5f, 0.5f, 1);
glTranslatef(0, -m_cameraOffset, 0);
glBindFramebuffer(GL_FRAMEBUFFER, m_lightFB);
glClearColor(0.03f,0.03f,0.05f, 0);
glClear(GL_COLOR_BUFFER_BIT);
for(std::unique_ptr<Renderable> &renderable: m_renderables)
renderable->renderLight();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glLoadIdentity();
glTranslatef(0, -m_cameraOffset, 0);
// background
{
float fW, fH;
SDL_GL_BindTexture(m_background.get(), &fW, &fH);
glBegin(GL_QUADS);
glColor3f(1,1,1);
glTexCoord2f(0, fH);
glVertex2f(0, 2400);
glTexCoord2f(fW, fH);
glVertex2f(800, 2400);
glTexCoord2f(fW, 0);
glVertex2f(800, -2400);
glTexCoord2f(0, 0);
glVertex2f(0, -2400);
glEnd();
SDL_GL_UnbindTexture(m_background.get());
}
for(std::unique_ptr<Renderable> &renderable: m_renderables)
renderable->render();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
glBindTexture(GL_TEXTURE_2D, m_lightTexture);
glBegin(GL_QUADS);
glColor4f(1,1,1,1);
glTexCoord2f(0, 1);
glVertex2f(0, 0);
glTexCoord2f(1, 1);
glVertex2f(800, 0);
glTexCoord2f(1, 0);
glVertex2f(800, 600);
glTexCoord2f(0, 0);
glVertex2f(0, 600);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
}
void softenTexture(SDL::Texture &tex)
{
float w, h;
SDL_GL_BindTexture(tex.get(), &w, &h);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
SDL_GL_UnbindTexture(tex.get());
}
// Called by Rocket when it wants to render geometry that it does not wish to optimise.
void RocketSDL2Renderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
{
// SDL uses shaders that we need to disable here
glUseProgramObjectARB(0);
glPushMatrix();
glTranslatef(translation.x, translation.y, 0);
std::vector<Rocket::Core::Vector2f> Positions(num_vertices);
std::vector<Rocket::Core::Colourb> Colors(num_vertices);
std::vector<Rocket::Core::Vector2f> TexCoords(num_vertices);
float texw, texh;
SDL_Texture* sdl_texture = NULL;
if(texture)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
sdl_texture = (SDL_Texture *) texture;
SDL_GL_BindTexture(sdl_texture, &texw, &texh);
}
for(int i = 0; i < num_vertices; i++) {
Positions[i] = vertices[i].position;
Colors[i] = vertices[i].colour;
if (sdl_texture) {
TexCoords[i].x = vertices[i].tex_coord.x * texw;
TexCoords[i].y = vertices[i].tex_coord.y * texh;
}
else TexCoords[i] = vertices[i].tex_coord;
};
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, &Positions[0]);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, &Colors[0]);
glTexCoordPointer(2, GL_FLOAT, 0, &TexCoords[0]);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDrawElements(GL_TRIANGLES, num_indices, GL_UNSIGNED_INT, indices);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
if (sdl_texture) {
SDL_GL_UnbindTexture(sdl_texture);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glColor4f(1.0, 1.0, 1.0, 1.0);
glPopMatrix();
/* Reset blending and draw a fake point just outside the screen to let SDL know that it needs to reset its state in case it wants to render a texture */
glDisable(GL_BLEND);
SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_NONE);
SDL_RenderDrawPoint(mRenderer, -1, -1);
}
/*
* Draw text with SDL2_ttf in OpenGL
*/
static void draw_text(VALUE el, char *text, int x, int y) {
struct text_data *data;
Data_Get_Struct(rb_iv_get(el, "@data"), struct text_data, data);
int w, h;
TTF_SizeText(data->font, text, &w, &h);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
SDL_GL_BindTexture(data->texture, NULL, NULL);
glBegin(GL_QUADS);
glColor4f(1, 1, 1, 1);
glTexCoord2f(0, 0); glVertex2f(x, y);
glTexCoord2f(w, 0); glVertex2f(x + w, y);
glTexCoord2f(w, h); glVertex2f(x + w, y + h);
glTexCoord2f(0, h); glVertex2f(x, y + h);
glEnd();
SDL_GL_UnbindTexture(data->texture);
}
// Called by Rocket when it wants to render geometry that it does not wish to optimise.
void RocketSDLRenderInterfaceOpenGLES2::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
{
SDL_Texture* sdl_texture = NULL;
if(texture) render_data.glUseProgram(program_texture_id);
else render_data.glUseProgram(program_color_id);
int width, height;
SDL_Rect rvp;
SDL_RenderGetViewport(renderer, &rvp);
GLfloat projection[4][4];
// Prepare an orthographic projection
projection[0][0] = 2.0f / rvp.w;
projection[0][1] = 0.0f;
projection[0][2] = 0.0f;
projection[0][3] = 0.0f;
projection[1][0] = 0.0f;
//if (renderer->target) {
// projection[1][1] = 2.0f / height;
//} else {
projection[1][1] = -2.0f / rvp.h;
//}
projection[1][2] = 0.0f;
projection[1][3] = 0.0f;
projection[2][0] = 0.0f;
projection[2][1] = 0.0f;
projection[2][2] = 0.0f;
projection[2][3] = 0.0f;
projection[3][0] = -1.0f;
//if (renderer->target) {
// projection[3][1] = -1.0f;
//} else {
projection[3][1] = 1.0f;
//}
projection[3][2] = 0.0f;
projection[3][3] = 1.0f;
// Set the projection matrix
if (texture) {
render_data.glUniformMatrix4fv(u_texture_projection, 1, GL_FALSE, (GLfloat *)projection);
render_data.glUniform2f(u_texture_translation, translation.x, translation.y);
}
else {
render_data.glUniformMatrix4fv(u_color_projection, 1, GL_FALSE, (GLfloat *)projection);
render_data.glUniform2f(u_color_translation, translation.x, translation.y);
}
render_data.glEnable(GL_BLEND);
render_data.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
float texw, texh;
unsigned short newIndicies[num_indices];
for (int i = 0; i < num_indices; i++)
{
newIndicies[i] = (unsigned short) indices[i];
}
glVertexAttribPointer(ROCKETGLUE_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(Rocket::Core::Vertex), &vertices[0].position);
glVertexAttribPointer(ROCKETGLUE_ATTRIBUTE_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Rocket::Core::Vertex), &vertices[0].colour);
render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_POSITION);
render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_TEXCOORD);
render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_COLOR);
if(texture) {
sdl_texture = (SDL_Texture *) texture;
SDL_GL_BindTexture(sdl_texture, &texw, &texh);
render_data.glUniform1i(u_texture, 0);
glVertexAttribPointer(ROCKETGLUE_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, sizeof(Rocket::Core::Vertex), &vertices[0].tex_coord);
}
else {
render_data.glActiveTexture(GL_TEXTURE0);
render_data.glDisable(GL_TEXTURE_2D);
render_data.glDisableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_TEXCOORD);
}
render_data.glDrawElements(GL_TRIANGLES, num_indices, GL_UNSIGNED_SHORT, newIndicies);
/* We can disable ROCKETGLUE_ATTRIBUTE_COLOR (2) safely as SDL will reenable the vertex attrib 2 if it is required */
render_data.glDisableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_COLOR);
/* Leave ROCKETGLUE_ATTRIBUTE_POSITION (0) and ROCKETGLUE_ATTRIBUTE_TEXCOORD (1) enabled for compatibility with SDL which
doesn't re enable them when you call RenderCopy/Ex */
if(sdl_texture) SDL_GL_UnbindTexture(sdl_texture);
else render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_TEXCOORD);
/* Reset blending and draw a fake point just outside the screen to let SDL know that it needs to reset its state in case it wants to render a texture */
render_data.glDisable(GL_BLEND);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
SDL_RenderDrawPoint(renderer, -1, -1);
}
