void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(140);
if (argc != 3)
usage(argv[0]);
test_vs = strcmp(argv[1], "vs") == 0;
if (!test_vs && strcmp(argv[1], "fs") != 0)
usage(argv[0]);
test_arb = strcmp(argv[2], "arb") == 0;
if (!test_arb && strcmp(argv[2], "core") != 0)
usage(argv[0]);
piglit_require_extension("GL_EXT_texture_integer");
piglit_require_extension("GL_ARB_texture_rg");
if (test_arb) {
piglit_require_extension("GL_ARB_texture_buffer_object");
} else {
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_buffer_object");
}
init_programs();
}
void onInit()
{
sys::info << "app::COGLDev06NormalMapApp::onInit()" << sys::endl;
pCamera = new app::CCamera(60.0f, mConfig.mRatio, 0.1f, 100.0f);
pCamera->translateLocal(math::vec3(0.0f, -2.0f, -5.0f));
pShadowFBO = new ogl::CShadowFramebuffer(mConfig.mWidth, mConfig.mHeight);
init_programs();
init_lights();
init_textures();
init_objects();
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepthf(1.0f);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
void onInit()
{
sys::info << "app::COGLDev45AmbientOcclusionApp::onInit() " << sys::endl;
init_programs();
init_scene();
init_renderers();
init_controllers();
}
// support functions
void config::
init(float aspect_ratio) {
glEnable(GL_MULTISAMPLE_ARB);
glClearColor(0.0,0.0,0.0,0.0);
aspect_ratio_ = aspect_ratio;
init_programs();
init_uniforms();
}
void onInit()
{
sys::info << "app::COGLDev42PCFShadowMapApp::onInit() " << sys::endl;
init_cameras();
init_programs();
init_lights();
init_objects();
init_renderers();
}
void onInit()
{
sys::info << "app::COGLDev10TessellationApp::onInit() " << sys::endl;
init_cameras();
init_programs();
init_lights();
init_objects();
init_renderers();
glExitIfError();
}
//1100110 record
//------------------------------------------------------------------------------
int main(int argc, char *argv[]){
int i;
if(! std_input_check(argc, argv))
return EXIT_FAILURE;
gl_pageID = 1;
init_programs();
for (i=0 ; i<gl_program_count; i++){
printf("pid:%i \t initML: %i \t totalML:%i \t totalPages: %i P#:%i \t Flag:%i \n",\
gl_programs[i].pid, \
gl_programs[i].init_memorylocation, \
gl_programs[i].total_memorylocation, \
gl_programs[i].total_pages, \
gl_programs[i].pagetable[gl_programs[0].init_memorylocation].pagenumber,\
gl_programs[i].pagetable[gl_programs[0].init_memorylocation].validbid);
//gl_programs[0] because it was the border point
}
run_programs();
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(140);
piglit_require_extension("GL_EXT_texture_integer");
piglit_require_extension("GL_ARB_texture_rg");
if (test_arb) {
piglit_require_extension("GL_ARB_texture_buffer_object");
} else {
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_buffer_object");
if (piglit_is_extension_supported("GL_ARB_texture_buffer_object_rgb32"))
test_rgb32 = true;
}
init_programs();
}
struct fv_map_painter *
fv_map_painter_new(struct fv_image_data *image_data,
struct fv_shader_data *shader_data)
{
struct fv_map_painter *painter;
struct tile_data data;
struct fv_map_painter_tile *tile;
int first, tx, ty;
int tex_width, tex_height;
GLuint tex_uniform;
painter = fv_alloc(sizeof *painter);
if (fv_gl.have_instanced_arrays) {
fv_gl.glGenBuffers(1, &painter->instance_buffer);
fv_gl.glBindBuffer(GL_ARRAY_BUFFER, painter->instance_buffer);
fv_gl.glBufferData(GL_ARRAY_BUFFER,
sizeof (struct instance) *
FV_MAP_PAINTER_MAX_SPECIALS,
NULL, /* data */
GL_DYNAMIC_DRAW);
}
init_programs(painter, shader_data);
if (!load_models(painter, image_data))
goto error_instance_buffer;
fv_image_data_get_size(image_data,
FV_IMAGE_DATA_MAP_TEXTURE,
&tex_width, &tex_height);
if (!fv_gl.have_npot_mipmaps) {
painter->texture_width = smallest_pot(tex_width);
painter->texture_height = smallest_pot(tex_height);
} else {
painter->texture_width = tex_width;
painter->texture_height = tex_height;
}
fv_gl.glGenTextures(1, &painter->texture);
fv_gl.glBindTexture(GL_TEXTURE_2D, painter->texture);
fv_gl.glTexImage2D(GL_TEXTURE_2D,
0, /* level */
GL_RGB,
painter->texture_width, painter->texture_height,
0, /* border */
GL_RGB,
GL_UNSIGNED_BYTE,
NULL);
fv_image_data_set_sub_2d(image_data,
GL_TEXTURE_2D,
0, /* level */
0, 0, /* x/y offset */
FV_IMAGE_DATA_MAP_TEXTURE);
fv_gl.glGenerateMipmap(GL_TEXTURE_2D);
fv_gl.glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST);
fv_gl.glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER,
GL_LINEAR);
fv_gl.glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
fv_gl.glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
tex_uniform = fv_gl.glGetUniformLocation(painter->map_program.id,
"tex");
fv_gl.glUseProgram(painter->map_program.id);
fv_gl.glUniform1i(tex_uniform, 0);
tex_uniform = fv_gl.glGetUniformLocation(painter->texture_program.id,
"tex");
fv_gl.glUseProgram(painter->texture_program.id);
fv_gl.glUniform1i(tex_uniform, 0);
fv_buffer_init(&data.vertices);
fv_buffer_init(&data.indices);
tile = painter->tiles;
for (ty = 0; ty < FV_MAP_TILES_Y; ty++) {
for (tx = 0; tx < FV_MAP_TILES_X; tx++) {
first = data.indices.length / sizeof (uint16_t);
tile->min = (data.vertices.length /
sizeof (struct vertex));
tile->offset = data.indices.length;
generate_tile(painter, &data, tx, ty);
tile->max = (data.vertices.length /
sizeof (struct vertex)) - 1;
tile->count = (data.indices.length /
sizeof (uint16_t) -
first);
tile++;
}
}
assert(data.vertices.length / sizeof (struct vertex) < 65536);
painter->array = fv_array_object_new();
fv_gl.glGenBuffers(1, &painter->vertices_buffer);
fv_gl.glBindBuffer(GL_ARRAY_BUFFER, painter->vertices_buffer);
fv_gl.glBufferData(GL_ARRAY_BUFFER,
data.vertices.length,
data.vertices.data,
GL_STATIC_DRAW);
fv_array_object_set_attribute(painter->array,
FV_SHADER_DATA_ATTRIB_POSITION,
4, /* size */
GL_UNSIGNED_BYTE,
GL_FALSE, /* normalized */
sizeof (struct vertex),
0, /* divisor */
painter->vertices_buffer,
offsetof(struct vertex, x));
fv_array_object_set_attribute(painter->array,
FV_SHADER_DATA_ATTRIB_TEX_COORD,
2, /* size */
GL_UNSIGNED_SHORT,
GL_TRUE, /* normalized */
sizeof (struct vertex),
0, /* divisor */
painter->vertices_buffer,
offsetof(struct vertex, s));
fv_gl.glGenBuffers(1, &painter->indices_buffer);
fv_array_object_set_element_buffer(painter->array,
painter->indices_buffer);
fv_gl.glBufferData(GL_ELEMENT_ARRAY_BUFFER,
data.indices.length,
data.indices.data,
GL_STATIC_DRAW);
fv_buffer_destroy(&data.indices);
fv_buffer_destroy(&data.vertices);
return painter;
error_instance_buffer:
if (fv_gl.have_instanced_arrays)
fv_gl.glDeleteBuffers(1, &painter->instance_buffer);
fv_free(painter);
return NULL;
}
