void device_stage_texture(device_t device, stagesurf_t dst, texture_t src)
{
struct gs_texture_2d *tex2d = (struct gs_texture_2d*)src;
if (!can_stage(dst, tex2d))
goto failed;
if (!gl_copy_texture(device, dst->texture, GL_TEXTURE_2D,
tex2d->base.texture, GL_TEXTURE_2D,
dst->width, dst->height))
goto failed;
if (!gl_bind_texture(GL_TEXTURE_2D, dst->texture))
goto failed;
if (!gl_bind_buffer(GL_PIXEL_PACK_BUFFER, dst->pack_buffer))
goto failed;
glGetTexImage(GL_TEXTURE_2D, 0, dst->gl_format, dst->gl_type, 0);
if (!gl_success("glGetTexImage"))
goto failed;
gl_bind_buffer(GL_PIXEL_PACK_BUFFER, 0);
gl_bind_texture(GL_TEXTURE_2D, 0);
return;
failed:
gl_bind_buffer(GL_PIXEL_PACK_BUFFER, 0);
gl_bind_texture(GL_TEXTURE_2D, 0);
blog(LOG_ERROR, "device_stage_texture (GL) failed");
}
void gl_draw_object(Scene_Camera* camera, Object* object) {
glUseProgram(object->shader->id);
glBindVertexArray(object->vao);
//Build model matrix
glm::mat4 model_matrix = build_model_matrix(object);
//Combine matrices
glm::mat4 model_view_projection = camera->projection * camera->view * model_matrix;
glm::mat3 normal_matrix = glm::transpose(glm::inverse(glm::mat3(
camera->view * model_matrix)));
//Bind uniforms
gl_bind_vec(object->shader->id, object->model->color, "matte_color");
gl_bind_vec(object->shader->id, camera->direction, "camera_direction");
gl_bind_vec(object->shader->id, object->light_direction, "light_direction");
gl_bind_mat(object->shader->id, model_view_projection, "model_view_projection");
gl_bind_mat(object->shader->id, normal_matrix, "normal_matrix");
//bind textures
gl_bind_texture(object->shader->id, object->texture->id, 0, "diffuse");
gl_bind_texture(object->shader->id, object->normal_map->id, 1, "normal");
gl_bind_texture(object->shader->id, object->specular_map->id, 2, "specular");
//Render VAO
glDrawArrays(GL_TRIANGLES, 0, object->model->face_count*3);
//Unbind VAO
glBindVertexArray(0);
}
void sprite_draw(struct sprite* s, float cx, float cy, float angle)
{
float w2 = s->width/2;
float h2 = s->height/2;
int i;
float sint = sin(torad(angle));
float cost = cos(torad(angle));
struct matrix2d rotation = { {
{cost, -sint},
{sint, cost} }};
struct vector2d v[4] = { {{-w2, -h2}}, {{-w2, h2}}, {{w2, h2}}, {{w2,-h2}} };
for(i=0; i<4;i++)
{
v[i] = matrix_vec_mult(rotation.m, v[i].vec);
}
for(i=0; i<4;i++)
{
v[i].vec[0] += cx;
v[i].vec[1] += cy;
}
gl_bind_texture(s->texture);
gl_vertex(v[0].vec[0], v[0].vec[1], 0, 0,0);
gl_vertex(v[1].vec[0], v[1].vec[1], 0, 0,1);
gl_vertex(v[2].vec[0], v[2].vec[1], 0, 1,1);
gl_vertex(v[3].vec[0], v[3].vec[1], 0, 1,0);
}
render_technique_ss::render_technique_ss(ui32 width, ui32 height, const std::string& name, const std::shared_ptr<material>& material) :
render_technique_base(width, height, name, 0),
m_material(material)
{
ui32 color_attachment_id;
gl_create_textures(1, &color_attachment_id);
gl_bind_texture(GL_TEXTURE_2D, color_attachment_id);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl_texture_image2d(GL_TEXTURE_2D, 0, GL_RGBA, m_frame_width, m_frame_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
gl_create_frame_buffers(1, &m_frame_buffer);
gl_bind_frame_buffer(GL_FRAMEBUFFER, m_frame_buffer);
gl_attach_frame_buffer_texture2d(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color_attachment_id, 0);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
std::string color_attachment_guid = m_name;
color_attachment_guid.append(".color");
m_color_attachment_texture = texture::construct(color_attachment_guid,
color_attachment_id,
m_frame_width,
m_frame_height);
m_color_attachment_texture->set_wrap_mode(GL_CLAMP_TO_EDGE);
m_quad = mesh_constructor::create_screen_quad();
}
void device_load_texture(gs_device_t *device, gs_texture_t *tex, int unit)
{
struct gs_shader_param *param;
struct gs_sampler_state *sampler;
struct gs_texture *cur_tex = device->cur_textures[unit];
/* need a pixel shader to properly bind textures */
if (!device->cur_pixel_shader)
tex = NULL;
if (cur_tex == tex)
return;
if (!gl_active_texture(GL_TEXTURE0 + unit))
goto fail;
/* the target for the previous text may not be the same as the
* next texture, so unbind the previous texture first to be safe */
if (cur_tex && (!tex || cur_tex->gl_target != tex->gl_target))
gl_bind_texture(cur_tex->gl_target, 0);
device->cur_textures[unit] = tex;
param = get_texture_param(device, unit);
if (!param)
return;
param->texture = tex;
if (!tex)
return;
// texelFetch doesn't need a sampler
if (param->sampler_id != (size_t)-1)
sampler = device->cur_samplers[param->sampler_id];
else
sampler = NULL;
if (!gl_bind_texture(tex->gl_target, tex->texture))
goto fail;
if (sampler && !load_texture_sampler(tex, sampler))
goto fail;
return;
fail:
blog(LOG_ERROR, "device_load_texture (GL) failed");
}
/**
* gst_vaapi_window_glx_put_texture:
* @window: a #GstVaapiWindowGLX
* @texture: a #GstVaapiTexture
* @src_rect: the sub-rectangle of the source texture to
* extract and process. If %NULL, the entire texture will be used.
* @dst_rect: the sub-rectangle of the destination
* window into which the texture is rendered. If %NULL, the entire
* window will be used.
*
* Renders the @texture region specified by @src_rect into the @window
* region specified by @dst_rect.
*
* NOTE: only GL_TEXTURE_2D textures are supported at this time.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_window_glx_put_texture (GstVaapiWindowGLX * window,
GstVaapiTexture * texture,
const GstVaapiRectangle * src_rect, const GstVaapiRectangle * dst_rect)
{
GstVaapiRectangle tmp_src_rect, tmp_dst_rect;
GLTextureState ts;
GLenum tex_target;
GLuint tex_id;
guint tex_width, tex_height;
guint win_width, win_height;
g_return_val_if_fail (GST_VAAPI_IS_WINDOW_GLX (window), FALSE);
g_return_val_if_fail (texture != NULL, FALSE);
gst_vaapi_texture_get_size (texture, &tex_width, &tex_height);
fill_rect (&tmp_src_rect, src_rect, tex_width, tex_height);
src_rect = &tmp_src_rect;
gst_vaapi_window_get_size (GST_VAAPI_WINDOW (window), &win_width,
&win_height);
fill_rect (&tmp_dst_rect, dst_rect, win_width, win_height);
dst_rect = &tmp_dst_rect;
/* XXX: only GL_TEXTURE_2D textures are supported at this time */
tex_target = gst_vaapi_texture_get_target (texture);
if (tex_target != GL_TEXTURE_2D)
return FALSE;
tex_id = gst_vaapi_texture_get_id (texture);
if (!gl_bind_texture (&ts, tex_target, tex_id))
return FALSE;
glColor4f (1.0f, 1.0f, 1.0f, 1.0f);
glPushMatrix ();
glTranslatef ((GLfloat) dst_rect->x, (GLfloat) dst_rect->y, 0.0f);
glBegin (GL_QUADS);
{
const float tx1 = (float) src_rect->x / tex_width;
const float tx2 = (float) (src_rect->x + src_rect->width) / tex_width;
const float ty1 = (float) src_rect->y / tex_height;
const float ty2 = (float) (src_rect->y + src_rect->height) / tex_height;
const guint w = dst_rect->width;
const guint h = dst_rect->height;
glTexCoord2f (tx1, ty1);
glVertex2i (0, 0);
glTexCoord2f (tx1, ty2);
glVertex2i (0, h);
glTexCoord2f (tx2, ty2);
glVertex2i (w, h);
glTexCoord2f (tx2, ty1);
glVertex2i (w, 0);
}
glEnd ();
glPopMatrix ();
gl_unbind_texture (&ts);
return TRUE;
}
render_target::render_target(const graphics_context_shared_ptr& graphics_context, GLint format,
const glm::ivec2& size, const texture_shared_ptr& custom_attachment) :
m_graphics_context(graphics_context),
m_size(size),
m_format(format),
m_is_custom_color_attachment(custom_attachment != nullptr)
{
if(!m_is_custom_color_attachment)
{
gl_create_textures(1, &m_color_attachment);
gl_bind_texture(GL_TEXTURE_2D, m_color_attachment);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl_texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl_texture_image2d(GL_TEXTURE_2D, 0, format,
m_size.x,
m_size.y,
0, format, GL_UNSIGNED_BYTE, NULL);
}
else
{
m_color_attachment = custom_attachment->get_texture_id();
}
gl_create_render_buffers(1, &m_depth_attachment);
gl_bind_render_buffer(GL_RENDERBUFFER, m_depth_attachment);
gl_create_render_buffer_storage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
m_size.x,
m_size.y);
gl_create_frame_buffers(1, &m_frame_buffer);
gl_bind_frame_buffer(GL_FRAMEBUFFER, m_frame_buffer);
gl_attach_frame_buffer_texture2d(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_color_attachment, 0);
gl_attach_frame_buffer_render_buffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth_attachment);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
#if defined(__PBO__)
ui32 size = m_size.x * m_size.y;
if(m_format == GL_RGBA)
{
size *= 4;
}
else if(m_format == GL_RGB)
{
size *= 3;
}
gl_create_buffers(1, &m_pixel_buffer);
gl_bind_buffer(GL_PIXEL_PACK_BUFFER, m_pixel_buffer);
gl_push_buffer_data(GL_PIXEL_PACK_BUFFER, size, NULL, GL_STREAM_READ);
gl_bind_buffer(GL_PIXEL_PACK_BUFFER, 0);
#endif
}
void device_load_texture(device_t device, texture_t tex, int unit)
{
struct shader_param *param;
struct gs_sampler_state *sampler;
struct gs_texture *cur_tex = device->cur_textures[unit];
/* need a pixel shader to properly bind textures */
if (!device->cur_pixel_shader)
tex = NULL;
if (cur_tex == tex)
return;
if (!gl_active_texture(GL_TEXTURE0 + unit))
goto fail;
if (cur_tex && cur_tex->gl_target != tex->gl_target)
gl_bind_texture(cur_tex->gl_target, 0);
device->cur_textures[unit] = tex;
param = get_texture_param(device, unit);
if (!param)
return;
param->texture = tex;
if (!tex)
return;
sampler = device->cur_samplers[param->sampler_id];
if (!gl_bind_texture(tex->gl_target, tex->texture))
goto fail;
if (sampler && !load_texture_sampler(tex, sampler))
goto fail;
return;
fail:
blog(LOG_ERROR, "device_load_texture (GL) failed");
}
static void clear_textures(struct gs_device *device)
{
GLenum i;
for (i = 0; i < GS_MAX_TEXTURES; i++) {
if (device->cur_textures[i]) {
gl_active_texture(GL_TEXTURE0 + i);
gl_bind_texture(device->cur_textures[i]->gl_target, 0);
device->cur_textures[i] = NULL;
}
}
}
static inline bool upload_texture_cube(struct gs_texture_cube *tex,
const uint8_t **data)
{
uint32_t row_size = tex->size * gs_get_format_bpp(tex->base.format);
uint32_t tex_size = tex->size * row_size / 8;
uint32_t num_levels = tex->base.levels;
bool compressed = gs_is_compressed_format(tex->base.format);
GLenum gl_type = get_gl_format_type(tex->base.format);
bool success = true;
uint32_t i;
if (!num_levels)
num_levels = gs_get_total_levels(tex->size, tex->size);
for (i = 0; i < 6; i++) {
GLenum target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
if (!gl_bind_texture(target, tex->base.texture))
success = false;
if (!gl_init_face(target, gl_type, num_levels,
tex->base.gl_format,
tex->base.gl_internal_format,
compressed, tex->size, tex->size,
tex_size, &data))
success = false;
if (!gl_bind_texture(target, 0))
success = false;
if (data)
data++;
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, num_levels);
if (!gl_success("glTexParameteri"))
success = false;
return success;
}
static bool gl_init_stage_surface(struct gs_stage_surface *surf)
{
bool success = true;
if (!gl_gen_textures(1, &surf->texture))
return false;
if (!gl_bind_texture(GL_TEXTURE_2D, surf->texture))
return false;
if (!gl_init_face(GL_TEXTURE_2D, surf->gl_type, 1, surf->gl_format,
surf->gl_internal_format, false,
surf->width, surf->height, 0, NULL))
success = false;
if (!gl_bind_texture(GL_TEXTURE_2D, 0))
success = false;
if (success)
success = create_pixel_pack_buffer(surf);
return success;
}
/**
* gst_vaapi_texture_glx_new_wrapped:
* @display: a #GstVaapiDisplay
* @texture_id: the foreign GL texture name to use
* @target: the target to which the texture is bound
* @format: the format of the pixel data
*
* Creates a texture from an existing GL texture, with the specified
* @target and @format. Note that only GL_TEXTURE_2D @target and
* GL_RGBA or GL_BGRA formats are supported at this time. The
* dimensions will be retrieved from the @texture_id.
*
* The application shall maintain the live GL context itself. That is,
* gst_vaapi_window_glx_make_current() must be called beforehand, or
* any other function like glXMakeCurrent() if the context is managed
* outside of this library.
*
* Return value: the newly created #GstVaapiTexture object
*/
GstVaapiTexture *
gst_vaapi_texture_glx_new_wrapped (GstVaapiDisplay * display,
guint texture_id, guint target, guint format)
{
guint width, height, border_width = 0;
GLTextureState ts = { 0, };
gboolean success;
GstVaapiGLApi gl_api;
g_return_val_if_fail (GST_VAAPI_IS_DISPLAY_GLX (display), NULL);
g_return_val_if_fail (texture_id != GL_NONE, NULL);
g_return_val_if_fail (target == GL_TEXTURE_2D, NULL);
g_return_val_if_fail (format == GL_RGBA || format == GL_BGRA, NULL);
gl_api = gl_get_curent_api_once ();
if (gl_api != GST_VAAPI_GL_API_OPENGL && gl_api != GST_VAAPI_GL_API_OPENGL3)
return NULL;
/* Check texture dimensions */
GST_VAAPI_DISPLAY_LOCK (display);
if (gl_api == GST_VAAPI_GL_API_OPENGL)
success = gl_bind_texture (&ts, target, texture_id);
else
success = gl3_bind_texture_2d (&ts, target, texture_id);
if (success) {
if (!gl_get_texture_param (target, GL_TEXTURE_WIDTH, &width) ||
!gl_get_texture_param (target, GL_TEXTURE_HEIGHT, &height))
success = FALSE;
if (success && gl_api == GST_VAAPI_GL_API_OPENGL)
success = gl_get_texture_param (target, GL_TEXTURE_BORDER, &border_width);
gl_unbind_texture (&ts);
}
GST_VAAPI_DISPLAY_UNLOCK (display);
if (!success)
return NULL;
width -= 2 * border_width;
height -= 2 * border_width;
g_return_val_if_fail (width > 0, NULL);
g_return_val_if_fail (height > 0, NULL);
return gst_vaapi_texture_new_internal (GST_VAAPI_TEXTURE_CLASS
(gst_vaapi_texture_glx_class ()), display, texture_id, target, format,
width, height);
}
void gl_draw_text(Scene_Camera* camera, Font* font, UChar* text, GLfloat size) {
glBindVertexArray(font->quad->vao);
glUseProgram(font->quad->shader->id);
//TODO: this bugs out when I enable depth-testing due to z-fighting
//on adjacent characters, I can probably fix it with blend mode?
glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE);
gl_bind_texture(font->quad->shader->id, font->page->id, 0, "diffuse");
int32_t length = u_strlen(text); UChar32 character;
for(int32_t i = 0; i < length; i++) {
U16_GET_UNSAFE(text, i, character);
gl_draw_font_glyph(camera, font, character, size);
}
glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE);
glBindVertexArray(0);
glUseProgram(0);
}
void texture_commiter_png::commit(const resource_transfering_data_shared_ptr& transfering_data)
{
m_status = e_commiter_status_in_progress;
assert(m_resource != nullptr);
ui32 texture_id = 0;
gl_create_textures(1, &texture_id);
gl_bind_texture(GL_TEXTURE_2D, texture_id);
texture_transfering_data_shared_ptr texture_transfering_data = std::static_pointer_cast<gb::texture_transfering_data>(transfering_data);
gl_texture_image2d(GL_TEXTURE_2D, 0, texture_transfering_data->m_format,
texture_transfering_data->m_width, texture_transfering_data->m_height,
0, texture_transfering_data->m_format, GL_UNSIGNED_BYTE, (GLvoid*)&texture_transfering_data->m_data[0]);
gl_generate_mipmap(GL_TEXTURE_2D);
m_status = e_commiter_status_success;
texture_transfering_data->m_texture_id = texture_id;
resource_commiter::on_transfering_data_commited(texture_transfering_data);
}
static void gl_create_fbo_texture(gl_t *gl,
void *chain_data, unsigned i, GLuint texture)
{
GLenum mag_filter, wrap_enum;
video_shader_ctx_filter_t filter_type;
video_shader_ctx_wrap_t wrap = {0};
bool fp_fbo = false;
bool smooth = false;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
settings_t *settings = config_get_ptr();
GLuint base_filt = settings->bools.video_smooth ? GL_LINEAR : GL_NEAREST;
GLuint base_mip_filt = settings->bools.video_smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST;
unsigned mip_level = i + 2;
bool mipmapped = video_shader_driver_mipmap_input(&mip_level);
GLenum min_filter = mipmapped ? base_mip_filt : base_filt;
filter_type.index = i + 2;
filter_type.smooth = &smooth;
if (video_shader_driver_filter_type(&filter_type))
{
min_filter = mipmapped ? (smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST)
: (smooth ? GL_LINEAR : GL_NEAREST);
}
mag_filter = min_filter_to_mag(min_filter);
wrap.idx = i + 2;
video_shader_driver_wrap_type(&wrap);
wrap_enum = gl_wrap_type_to_enum(wrap.type);
gl_bind_texture(texture, wrap_enum, mag_filter, min_filter);
fp_fbo = chain->fbo_scale[i].fp_fbo;
if (fp_fbo)
{
if (!chain->has_fp_fbo)
RARCH_ERR("[GL]: Floating-point FBO was requested, but is not supported. Falling back to UNORM. Result may band/clip/etc.!\n");
}
#if !defined(HAVE_OPENGLES2)
if (fp_fbo && chain->has_fp_fbo)
{
RARCH_LOG("[GL]: FBO pass #%d is floating-point.\n", i);
gl_load_texture_image(GL_TEXTURE_2D, 0, GL_RGBA32F,
gl->fbo_rect[i].width, gl->fbo_rect[i].height,
0, GL_RGBA, GL_FLOAT, NULL);
}
else
#endif
{
#ifndef HAVE_OPENGLES
bool srgb_fbo = chain->fbo_scale[i].srgb_fbo;
if (!fp_fbo && srgb_fbo)
{
if (!chain->has_srgb_fbo)
RARCH_ERR("[GL]: sRGB FBO was requested, but it is not supported. Falling back to UNORM. Result may have banding!\n");
}
if (settings->bools.video_force_srgb_disable)
srgb_fbo = false;
if (srgb_fbo && chain->has_srgb_fbo)
{
RARCH_LOG("[GL]: FBO pass #%d is sRGB.\n", i);
#ifdef HAVE_OPENGLES2
/* EXT defines are same as core GLES3 defines,
* but GLES3 variant requires different arguments. */
glTexImage2D(GL_TEXTURE_2D,
0, GL_SRGB_ALPHA_EXT,
gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0,
chain->has_srgb_fbo_gles3 ? GL_RGBA : GL_SRGB_ALPHA_EXT,
GL_UNSIGNED_BYTE, NULL);
#else
gl_load_texture_image(GL_TEXTURE_2D,
0, GL_SRGB8_ALPHA8,
gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
#endif
}
else
#endif
{
#if defined(HAVE_OPENGLES2) || defined(HAVE_PSGL)
glTexImage2D(GL_TEXTURE_2D,
0, GL_RGBA,
gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
#else
/* Avoid potential performance
* reductions on particular platforms. */
gl_load_texture_image(GL_TEXTURE_2D,
0, RARCH_GL_INTERNAL_FORMAT32,
gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0,
RARCH_GL_TEXTURE_TYPE32, RARCH_GL_FORMAT32, NULL);
#endif
}
}
}
void gl_grop_handler(struct groprender *r, struct gropnode *n) {
struct glbitmap *glb;
GLfloat vector[4];
switch (n->type) {
case PG_GROP_GL_BINDTEXTURE:
if (!iserror(rdhandle((void**)&glb,PG_TYPE_BITMAP,-1,n->param[0])) && glb)
gl_bind_texture(glb);
break;
case PG_GROP_GL_ENABLE:
glEnable(n->param[0]);
break;
case PG_GROP_GL_DISABLE:
glDisable(n->param[0]);
break;
case PG_GROP_GL_DEPTHFUNC:
glDepthFunc(n->param[0]);
break;
case PG_GROP_GL_SHADEMODEL:
glShadeModel(n->param[0]);
break;
case PG_GROP_GL_MATRIXMODE:
glMatrixMode(n->param[0]);
break;
case PG_GROP_GL_LOADIDENTITY:
glLoadIdentity();
break;
case PG_GROP_GL_PUSHMATRIX:
glPushMatrix();
break;
case PG_GROP_GL_POPMATRIX:
glPopMatrix();
break;
case PG_GROP_GL_TRANSLATEF:
glTranslatef(UNFIX(n->param[0]),
UNFIX(n->param[1]),
UNFIX(n->param[2]));
break;
case PG_GROP_GL_ROTATEF:
glRotatef(UNFIX16(n->r.x,n->r.y),
UNFIX(n->param[0]),
UNFIX(n->param[1]),
UNFIX(n->param[2]));
break;
case PG_GROP_GL_SCALEF:
glScalef(UNFIX(n->param[0]),
UNFIX(n->param[1]),
UNFIX(n->param[2]));
break;
case PG_GROP_GL_BEGIN:
glBegin(n->param[0]);
break;
case PG_GROP_GL_TEXCOORD2F:
glTexCoord2f(UNFIX(n->param[0]),
UNFIX(n->param[1]));
break;
case PG_GROP_GL_VERTEX3F:
glVertex3f(UNFIX(n->param[0]),
UNFIX(n->param[1]),
UNFIX(n->param[2]));
break;
case PG_GROP_GL_END:
glEnd();
break;
case PG_GROP_GL_HINT:
glHint(n->param[0],n->param[1]);
break;
case PG_GROP_GL_NORMAL3F:
glNormal3f(UNFIX(n->param[0]),
UNFIX(n->param[1]),
UNFIX(n->param[2]));
break;
case PG_GROP_GL_LIGHTFV:
vector[0] = UNFIX(n->param[0]);
vector[1] = UNFIX(n->param[1]);
vector[2] = UNFIX(n->param[2]);
vector[3] = UNFIX16(n->r.w,n->r.h);
glLightfv(n->r.x,n->r.y,(const GLfloat *)&vector);
break;
case PG_GROP_GL_MATERIALFV:
vector[0] = UNFIX(n->param[0]);
vector[1] = UNFIX(n->param[1]);
vector[2] = UNFIX(n->param[2]);
vector[3] = UNFIX16(n->r.w,n->r.h);
glMaterialfv(n->r.x,n->r.y,(const GLfloat *)&vector);
break;
case PG_GROP_GL_TEXGENFV:
vector[0] = UNFIX(n->param[0]);
vector[1] = UNFIX(n->param[1]);
vector[2] = UNFIX(n->param[2]);
vector[3] = UNFIX16(n->r.w,n->r.h);
glTexGenfv(n->r.x,n->r.y,(const GLfloat *)&vector);
break;
case PG_GROP_GL_TEXGENI:
glTexGeni(n->param[0], n->param[1], n->param[2]);
break;
case PG_GROP_GL_MATERIALI:
glMateriali(n->param[0], n->param[1], n->param[2]);
break;
case PG_GROP_GL_MATRIX_PIXELCOORD:
gl_matrix_pixelcoord();
break;
case PG_GROP_GL_COLOR:
gl_color(n->param[0]);
break;
case PG_GROP_GL_BLENDFUNC:
glBlendFunc(n->param[0],n->param[1]);
break;
case PG_GROP_GL_FEEDBACK:
gl_feedback(n->r.x, n->r.y, n->r.w, n->r.h,
r->lgop, n->param[0], n->param[1],
(n->param[2]>>16) & 0xFFFF, (n->param[2] & 0xFFFF));
break;
case PG_GROP_GL_TEXPARAMETERI:
glTexParameteri(n->param[0],n->param[1],n->param[2]);
break;
}
}
