void raytracer_app::load_shaders()
{
GLuint shaders[2];
shaders[0] = load("shaders/trace-prepare.vs.glsl", GL_VERTEX_SHADER);
shaders[1] = load("shaders/trace-prepare.fs.glsl", GL_FRAGMENT_SHADER);
if (prepare_program != 0)
glDeleteProgram(prepare_program);
prepare_program = create_program(shaders, 2, true);
// uniforms
uniforms.ray_origin = glGetUniformLocation(prepare_program, "ray_origin");
uniforms.ray_lookat = glGetUniformLocation(prepare_program, "ray_lookat");
uniforms.aspect = glGetUniformLocation(prepare_program, "aspect");
// trace program
shaders[0] = load("shaders/raytracer.vs.glsl", GL_VERTEX_SHADER);
shaders[1] = load("shaders/raytracer.fs.glsl", GL_FRAGMENT_SHADER);
if (trace_program)
glDeleteProgram(trace_program);
trace_program = create_program(shaders, 2, true);
shaders[0] = load("shaders/blit.vs.glsl", GL_VERTEX_SHADER);
shaders[1] = load("shaders/blit.fs.glsl", GL_FRAGMENT_SHADER);
if (blit_program)
glDeleteProgram(blit_program);
blit_program = create_program(shaders, 2, true);
}
static void
init_programs()
{
create_program(&prog_f, "");
create_program(&prog_i, "i");
create_program(&prog_u, "u");
}
static int setup_program(SceneData* sceneData, SceneObject* so, SoData* soData, GLuint* programHandle) {
GLuint vShaderHandle;
GLuint fShaderHandle;
if ( -1 == setup_shaders( sceneData, so, soData, &vShaderHandle, &fShaderHandle ) ) return -1;
char progKey[KEYSIZE];
snprintf (progKey, KEYSIZE, "%p,%p", &so->vShader, &so->fShader);
GLuint program = (GLuint)hashmap_find(progKey, sceneData->mapShaderShader2Handle);
size_t programUsers;
if (program) {
*programHandle = program;
programUsers = (size_t)hashmap_find ( progKey, sceneData->countProgramUsers );
hashmap_insert ( progKey, (void*)(programUsers+1), sceneData->countProgramUsers );
} else {
program = create_program( so->vShader, so->fShader, vShaderHandle, fShaderHandle );
if ( -1 == program ) return -1;
list_add ( (void*)program, sceneData->listPrograms );
hashmap_insert ( progKey, (void*)program, sceneData->mapShaderShader2Handle );
hashmap_insert ( progKey, (void*)1, sceneData->countProgramUsers );
*programHandle = program;
}
return 0;
}
fractal_t::fractal_t()
: pos_(0.5, 0), scale_factor_(1)
{
#ifdef USE_CORE_OPENGL
TwInit(TW_OPENGL_CORE, NULL);
#else
TwInit(TW_OPENGL, NULL);
#endif
// Определение "контролов" GUI
TwBar *bar = TwNewBar("Parameters");
TwDefine(" Parameters size='300 50' color='70 100 120' valueswidth=220 iconpos=topleft");
TwAddButton(bar, "Fullscreen toggle", toggle_fullscreen_callback, NULL,
" label='Toggle fullscreen mode' key=f");
// Создание шейдеров
vs_ = create_shader(GL_VERTEX_SHADER , "shaders//fractal.glslvs");
fs_ = create_shader(GL_FRAGMENT_SHADER, "shaders//fractal.glslfs");
// Создание программы путём линковки шейдерова
program_ = create_program(vs_, fs_);
// Создание буфера с вершинными данными
init_buffer();
// Создание VAO
init_vertex_array();
}
RenderData() : program_object(create_program(vertex_shader(), fragment_shader()))
{
position_loc = glGetAttribLocation(program_object, "a_position");
tex_coord_loc = glGetAttribLocation(program_object, "a_texCoord");
sampler_loc = glGetUniformLocation(program_object, "s_texture");
matrix_loc = glGetUniformLocation(program_object, "m_texMatrix");
}
int init_resources() {
/* Initialize the FreeType2 library */
if (FT_Init_FreeType(&ft)) {
fprintf(stderr, "Could not init freetype library\n");
return 0;
}
/* Load a font */
if (FT_New_Face(ft, "/Users/liesaweigert/ClionProjects/AR/assets/orange juice 2.0.ttf", 0, &face)) {
fprintf(stderr, "Could not open font!\n");
return 0;
}
program = create_program("/Users/liesaweigert/ClionProjects/AR/src/text.v.glsl", "/Users/liesaweigert/ClionProjects/AR/src/text.f.glsl");
if(program == 0)
return 0;
attribute_coord = get_attrib(program, "coord");
uniform_tex = get_uniform(program, "tex");
uniform_color = get_uniform(program, "color");
if(attribute_coord == -1 || uniform_tex == -1 || uniform_color == -1)
return 0;
// Create the vertex buffer object
glGenBuffers(1, &vbo);
return 1;
}
pj_status_t pjmedia_vid_dev_opengl_init_buffers(gl_buffers *glb)
{
/* Attributes */
GLint attribLocation[NUM_ATTRIBUTES] = { ATTRIB_VERTEX,
ATTRIB_TEXTUREPOSITON };
GLchar *attribName[NUM_ATTRIBUTES] = { "position", "texCoord" };
if (!glb->direct ) {
glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH,
&glb->rendBufW);
glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT,
&glb->rendBufH);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, glb->rendBuf);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
LOG("Unable to create frame buffer");
return -1;
}
}
create_program(vertSrc, fragSrc, NUM_ATTRIBUTES,
(const GLchar **)&attribName[0], attribLocation,
&glb->directProg);
if (!glb->directProg) {
LOG("Unable to create program");
return -2;
}
return PJ_SUCCESS;
}
unsigned int create_program_link(unsigned int sdr0, ...)
{
unsigned int prog, sdr;
va_list ap;
if(!(prog = create_program())) {
return 0;
}
attach_shader(prog, sdr0);
if(glGetError()) {
return 0;
}
va_start(ap, sdr0);
while((sdr = va_arg(ap, unsigned int))) {
attach_shader(prog, sdr);
if(glGetError()) {
return 0;
}
}
va_end(ap);
if(link_program(prog) == -1) {
free_program(prog);
return 0;
}
return prog;
}
tvm_t* tvm_create(char* filename)
{
tvm_t* vm = (tvm_t*)malloc(sizeof(tvm_t));
if(!vm)
return NULL;
vm->pMemory = create_memory(MIN_MEMORY_SIZE);
if(!vm->pMemory) {
free(vm);
return NULL;
}
vm->pProgram = create_program();
if(!vm->pProgram) {
destroy_memory(vm->pMemory);
free(vm);
return NULL;
}
create_stack(vm->pMemory, MIN_STACK_SIZE);
if(interpret_program(vm->pProgram, filename, vm->pMemory) != 0) {
// avoid memory leak when the interpret_program failed!
tvm_destroy(vm);
return NULL;
}
//if(!vm || !vm->pMemory || !vm->pProgram) return NULL;
return vm;
}
LG_HPROGRAM lg_create_program(LG_HFSM hFsm,
const LG_ProgramOptions* options)
{
return trapWithRetval(
[hFsm,options](){ return create_program(hFsm, options); },
nullptr
);
}
void Shader::LoadShader(const char* vertex,const char* fragment) {
std::vector<GLuint>shaders;
shaders.push_back(create_shader(vertex,GL_VERTEX_SHADER));
shaders.push_back(create_shader(fragment,GL_FRAGMENT_SHADER));
GLuint ProgramID=create_program(shaders);
programID=ProgramID;
}
bool FontEngine::init() {
if (FT_Init_FreeType(&library)) {
INFO("FT_Init_FreeType");
return 0;
}
program = create_program(VERTEX_SHADER_FILE, FRAGMENT_SHADER_FILE);
if (!program) {
INFO("Didn't Create Program");
return 0;
}
coord = get_attrib(program, "coord");
uniform_tex = get_uniform(program, "tex");
uniform_color = get_uniform(program, "color");
if (coord < 0 || uniform_tex < 0 || uniform_color < 0) {
INFO("attribs not properly allocated");
return 0;
}
billboard_program = create_program(VERTEX_SHADER_FILE_BILLBOARD, FRAGMENT_SHADER_FILE_BILLBOARD);
if (!billboard_program) {
INFO("Didn't Create BillBoard Program");
return 0;
}
billboard_pos = get_attrib(billboard_program, "position");
billboard_coord = get_attrib(billboard_program, "texcoord");
billboard_uniform_tex = get_uniform(billboard_program, "tex");
billboard_uniform_color = get_uniform(billboard_program, "color");
billboard_uniform_projection = get_uniform(billboard_program, "uProjection");
billboard_uniform_view = get_uniform(billboard_program, "uView");
if (billboard_pos < 0 || billboard_coord < 0|| billboard_uniform_tex < 0|| billboard_uniform_color< 0 || billboard_uniform_projection < 0 || billboard_uniform_view < 0) {
INFO("billboard attribs not properly allocated");
return 0;
}
glGenBuffers(1, &vbo);
initialized = 1;
return 1;
}
static void
render_triangle(struct nested_client *client, uint32_t time)
{
static const GLfloat verts[3][2] = {
{ -0.5, -0.5 },
{ 0.5, -0.5 },
{ 0, 0.5 }
};
static const GLfloat colors[3][3] = {
{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }
};
static GLfloat angle;
GLfloat rotation[4][4] = {
{ 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 }
};
if (client->program == 0)
create_program(client, vertex_shader_text,
color_fragment_shader_text);
angle += 0.1f;
rotation[0][0] = cos(angle);
rotation[0][2] = sin(angle);
rotation[2][0] = -sin(angle);
rotation[2][2] = cos(angle);
// printf ("client: rotation: %.2f\n", angle);
glClearColor(0.4, 0.4, 0.4, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(client->program);
glViewport(0, 0, client->width, client->height);
glUniformMatrix4fv(client->rotation, 1, GL_FALSE, (GLfloat *) rotation);
glVertexAttribPointer(POS, 2, GL_FLOAT, GL_FALSE, 0, verts);
glVertexAttribPointer(COL, 3, GL_FLOAT, GL_FALSE, 0, colors);
glEnableVertexAttribArray(POS);
glEnableVertexAttribArray(COL);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray(POS);
glDisableVertexAttribArray(COL);
glFlush();
}
bool init_grid()
{
grid_program = create_program(GRID_VERTEX_SHADER, GRID_FRAGMENT_SHADER);
/* grid_position_attrib = glGetAttribLocation(grid_program, "position"); */
/* grid_horizontal_attrib = glGetAttribLocation(grid_program, "horizontal"); */
/* grid_vertex_attrib = glGetAttribLocation(grid_program, "vertex_pos"); */
/* grid_transform_uniform = glGetUniformLocation(grid_program, "transform"); */
/* grid_texture_uniform = glGetUniformLocation(grid_program, "texture"); */
/* grid_color_uniform = glGetUniformLocation(grid_program, "color"); */
/* if(checkGLError()) */
/* return false; */
glGenBuffers(1, &grid_buffer);
glBindBuffer(GL_ARRAY_BUFFER, grid_buffer);
glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), GRID_BUFFER_DATA, GL_STATIC_DRAW);
if(checkGLError())
return false;
float position_buffer_data[TILEMAP_DIMS * 6];
GLuint horiz_buffer_data[TILEMAP_DIMS * 2];
for(int i = 0; i < TILEMAP_DIMS; ++i) {
position_buffer_data[i*3] = i * 32;
position_buffer_data[i*3 + 1] = 0;
position_buffer_data[i*3 + 2] = -1;
horiz_buffer_data[i] = 0;
}
for(int i = 0; i < TILEMAP_DIMS; ++i) {
position_buffer_data[(TILEMAP_DIMS * 3) + (i*3)] = 0;
position_buffer_data[(TILEMAP_DIMS * 3) + (i*3 + 1)] = i * 32;
position_buffer_data[(TILEMAP_DIMS * 3) + (i*3 + 2)] = -1;
horiz_buffer_data[(TILEMAP_DIMS) + i] = 1;
}
glGenBuffers(1, &grid_position_buffer);
glBindBuffer(GL_ARRAY_BUFFER, grid_position_buffer);
glBufferData(GL_ARRAY_BUFFER, 6 * TILEMAP_DIMS * sizeof(float), position_buffer_data, GL_STATIC_DRAW);
if(checkGLError())
return false;
glGenBuffers(1, &grid_horiz_buffer);
glBindBuffer(GL_ARRAY_BUFFER, grid_horiz_buffer);
glBufferData(GL_ARRAY_BUFFER, 2 * TILEMAP_DIMS * sizeof(GLuint), horiz_buffer_data, GL_STATIC_DRAW);
if(checkGLError())
return false;
grid_dash_texture = create_texture_data(1, 5, GRID_TEXTURE_BUFFER_DATA);
return true;
}
tvm_t* tvm_create(char* filename)
{
tvm_t* vm = (tvm_t*)malloc(sizeof(tvm_t));
vm->pMemory = create_memory(MIN_MEMORY_SIZE);
vm->pProgram = create_program();
create_stack(vm->pMemory, MIN_STACK_SIZE);
if(!vm || !vm->pMemory || !vm->pProgram) return NULL;
return vm;
}
int InitProgram() {
programDepth = create_program("cube.v.glsl", "cube.f.glsl", vsDepth, fs);
if (programDepth == 0)
return 0;
attribute_coord3d = get_attrib(programDepth, "vertex_position");
attribute_normal = get_attrib(programDepth, "vertex_normal");
attribute_colour = get_attrib(programDepth, "vertex_colour");
uniform_m = get_uniform(programDepth, "model");
uniform_v = get_uniform(programDepth, "view");
uniform_p = get_uniform(programDepth, "projection");
return 1;
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
dtx_set(DTX_PADDING, 64);
if(!(font = dtx_open_font_glyphmap("regular.glyphmap")) ||
dtx_get_glyphmap_ptsize(dtx_get_glyphmap(font, 0)) != FONT_SZ) {
if(!(font = dtx_open_font("sans.ttf", 0))) {
return 1;
}
dtx_prepare_range(font, FONT_SZ * SCALE_FACTOR, 32, 127); /* printable ASCII range */
dtx_resize_glyphmap(dtx_get_glyphmap(font, 0), 1, SCALE_FACTOR, DTX_LINEAR);
dtx_save_glyphmap("regular.glyphmap", dtx_get_glyphmap(font, 0));
}
if(!(font_dist = dtx_open_font_glyphmap("distfield.glyphmap")) ||
dtx_get_glyphmap_ptsize(dtx_get_glyphmap(font_dist, 0)) != FONT_SZ) {
if(!(font_dist = dtx_open_font("sans.ttf", 0))) {
return 1;
}
/* XXX use a large font size for the initial distance field generation
* then resize the resulting glyphmap to 1/8 of its size afterwards.
*/
dtx_prepare_range(font_dist, FONT_SZ * SCALE_FACTOR, 32, 127); /* printable ASCII range */
dtx_calc_font_distfield(font_dist, 1, SCALE_FACTOR);
dtx_save_glyphmap("distfield.glyphmap", dtx_get_glyphmap(font_dist, 0));
}
glutInitWindowSize(800, 600);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutCreateWindow("libdrawtext example: distance fields");
glutDisplayFunc(disp);
glutReshapeFunc(reshape);
glutKeyboardFunc(keydown);
glutKeyboardUpFunc(keyup);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glewInit();
sdrprog = create_program(vsdr, psdr);
glUseProgram(sdrprog);
uloc_soft = glGetUniformLocation(sdrprog, "softness");
glutMainLoop();
return 0;
}
void initialize(GLuint &vao) {
// Use a Vertex Array Object
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// 4 triangles to be rendered
GLfloat vertices_position[24] = {
0.0, 0.0,
0.5, 0.0,
0.5, 0.5,
0.0, 0.0,
0.0, 0.5,
-0.5, 0.5,
0.0, 0.0,
-0.5, 0.0,
-0.5, -0.5,
0.0, 0.0,
0.0, -0.5,
0.5, -0.5,
};
// Create a Vector Buffer Object that will store the vertices on video memory
GLuint vbo;
glGenBuffers(1, &vbo);
// Allocate space and upload the data from CPU to GPU
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_position), vertices_position, GL_STATIC_DRAW);
GLuint shaderProgram = create_program("shaders/vert.shader", "shaders/frag.shader");
// Bind the output names from the fragment program
glBindFragDataLocation(shaderProgram, 0, "out_color");
// Get the location of the attributes that enters in the vertex shader
GLint position_attribute = glGetAttribLocation(shaderProgram, "position");
// Specify how the data for position can be accessed
glVertexAttribPointer(position_attribute, 2, GL_FLOAT, GL_FALSE, 0, 0);
// Enable the attribute
glEnableVertexAttribArray(position_attribute);
// Draw wireframe triangles:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
ProgramData GameObject::load_program(const std::string &vertex_shader_file_name, const std::string &fragment_shader_file_name)
{
std::vector<GLuint> shader_list;
shader_list.push_back(load_shader(GL_VERTEX_SHADER, vertex_shader_file_name));
shader_list.push_back(load_shader(GL_FRAGMENT_SHADER, fragment_shader_file_name));
ProgramData program_data;
program_data.program = create_program(shader_list);
program_data.model_to_clip_mat_unif = glGetUniformLocation(program_data.program, "model_to_clip_matrix");
program_data.normal_model_to_world_mat_unif = glGetUniformLocation(program_data.program, "normal_model_to_world_matrix");
program_data.dir_to_light_unif = glGetUniformLocation(program_data.program, "dir_to_light");
program_data.light_intensity_unif = glGetUniformLocation(program_data.program, "light_intensity");
program_data.ambient_intensity_unif = glGetUniformLocation(program_data.program, "ambient_intensity");
return program_data;
}
void init()
{
render_begin();
// enable_gl_synchronuous_debug()
std::string shader_path = INSTALL_PREFIX "/share/wayfire/shaders";
program.id = create_program(
shader_path + "/vertex.glsl", shader_path + "/frag.glsl");
program.mvpID = GL_CALL(glGetUniformLocation(program.id, "MVP"));
program.colorID = GL_CALL(glGetUniformLocation(program.id, "color"));
program.position = GL_CALL(glGetAttribLocation(program.id, "position"));
program.uvPosition = GL_CALL(glGetAttribLocation(program.id, "uvPosition"));
render_end();
}
// create_cpu will initialize the cpu and allocate enough memory.
cpu* create_cpu() {
// Allocate Memory.
cpu* local_cpu = (cpu*)malloc(sizeof(cpu));
// Allocate / Create a new stack. (priority stack)
local_cpu->stack = (stack*)create_stack();
local_cpu->program = (program*)create_program();
local_cpu->registers = (registers*)create_registers();
local_cpu->num_registers = 8;
// Reset Registers & Stack.
reset_cpu(local_cpu);
return local_cpu;
}
static void capture_init() {
int i;
for (i = 0; i < 10; i++) {
glGenTextures(1, &texids[i]);
glBindTexture(GL_TEXTURE_2D, texids[i]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1280, 720, 0, GL_RGBA,
GL_UNSIGNED_BYTE, 0);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
progid = create_program(vertShader, fragShader);
pixelbuffer = (char *)memalign(4096, 1280 * 720 * 4);
frame = 0;
}
static void shader_load_all(struct shader* self) {
const char* shaders[] = {
"res/shaders/color.vert",
"res/shaders/color.frag",
"res/shaders/text.vert",
"res/shaders/text.frag",
};
int n = sizeof(shaders)/sizeof(const char*)/2;
for (int i = 0; i < n; ++i) {
int index = i*2;
GLuint vs = craete_shader_from_file(GL_VERTEX_SHADER, shaders[index]);
GLuint fs = craete_shader_from_file(GL_FRAGMENT_SHADER, shaders[index+1]);
GLuint program = create_program(vs, fs);
self->shader_programs[i] = program;
}
}
// the function we use to initialize opengl and the world
static int init_resources(){
started = false;
shaderProgram = create_program("frig.vert","frig.frag");
if(!shaderProgram)
return 0;
attribute_coord = get_attrib(shaderProgram, "coord");
uniform_mvp = get_uniform(shaderProgram, "mvp");
uniform_sampler = get_uniform(shaderProgram, "texture");
if(attribute_coord == -1 || uniform_mvp == -1)
return 0;
if(ui::text::init_text()){
std::cerr << "Could not initialize fonts!" << std::endl;
return 0;
}
glEnableVertexAttribArray(attribute_coord);
cameraPos = glm::vec3(32.0,64.0,32.0);
cameraRot = glm::vec3(0,0,0);
// GENERATE HERE
sc = new SuperChunk();
blockTexture = Texture::loadTexture("assets/blockStrip.png");
glUseProgram(shaderProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,blockTexture);
glUniform1f(uniform_sampler,0);
glPolygonOffset(1, 1);
glClearColor(0.6, 0.8, 1.0, 0.0);
return 1;
}
void render_init() {
render_gen_framebuffers();
static const GLfloat fullscreen_quad[] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
};
glGenBuffers(1, &quad_vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof (fullscreen_quad), fullscreen_quad, GL_STATIC_DRAW);
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);
vect_passthrough = create_shader("shaders/pass_through.vert", GL_VERTEX_SHADER);
frag_starfield = create_shader("shaders/starfield.frag", GL_FRAGMENT_SHADER);
frag_star = create_shader("shaders/star.frag", GL_FRAGMENT_SHADER);
frag_nebula1 = create_shader("shaders/nebula1.frag", GL_FRAGMENT_SHADER);
frag_nebula2 = create_shader("shaders/nebula2.frag", GL_FRAGMENT_SHADER);
frag_sun = create_shader("shaders/sun.frag", GL_FRAGMENT_SHADER);
frag_screen = create_shader("shaders/screen.frag", GL_FRAGMENT_SHADER);
program_starfield = create_program(vect_passthrough, frag_starfield);
program_star = create_program(vect_passthrough, frag_star);
program_nebula1 = create_program(vect_passthrough, frag_nebula1);
program_nebula2 = create_program(vect_passthrough, frag_nebula2);
program_sun = create_program(vect_passthrough, frag_sun);
program_screen = create_program(vect_passthrough, frag_screen);
glDeleteShader(vect_passthrough);
glDeleteShader(frag_starfield);
glDeleteShader(frag_star);
glDeleteShader(frag_nebula1);
glDeleteShader(frag_nebula2);
glDeleteShader(frag_sun);
}
View::View(UAUiWindow* surface)
: surface(surface),
rotation_angle(0.f),
num_vertex(3)
{
// assert(eglBindAPI(EGL_OPENGL_ES_API) == EGL_TRUE);
egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
assert(egl_display != EGL_NO_DISPLAY);
EGLint major, minor;
if (EGL_FALSE == eglInitialize(egl_display, &major, &minor))
{
printf("egl error: problem initializing.\n");
exit(1);
}
EGLint attribs[] =
{
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLint n;
if (EGL_FALSE == eglChooseConfig(
egl_display,
attribs,
&egl_config,
1,
&n))
{
printf("egl error: Cannot choose configuration.\n");
}
EGLint context_attribs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
egl_context = eglCreateContext(
egl_display,
egl_config,
EGL_NO_CONTEXT,
context_attribs);
assert(EGL_NO_CONTEXT != egl_context);
EGLNativeWindowType nativeWindow = ua_ui_window_get_native_type(surface);
egl_surface = eglCreateWindowSurface(egl_display, egl_config, nativeWindow, NULL);
eglMakeCurrent(
egl_display,
egl_surface,
egl_surface,
egl_context);
vertex_data = triangle();
color_data = color_triangle();
gProgram = create_program(vertex_shader(), fragment_shader());
if (!gProgram)
{
printf("error making program\n");
return;
}
gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
gvColorHandle = glGetAttribLocation(gProgram, "vColor");
rotation_uniform = glGetUniformLocation(gProgram, "angle");
return;
}
void
piglit_init(int argc, char**argv)
{
GLuint ms_fbo, ms_rb;
GLuint ss_fbo, ss_rb;
GLuint programs[N_SAMPLES];
bool use_uniform = false;
GLuint shader_id_location = -1;
GLfloat results[N_SAMPLES][2];
bool pass = true;
int i, j;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "uniform")) {
use_uniform = true;
} else {
fprintf(stderr, "unknown argument \"%s\"\n", argv[i]);
piglit_report_result(PIGLIT_FAIL);
}
}
piglit_require_extension("GL_ARB_gpu_shader5");
piglit_require_GLSL_version(150);
if (use_uniform) {
programs[0] = create_program(-1);
glUseProgram(programs[0]);
shader_id_location = glGetUniformLocation(programs[0],
"sample_id");
} else {
for (i = 0; i < N_SAMPLES; i++)
programs[i] = create_program(i);
}
create_framebuffer(N_SAMPLES,
&ms_fbo, &ms_rb);
create_framebuffer(1, /* sample_count */
&ss_fbo, &ss_rb);
glViewport(0, 0, 1, 1);
for (i = 0; i < N_SAMPLES; i++) {
if (use_uniform)
glUniform1i(shader_id_location, i);
else
glUseProgram(programs[i]);
glBindFramebuffer(GL_FRAMEBUFFER, ms_fbo);
glClear(GL_COLOR_BUFFER_BIT);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glBindFramebuffer(GL_READ_FRAMEBUFFER, ms_fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ss_fbo);
glClear(GL_COLOR_BUFFER_BIT);
glBlitFramebuffer(0, 0, /* srcX/Y0 */
1, 1, /* srcX/Y1 */
0, 0, /* dstX/Y0 */
1, 1, /* dstX/Y1 */
GL_COLOR_BUFFER_BIT,
GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, ss_fbo);
glReadPixels(0, 0, /* x/y */
1, 1, /* width/height */
GL_RG, GL_FLOAT,
results[i]);
}
for (i = 0; i < N_SAMPLES; i++) {
printf("value at sample %i = %f %f\n",
i,
results[i][0],
results[i][1]);
}
/* Check that the samples are within [0, 1] */
for (i = 0; i < N_SAMPLES; i++) {
if (results[i][0] < 0.0f || results[i][0] > 1.0f ||
results[i][1] < 0.0f || results[i][1] > 1.0f) {
fprintf(stderr,
"results for sample %i are out of range\n",
i);
pass = false;
}
}
/* Check that all of the samples are different */
for (i = 1; i < N_SAMPLES; i++) {
for (j = 0; j < i; j++) {
if (results[i][0] == results[j][0] &&
results[i][1] == results[j][1]) {
fprintf(stderr,
"samples %i and %i have the same "
"value\n",
i, j);
pass = false;
break;
}
}
}
glDeleteFramebuffers(1, &ms_fbo);
glDeleteRenderbuffers(1, &ms_rb);
glDeleteFramebuffers(1, &ss_fbo);
glDeleteRenderbuffers(1, &ss_rb);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
int renderman_rendertask_setup(RenderContext* ctx) {
if (EGL_TRUE != eglMakeCurrent(ctx->esContext->display, ctx->esContext->surface, ctx->esContext->surface, ctx->esContext->context)) return -1;
SceneData* sceneData = alloc_scene_data ( ctx->scene );
glViewport ( 0, 0, ctx->esContext->screenWidth, ctx->esContext->screenHeight );
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glPixelStorei (GL_PACK_ALIGNMENT, 1);
glFrontFace(GL_CW);
glCullFace(GL_BACK);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glGenFramebuffers(2, sceneData->fbos);
glGenRenderbuffers(1, sceneData->rbos);
glGenTextures(2, sceneData->tbos);
GLenum status;
// FBO 0
glBindTexture(GL_TEXTURE_2D, sceneData->tbos[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ctx->esContext->screenWidth, ctx->esContext->screenHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
// RBO 0
glBindRenderbuffer(GL_RENDERBUFFER, sceneData->rbos[0]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, ctx->esContext->screenWidth, ctx->esContext->screenHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, sceneData->fbos[0]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sceneData->tbos[0], 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, sceneData->rbos[0]);
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if ( GL_FRAMEBUFFER_COMPLETE != status ) {
log_message ("error: could not set up gbuffer");
return -1;
}
// FBO 1
glBindTexture(GL_TEXTURE_2D, sceneData->tbos[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ctx->esContext->screenWidth, ctx->esContext->screenHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, sceneData->fbos[1]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sceneData->tbos[1], 0);
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if ( GL_FRAMEBUFFER_COMPLETE != status ) {
log_message ("error: could not set up light buffer");
return -1;
}
// compile static shaders
GLuint vHandle;
GLuint fHandle;
GLuint pHandle;
if ( -1 == compile_shader ( GL_VERTEX_SHADER, vGShader, &vHandle ) ) return -1;
hashmap_insert( "vGShader", (void*)vHandle, staticShaders );
if ( -1 == compile_shader ( GL_FRAGMENT_SHADER, fGShader, &fHandle ) ) return -1;
hashmap_insert( "fGShader", (void*)fHandle, staticShaders );
pHandle = create_program (vGShader, fGShader, vHandle, fHandle);
if ( -1 == pHandle ) return -1;
hashmap_insert( "gbuffer", (void*)pHandle, staticPrograms );
glBindFramebuffer(GL_FRAMEBUFFER, 0);
int i;
SceneObject* so;
for ( i = list_size ( ctx->scene->initialObjects ) - 1; i >= 0; i-- ) {
so = list_get ( i, ctx->scene->initialObjects );
if ( -1 == setup_so ( sceneData, so ) ) {
log_message ( "error setting up so. removing." );
tear_down_so ( sceneData, so );
} else {
if ( (1 & so->stage) == 1) list_add( so, sceneData->stageGbuffer);
if ( (2 & so->stage) == 2) list_add( so, sceneData->stageLight);
if ( (4 & so->stage) == 4) list_add( so, sceneData->stageGeometry);
if ( (8 & so->stage) == 8) list_add( so, sceneData->stageParticle);
if ( (16 & so->stage) == 16) list_add( so, sceneData->stageOverlay);
}
}
list_clear ( ctx->scene->initialObjects );
return 0;
}
int main (void) {
int *a;
cl_mem a_in;
cl_event event;
cl_kernel kernel;
cl_context context;
cl_program program;
cl_uint devices_num;
char *program_source;
cl_device_id device_id;
cl_platform_id platform_id;
cl_command_queue command_queue;
program_source = (char *) calloc (1000, sizeof (char));
program_source = readKernel ();
/* number of platforms on the system */
platforms_number ();
/* id of the first platform proposed by the system */
platform_id = get_platform ();
/* number of devices on the platform specified by platform_id */
devices_num = devices_number (platform_id);
/* id of the first device proposed by the system on the platform
specified by platform_id */
device_id = create_device (platform_id);
/* create a context to stablish a communication channel between the
host process and the device */
context = create_context (device_id);
/* create a program providing the source code */
program = create_program (context, program_source);
/* compile the program for the specific device architecture */
build_program (program, device_id);
/* create a kernel given the program */
kernel = create_kernel (program);
/* create a memory object, in this case this will be an array of
integers of length specified by the LENGTH macro */
a = create_memory_object (LENGTH, "a");
/* create a buffer, this will be allocated on the global memory of
the device */
a_in = create_buffer (LENGTH, context, "a_in");
/* assign this buffer as the only kernel argument */
set_kernel_argument (kernel, a_in, 0, "a_in");
/* create a command queue, here we can enqueue tasks for the device
specified by device_id */
command_queue = create_command_queue (context, device_id);
/* copy the memory object allocated on the host memory into the
buffer created on the global memory of the device */
enqueue_write_buffer_task (command_queue, a_in, LENGTH, a, "a_in");
/* enqueue a task to execute the kernel on the device */
event = enqueue_kernel_execution (command_queue, kernel, LENGTH, 0, NULL);
enqueue_kernel_execution (command_queue, kernel, LENGTH, 1, &event);
/* copy the content of the buffer from the global memory of the
device to the host memory */
enqueue_read_buffer_task (command_queue, a_in, LENGTH, a, "a_in");
/* print the memory object with the result of the execution */
print_memory_object (a, LENGTH, "a");
return 0;
}
//------------------------------------------------------------------------------
int main(int argc, char** argv) {
//GRAPHICS SETUP
glfwSetErrorCallback(error_callback);
if(!glfwInit()) {
std::cerr << "ERROR - glfwInit" << std::endl;
exit(EXIT_FAILURE);
}
GLFWwindow* window = glfwCreateWindow(800, 600,
"Ray 1!", NULL, NULL);
if (!window) {
std::cerr << "ERROR - glfwCreateWindow" << std::endl;
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetKeyCallback(window, key_callback);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwMakeContextCurrent(window);
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: "
<< glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
//GEOMETRY
//geometry: textured quad
float quad[] = {-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 0.0f, 1.0f};
float texcoord[] = {0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f};
//OpenGL >= 3.3 core requires a vertex array object containing multiple attribute
//buffers
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
//geometry buffer
GLuint quadvbo;
glGenBuffers(1, &quadvbo);
glBindBuffer(GL_ARRAY_BUFFER, quadvbo);
glBufferData(GL_ARRAY_BUFFER, 6 * 4 * sizeof(float),
&quad[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//texture coordinate buffer
GLuint texbo;
glGenBuffers(1, &texbo);
glBindBuffer(GL_ARRAY_BUFFER, texbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float),
&texcoord[0], GL_STATIC_DRAW);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
//OPENGL RENDERING SHADERS
GLuint glprogram = create_program(vertexShaderSrc, fragmentShaderSrc);
//enable gl program
glUseProgram(glprogram);
//extract ids of shader variables
GLint mvpID = glGetUniformLocation(glprogram, "MVP");
assert(mvpID>=0);
GLint textureID = glGetUniformLocation(glprogram, "cltexture");
assert(textureID>=0);
//beckground color
glClearColor(0.0f, 0.0f, 0.4f, 1.0f);
g_Backbuffer = std::make_shared<Backbuffer>();
int width, height;
glfwGetFramebufferSize(window, &width, &height);
framebuffer_size_callback(window, width, height);
//RENDER LOOP
//rendering & simulation loop
while (!glfwWindowShouldClose(window)) {
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT);
//setup OpenGL matrices
const Eigen::Matrix4f modelView = Eigen::Matrix4f::Identity();
const Eigen::Matrix4f MVP = g_Backbuffer->m_Projection * modelView;
glUniformMatrix4fv(mvpID, 1, GL_FALSE, MVP.data());
//only need texture unit 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_Backbuffer->m_Texture);
glUniform1i(textureID, 0);
//select geometry to render
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
//draw
glDrawArrays(GL_TRIANGLES, 0, 6);
//unbind
glBindVertexArray(0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glBindTexture(GL_TEXTURE_2D, 0);
//put pixels on screen
glfwSwapBuffers(window);
//query events
glfwPollEvents();
}
//CLEANUP
glDeleteBuffers(1, &quadvbo);
glDeleteBuffers(1, &texbo);
glDeleteVertexArrays(1, &vao);
g_Backbuffer.reset();
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
return 0;
}
