#include "yagl_gles_driver.h"
#include "yagl_gles_api_ps.h"
#include "yagl_gles_api_ts.h"
-#include "yagl_tls.h"
#include "yagl_log.h"
#include "yagl_process.h"
#include "yagl_thread.h"
#include "yagl_object_map.h"
#include "yagl_transport.h"
-// TODO remove and pass via argument
-static YAGL_DEFINE_TLS(struct yagl_gles_api_ts*, gles_api_ts);
-
struct yagl_gles_object
{
struct yagl_object base;
GLuint current_vbo;
uint32_t size;
void *ptr;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
YAGL_LOG_FUNC_SET(yagl_gles_bind_array);
gles_api_ts->num_arrays = indx + 1;
}
- gles_api_ts->driver->GetIntegerv(GL_ARRAY_BUFFER_BINDING,
+ cur_ts->gles_api_ts->driver->GetIntegerv(GL_ARRAY_BUFFER_BINDING,
(GLint*)¤t_vbo);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, gles_api_ts->arrays[indx].vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, gles_api_ts->arrays[indx].vbo);
size = first * stride + data_count;
{
GLuint current_ebo;
void *ptr;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
YAGL_LOG_FUNC_SET(yagl_gles_bind_ebo);
gles_api_ts->driver->GenBuffers(1, &gles_api_ts->ebo);
}
- gles_api_ts->driver->GetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING,
+ cur_ts->gles_api_ts->driver->GetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING,
(GLint*)¤t_ebo);
- gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, gles_api_ts->ebo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, gles_api_ts->ebo);
if (size > gles_api_ts->ebo_size) {
gles_api_ts->driver->BufferData(GL_ELEMENT_ARRAY_BUFFER,
GLint uniform_name_max_length = 0;
GLchar *uniform_name = NULL;
bool res = false;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
YAGL_LOG_FUNC_SET(yagl_gles_program_get_uniform_type);
return false;
}
- gles_api_ts->driver->GetProgramiv(program,
+ cur_ts->gles_api_ts->driver->GetProgramiv(program,
GL_LINK_STATUS,
&link_status);
return false;
}
- gles_api_ts->driver->GetProgramiv(program,
+ cur_ts->gles_api_ts->driver->GetProgramiv(program,
GL_ACTIVE_UNIFORMS,
&num_active_uniforms);
- gles_api_ts->driver->GetProgramiv(program,
+ cur_ts->gles_api_ts->driver->GetProgramiv(program,
GL_ACTIVE_UNIFORM_MAX_LENGTH,
&uniform_name_max_length);
return true;
}
-static void yagl_gles_object_add(struct yagl_process_state *ps,
+static void yagl_gles_object_add(struct yagl_thread_state *cur_ts,
GLuint local_name,
GLuint global_name,
uint32_t ctx_id,
- void (*destroy_func)(struct yagl_object */*obj*/))
+ yagl_object_destroy_func destroy_func)
{
struct yagl_gles_object *obj;
obj = g_malloc(sizeof(*obj));
obj->base.global_name = global_name;
- obj->base.ps = ps;
obj->base.destroy = destroy_func;
- obj->driver = gles_api_ts->driver;
+ obj->driver = cur_ts->gles_api_ts->driver;
obj->ctx_id = ctx_id;
- yagl_object_map_add(ps->object_map,
+ yagl_object_map_add(cur_ts->ps->object_map,
local_name,
&obj->base);
}
-static void yagl_gles_buffer_destroy(struct yagl_object *obj)
+static void yagl_gles_buffer_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_buffer_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
gles_obj->driver->DeleteBuffers(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, 0);
+ yagl_unensure_ctx(cur_ts, 0);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_texture_destroy(struct yagl_object *obj)
+static void yagl_gles_texture_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_texture_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
gles_obj->driver->DeleteTextures(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, 0);
+ yagl_unensure_ctx(cur_ts, 0);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_framebuffer_destroy(struct yagl_object *obj)
+static void yagl_gles_framebuffer_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_framebuffer_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_ensure_ctx(cur_ts, gles_obj->ctx_id);
gles_obj->driver->DeleteFramebuffers(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_unensure_ctx(cur_ts, gles_obj->ctx_id);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_renderbuffer_destroy(struct yagl_object *obj)
+static void yagl_gles_renderbuffer_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_renderbuffer_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
gles_obj->driver->DeleteRenderbuffers(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, 0);
+ yagl_unensure_ctx(cur_ts, 0);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_program_destroy(struct yagl_object *obj)
+static void yagl_gles_program_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_program_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
gles_obj->driver->DeleteProgram(obj->global_name);
- yagl_unensure_ctx(obj->ps, 0);
+ yagl_unensure_ctx(cur_ts, 0);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_shader_destroy(struct yagl_object *obj)
+static void yagl_gles_shader_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_shader_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
gles_obj->driver->DeleteShader(obj->global_name);
- yagl_unensure_ctx(obj->ps, 0);
+ yagl_unensure_ctx(cur_ts, 0);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_vertex_array_destroy(struct yagl_object *obj)
+static void yagl_gles_vertex_array_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_vertex_array_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_ensure_ctx(cur_ts, gles_obj->ctx_id);
gles_obj->driver->DeleteVertexArrays(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_unensure_ctx(cur_ts, gles_obj->ctx_id);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_transform_feedback_destroy(struct yagl_object *obj)
+static void yagl_gles_transform_feedback_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_transform_feedback_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_ensure_ctx(cur_ts, gles_obj->ctx_id);
gles_obj->driver->DeleteTransformFeedbacks(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_unensure_ctx(cur_ts, gles_obj->ctx_id);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_query_destroy(struct yagl_object *obj)
+static void yagl_gles_query_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_query_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_ensure_ctx(cur_ts, gles_obj->ctx_id);
gles_obj->driver->DeleteQueries(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, gles_obj->ctx_id);
+ yagl_unensure_ctx(cur_ts, gles_obj->ctx_id);
g_free(gles_obj);
YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_gles_sampler_destroy(struct yagl_object *obj)
+static void yagl_gles_sampler_destroy(struct yagl_thread_state *cur_ts,
+ struct yagl_object *obj)
{
struct yagl_gles_object *gles_obj = (struct yagl_gles_object*)obj;
- YAGL_LOG_NO_TS;
YAGL_LOG_FUNC_ENTER(yagl_gles_sampler_destroy, "%u", obj->global_name);
- yagl_ensure_ctx(obj->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
gles_obj->driver->DeleteSamplers(1, &obj->global_name);
- yagl_unensure_ctx(obj->ps, 0);
+ yagl_unensure_ctx(cur_ts, 0);
g_free(gles_obj);
YAGL_LOG_FUNC_ENTER(yagl_host_gles_thread_init, NULL);
- gles_api_ts = g_malloc0(sizeof(*gles_api_ts));
-
- yagl_gles_api_ts_init(cur_ts, gles_api_ts, gles_api_ps->driver, gles_api_ps);
+ cur_ts->gles_api_ts = g_malloc0(sizeof(struct yagl_gles_api_ts));
- cur_ts->gles_api_ts = gles_api_ts;
+ yagl_gles_api_ts_init(cur_ts, cur_ts->gles_api_ts, gles_api_ps->driver, gles_api_ps);
YAGL_LOG_FUNC_EXIT(NULL);
}
static void yagl_host_gles_batch_start(struct yagl_thread_state *cur_ts,
struct yagl_api_ps *api_ps)
{
- gles_api_ts = cur_ts->gles_api_ts;
}
static void yagl_host_gles_batch_end(struct yagl_thread_state *cur_ts,
{
YAGL_LOG_FUNC_ENTER(yagl_host_gles_thread_fini, NULL);
- gles_api_ts = cur_ts->gles_api_ts;
-
- yagl_gles_api_ts_cleanup(cur_ts, gles_api_ts);
+ yagl_gles_api_ts_cleanup(cur_ts, cur_ts->gles_api_ts);
- g_free(gles_api_ts);
+ g_free(cur_ts->gles_api_ts);
- gles_api_ts = cur_ts->gles_api_ts = NULL;
+ cur_ts->gles_api_ts = NULL;
YAGL_LOG_FUNC_EXIT(NULL);
}
GLint first,
GLsizei count)
{
- gles_api_ts->driver->DrawArrays(mode, first, count);
+ cur_ts->gles_api_ts->driver->DrawArrays(mode, first, count);
}
void yagl_host_glDrawElements(struct yagl_thread_state *cur_ts,
if (indices) {
GLuint current_ebo = yagl_gles_bind_ebo(cur_ts, indices, indices_count);
- gles_api_ts->driver->DrawElements(mode, count, type, NULL);
+ cur_ts->gles_api_ts->driver->DrawElements(mode, count, type, NULL);
- gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_ebo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_ebo);
} else {
- gles_api_ts->driver->DrawElements(mode, count, type,
- (const GLvoid*)(uintptr_t)indices_count);
+ cur_ts->gles_api_ts->driver->DrawElements(mode, count, type,
+ (const GLvoid*)(uintptr_t)indices_count);
}
}
GLenum type,
GLvoid *pixels, int32_t pixels_maxcount, int32_t *pixels_count)
{
- gles_api_ts->driver->ReadPixels(x,
- y,
- width,
- height,
- format,
- type,
- pixels);
+ cur_ts->gles_api_ts->driver->ReadPixels(x,
+ y,
+ width,
+ height,
+ format,
+ type,
+ pixels);
*pixels_count = pixels_maxcount;
}
GLenum type,
uintptr_t pixels)
{
- gles_api_ts->driver->ReadPixels(x,
- y,
- width,
- height,
- format,
- type,
- (GLvoid*)pixels);
+ cur_ts->gles_api_ts->driver->ReadPixels(x,
+ y,
+ width,
+ height,
+ format,
+ type,
+ (GLvoid*)pixels);
}
void yagl_host_glDrawArraysInstanced(struct yagl_thread_state *cur_ts,
GLsizei count,
GLsizei primcount)
{
- gles_api_ts->driver->DrawArraysInstanced(mode, start, count, primcount);
+ cur_ts->gles_api_ts->driver->DrawArraysInstanced(mode, start, count, primcount);
}
void yagl_host_glDrawElementsInstanced(struct yagl_thread_state *cur_ts,
if (indices) {
GLuint current_ebo = yagl_gles_bind_ebo(cur_ts, indices, indices_count);
- gles_api_ts->driver->DrawElementsInstanced(mode, count, type, NULL, primcount);
+ cur_ts->gles_api_ts->driver->DrawElementsInstanced(mode, count, type, NULL, primcount);
- gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_ebo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_ebo);
} else {
- gles_api_ts->driver->DrawElementsInstanced(mode,
- count,
- type,
- (const GLvoid*)(uintptr_t)indices_count,
- primcount);
+ cur_ts->gles_api_ts->driver->DrawElementsInstanced(mode,
+ count,
+ type,
+ (const GLvoid*)(uintptr_t)indices_count,
+ primcount);
}
}
if (indices) {
GLuint current_ebo = yagl_gles_bind_ebo(cur_ts, indices, indices_count);
- gles_api_ts->driver->DrawRangeElements(mode, start, end, count, type, NULL);
+ cur_ts->gles_api_ts->driver->DrawRangeElements(mode, start, end, count, type, NULL);
- gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_ebo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_ebo);
} else {
- gles_api_ts->driver->DrawRangeElements(mode, start, end, count, type,
- (const GLvoid*)(uintptr_t)indices_count);
+ cur_ts->gles_api_ts->driver->DrawRangeElements(mode, start, end, count, type,
+ (const GLvoid*)(uintptr_t)indices_count);
}
}
for (i = 0; i < arrays_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenVertexArrays(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenVertexArrays(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
arrays[i],
global_name,
- yagl_get_ctx_id(cur_ts->ps),
+ yagl_get_ctx_id(cur_ts),
&yagl_gles_vertex_array_destroy);
}
}
void yagl_host_glBindVertexArray(struct yagl_thread_state *cur_ts,
GLuint array)
{
- gles_api_ts->driver->BindVertexArray(yagl_gles_object_get(cur_ts, array));
+ cur_ts->gles_api_ts->driver->BindVertexArray(yagl_gles_object_get(cur_ts, array));
}
void yagl_host_glDisableVertexAttribArray(struct yagl_thread_state *cur_ts,
GLuint index)
{
- gles_api_ts->driver->DisableVertexAttribArray(index);
+ cur_ts->gles_api_ts->driver->DisableVertexAttribArray(index);
}
void yagl_host_glEnableVertexAttribArray(struct yagl_thread_state *cur_ts,
GLuint index)
{
- gles_api_ts->driver->EnableVertexAttribArray(index);
+ cur_ts->gles_api_ts->driver->EnableVertexAttribArray(index);
}
void yagl_host_glVertexAttribPointerData(struct yagl_thread_state *cur_ts,
GLuint current_vbo = yagl_gles_bind_array(cur_ts, indx, first, stride,
data, data_count);
- gles_api_ts->driver->VertexAttribPointer(indx, size, type, normalized,
- stride,
- NULL);
+ cur_ts->gles_api_ts->driver->VertexAttribPointer(indx, size, type, normalized,
+ stride,
+ NULL);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
}
void yagl_host_glVertexAttribPointerOffset(struct yagl_thread_state *cur_ts,
GLsizei stride,
uintptr_t offset)
{
- gles_api_ts->driver->VertexAttribPointer(indx, size, type, normalized,
- stride,
- (const GLvoid*)offset);
+ cur_ts->gles_api_ts->driver->VertexAttribPointer(indx, size, type, normalized,
+ stride,
+ (const GLvoid*)offset);
}
void yagl_host_glVertexPointerData(struct yagl_thread_state *cur_ts,
first, stride,
data, data_count);
- gles_api_ts->driver->VertexPointer(size, type, stride, NULL);
+ cur_ts->gles_api_ts->driver->VertexPointer(size, type, stride, NULL);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
}
void yagl_host_glVertexPointerOffset(struct yagl_thread_state *cur_ts,
GLsizei stride,
uintptr_t offset)
{
- gles_api_ts->driver->VertexPointer(size, type, stride, (const GLvoid*)offset);
+ cur_ts->gles_api_ts->driver->VertexPointer(size, type, stride, (const GLvoid*)offset);
}
void yagl_host_glNormalPointerData(struct yagl_thread_state *cur_ts,
first, stride,
data, data_count);
- gles_api_ts->driver->NormalPointer(type, stride, NULL);
+ cur_ts->gles_api_ts->driver->NormalPointer(type, stride, NULL);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
}
void yagl_host_glNormalPointerOffset(struct yagl_thread_state *cur_ts,
GLsizei stride,
uintptr_t offset)
{
- gles_api_ts->driver->NormalPointer(type, stride, (const GLvoid*)offset);
+ cur_ts->gles_api_ts->driver->NormalPointer(type, stride, (const GLvoid*)offset);
}
void yagl_host_glColorPointerData(struct yagl_thread_state *cur_ts,
first, stride,
data, data_count);
- gles_api_ts->driver->ColorPointer(size, type, stride, NULL);
+ cur_ts->gles_api_ts->driver->ColorPointer(size, type, stride, NULL);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
}
void yagl_host_glColorPointerOffset(struct yagl_thread_state *cur_ts,
GLsizei stride,
uintptr_t offset)
{
- gles_api_ts->driver->ColorPointer(size, type, stride, (const GLvoid*)offset);
+ cur_ts->gles_api_ts->driver->ColorPointer(size, type, stride, (const GLvoid*)offset);
}
void yagl_host_glTexCoordPointerData(struct yagl_thread_state *cur_ts,
first, stride,
data, data_count);
- gles_api_ts->driver->TexCoordPointer(size, type, stride, NULL);
+ cur_ts->gles_api_ts->driver->TexCoordPointer(size, type, stride, NULL);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
}
void yagl_host_glTexCoordPointerOffset(struct yagl_thread_state *cur_ts,
GLsizei stride,
uintptr_t offset)
{
- gles_api_ts->driver->TexCoordPointer(size, type, stride, (const GLvoid*)offset);
+ cur_ts->gles_api_ts->driver->TexCoordPointer(size, type, stride, (const GLvoid*)offset);
}
void yagl_host_glDisableClientState(struct yagl_thread_state *cur_ts,
GLenum array)
{
- gles_api_ts->driver->DisableClientState(array);
+ cur_ts->gles_api_ts->driver->DisableClientState(array);
}
void yagl_host_glEnableClientState(struct yagl_thread_state *cur_ts,
GLenum array)
{
- gles_api_ts->driver->EnableClientState(array);
+ cur_ts->gles_api_ts->driver->EnableClientState(array);
}
void yagl_host_glVertexAttribDivisor(struct yagl_thread_state *cur_ts,
GLuint index,
GLuint divisor)
{
- gles_api_ts->driver->VertexAttribDivisor(index, divisor);
+ cur_ts->gles_api_ts->driver->VertexAttribDivisor(index, divisor);
}
void yagl_host_glVertexAttribIPointerData(struct yagl_thread_state *cur_ts,
GLuint current_vbo = yagl_gles_bind_array(cur_ts, index, first, stride,
data, data_count);
- gles_api_ts->driver->VertexAttribIPointer(index, size, type, stride, NULL);
+ cur_ts->gles_api_ts->driver->VertexAttribIPointer(index, size, type, stride, NULL);
- gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_ARRAY_BUFFER, current_vbo);
}
void yagl_host_glVertexAttribIPointerOffset(struct yagl_thread_state *cur_ts,
GLsizei stride,
uintptr_t offset)
{
- gles_api_ts->driver->VertexAttribIPointer(index, size, type,
- stride,
- (const GLvoid*)offset);
+ cur_ts->gles_api_ts->driver->VertexAttribIPointer(index, size, type,
+ stride,
+ (const GLvoid*)offset);
}
void yagl_host_glGenBuffers(struct yagl_thread_state *cur_ts,
for (i = 0; i < buffers_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenBuffers(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenBuffers(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
buffers[i],
global_name,
0,
GLenum target,
GLuint buffer)
{
- gles_api_ts->driver->BindBuffer(target, yagl_gles_object_get(cur_ts, buffer));
+ cur_ts->gles_api_ts->driver->BindBuffer(target, yagl_gles_object_get(cur_ts, buffer));
}
void yagl_host_glBufferData(struct yagl_thread_state *cur_ts,
const GLvoid *data, int32_t data_count,
GLenum usage)
{
- gles_api_ts->driver->BufferData(target, data_count, data, usage);
+ cur_ts->gles_api_ts->driver->BufferData(target, data_count, data, usage);
}
void yagl_host_glBufferSubData(struct yagl_thread_state *cur_ts,
const GLvoid *data, int32_t data_count)
{
void *ptr;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
YAGL_LOG_FUNC_SET(glBufferSubData);
GLuint index,
GLuint buffer)
{
- gles_api_ts->driver->BindBufferBase(target, index,
- yagl_gles_object_get(cur_ts, buffer));
+ cur_ts->gles_api_ts->driver->BindBufferBase(target, index,
+ yagl_gles_object_get(cur_ts, buffer));
}
void yagl_host_glBindBufferRange(struct yagl_thread_state *cur_ts,
GLint offset,
GLsizei size)
{
- gles_api_ts->driver->BindBufferRange(target, index,
- yagl_gles_object_get(cur_ts, buffer),
- offset, size);
+ cur_ts->gles_api_ts->driver->BindBufferRange(target, index,
+ yagl_gles_object_get(cur_ts, buffer),
+ offset, size);
}
void yagl_host_glMapBuffer(struct yagl_thread_state *cur_ts,
YAGL_LOG_FUNC_SET(glMapBuffer);
- gles_api_ts->driver->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB,
+ cur_ts->gles_api_ts->driver->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB,
(GLint*)¤t_pbo);
- gles_api_ts->driver->BindBuffer(GL_PIXEL_PACK_BUFFER_ARB, yagl_gles_object_get(cur_ts, buffer));
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_PIXEL_PACK_BUFFER_ARB, yagl_gles_object_get(cur_ts, buffer));
- map_ptr = gles_api_ts->driver->MapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
+ map_ptr = cur_ts->gles_api_ts->driver->MapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
if (!map_ptr) {
YAGL_LOG_ERROR("glMapBuffer failed");
*data_count = data_ptr - data;
out2:
- gles_api_ts->driver->UnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
+ cur_ts->gles_api_ts->driver->UnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
out1:
- gles_api_ts->driver->BindBuffer(GL_PIXEL_PACK_BUFFER_ARB, current_pbo);
+ cur_ts->gles_api_ts->driver->BindBuffer(GL_PIXEL_PACK_BUFFER_ARB, current_pbo);
}
void yagl_host_glCopyBufferSubData(struct yagl_thread_state *cur_ts,
GLintptr writeOffset,
GLsizei size)
{
- gles_api_ts->driver->CopyBufferSubData(readTarget, writeTarget,
- readOffset, writeOffset, size);
+ cur_ts->gles_api_ts->driver->CopyBufferSubData(readTarget, writeTarget,
+ readOffset, writeOffset, size);
}
void yagl_host_glGenTextures(struct yagl_thread_state *cur_ts,
* might be called without an active context, but
* which needs to create a texture.
*/
- yagl_ensure_ctx(cur_ts->ps, 0);
- gles_api_ts->driver->GenTextures(1, &global_name);
- yagl_unensure_ctx(cur_ts->ps, 0);
+ yagl_ensure_ctx(cur_ts, 0);
+ cur_ts->gles_api_ts->driver->GenTextures(1, &global_name);
+ yagl_unensure_ctx(cur_ts, 0);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
textures[i],
global_name,
0,
GLenum target,
GLuint texture)
{
- gles_api_ts->driver->BindTexture(target, yagl_gles_object_get(cur_ts, texture));
+ cur_ts->gles_api_ts->driver->BindTexture(target, yagl_gles_object_get(cur_ts, texture));
}
void yagl_host_glActiveTexture(struct yagl_thread_state *cur_ts,
GLenum texture)
{
- gles_api_ts->driver->ActiveTexture(texture);
+ cur_ts->gles_api_ts->driver->ActiveTexture(texture);
}
void yagl_host_glCopyTexImage2D(struct yagl_thread_state *cur_ts,
GLsizei height,
GLint border)
{
- gles_api_ts->driver->CopyTexImage2D(target,
+ cur_ts->gles_api_ts->driver->CopyTexImage2D(target,
level,
internalformat,
x,
GLsizei width,
GLsizei height)
{
- gles_api_ts->driver->CopyTexSubImage2D(target,
+ cur_ts->gles_api_ts->driver->CopyTexSubImage2D(target,
level,
xoffset,
yoffset,
{
GLfloat params[10];
- gles_api_ts->driver->GetTexParameterfv(target,
+ cur_ts->gles_api_ts->driver->GetTexParameterfv(target,
pname,
params);
{
GLint params[10];
- gles_api_ts->driver->GetTexParameteriv(target,
+ cur_ts->gles_api_ts->driver->GetTexParameteriv(target,
pname,
params);
GLenum type,
const GLvoid *pixels, int32_t pixels_count)
{
- gles_api_ts->driver->TexImage2D(target,
+ cur_ts->gles_api_ts->driver->TexImage2D(target,
level,
internalformat,
width,
GLenum type,
uintptr_t pixels)
{
- gles_api_ts->driver->TexImage2D(target,
+ cur_ts->gles_api_ts->driver->TexImage2D(target,
level,
internalformat,
width,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->TexParameterf(target, pname, param);
+ cur_ts->gles_api_ts->driver->TexParameterf(target, pname, param);
}
void yagl_host_glTexParameterfv(struct yagl_thread_state *cur_ts,
tmp[0] = *params;
}
- gles_api_ts->driver->TexParameterfv(target,
- pname,
- (params ? tmp : NULL));
+ cur_ts->gles_api_ts->driver->TexParameterfv(target,
+ pname,
+ (params ? tmp : NULL));
}
void yagl_host_glTexParameteri(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint param)
{
- gles_api_ts->driver->TexParameteri(target, pname, param);
+ cur_ts->gles_api_ts->driver->TexParameteri(target, pname, param);
}
void yagl_host_glTexParameteriv(struct yagl_thread_state *cur_ts,
tmp[0] = *params;
}
- gles_api_ts->driver->TexParameteriv(target,
- pname,
- (params ? tmp : NULL));
+ cur_ts->gles_api_ts->driver->TexParameteriv(target,
+ pname,
+ (params ? tmp : NULL));
}
void yagl_host_glTexSubImage2DData(struct yagl_thread_state *cur_ts,
const GLvoid *pixels, int32_t pixels_count)
{
GLint row_length;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
/*
* Nvidia Windows OpenGL drivers don't account for GL_UNPACK_ALIGNMENT
uintptr_t pixels)
{
GLint row_length;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
/*
* Nvidia Windows OpenGL drivers don't account for GL_UNPACK_ALIGNMENT
void yagl_host_glClientActiveTexture(struct yagl_thread_state *cur_ts,
GLenum texture)
{
- gles_api_ts->driver->ClientActiveTexture(texture);
+ cur_ts->gles_api_ts->driver->ClientActiveTexture(texture);
}
void yagl_host_glTexEnvi(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint param)
{
- gles_api_ts->driver->TexEnvi(target, pname, param);
+ cur_ts->gles_api_ts->driver->TexEnvi(target, pname, param);
}
void yagl_host_glTexEnvf(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->TexEnvf(target, pname, param);
+ cur_ts->gles_api_ts->driver->TexEnvf(target, pname, param);
}
void yagl_host_glMultiTexCoord4f(struct yagl_thread_state *cur_ts,
GLfloat r,
GLfloat q)
{
- gles_api_ts->driver->MultiTexCoord4f(target, s, tt, r, q);
+ cur_ts->gles_api_ts->driver->MultiTexCoord4f(target, s, tt, r, q);
}
void yagl_host_glTexEnviv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLint *params, int32_t params_count)
{
- gles_api_ts->driver->TexEnviv(target, pname, params);
+ cur_ts->gles_api_ts->driver->TexEnviv(target, pname, params);
}
void yagl_host_glTexEnvfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *params, int32_t params_count)
{
- gles_api_ts->driver->TexEnvfv(target, pname, params);
+ cur_ts->gles_api_ts->driver->TexEnvfv(target, pname, params);
}
void yagl_host_glGetTexEnviv(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint *params, int32_t params_maxcount, int32_t *params_count)
{
- gles_api_ts->driver->GetTexEnviv(env, pname, params);
+ cur_ts->gles_api_ts->driver->GetTexEnviv(env, pname, params);
*params_count = params_maxcount;
}
GLenum pname,
GLfloat *params, int32_t params_maxcount, int32_t *params_count)
{
- gles_api_ts->driver->GetTexEnvfv(env, pname, params);
+ cur_ts->gles_api_ts->driver->GetTexEnvfv(env, pname, params);
*params_count = params_maxcount;
}
GLenum type,
const void *pixels, int32_t pixels_count)
{
- gles_api_ts->driver->TexImage3D(target,
- level,
- internalformat,
- width,
- height,
- depth,
- border,
- format,
- type,
- pixels);
+ cur_ts->gles_api_ts->driver->TexImage3D(target,
+ level,
+ internalformat,
+ width,
+ height,
+ depth,
+ border,
+ format,
+ type,
+ pixels);
}
void yagl_host_glTexImage3DOffset(struct yagl_thread_state *cur_ts,
GLenum type,
uintptr_t pixels)
{
- gles_api_ts->driver->TexImage3D(target,
- level,
- internalformat,
- width,
- height,
- depth,
- border,
- format,
- type,
- (const void*)pixels);
+ cur_ts->gles_api_ts->driver->TexImage3D(target,
+ level,
+ internalformat,
+ width,
+ height,
+ depth,
+ border,
+ format,
+ type,
+ (const void*)pixels);
}
void yagl_host_glTexSubImage3DData(struct yagl_thread_state *cur_ts,
GLenum type,
const void *pixels, int32_t pixels_count)
{
- gles_api_ts->driver->TexSubImage3D(target,
- level,
- xoffset,
- yoffset,
- zoffset,
- width,
- height,
- depth,
- format,
- type,
- pixels);
+ cur_ts->gles_api_ts->driver->TexSubImage3D(target,
+ level,
+ xoffset,
+ yoffset,
+ zoffset,
+ width,
+ height,
+ depth,
+ format,
+ type,
+ pixels);
}
void yagl_host_glTexSubImage3DOffset(struct yagl_thread_state *cur_ts,
GLenum type,
uintptr_t pixels)
{
- gles_api_ts->driver->TexSubImage3D(target,
- level,
- xoffset,
- yoffset,
- zoffset,
- width,
- height,
- depth,
- format,
- type,
- (const void*)pixels);
+ cur_ts->gles_api_ts->driver->TexSubImage3D(target,
+ level,
+ xoffset,
+ yoffset,
+ zoffset,
+ width,
+ height,
+ depth,
+ format,
+ type,
+ (const void*)pixels);
}
void yagl_host_glCopyTexSubImage3D(struct yagl_thread_state *cur_ts,
GLsizei width,
GLsizei height)
{
- gles_api_ts->driver->CopyTexSubImage3D(target,
- level,
- xoffset,
- yoffset,
- zoffset,
- x,
- y,
- width,
- height);
+ cur_ts->gles_api_ts->driver->CopyTexSubImage3D(target,
+ level,
+ xoffset,
+ yoffset,
+ zoffset,
+ x,
+ y,
+ width,
+ height);
}
void yagl_host_glGenFramebuffers(struct yagl_thread_state *cur_ts,
for (i = 0; i < framebuffers_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenFramebuffers(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenFramebuffers(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
framebuffers[i],
global_name,
- yagl_get_ctx_id(cur_ts->ps),
+ yagl_get_ctx_id(cur_ts),
&yagl_gles_framebuffer_destroy);
}
}
GLenum target,
GLuint framebuffer)
{
- gles_api_ts->driver->BindFramebuffer(target,
- yagl_gles_object_get(cur_ts, framebuffer));
+ cur_ts->gles_api_ts->driver->BindFramebufferYAGL(cur_ts,
+ target,
+ yagl_gles_object_get(cur_ts, framebuffer));
}
void yagl_host_glFramebufferTexture2D(struct yagl_thread_state *cur_ts,
GLuint texture,
GLint level)
{
- gles_api_ts->driver->FramebufferTexture2D(target, attachment,
- textarget,
- yagl_gles_object_get(cur_ts, texture),
- level);
+ cur_ts->gles_api_ts->driver->FramebufferTexture2D(target, attachment,
+ textarget,
+ yagl_gles_object_get(cur_ts, texture),
+ level);
}
void yagl_host_glFramebufferRenderbuffer(struct yagl_thread_state *cur_ts,
GLenum renderbuffertarget,
GLuint renderbuffer)
{
- gles_api_ts->driver->FramebufferRenderbuffer(target,
- attachment,
- renderbuffertarget,
- yagl_gles_object_get(cur_ts, renderbuffer));
+ cur_ts->gles_api_ts->driver->FramebufferRenderbuffer(target,
+ attachment,
+ renderbuffertarget,
+ yagl_gles_object_get(cur_ts, renderbuffer));
}
void yagl_host_glBlitFramebuffer(struct yagl_thread_state *cur_ts,
GLbitfield mask,
GLenum filter)
{
- gles_api_ts->driver->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1,
- dstX0, dstY0, dstX1, dstY1,
- mask, filter);
+ cur_ts->gles_api_ts->driver->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1,
+ dstX0, dstY0, dstX1, dstY1,
+ mask, filter);
}
void yagl_host_glDrawBuffers(struct yagl_thread_state *cur_ts,
const GLenum *bufs, int32_t bufs_count)
{
- gles_api_ts->driver->DrawBuffers(bufs_count, bufs);
+ cur_ts->gles_api_ts->driver->DrawBuffers(bufs_count, bufs);
}
void yagl_host_glReadBuffer(struct yagl_thread_state *cur_ts,
GLenum mode)
{
- gles_api_ts->driver->ReadBuffer(mode);
+ cur_ts->gles_api_ts->driver->ReadBuffer(mode);
}
void yagl_host_glFramebufferTexture3D(struct yagl_thread_state *cur_ts,
GLint level,
GLint zoffset)
{
- gles_api_ts->driver->FramebufferTexture3D(target, attachment,
- textarget,
- yagl_gles_object_get(cur_ts, texture),
- level, zoffset);
+ cur_ts->gles_api_ts->driver->FramebufferTexture3D(target, attachment,
+ textarget,
+ yagl_gles_object_get(cur_ts, texture),
+ level, zoffset);
}
void yagl_host_glFramebufferTextureLayer(struct yagl_thread_state *cur_ts,
GLint level,
GLint layer)
{
- gles_api_ts->driver->FramebufferTextureLayer(target, attachment,
- yagl_gles_object_get(cur_ts, texture),
- level, layer);
+ cur_ts->gles_api_ts->driver->FramebufferTextureLayer(target, attachment,
+ yagl_gles_object_get(cur_ts, texture),
+ level, layer);
}
void yagl_host_glClearBufferiv(struct yagl_thread_state *cur_ts,
GLint drawbuffer,
const GLint *value, int32_t value_count)
{
- gles_api_ts->driver->ClearBufferiv(buffer, drawbuffer, value);
+ cur_ts->gles_api_ts->driver->ClearBufferiv(buffer, drawbuffer, value);
}
void yagl_host_glClearBufferuiv(struct yagl_thread_state *cur_ts,
GLint drawbuffer,
const GLuint *value, int32_t value_count)
{
- gles_api_ts->driver->ClearBufferuiv(buffer, drawbuffer, value);
+ cur_ts->gles_api_ts->driver->ClearBufferuiv(buffer, drawbuffer, value);
}
void yagl_host_glClearBufferfi(struct yagl_thread_state *cur_ts,
GLfloat depth,
GLint stencil)
{
- gles_api_ts->driver->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+ cur_ts->gles_api_ts->driver->ClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void yagl_host_glClearBufferfv(struct yagl_thread_state *cur_ts,
GLint drawbuffer,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->ClearBufferfv(buffer, drawbuffer, value);
+ cur_ts->gles_api_ts->driver->ClearBufferfv(buffer, drawbuffer, value);
}
void yagl_host_glGenRenderbuffers(struct yagl_thread_state *cur_ts,
for (i = 0; i < renderbuffers_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenRenderbuffers(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenRenderbuffers(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
renderbuffers[i],
global_name,
0,
GLenum target,
GLuint renderbuffer)
{
- gles_api_ts->driver->BindRenderbuffer(target,
+ cur_ts->gles_api_ts->driver->BindRenderbuffer(target,
yagl_gles_object_get(cur_ts, renderbuffer));
}
GLsizei width,
GLsizei height)
{
- gles_api_ts->driver->RenderbufferStorage(target, internalformat, width, height);
+ cur_ts->gles_api_ts->driver->RenderbufferStorage(target, internalformat, width, height);
}
void yagl_host_glGetRenderbufferParameteriv(struct yagl_thread_state *cur_ts,
{
GLint params[10];
- gles_api_ts->driver->GetRenderbufferParameteriv(target,
+ cur_ts->gles_api_ts->driver->GetRenderbufferParameteriv(target,
pname,
params);
GLsizei width,
GLsizei height)
{
- gles_api_ts->driver->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+ cur_ts->gles_api_ts->driver->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void yagl_host_glCreateProgram(struct yagl_thread_state *cur_ts,
GLuint program)
{
- GLuint global_name = gles_api_ts->driver->CreateProgram();
+ GLuint global_name = cur_ts->gles_api_ts->driver->CreateProgram();
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
program,
global_name,
0,
GLuint shader,
GLenum type)
{
- GLuint global_name = gles_api_ts->driver->CreateShader(type);
+ GLuint global_name = cur_ts->gles_api_ts->driver->CreateShader(type);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
shader,
global_name,
0,
strings[0] = string;
lenghts[0] = string_count - 1;
- gles_api_ts->driver->ShaderSource(yagl_gles_object_get(cur_ts, shader),
- 1,
- strings,
- lenghts);
+ cur_ts->gles_api_ts->driver->ShaderSource(yagl_gles_object_get(cur_ts, shader),
+ 1,
+ strings,
+ lenghts);
}
void yagl_host_glAttachShader(struct yagl_thread_state *cur_ts,
GLuint program,
GLuint shader)
{
- gles_api_ts->driver->AttachShader(yagl_gles_object_get(cur_ts, program),
- yagl_gles_object_get(cur_ts, shader));
+ cur_ts->gles_api_ts->driver->AttachShader(yagl_gles_object_get(cur_ts, program),
+ yagl_gles_object_get(cur_ts, shader));
}
void yagl_host_glDetachShader(struct yagl_thread_state *cur_ts,
GLuint program,
GLuint shader)
{
- gles_api_ts->driver->DetachShader(yagl_gles_object_get(cur_ts, program),
- yagl_gles_object_get(cur_ts, shader));
+ cur_ts->gles_api_ts->driver->DetachShader(yagl_gles_object_get(cur_ts, program),
+ yagl_gles_object_get(cur_ts, shader));
}
void yagl_host_glCompileShader(struct yagl_thread_state *cur_ts,
GLuint shader)
{
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
#ifndef CONFIG_DARWIN
gles_api_ts->driver->CompileShader(yagl_gles_object_get(cur_ts, shader));
#else
GLuint index,
const GLchar *name, int32_t name_count)
{
- gles_api_ts->driver->BindAttribLocation(yagl_gles_object_get(cur_ts, program),
- index,
- name);
+ cur_ts->gles_api_ts->driver->BindAttribLocation(yagl_gles_object_get(cur_ts, program),
+ index,
+ name);
}
void yagl_host_glGetActiveAttrib(struct yagl_thread_state *cur_ts,
{
GLsizei tmp = -1;
- gles_api_ts->driver->GetActiveAttrib(yagl_gles_object_get(cur_ts, program),
- index,
- name_maxcount,
- &tmp,
- size,
- type,
- name);
+ cur_ts->gles_api_ts->driver->GetActiveAttrib(yagl_gles_object_get(cur_ts, program),
+ index,
+ name_maxcount,
+ &tmp,
+ size,
+ type,
+ name);
if (tmp >= 0) {
*name_count = MIN(tmp + 1, name_maxcount);
{
GLsizei tmp = -1;
- gles_api_ts->driver->GetActiveUniform(yagl_gles_object_get(cur_ts, program),
- index,
- name_maxcount,
- &tmp,
- size,
- type,
- name);
+ cur_ts->gles_api_ts->driver->GetActiveUniform(yagl_gles_object_get(cur_ts, program),
+ index,
+ name_maxcount,
+ &tmp,
+ size,
+ type,
+ name);
if (tmp >= 0) {
*name_count = MIN(tmp + 1, name_maxcount);
GLuint program,
const GLchar *name, int32_t name_count)
{
- return gles_api_ts->driver->GetAttribLocation(yagl_gles_object_get(cur_ts, program),
- name);
+ return cur_ts->gles_api_ts->driver->GetAttribLocation(yagl_gles_object_get(cur_ts, program),
+ name);
}
void yagl_host_glGetProgramiv(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint *param)
{
- gles_api_ts->driver->GetProgramiv(yagl_gles_object_get(cur_ts, program),
- pname,
- param);
+ cur_ts->gles_api_ts->driver->GetProgramiv(yagl_gles_object_get(cur_ts, program),
+ pname,
+ param);
}
GLboolean yagl_host_glGetProgramInfoLog(struct yagl_thread_state *cur_ts,
{
GLsizei tmp = -1;
- gles_api_ts->driver->GetProgramInfoLog(yagl_gles_object_get(cur_ts, program),
- infolog_maxcount,
- &tmp,
- infolog);
+ cur_ts->gles_api_ts->driver->GetProgramInfoLog(yagl_gles_object_get(cur_ts, program),
+ infolog_maxcount,
+ &tmp,
+ infolog);
if (tmp >= 0) {
*infolog_count = MIN(tmp + 1, infolog_maxcount);
GLenum pname,
GLint *param)
{
- gles_api_ts->driver->GetShaderiv(yagl_gles_object_get(cur_ts, shader),
- pname,
- param);
+ cur_ts->gles_api_ts->driver->GetShaderiv(yagl_gles_object_get(cur_ts, shader),
+ pname,
+ param);
}
GLboolean yagl_host_glGetShaderInfoLog(struct yagl_thread_state *cur_ts,
{
GLsizei tmp = -1;
- gles_api_ts->driver->GetShaderInfoLog(yagl_gles_object_get(cur_ts, shader),
- infolog_maxcount,
- &tmp,
- infolog);
+ cur_ts->gles_api_ts->driver->GetShaderInfoLog(yagl_gles_object_get(cur_ts, shader),
+ infolog_maxcount,
+ &tmp,
+ infolog);
if (tmp >= 0) {
*infolog_count = MIN(tmp + 1, infolog_maxcount);
{
GLenum type;
GLuint global_name = yagl_gles_object_get(cur_ts, program);
- GLint actual_location = yagl_gles_api_ps_translate_location(gles_api_ts->ps,
+ GLint actual_location = yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps,
tl,
location);
return;
}
- gles_api_ts->driver->GetUniformfv(global_name,
- actual_location,
- params);
+ cur_ts->gles_api_ts->driver->GetUniformfv(global_name,
+ actual_location,
+ params);
}
void yagl_host_glGetUniformiv(struct yagl_thread_state *cur_ts,
{
GLenum type;
GLuint global_name = yagl_gles_object_get(cur_ts, program);
- GLint actual_location = yagl_gles_api_ps_translate_location(gles_api_ts->ps,
+ GLint actual_location = yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps,
tl,
location);
return;
}
- gles_api_ts->driver->GetUniformiv(global_name,
- actual_location,
- params);
+ cur_ts->gles_api_ts->driver->GetUniformiv(global_name,
+ actual_location,
+ params);
}
int yagl_host_glGetUniformLocation(struct yagl_thread_state *cur_ts,
GLuint program,
const GLchar *name, int32_t name_count)
{
- return gles_api_ts->driver->GetUniformLocation(yagl_gles_object_get(cur_ts, program),
- name);
+ return cur_ts->gles_api_ts->driver->GetUniformLocation(yagl_gles_object_get(cur_ts, program),
+ name);
}
void yagl_host_glGetVertexAttribfv(struct yagl_thread_state *cur_ts,
return;
}
- gles_api_ts->driver->GetVertexAttribfv(index, pname, params);
+ cur_ts->gles_api_ts->driver->GetVertexAttribfv(index, pname, params);
}
void yagl_host_glGetVertexAttribiv(struct yagl_thread_state *cur_ts,
return;
}
- gles_api_ts->driver->GetVertexAttribiv(index, pname, params);
+ cur_ts->gles_api_ts->driver->GetVertexAttribiv(index, pname, params);
}
void yagl_host_glLinkProgram(struct yagl_thread_state *cur_ts,
GLint *params, int32_t params_maxcount, int32_t *params_count)
{
GLuint obj = yagl_gles_object_get(cur_ts, program);
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
gles_api_ts->driver->LinkProgram(obj);
uint32_t location,
GLfloat x)
{
- gles_api_ts->driver->Uniform1f(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location), x);
+ cur_ts->gles_api_ts->driver->Uniform1f(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location), x);
}
void yagl_host_glUniform1fv(struct yagl_thread_state *cur_ts,
uint32_t location,
const GLfloat *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform1fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform1fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v_count, v);
}
uint32_t location,
GLint x)
{
- gles_api_ts->driver->Uniform1i(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform1i(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x);
}
uint32_t location,
const GLint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform1iv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform1iv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v_count, v);
}
GLfloat x,
GLfloat y)
{
- gles_api_ts->driver->Uniform2f(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform2f(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x, y);
}
uint32_t location,
const GLfloat *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform2fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform2fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 2), v);
}
GLint x,
GLint y)
{
- gles_api_ts->driver->Uniform2i(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform2i(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x, y);
}
uint32_t location,
const GLint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform2iv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform2iv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 2), v);
}
GLfloat y,
GLfloat z)
{
- gles_api_ts->driver->Uniform3f(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform3f(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x, y, z);
}
uint32_t location,
const GLfloat *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform3fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform3fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 3), v);
}
GLint y,
GLint z)
{
- gles_api_ts->driver->Uniform3i(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform3i(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x, y, z);
}
uint32_t location,
const GLint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform3iv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform3iv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 3), v);
}
GLfloat z,
GLfloat w)
{
- gles_api_ts->driver->Uniform4f(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform4f(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x, y, z, w);
}
uint32_t location,
const GLfloat *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform4fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform4fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 4), v);
}
GLint z,
GLint w)
{
- gles_api_ts->driver->Uniform4i(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform4i(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
x, y, z, w);
}
uint32_t location,
const GLint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform4iv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform4iv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 4), v);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix2fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix2fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (2 * 2), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix3fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix3fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (3 * 3), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix4fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix4fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (4 * 4), transpose, value);
}
void yagl_host_glUseProgram(struct yagl_thread_state *cur_ts,
GLuint program)
{
- gles_api_ts->driver->UseProgram(yagl_gles_object_get(cur_ts, program));
+ cur_ts->gles_api_ts->driver->UseProgram(yagl_gles_object_get(cur_ts, program));
}
void yagl_host_glValidateProgram(struct yagl_thread_state *cur_ts,
GLuint program)
{
- gles_api_ts->driver->ValidateProgram(yagl_gles_object_get(cur_ts, program));
+ cur_ts->gles_api_ts->driver->ValidateProgram(yagl_gles_object_get(cur_ts, program));
}
void yagl_host_glVertexAttrib1f(struct yagl_thread_state *cur_ts,
GLuint indx,
GLfloat x)
{
- gles_api_ts->driver->VertexAttrib1f(indx, x);
+ cur_ts->gles_api_ts->driver->VertexAttrib1f(indx, x);
}
void yagl_host_glVertexAttrib1fv(struct yagl_thread_state *cur_ts,
GLuint indx,
const GLfloat *values, int32_t values_count)
{
- gles_api_ts->driver->VertexAttrib1fv(indx, values);
+ cur_ts->gles_api_ts->driver->VertexAttrib1fv(indx, values);
}
void yagl_host_glVertexAttrib2f(struct yagl_thread_state *cur_ts,
GLfloat x,
GLfloat y)
{
- gles_api_ts->driver->VertexAttrib2f(indx, x, y);
+ cur_ts->gles_api_ts->driver->VertexAttrib2f(indx, x, y);
}
void yagl_host_glVertexAttrib2fv(struct yagl_thread_state *cur_ts,
GLuint indx,
const GLfloat *values, int32_t values_count)
{
- gles_api_ts->driver->VertexAttrib2fv(indx, values);
+ cur_ts->gles_api_ts->driver->VertexAttrib2fv(indx, values);
}
void yagl_host_glVertexAttrib3f(struct yagl_thread_state *cur_ts,
GLfloat y,
GLfloat z)
{
- gles_api_ts->driver->VertexAttrib3f(indx, x, y, z);
+ cur_ts->gles_api_ts->driver->VertexAttrib3f(indx, x, y, z);
}
void yagl_host_glVertexAttrib3fv(struct yagl_thread_state *cur_ts,
GLuint indx,
const GLfloat *values, int32_t values_count)
{
- gles_api_ts->driver->VertexAttrib3fv(indx, values);
+ cur_ts->gles_api_ts->driver->VertexAttrib3fv(indx, values);
}
void yagl_host_glVertexAttrib4f(struct yagl_thread_state *cur_ts,
GLfloat z,
GLfloat w)
{
- gles_api_ts->driver->VertexAttrib4f(indx, x, y, z, w);
+ cur_ts->gles_api_ts->driver->VertexAttrib4f(indx, x, y, z, w);
}
void yagl_host_glVertexAttrib4fv(struct yagl_thread_state *cur_ts,
GLuint indx,
const GLfloat *values, int32_t values_count)
{
- gles_api_ts->driver->VertexAttrib4fv(indx, values);
+ cur_ts->gles_api_ts->driver->VertexAttrib4fv(indx, values);
}
void yagl_host_glGetActiveUniformsiv(struct yagl_thread_state *cur_ts,
}
for (i = 0; i < num_pnames; ++i) {
- gles_api_ts->driver->GetActiveUniformsiv(obj,
- uniformIndices_count,
- uniformIndices,
- pnames[i],
- params);
+ cur_ts->gles_api_ts->driver->GetActiveUniformsiv(obj,
+ uniformIndices_count,
+ uniformIndices,
+ pnames[i],
+ params);
params += uniformIndices_count;
}
const GLchar **name_pointers;
int num_active_uniforms = 0;
GLchar *uniform_name;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
YAGL_LOG_FUNC_SET(glGetUniformIndices);
GLuint program,
const GLchar *uniformBlockName, int32_t uniformBlockName_count)
{
- return gles_api_ts->driver->GetUniformBlockIndex(yagl_gles_object_get(cur_ts, program),
- uniformBlockName);
+ return cur_ts->gles_api_ts->driver->GetUniformBlockIndex(yagl_gles_object_get(cur_ts, program),
+ uniformBlockName);
}
void yagl_host_glUniformBlockBinding(struct yagl_thread_state *cur_ts,
GLuint uniformBlockIndex,
GLuint uniformBlockBinding)
{
- gles_api_ts->driver->UniformBlockBinding(yagl_gles_object_get(cur_ts, program),
- uniformBlockIndex,
- uniformBlockBinding);
+ cur_ts->gles_api_ts->driver->UniformBlockBinding(yagl_gles_object_get(cur_ts, program),
+ uniformBlockIndex,
+ uniformBlockBinding);
}
void yagl_host_glGetActiveUniformBlockName(struct yagl_thread_state *cur_ts,
{
GLsizei tmp = -1;
- gles_api_ts->driver->GetActiveUniformBlockName(yagl_gles_object_get(cur_ts, program),
- uniformBlockIndex,
- uniformBlockName_maxcount,
- &tmp,
- uniformBlockName);
+ cur_ts->gles_api_ts->driver->GetActiveUniformBlockName(yagl_gles_object_get(cur_ts, program),
+ uniformBlockIndex,
+ uniformBlockName_maxcount,
+ &tmp,
+ uniformBlockName);
if (tmp >= 0) {
*uniformBlockName_count = MIN(tmp + 1, uniformBlockName_maxcount);
}
for (i = 0; i < num_pnames; ++i) {
- gles_api_ts->driver->GetActiveUniformBlockiv(obj,
- uniformBlockIndex,
- pnames[i],
- ¶ms[i]);
+ cur_ts->gles_api_ts->driver->GetActiveUniformBlockiv(obj,
+ uniformBlockIndex,
+ pnames[i],
+ ¶ms[i]);
}
*params_count = num_pnames;
* Return active uniform indices only.
*/
- gles_api_ts->driver->GetActiveUniformBlockiv(obj,
- uniformBlockIndex,
- GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
- params);
+ cur_ts->gles_api_ts->driver->GetActiveUniformBlockiv(obj,
+ uniformBlockIndex,
+ GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
+ params);
*params_count = params_maxcount;
return;
}
- gles_api_ts->driver->GetVertexAttribIiv(index, pname, params);
+ cur_ts->gles_api_ts->driver->GetVertexAttribIiv(index, pname, params);
}
void yagl_host_glGetVertexAttribIuiv(struct yagl_thread_state *cur_ts,
return;
}
- gles_api_ts->driver->GetVertexAttribIuiv(index, pname, params);
+ cur_ts->gles_api_ts->driver->GetVertexAttribIuiv(index, pname, params);
}
void yagl_host_glVertexAttribI4i(struct yagl_thread_state *cur_ts,
GLint z,
GLint w)
{
- gles_api_ts->driver->VertexAttribI4i(index, x, y, z, w);
+ cur_ts->gles_api_ts->driver->VertexAttribI4i(index, x, y, z, w);
}
void yagl_host_glVertexAttribI4ui(struct yagl_thread_state *cur_ts,
GLuint z,
GLuint w)
{
- gles_api_ts->driver->VertexAttribI4ui(index, x, y, z, w);
+ cur_ts->gles_api_ts->driver->VertexAttribI4ui(index, x, y, z, w);
}
void yagl_host_glVertexAttribI4iv(struct yagl_thread_state *cur_ts,
GLuint index,
const GLint *v, int32_t v_count)
{
- gles_api_ts->driver->VertexAttribI4iv(index, v);
+ cur_ts->gles_api_ts->driver->VertexAttribI4iv(index, v);
}
void yagl_host_glVertexAttribI4uiv(struct yagl_thread_state *cur_ts,
GLuint index,
const GLuint *v, int32_t v_count)
{
- gles_api_ts->driver->VertexAttribI4uiv(index, v);
+ cur_ts->gles_api_ts->driver->VertexAttribI4uiv(index, v);
}
void yagl_host_glGetUniformuiv(struct yagl_thread_state *cur_ts,
{
GLenum type;
GLuint global_name = yagl_gles_object_get(cur_ts, program);
- GLint actual_location = yagl_gles_api_ps_translate_location(gles_api_ts->ps,
+ GLint actual_location = yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps,
tl,
location);
return;
}
- gles_api_ts->driver->GetUniformuiv(global_name,
- actual_location,
- params);
+ cur_ts->gles_api_ts->driver->GetUniformuiv(global_name,
+ actual_location,
+ params);
}
void yagl_host_glUniform1ui(struct yagl_thread_state *cur_ts,
uint32_t location,
GLuint v0)
{
- gles_api_ts->driver->Uniform1ui(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform1ui(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v0);
}
GLuint v0,
GLuint v1)
{
- gles_api_ts->driver->Uniform2ui(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform2ui(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v0, v1);
}
GLuint v1,
GLuint v2)
{
- gles_api_ts->driver->Uniform3ui(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform3ui(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v0, v1, v2);
}
GLuint v2,
GLuint v3)
{
- gles_api_ts->driver->Uniform4ui(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform4ui(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v0, v1, v2, v3);
}
uint32_t location,
const GLuint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform1uiv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform1uiv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
v_count, v);
}
uint32_t location,
const GLuint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform2uiv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform2uiv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 2), v);
}
uint32_t location,
const GLuint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform3uiv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform3uiv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 3), v);
}
uint32_t location,
const GLuint *v, int32_t v_count)
{
- gles_api_ts->driver->Uniform4uiv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->Uniform4uiv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
(v_count / 4), v);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix2x3fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix2x3fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (2 * 3), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix2x4fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix2x4fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (2 * 4), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix3x2fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix3x2fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (3 * 2), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix3x4fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix3x4fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (3 * 4), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix4x2fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix4x2fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (4 * 2), transpose, value);
}
GLboolean transpose,
const GLfloat *value, int32_t value_count)
{
- gles_api_ts->driver->UniformMatrix4x3fv(
- yagl_gles_api_ps_translate_location(gles_api_ts->ps, tl, location),
+ cur_ts->gles_api_ts->driver->UniformMatrix4x3fv(
+ yagl_gles_api_ps_translate_location(cur_ts->gles_api_ts->ps, tl, location),
value_count / (4 * 3), transpose, value);
}
GLuint program,
const GLchar *name, int32_t name_count)
{
- return gles_api_ts->driver->GetFragDataLocation(yagl_gles_object_get(cur_ts, program),
- name);
+ return cur_ts->gles_api_ts->driver->GetFragDataLocation(yagl_gles_object_get(cur_ts, program),
+ name);
}
void yagl_host_glGetIntegerv(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint *params, int32_t params_maxcount, int32_t *params_count)
{
- gles_api_ts->driver->GetIntegerv(pname, params);
+ cur_ts->gles_api_ts->driver->GetIntegerv(pname, params);
*params_count = params_maxcount;
}
GLenum pname,
GLfloat *params, int32_t params_maxcount, int32_t *params_count)
{
- gles_api_ts->driver->GetFloatv(pname, params);
+ cur_ts->gles_api_ts->driver->GetFloatv(pname, params);
*params_count = params_maxcount;
}
GLchar *str, int32_t str_maxcount, int32_t *str_count)
{
const char *tmp;
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
if ((name == GL_EXTENSIONS) &&
(gles_api_ts->driver->gl_version > yagl_gl_2)) {
GLboolean yagl_host_glIsEnabled(struct yagl_thread_state *cur_ts,
GLenum cap)
{
- return gles_api_ts->driver->IsEnabled(cap);
+ return cur_ts->gles_api_ts->driver->IsEnabled(cap);
}
void yagl_host_glGenTransformFeedbacks(struct yagl_thread_state *cur_ts,
for (i = 0; i < ids_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenTransformFeedbacks(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenTransformFeedbacks(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
ids[i],
global_name,
- yagl_get_ctx_id(cur_ts->ps),
+ yagl_get_ctx_id(cur_ts),
&yagl_gles_transform_feedback_destroy);
}
}
GLenum target,
GLuint id)
{
- gles_api_ts->driver->BindTransformFeedback(target,
- yagl_gles_object_get(cur_ts, id));
+ cur_ts->gles_api_ts->driver->BindTransformFeedback(target,
+ yagl_gles_object_get(cur_ts, id));
}
void yagl_host_glBeginTransformFeedback(struct yagl_thread_state *cur_ts,
GLenum primitiveMode)
{
- gles_api_ts->driver->BeginTransformFeedback(primitiveMode);
+ cur_ts->gles_api_ts->driver->BeginTransformFeedback(primitiveMode);
}
void yagl_host_glEndTransformFeedback(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->EndTransformFeedback();
+ cur_ts->gles_api_ts->driver->EndTransformFeedback();
}
void yagl_host_glPauseTransformFeedback(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->PauseTransformFeedback();
+ cur_ts->gles_api_ts->driver->PauseTransformFeedback();
}
void yagl_host_glResumeTransformFeedback(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->ResumeTransformFeedback();
+ cur_ts->gles_api_ts->driver->ResumeTransformFeedback();
}
void yagl_host_glTransformFeedbackVaryings(struct yagl_thread_state *cur_ts,
varyings_count,
&num_strings);
- gles_api_ts->driver->TransformFeedbackVaryings(yagl_gles_object_get(cur_ts, program),
- num_strings,
- strings,
- bufferMode);
+ cur_ts->gles_api_ts->driver->TransformFeedbackVaryings(yagl_gles_object_get(cur_ts, program),
+ num_strings,
+ strings,
+ bufferMode);
g_free(strings);
}
GLsizei length = -1;
GLchar c[2];
- gles_api_ts->driver->GetTransformFeedbackVarying(obj,
- i, sizeof(c), &length,
- &sizes[i], &types[i],
- c);
+ cur_ts->gles_api_ts->driver->GetTransformFeedbackVarying(obj,
+ i, sizeof(c), &length,
+ &sizes[i], &types[i],
+ c);
if (length <= 0) {
sizes[i] = 0;
for (i = 0; i < ids_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenQueries(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenQueries(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
ids[i],
global_name,
- yagl_get_ctx_id(cur_ts->ps),
+ yagl_get_ctx_id(cur_ts),
&yagl_gles_query_destroy);
}
}
GLenum target,
GLuint id)
{
- gles_api_ts->driver->BeginQuery(target, yagl_gles_object_get(cur_ts, id));
+ cur_ts->gles_api_ts->driver->BeginQuery(target, yagl_gles_object_get(cur_ts, id));
}
void yagl_host_glEndQuery(struct yagl_thread_state *cur_ts,
GLenum target)
{
- gles_api_ts->driver->EndQuery(target);
+ cur_ts->gles_api_ts->driver->EndQuery(target);
}
GLboolean yagl_host_glGetQueryObjectuiv(struct yagl_thread_state *cur_ts,
GLuint tmp = 0;
if (pname == GL_QUERY_RESULT_AVAILABLE) {
- gles_api_ts->driver->GetQueryObjectuiv(obj, GL_QUERY_RESULT_AVAILABLE, &tmp);
+ cur_ts->gles_api_ts->driver->GetQueryObjectuiv(obj, GL_QUERY_RESULT_AVAILABLE, &tmp);
if (tmp) {
- gles_api_ts->driver->GetQueryObjectuiv(obj, GL_QUERY_RESULT, result);
+ cur_ts->gles_api_ts->driver->GetQueryObjectuiv(obj, GL_QUERY_RESULT, result);
}
} else {
- gles_api_ts->driver->GetQueryObjectuiv(obj, GL_QUERY_RESULT, result);
+ cur_ts->gles_api_ts->driver->GetQueryObjectuiv(obj, GL_QUERY_RESULT, result);
tmp = GL_TRUE;
}
for (i = 0; i < samplers_count; ++i) {
GLuint global_name;
- gles_api_ts->driver->GenSamplers(1, &global_name);
+ cur_ts->gles_api_ts->driver->GenSamplers(1, &global_name);
- yagl_gles_object_add(cur_ts->ps,
+ yagl_gles_object_add(cur_ts,
samplers[i],
global_name,
0,
GLuint unit,
GLuint sampler)
{
- gles_api_ts->driver->BindSampler(unit, yagl_gles_object_get(cur_ts, sampler));
+ cur_ts->gles_api_ts->driver->BindSampler(unit, yagl_gles_object_get(cur_ts, sampler));
}
void yagl_host_glSamplerParameteri(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint param)
{
- gles_api_ts->driver->SamplerParameteri(yagl_gles_object_get(cur_ts, sampler), pname, param);
+ cur_ts->gles_api_ts->driver->SamplerParameteri(yagl_gles_object_get(cur_ts, sampler), pname, param);
}
void yagl_host_glSamplerParameteriv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLint *param, int32_t param_count)
{
- gles_api_ts->driver->SamplerParameteriv(yagl_gles_object_get(cur_ts, sampler), pname, param);
+ cur_ts->gles_api_ts->driver->SamplerParameteriv(yagl_gles_object_get(cur_ts, sampler), pname, param);
}
void yagl_host_glSamplerParameterf(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->SamplerParameterf(yagl_gles_object_get(cur_ts, sampler), pname, param);
+ cur_ts->gles_api_ts->driver->SamplerParameterf(yagl_gles_object_get(cur_ts, sampler), pname, param);
}
void yagl_host_glSamplerParameterfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *param, int32_t param_count)
{
- gles_api_ts->driver->SamplerParameterfv(yagl_gles_object_get(cur_ts, sampler), pname, param);
+ cur_ts->gles_api_ts->driver->SamplerParameterfv(yagl_gles_object_get(cur_ts, sampler), pname, param);
}
void yagl_host_glDeleteObjects(struct yagl_thread_state *cur_ts,
int i;
for (i = 0; i < objects_count; ++i) {
- yagl_object_map_remove(cur_ts->ps->object_map, objects[i]);
+ yagl_object_map_remove(cur_ts, cur_ts->ps->object_map, objects[i]);
}
}
void yagl_host_glBlendEquation(struct yagl_thread_state *cur_ts,
GLenum mode)
{
- gles_api_ts->driver->BlendEquation(mode);
+ cur_ts->gles_api_ts->driver->BlendEquation(mode);
}
void yagl_host_glBlendEquationSeparate(struct yagl_thread_state *cur_ts,
GLenum modeRGB,
GLenum modeAlpha)
{
- gles_api_ts->driver->BlendEquationSeparate(modeRGB, modeAlpha);
+ cur_ts->gles_api_ts->driver->BlendEquationSeparate(modeRGB, modeAlpha);
}
void yagl_host_glBlendFunc(struct yagl_thread_state *cur_ts,
GLenum sfactor,
GLenum dfactor)
{
- gles_api_ts->driver->BlendFunc(sfactor, dfactor);
+ cur_ts->gles_api_ts->driver->BlendFunc(sfactor, dfactor);
}
void yagl_host_glBlendFuncSeparate(struct yagl_thread_state *cur_ts,
GLenum srcAlpha,
GLenum dstAlpha)
{
- gles_api_ts->driver->BlendFuncSeparate(srcRGB,
+ cur_ts->gles_api_ts->driver->BlendFuncSeparate(srcRGB,
dstRGB,
srcAlpha,
dstAlpha);
GLclampf blue,
GLclampf alpha)
{
- gles_api_ts->driver->BlendColor(red, green, blue, alpha);
+ cur_ts->gles_api_ts->driver->BlendColor(red, green, blue, alpha);
}
void yagl_host_glClear(struct yagl_thread_state *cur_ts,
GLbitfield mask)
{
- gles_api_ts->driver->Clear(mask);
+ cur_ts->gles_api_ts->driver->Clear(mask);
}
void yagl_host_glClearColor(struct yagl_thread_state *cur_ts,
GLclampf blue,
GLclampf alpha)
{
- gles_api_ts->driver->ClearColor(red, green, blue, alpha);
+ cur_ts->gles_api_ts->driver->ClearColor(red, green, blue, alpha);
}
void yagl_host_glClearDepthf(struct yagl_thread_state *cur_ts,
GLclampf depth)
{
- gles_api_ts->driver->ClearDepth(depth);
+ cur_ts->gles_api_ts->driver->ClearDepth(depth);
}
void yagl_host_glClearStencil(struct yagl_thread_state *cur_ts,
GLint s)
{
- gles_api_ts->driver->ClearStencil(s);
+ cur_ts->gles_api_ts->driver->ClearStencil(s);
}
void yagl_host_glColorMask(struct yagl_thread_state *cur_ts,
GLboolean blue,
GLboolean alpha)
{
- gles_api_ts->driver->ColorMask(red, green, blue, alpha);
+ cur_ts->gles_api_ts->driver->ColorMask(red, green, blue, alpha);
}
void yagl_host_glCullFace(struct yagl_thread_state *cur_ts,
GLenum mode)
{
- gles_api_ts->driver->CullFace(mode);
+ cur_ts->gles_api_ts->driver->CullFace(mode);
}
void yagl_host_glDepthFunc(struct yagl_thread_state *cur_ts,
GLenum func)
{
- gles_api_ts->driver->DepthFunc(func);
+ cur_ts->gles_api_ts->driver->DepthFunc(func);
}
void yagl_host_glDepthMask(struct yagl_thread_state *cur_ts,
GLboolean flag)
{
- gles_api_ts->driver->DepthMask(flag);
+ cur_ts->gles_api_ts->driver->DepthMask(flag);
}
void yagl_host_glDepthRangef(struct yagl_thread_state *cur_ts,
GLclampf zNear,
GLclampf zFar)
{
- gles_api_ts->driver->DepthRange(zNear, zFar);
+ cur_ts->gles_api_ts->driver->DepthRange(zNear, zFar);
}
void yagl_host_glEnable(struct yagl_thread_state *cur_ts,
GLenum cap)
{
- gles_api_ts->driver->Enable(cap);
+ cur_ts->gles_api_ts->driver->Enable(cap);
}
void yagl_host_glDisable(struct yagl_thread_state *cur_ts,
GLenum cap)
{
- gles_api_ts->driver->Disable(cap);
+ cur_ts->gles_api_ts->driver->Disable(cap);
}
void yagl_host_glFlush(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->Flush();
+ cur_ts->gles_api_ts->driver->Flush();
}
void yagl_host_glFrontFace(struct yagl_thread_state *cur_ts,
GLenum mode)
{
- gles_api_ts->driver->FrontFace(mode);
+ cur_ts->gles_api_ts->driver->FrontFace(mode);
}
void yagl_host_glGenerateMipmap(struct yagl_thread_state *cur_ts,
GLenum target)
{
- gles_api_ts->driver->GenerateMipmap(target);
+ cur_ts->gles_api_ts->driver->GenerateMipmap(target);
}
void yagl_host_glHint(struct yagl_thread_state *cur_ts,
GLenum target,
GLenum mode)
{
- gles_api_ts->driver->Hint(target, mode);
+ cur_ts->gles_api_ts->driver->Hint(target, mode);
}
void yagl_host_glLineWidth(struct yagl_thread_state *cur_ts,
GLfloat width)
{
- gles_api_ts->driver->LineWidth(width);
+ cur_ts->gles_api_ts->driver->LineWidth(width);
}
void yagl_host_glPixelStorei(struct yagl_thread_state *cur_ts,
GLenum pname,
GLint param)
{
- gles_api_ts->driver->PixelStorei(pname, param);
+ cur_ts->gles_api_ts->driver->PixelStorei(pname, param);
}
void yagl_host_glPolygonOffset(struct yagl_thread_state *cur_ts,
GLfloat factor,
GLfloat units)
{
- gles_api_ts->driver->PolygonOffset(factor, units);
+ cur_ts->gles_api_ts->driver->PolygonOffset(factor, units);
}
void yagl_host_glScissor(struct yagl_thread_state *cur_ts,
GLsizei width,
GLsizei height)
{
- gles_api_ts->driver->Scissor(x, y, width, height);
+ cur_ts->gles_api_ts->driver->Scissor(x, y, width, height);
}
void yagl_host_glStencilFunc(struct yagl_thread_state *cur_ts,
GLint ref,
GLuint mask)
{
- gles_api_ts->driver->StencilFunc(func, ref, mask);
+ cur_ts->gles_api_ts->driver->StencilFunc(func, ref, mask);
}
void yagl_host_glStencilMask(struct yagl_thread_state *cur_ts,
GLuint mask)
{
- gles_api_ts->driver->StencilMask(mask);
+ cur_ts->gles_api_ts->driver->StencilMask(mask);
}
void yagl_host_glStencilOp(struct yagl_thread_state *cur_ts,
GLenum zfail,
GLenum zpass)
{
- gles_api_ts->driver->StencilOp(fail, zfail, zpass);
+ cur_ts->gles_api_ts->driver->StencilOp(fail, zfail, zpass);
}
void yagl_host_glSampleCoverage(struct yagl_thread_state *cur_ts,
GLclampf value,
GLboolean invert)
{
- gles_api_ts->driver->SampleCoverage(value, invert);
+ cur_ts->gles_api_ts->driver->SampleCoverage(value, invert);
}
void yagl_host_glViewport(struct yagl_thread_state *cur_ts,
GLsizei width,
GLsizei height)
{
- gles_api_ts->driver->Viewport(x, y, width, height);
+ cur_ts->gles_api_ts->driver->Viewport(x, y, width, height);
}
void yagl_host_glStencilFuncSeparate(struct yagl_thread_state *cur_ts,
GLint ref,
GLuint mask)
{
- gles_api_ts->driver->StencilFuncSeparate(face, func, ref, mask);
+ cur_ts->gles_api_ts->driver->StencilFuncSeparate(face, func, ref, mask);
}
void yagl_host_glStencilMaskSeparate(struct yagl_thread_state *cur_ts,
GLenum face,
GLuint mask)
{
- gles_api_ts->driver->StencilMaskSeparate(face, mask);
+ cur_ts->gles_api_ts->driver->StencilMaskSeparate(face, mask);
}
void yagl_host_glStencilOpSeparate(struct yagl_thread_state *cur_ts,
GLenum zfail,
GLenum zpass)
{
- gles_api_ts->driver->StencilOpSeparate(face, fail, zfail, zpass);
+ cur_ts->gles_api_ts->driver->StencilOpSeparate(face, fail, zfail, zpass);
}
void yagl_host_glPointSize(struct yagl_thread_state *cur_ts,
GLfloat size)
{
- gles_api_ts->driver->PointSize(size);
+ cur_ts->gles_api_ts->driver->PointSize(size);
}
void yagl_host_glAlphaFunc(struct yagl_thread_state *cur_ts,
GLenum func,
GLclampf ref)
{
- gles_api_ts->driver->AlphaFunc(func, ref);
+ cur_ts->gles_api_ts->driver->AlphaFunc(func, ref);
}
void yagl_host_glMatrixMode(struct yagl_thread_state *cur_ts,
GLenum mode)
{
- gles_api_ts->driver->MatrixMode(mode);
+ cur_ts->gles_api_ts->driver->MatrixMode(mode);
}
void yagl_host_glLoadIdentity(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->LoadIdentity();
+ cur_ts->gles_api_ts->driver->LoadIdentity();
}
void yagl_host_glPopMatrix(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->PopMatrix();
+ cur_ts->gles_api_ts->driver->PopMatrix();
}
void yagl_host_glPushMatrix(struct yagl_thread_state *cur_ts)
{
- gles_api_ts->driver->PushMatrix();
+ cur_ts->gles_api_ts->driver->PushMatrix();
}
void yagl_host_glRotatef(struct yagl_thread_state *cur_ts,
GLfloat y,
GLfloat z)
{
- gles_api_ts->driver->Rotatef(angle, x, y, z);
+ cur_ts->gles_api_ts->driver->Rotatef(angle, x, y, z);
}
void yagl_host_glTranslatef(struct yagl_thread_state *cur_ts,
GLfloat y,
GLfloat z)
{
- gles_api_ts->driver->Translatef(x, y, z);
+ cur_ts->gles_api_ts->driver->Translatef(x, y, z);
}
void yagl_host_glScalef(struct yagl_thread_state *cur_ts,
GLfloat y,
GLfloat z)
{
- gles_api_ts->driver->Scalef(x, y, z);
+ cur_ts->gles_api_ts->driver->Scalef(x, y, z);
}
void yagl_host_glOrthof(struct yagl_thread_state *cur_ts,
GLfloat zNear,
GLfloat zFar)
{
- gles_api_ts->driver->Ortho(left, right, bottom, top, zNear, zFar);
+ cur_ts->gles_api_ts->driver->Ortho(left, right, bottom, top, zNear, zFar);
}
void yagl_host_glColor4f(struct yagl_thread_state *cur_ts,
GLfloat blue,
GLfloat alpha)
{
- gles_api_ts->driver->Color4f(red, green, blue, alpha);
+ cur_ts->gles_api_ts->driver->Color4f(red, green, blue, alpha);
}
void yagl_host_glColor4ub(struct yagl_thread_state *cur_ts,
GLubyte blue,
GLubyte alpha)
{
- gles_api_ts->driver->Color4ub(red, green, blue, alpha);
+ cur_ts->gles_api_ts->driver->Color4ub(red, green, blue, alpha);
}
void yagl_host_glNormal3f(struct yagl_thread_state *cur_ts,
GLfloat ny,
GLfloat nz)
{
- gles_api_ts->driver->Normal3f(nx, ny, nz);
+ cur_ts->gles_api_ts->driver->Normal3f(nx, ny, nz);
}
void yagl_host_glPointParameterf(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->PointParameterf(pname, param);
+ cur_ts->gles_api_ts->driver->PointParameterf(pname, param);
}
void yagl_host_glPointParameterfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *params, int32_t params_count)
{
- gles_api_ts->driver->PointParameterfv(pname, params);
+ cur_ts->gles_api_ts->driver->PointParameterfv(pname, params);
}
void yagl_host_glFogf(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->Fogf(pname, param);
+ cur_ts->gles_api_ts->driver->Fogf(pname, param);
}
void yagl_host_glFogfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *params, int32_t params_count)
{
- gles_api_ts->driver->Fogfv(pname, params);
+ cur_ts->gles_api_ts->driver->Fogfv(pname, params);
}
void yagl_host_glFrustumf(struct yagl_thread_state *cur_ts,
GLfloat zNear,
GLfloat zFar)
{
- gles_api_ts->driver->Frustum(left, right, bottom, top, zNear, zFar);
+ cur_ts->gles_api_ts->driver->Frustum(left, right, bottom, top, zNear, zFar);
}
void yagl_host_glLightf(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->Lightf(light, pname, param);
+ cur_ts->gles_api_ts->driver->Lightf(light, pname, param);
}
void yagl_host_glLightfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *params, int32_t params_count)
{
- gles_api_ts->driver->Lightfv(light, pname, params);
+ cur_ts->gles_api_ts->driver->Lightfv(light, pname, params);
}
void yagl_host_glGetLightfv(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat *params, int32_t params_maxcount, int32_t *params_count)
{
- gles_api_ts->driver->GetLightfv(light, pname, params);
+ cur_ts->gles_api_ts->driver->GetLightfv(light, pname, params);
*params_count = params_maxcount;
}
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->LightModelf(pname, param);
+ cur_ts->gles_api_ts->driver->LightModelf(pname, param);
}
void yagl_host_glLightModelfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *params, int32_t params_count)
{
- gles_api_ts->driver->LightModelfv(pname, params);
+ cur_ts->gles_api_ts->driver->LightModelfv(pname, params);
}
void yagl_host_glMaterialf(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat param)
{
- gles_api_ts->driver->Materialf(face, pname, param);
+ cur_ts->gles_api_ts->driver->Materialf(face, pname, param);
}
void yagl_host_glMaterialfv(struct yagl_thread_state *cur_ts,
GLenum pname,
const GLfloat *params, int32_t params_count)
{
- gles_api_ts->driver->Materialfv(face, pname, params);
+ cur_ts->gles_api_ts->driver->Materialfv(face, pname, params);
}
void yagl_host_glGetMaterialfv(struct yagl_thread_state *cur_ts,
GLenum pname,
GLfloat *params, int32_t params_maxcount, int32_t *params_count)
{
- gles_api_ts->driver->GetMaterialfv(face, pname, params);
+ cur_ts->gles_api_ts->driver->GetMaterialfv(face, pname, params);
*params_count = params_maxcount;
}
void yagl_host_glShadeModel(struct yagl_thread_state *cur_ts,
GLenum mode)
{
- gles_api_ts->driver->ShadeModel(mode);
+ cur_ts->gles_api_ts->driver->ShadeModel(mode);
}
void yagl_host_glLogicOp(struct yagl_thread_state *cur_ts,
GLenum opcode)
{
- gles_api_ts->driver->LogicOp(opcode);
+ cur_ts->gles_api_ts->driver->LogicOp(opcode);
}
void yagl_host_glMultMatrixf(struct yagl_thread_state *cur_ts,
const GLfloat *m, int32_t m_count)
{
- gles_api_ts->driver->MultMatrixf(m);
+ cur_ts->gles_api_ts->driver->MultMatrixf(m);
}
void yagl_host_glLoadMatrixf(struct yagl_thread_state *cur_ts,
const GLfloat *m, int32_t m_count)
{
- gles_api_ts->driver->LoadMatrixf(m);
+ cur_ts->gles_api_ts->driver->LoadMatrixf(m);
}
void yagl_host_glClipPlanef(struct yagl_thread_state *cur_ts,
equationd[1] = equation[1];
equationd[2] = equation[2];
equationd[3] = equation[3];
- gles_api_ts->driver->ClipPlane(plane, equationd);
+ cur_ts->gles_api_ts->driver->ClipPlane(plane, equationd);
} else {
- gles_api_ts->driver->ClipPlane(plane, NULL);
+ cur_ts->gles_api_ts->driver->ClipPlane(plane, NULL);
}
}
{
yagl_GLdouble eqnd[4];
- gles_api_ts->driver->GetClipPlane(pname, eqnd);
+ cur_ts->gles_api_ts->driver->GetClipPlane(pname, eqnd);
if (eqn) {
eqn[0] = eqnd[0];
GLenum format = 0;
GLuint cur_tex = 0;
GLsizei unpack[3];
+ struct yagl_gles_api_ts *gles_api_ts = cur_ts->gles_api_ts;
YAGL_LOG_FUNC_SET(glUpdateOffscreenImageYAGL);
GLuint program,
const GLchar *name, int32_t name_count)
{
- yagl_gles_api_ps_add_location(gles_api_ts->ps,
+ yagl_gles_api_ps_add_location(cur_ts->gles_api_ts->ps,
location,
- gles_api_ts->driver->GetUniformLocation(yagl_gles_object_get(cur_ts, program), name));
+ cur_ts->gles_api_ts->driver->GetUniformLocation(yagl_gles_object_get(cur_ts, program), name));
}
void yagl_host_glDeleteUniformLocationsYAGL(struct yagl_thread_state *cur_ts,
int i;
for (i = 0; i < locations_count; ++i) {
- yagl_gles_api_ps_remove_location(gles_api_ts->ps, locations[i]);
+ yagl_gles_api_ps_remove_location(cur_ts->gles_api_ts->ps, locations[i]);
}
}
projects / sdk / emulator / qemu.git / commitdiff