Shader shader_new(char* vert_file, char* frag_file)
{
Shader shader = 0;
ObjectProgram vert_p = shader_compile(vert_file, GL_VERTEX_SHADER);
ObjectProgram frag_p = shader_compile(frag_file, GL_FRAGMENT_SHADER);
if(vert_p && frag_p)
{
shader = glCreateProgram();
glAttachShader(shader,vert_p);
glAttachShader(shader,frag_p);
glLinkProgram(shader);
int linked = 0;
glGetProgramiv(shader,GL_LINK_STATUS,&linked);
if( !linked)
{
char log[5000];
int log_size = 0;
glGetProgramInfoLog(shader,5000,&log_size,log);
printf("ERROR LINKING SHADER: %s, %s:\n%s\n",vert_file,frag_file,log);
}
}
return shader;
}
void ar_shader_init(
struct ar_shader *shader,
const char *vert_src,
const char *frag_src
){
shader->vertex_shader = shader_compile(vert_src, GL_VERTEX_SHADER);
shader->fragment_shader = shader_compile(frag_src, GL_FRAGMENT_SHADER);
shader->program = glCreateProgram();
glAttachShader(shader->program, shader->vertex_shader);
glAttachShader(shader->program, shader->fragment_shader);
glLinkProgram(shader->program);
if(!shader_link_check(shader->program)) exit(-1);
ar_shader_use(shader);
int i;
for (i = 0; i < AR_MAX_ATTRIBUTES; i++){
char name[] = "a_data0";
name[6] = '0' + i;
shader->attributes[i] = glGetAttribLocation(shader->program, name);
}
for (i = 0; i < AR_MAX_UNIFORMS; i++){
char name[] = "u_0";
name[2] = '0' + i;
shader->uniforms[i] = glGetUniformLocation(shader->program, name);
}
}
static int Shader_allocate(lua_State* L)
{
struct _kl_shader* shader = NULL;
GLuint gl_shader;
GLenum shader_type;
const char* shader_src = NULL;
luaL_argcheck(L, lua_isstring(L, 1), 1, "expected shader source");
luaL_argcheck(L, lua_isnumber(L, 2), 2, "expected shader type");
shader_src = lua_tostring(L, 1);
shader_type = (GLenum)lua_tointeger(L, 2);
if(shader_compile(shader_src, shader_type, &gl_shader) == KL_SUCCESS)
{
shader = (struct _kl_shader*)lua_newuserdata(L, sizeof(struct _kl_shader));
shader->shader = gl_shader;
shader->shader_type = shader_type;
luaL_getmetatable(L, SHADER_LUA_LIB);
lua_setmetatable(L, -2);
}
else
{
lua_pushstring(L, "error compiling shader");
lua_error(L);
}
return 1;
}
static int Shader_update(lua_State* L)
{
struct _kl_shader* shader = (struct _kl_shader*)lua_touserdata(L, 1);
const char* shader_src = NULL;
GLuint gl_shader;
luaL_argcheck(L, lua_isstring(L, 2), 2, "expected shader source");
shader_src = lua_tostring(L, 2);
if(shader_compile(shader_src, shader->shader_type, &gl_shader) == KL_SUCCESS)
{
GLuint old_shader = shader->shader;
shader->shader = gl_shader;
glDeleteShader(old_shader);
lua_pushboolean(L, 1);
}
else
{
lua_pushboolean(L, 0);
}
return 1;
}
Shader* make_shader(std::map<std::string, GLenum> shaders) {
std::vector<GLuint> ids;
for (auto &p : shaders) {
ids.push_back(shader_compile(p.first.c_str(), p.second));
}
return new Shader(ids);
}
void
piglit_init(int argc, char **argv)
{
if (argc < 2)
print_usage_and_exit(argv[0]);
{
char *endptr = NULL;
num_samples = strtol(argv[1], &endptr, 0);
if (endptr != argv[1] + strlen(argv[1]))
print_usage_and_exit(argv[0]);
}
piglit_require_gl_version(30);
piglit_ortho_projection(pattern_width, pattern_height, GL_TRUE);
/* Skip the test if num_samples > GL_MAX_SAMPLES */
GLint max_samples;
glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
if (num_samples > max_samples)
piglit_report_result(PIGLIT_SKIP);
ms_fbo.setup(FboConfig(num_samples, pattern_width, pattern_height));
resolve_fbo.setup(FboConfig(0, pattern_width, pattern_height));
buffer_to_test = GL_COLOR_BUFFER_BIT;
shader_compile();
glEnable(GL_POLYGON_STIPPLE);
glPolygonStipple(stipple_pattern);
}
void Shader::compile(const std::string& vert, const std::string& frag) { COLD_RENDER_DEBUG
COLD_DEBUG_ASSERT(gl_vertex_shader != 0 && gl_fragment_shader != 0 && gl_program != 0);
shader_compile(gl_vertex_shader, vert); COLD_RENDER_CHECK
shader_compile(gl_fragment_shader, frag); COLD_RENDER_CHECK
glLinkProgram(gl_program); COLD_RENDER_CHECK
#if defined(_DEBUG) && 0
/*
int size;
char text[256];
glGetInfoLogARB(gl_program, 256, &size, text);
if (*text) {
os::message_box("Shader compiler error", text, os::MBOX_ERROR);
}
*/
#endif
}
void shader_load(gfx_shader* shader, const char* v_src_path, const char* f_src_path ){
char* vertex_src;
char* frag_src;
vertex_src = read_file((char*)v_src_path);
frag_src = read_file((char*)f_src_path);
shader_compile(shader, vertex_src, frag_src, v_src_path, f_src_path );
free(vertex_src);
free(frag_src);
}
int init_shader(struct shader *sh, const char *vp, const char *fp)
{
if (shader_init(sh) < 0)
return -1;
if (shader_read_file(sh, GL_VERTEX_SHADER, vp) < 0)
return -1;
if (shader_read_file(sh, GL_FRAGMENT_SHADER, fp) < 0)
return -1;
if (shader_compile(sh) < 0 || shader_link(sh) < 0)
return -1;
return 0;
}
void
piglit_init(int argc, char **argv)
{
int samples;
/* At present fragment shader supports only fixed number of
* attachments (3)
*/
int num_attachments = 3;
if (argc < 2)
print_usage_and_exit(argv[0]);
{
char *endptr = NULL;
samples = strtol(argv[1], &endptr, 0);
if (endptr != argv[1] + strlen(argv[1]))
print_usage_and_exit(argv[0]);
}
piglit_require_gl_version(21);
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_ARB_vertex_array_object");
int pattern_width = piglit_width / 2;
int pattern_height = piglit_height / num_attachments;
piglit_ortho_projection(pattern_width,
pattern_height,
GL_TRUE);
/* Skip the test if samples > GL_MAX_SAMPLES */
GLint max_samples;
glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
if (samples > max_samples)
piglit_report_result(PIGLIT_SKIP);
ms_fbo_and_draw_buffers_setup(samples,
pattern_width,
pattern_height,
num_attachments,
GL_COLOR_BUFFER_BIT,
GL_RGBA);
shader_compile(true /* sample_alpha_to_coverage */,
false /* dual_src_blend */);
}
void
piglit_init(int argc, char **argv)
{
int samples;
const int num_attachments = 1;
if (argc < 2)
print_usage_and_exit(argv[0]);
{
char *endptr = NULL;
samples = strtol(argv[1], &endptr, 0);
if (endptr != argv[1] + strlen(argv[1]))
print_usage_and_exit(argv[0]);
}
piglit_require_gl_version(30);
int pattern_width = piglit_width / 2;
int pattern_height = piglit_height / num_attachments;
piglit_ortho_projection(pattern_width,
pattern_height,
GL_TRUE);
/* Skip the test if samples > GL_MAX_SAMPLES */
GLint max_samples;
glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
if (samples > max_samples)
piglit_report_result(PIGLIT_SKIP);
ms_fbo_and_draw_buffers_setup(samples,
pattern_width,
pattern_height,
num_attachments,
GL_COLOR_BUFFER_BIT,
GL_RGBA);
shader_compile(true /* sample_alpha_to_coverage */,
true /* dual_src_blend */,
true /* frag_out_zero_write */);
}
void
piglit_init(int argc, char **argv)
{
if (argc < 2)
print_usage_and_exit(argv[0]);
{
char *endptr = NULL;
samples = strtol(argv[1], &endptr, 0);
if (endptr != argv[1] + strlen(argv[1]))
print_usage_and_exit(argv[0]);
}
piglit_require_gl_version(30);
int pattern_width = piglit_width / 2;
int pattern_height = piglit_height / num_attachments;
piglit_ortho_projection(pattern_width,
pattern_height,
GL_TRUE);
/* Skip the test if samples > GL_MAX_SAMPLES */
GLint max_samples;
glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
if (samples > max_samples)
piglit_report_result(PIGLIT_SKIP);
/* Testing of integer formats other than GL_RGBA8I is not supported
* by utility functions in draw-buffers-common.cpp.
*/
ms_fbo_and_draw_buffers_setup(samples,
pattern_width,
pattern_height,
num_attachments,
GL_COLOR_BUFFER_BIT,
GL_RGBA8I);
shader_compile(false /* sample_alpha_to_coverage */,
false /* dual_src_blend */);
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
const int num_attachments = 1;
/* For single sample buffer */
const int samples = 0;
piglit_require_gl_version(21);
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_ARB_vertex_array_object");
int pattern_width = piglit_width / 2;
int pattern_height = piglit_height / num_attachments;
piglit_ortho_projection(pattern_width,
pattern_height,
GL_TRUE);
/* Skip the test if samples > GL_MAX_SAMPLES */
GLint max_samples;
glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
if (samples > max_samples)
piglit_report_result(PIGLIT_SKIP);
ms_fbo_and_draw_buffers_setup(samples,
pattern_width,
pattern_height,
num_attachments,
GL_COLOR_BUFFER_BIT,
GL_RGBA);
shader_compile(false /* sample_alpha_to_coverage */,
false /* dual_src_blend */);
}
