void SDLFrontend::bindTexture (Texture* texture, int textureUnit)
{
if (textureUnit != 0)
error(LOG_CLIENT, "only one texture unit is supported in the sdl frontend");
SDL_Texture *sdltexture = static_cast<SDL_Texture *>(texture->getData());
SDL_GL_BindTexture(sdltexture, nullptr, nullptr);
}
static void render_textbox(char * text, int width, int height) {
GLint location;
glUseProgramObjectARB(text_shader);
location = glGetUniformLocationARB(text_shader, "iResolution");
glUniform2fARB(location, width, height);
int text_w;
int text_h;
SDL_Texture * tex = render_text(text, &text_w, &text_h);
location = glGetUniformLocationARB(text_shader, "iTextResolution");
glUniform2fARB(location, text_w, text_h);
location = glGetUniformLocationARB(text_shader, "iText");
glUniform1iARB(location, 0);
glActiveTexture(GL_TEXTURE0);
SDL_GL_BindTexture(tex, NULL, NULL);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
fill(width, height);
SDL_DestroyTexture(tex);
}
/*
* 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);
}
static void ui_render(bool select) {
GLint location;
GLenum e;
// Render strip indicators
switch(strip_indicator) {
case STRIPS_SOLID:
case STRIPS_COLORED:
glLoadIdentity();
glViewport(0, 0, config.pattern.master_width, config.pattern.master_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, strip_fb);
glUseProgramObjectARB(strip_shader);
location = glGetUniformLocationARB(strip_shader, "iPreview");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(strip_shader, "iResolution");
glUniform2fARB(location, config.pattern.master_width, config.pattern.master_height);
location = glGetUniformLocationARB(strip_shader, "iIndicator");
glUniform1iARB(location, strip_indicator);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, crossfader.tex_output);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
for(struct output_device * d = output_device_head; d != NULL; d = d->next) {
#ifdef SOLID_LINE_INDICATOR
bool first = true;
double x;
double y;
for(struct output_vertex * v = d->vertex_head; v != NULL; v = v->next) {
if(!first) {
double dx = v->x - x;
double dy = -v->y - y;
double dl = hypot(dx, dy);
dx = config.ui.strip_thickness * dx / dl;
dy = config.ui.strip_thickness * dy / dl;
glVertex2d(x + dy, y - dx);
glVertex2d(v->x + dy, -v->y - dx);
glVertex2d(v->x - dy, -v->y + dx);
glVertex2d(x - dy, y + dx);
} else {
first = false;
}
x = v->x;
y = -v->y;
}
#else // PIXEL INDICATOR
// Maybe this is horrendously slow because it has to draw a quad for every output pixel?
// It looks cool though
for (size_t i = 0; i < d->pixels.length; i++) {
double x = d->pixels.xs[i];
double y = d->pixels.ys[i];
double dx = config.ui.point_thickness;
double dy = config.ui.point_thickness;
glVertex2d(x + dx, y);
glVertex2d(x, y + dy);
glVertex2d(x - dx, y);
glVertex2d(x, y - dy);
}
#endif
}
glEnd();
break;
default:
case STRIPS_NONE:
break;
}
// Render the patterns
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pat_fb);
int pw = config.ui.pattern_width;
int ph = config.ui.pattern_height;
glUseProgramObjectARB(pat_shader);
location = glGetUniformLocationARB(pat_shader, "iResolution");
glUniform2fARB(location, pw, ph);
glUseProgramObjectARB(pat_shader);
location = glGetUniformLocationARB(pat_shader, "iSelection");
glUniform1iARB(location, select);
location = glGetUniformLocationARB(pat_shader, "iPreview");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(pat_shader, "iName");
glUniform1iARB(location, 1);
GLint pattern_index = glGetUniformLocationARB(pat_shader, "iPatternIndex");
GLint pattern_intensity = glGetUniformLocationARB(pat_shader, "iIntensity");
GLint name_resolution = glGetUniformLocationARB(pat_shader, "iNameResolution");
glLoadIdentity();
gluOrtho2D(0, pw, 0, ph);
glViewport(0, 0, pw, ph);
for(int i = 0; i < config.ui.n_patterns; i++) {
struct pattern * p = deck[map_deck[i]].pattern[map_pattern[i]];
if(p != NULL) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, p->tex_output);
glActiveTexture(GL_TEXTURE1);
SDL_GL_BindTexture(pattern_name_textures[i], NULL, NULL);
glUniform1iARB(pattern_index, i);
glUniform1fARB(pattern_intensity, p->intensity);
glUniform2fARB(name_resolution, pattern_name_width[i], pattern_name_height[i]);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, pattern_textures[i], 0);
glClear(GL_COLOR_BUFFER_BIT);
fill(pw, ph);
}
}
// Render the crossfader
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, crossfader_fb);
int cw = config.ui.crossfader_width;
int ch = config.ui.crossfader_height;
glUseProgramObjectARB(crossfader_shader);
location = glGetUniformLocationARB(crossfader_shader, "iResolution");
glUniform2fARB(location, cw, ch);
location = glGetUniformLocationARB(crossfader_shader, "iSelection");
glUniform1iARB(location, select);
location = glGetUniformLocationARB(crossfader_shader, "iPreview");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(crossfader_shader, "iStrips");
glUniform1iARB(location, 1);
location = glGetUniformLocationARB(crossfader_shader, "iIntensity");
glUniform1fARB(location, crossfader.position);
location = glGetUniformLocationARB(crossfader_shader, "iIndicator");
glUniform1iARB(location, strip_indicator);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, crossfader.tex_output);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, strip_texture);
glLoadIdentity();
gluOrtho2D(0, cw, 0, ch);
glViewport(0, 0, cw, ch);
glClear(GL_COLOR_BUFFER_BIT);
fill(cw, ch);
int sw = 0;
int sh = 0;
int vw = 0;
int vh = 0;
if(!select) {
analyze_render(tex_spectrum_data, tex_waveform_data, tex_waveform_beats_data);
// Render the spectrum
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, spectrum_fb);
sw = config.ui.spectrum_width;
sh = config.ui.spectrum_height;
glUseProgramObjectARB(spectrum_shader);
location = glGetUniformLocationARB(spectrum_shader, "iResolution");
glUniform2fARB(location, sw, sh);
location = glGetUniformLocationARB(spectrum_shader, "iBins");
glUniform1iARB(location, config.audio.spectrum_bins);
location = glGetUniformLocationARB(spectrum_shader, "iSpectrum");
glUniform1iARB(location, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, tex_spectrum_data);
glLoadIdentity();
gluOrtho2D(0, sw, 0, sh);
glViewport(0, 0, sw, sh);
glClear(GL_COLOR_BUFFER_BIT);
fill(sw, sh);
// Render the waveform
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waveform_fb);
vw = config.ui.waveform_width;
vh = config.ui.waveform_height;
glUseProgramObjectARB(waveform_shader);
location = glGetUniformLocationARB(waveform_shader, "iResolution");
glUniform2fARB(location, sw, sh);
location = glGetUniformLocationARB(waveform_shader, "iLength");
glUniform1iARB(location, config.audio.waveform_length);
location = glGetUniformLocationARB(waveform_shader, "iWaveform");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(waveform_shader, "iBeats");
glUniform1iARB(location, 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, tex_waveform_data);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_1D, tex_waveform_beats_data);
glLoadIdentity();
gluOrtho2D(0, vw, 0, vh);
glViewport(0, 0, vw, vh);
glClear(GL_COLOR_BUFFER_BIT);
fill(vw, vh);
}
// Render to screen (or select fb)
if(select) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, select_fb);
} else {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
glLoadIdentity();
gluOrtho2D(0, ww, 0, wh);
glViewport(0, 0, ww, wh);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgramObjectARB(main_shader);
location = glGetUniformLocationARB(main_shader, "iResolution");
glUniform2fARB(location, ww, wh);
location = glGetUniformLocationARB(main_shader, "iSelection");
glUniform1iARB(location, select);
location = glGetUniformLocationARB(main_shader, "iSelected");
glUniform1iARB(location, selected);
location = glGetUniformLocationARB(main_shader, "iLeftDeckSelector");
glUniform1iARB(location, left_deck_selector);
location = glGetUniformLocationARB(main_shader, "iRightDeckSelector");
glUniform1iARB(location, right_deck_selector);
fill(ww, wh);
// Blit UI elements on top
glEnable(GL_BLEND);
glUseProgramObjectARB(blit_shader);
glActiveTexture(GL_TEXTURE0);
location = glGetUniformLocationARB(blit_shader, "iTexture");
glUniform1iARB(location, 0);
for(int i = 0; i < config.ui.n_patterns; i++) {
struct pattern * pattern = deck[map_deck[i]].pattern[map_pattern[i]];
if(pattern != NULL) {
glBindTexture(GL_TEXTURE_2D, pattern_textures[i]);
blit(map_x[i], map_y[i], pw, ph);
}
}
glBindTexture(GL_TEXTURE_2D, crossfader_texture);
blit(config.ui.crossfader_x, config.ui.crossfader_y, cw, ch);
if(!select) {
glBindTexture(GL_TEXTURE_2D, spectrum_texture);
blit(config.ui.spectrum_x, config.ui.spectrum_y, sw, sh);
glBindTexture(GL_TEXTURE_2D, waveform_texture);
blit(config.ui.waveform_x, config.ui.waveform_y, vw, vh);
if(pat_entry) {
for(int i = 0; i < config.ui.n_patterns; i++) {
if(map_selection[i] == selected) {
glBindTexture(GL_TEXTURE_2D, pat_entry_texture);
blit(map_pe_x[i], map_pe_y[i], config.ui.pat_entry_width, config.ui.pat_entry_height);
break;
}
}
}
}
glDisable(GL_BLEND);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
}
void renderBackgroundImage(AppState* state,Uint8* image)
{
Uint8 *pixels = 0;
int pitch1;
if (0 == SDL_LockTexture(state->background, NULL, (void **)&pixels, &pitch1))
{
GLboolean isLightingOn = glIsEnabled(GL_LIGHTING);
GLboolean isDepthTestOn = glIsEnabled(GL_DEPTH_TEST);
if (isDepthTestOn) glDisable(GL_DEPTH_TEST);
if (isLightingOn) glDisable(GL_LIGHTING);
switch(gsBGTextureFormat) {
case SDL_PIXELFORMAT_YV12:
// memcpy(pixels, image, size1 );
// memcpy(pixels + size1, pFrame_YUV420P->data[2], size1/4);
// memcpy(pixels + size1*5/4, pFrame_YUV420P->data[1], size1/4);
break;
case SDL_PIXELFORMAT_RGB24:
memcpy( pixels, image, gsARTImageHeight*gsARTImageWidth*sizeof(Uint8)*3);
break;
}
SDL_UnlockTexture(state->background);
SDL_UpdateTexture(state->background, NULL, pixels, pitch1);
float width,height;
float posX = 0, posY = 0;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0.0f, gsARTImageWidth, gsARTImageHeight, 0.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
/* this accounts for Texture2D vs TextureRectangle */
if (0 == SDL_GL_BindTexture(state->background, &width, &height ))
{
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(posX,posY);
glTexCoord2f(1*width, 0);
glVertex2f(posX + width, posY);
glTexCoord2f(1*width, 1*height);
glVertex2f(posX + width, posY + height);
glTexCoord2f(0, 1*height);
glVertex2f(posX, posY + height);
glEnd();
// SDL_GL_UnbindTexture(state->background);
}
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
if (isDepthTestOn) glEnable(GL_DEPTH_TEST);
if (isLightingOn) glEnable(GL_LIGHTING);
}
}
// 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);
}
