void Shader::LoadShader(const char* vertex_file_path,const char* fragment_file_path){
GLuint VertexShaderID=glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID=glCreateShader(GL_FRAGMENT_SHADER);
std::string VertexShaderCode;
read_shader(VertexShaderCode,vertex_file_path);
std::string FragmentShaderCode;
read_shader(FragmentShaderCode,fragment_file_path);
GLint Result=GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
compile_shader(VertexShaderID,VertexShaderCode);
check_shader(VertexShaderID,Result,InfoLogLength);// Check Vertex Shader
// Compile Fragment Shader
compile_shader(FragmentShaderID,FragmentShaderCode);
check_shader(FragmentShaderID,Result,InfoLogLength);
// Link the program
GLuint ProgramID=glCreateProgram();
glAttachShader(ProgramID,VertexShaderID);
glAttachShader(ProgramID,FragmentShaderID);
glLinkProgram(ProgramID);
// Check the program
glGetProgramiv(ProgramID,GL_LINK_STATUS,&Result);
glGetProgramiv(ProgramID,GL_INFO_LOG_LENGTH,&InfoLogLength);
check_program(ProgramID,InfoLogLength);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
programID=ProgramID;
}
GLuint init_shaders(char* vertex_shader_name, char* geometry_shader_name,
char* fragment_shader_name)
{
GLuint p, v, g, f;
p = glCreateProgram();
v = read_shader(vertex_shader_name, VERTEX);
g = read_shader(geometry_shader_name, GEOMETRY);
f = read_shader(fragment_shader_name, FRAGMENT);
glCompileShader(v);
print_shader_error(v);
glCompileShader(g);
print_shader_error(g);
glCompileShader(f);
print_shader_error(f);
glAttachShader(p,v);
glAttachShader(p,g);
glAttachShader(p,f);
glLinkProgram(p);
print_program_error(p);
return p;
}
GLuint Shader::create_shader(const char* src,GLenum type) {
GLuint ShaderID=glCreateShader(type);
std::string ShaderCode;
read_shader(ShaderCode,src);
// Compile Shader
compile_shader(ShaderID,ShaderCode);
return ShaderID;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitWindowSize( 260, 330 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( "Freetype OpenGL / subpixel rendering" );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
size_t i;
texture_font_t *font;
const char * filename = "./Vera.ttf";
wchar_t *text = L"|... A Quick Brown Fox Jumps Over The Lazy Dog";
vec2 pen = {{0,0}};
vec4 black = {{0,0,0,1}};
atlas = texture_atlas_new( 512, 512, 3 );
font = texture_font_new( atlas, filename, 9 );
buffer = vertex_buffer_new( "v3f:t2f:c4f:1g1f" );
pen.x = 0; pen.y = 0;
pen.y -= font->ascender;
for( i=0; i < 30; ++i)
{
pen.x = 20 + i * 0.1;
pen.y = 310 - i * 10;
add_text( buffer, font, text, &black, &pen );
}
// Create the GLSL program
char * vertex_shader_source = read_shader("./subpixel.vert");
char * fragment_shader_source = read_shader("./subpixel.frag");
program = build_program( vertex_shader_source, fragment_shader_source );
texture_location = glGetUniformLocation(program, "texture");
pixel_location = glGetUniformLocation(program, "pixel");
glBindTexture( GL_TEXTURE_2D, atlas->id );
glutMainLoop( );
return 0;
}
void line_opengl::init()
{
shader_id_data = read_shader("shaders/shader_line.vert","shaders/shader_line.frag");
vec3 line[]={ {0.0f,0.0f,0.0f} , {1.0f,0.0f,0.0f} };
glGenBuffers(1,&vbo_data); PRINT_OPENGL_ERROR();
ASSERT_CPE(vbo_data!=0,"Problem creating VBO");
glBindBuffer(GL_ARRAY_BUFFER,vbo_data); PRINT_OPENGL_ERROR();
glBufferData(GL_ARRAY_BUFFER,6*sizeof(float),&line[0],GL_DYNAMIC_DRAW); PRINT_OPENGL_ERROR();
ASSERT_CPE(glIsBuffer(vbo_data),"Problem creating VBO");
}
GLuint load_shader(const char *filename, GLenum shader_type)
{
GLuint shader_id;
char *glsl_source;
shader_id = 0;
glsl_source = read_shader(filename);
shader_id = glCreateShader(shader_type);
if (glsl_source && shader_id != 0)
{
glShaderSource(shader_id, 1, (const GLchar **)&glsl_source, NULL);
glCompileShader(shader_id);
free(glsl_source);
exit_on_glerror("Could not compile a shader");
}
else
ft_putendl("ERROR: Could not create a shader.");
return (shader_id);
}
static bool load_shaders_file(char const *file, uint32_t *dst)
{
uint32_t shaders[g_shader_t.length];
int tmp;
bool success;
t_list lines;
if ((tmp = open(file, O_RDONLY)) < 0)
return (false);
ft_bzero(shaders, sizeof(uint32_t[g_shader_t.length]));
lines = LIST(t_sub);
success = read_shader(tmp, &lines, shaders, g_shader_t.all);
close(tmp);
ft_listremove_next(&lines, LIST_IT(&lines), -1);
success = success && link_shader(shaders, dst);
tmp = -1;
while (++tmp < g_shader_t.length)
if (shaders[tmp] > 0)
glDeleteShader(shaders[tmp]);
return (success);
}
void Shader::read_shader(std::string &ShaderCode,const char* path) {
std::ifstream ShaderStream(path, std::ios::in);
if(ShaderStream.is_open()) {
ShaderCode="";
std::string Line ="";
while(getline(ShaderStream,Line)) {
if(!Line.empty()) {
if(Line.find(std::string("#include"))!=std::string::npos) {
Line=Tim::String::cut(Line,std::string("#include"),true,true);
Line=Tim::String::cut(Line,std::string(" "),true,true);
Line=Tim::String::cut(Line,std::string("<"),true,true);
Line=Tim::String::cut(Line,std::string(">"),true,true);
//std::cout<<Line<<std::endl;
read_shader(Line,Line.c_str());
//std::cout<<Line<<std::endl;
}
ShaderCode+="\n"+Line;
}
}
ShaderStream.close();
} else {
std::cout<<"load Shader:"<<path<<"false"<<std::endl;
}
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitWindowSize( 512, 512 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( "Freetype OpenGL" );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
size_t i;
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 white = {{1.0, 1.0, 1.0, 1.0}};
vec4 none = {{1.0, 1.0, 1.0, 0.0}};
markup_t markup = {
.family = "Bitstream Vera Sans",
.size = 15.0,
.bold = 0,
.italic = 0,
.rise = 0.0,
.spacing = 0.0,
.gamma = 1.5,
.foreground_color = white,
.background_color = none,
.underline = 0,
.underline_color = white,
.overline = 0,
.overline_color = white,
.strikethrough = 0,
.strikethrough_color = white,
.font = 0,
};
atlas = texture_atlas_new( 512, 512, 3 );
buffer = vertex_buffer_new( "v3f:t2f:c4f:1g1f:2g1f" );
markup.font = texture_font_new( atlas, "./Vera.ttf", markup.size );
vec2 pen;
pen.y = 512.0 - markup.font->ascender - 5;
for( i=0; i < 14; ++i )
{
pen.x = 25.0;
markup.gamma = 0.75 + 1.5*i*(1.0/14);
add_text( buffer, &pen,
&markup, L"The quick brown fox jumps over the lazy dog. ",
&markup, L"0123456789.", NULL);
pen.y -= markup.font->height;
}
markup.foreground_color = black;
pen.y = 256.0 - markup.font->ascender - 5;
for( i=0; i < 14; ++i )
{
pen.x = 25.0;
markup.gamma = 0.75 + 1.5*i*(1.0/14);
add_text( buffer, &pen,
&markup, L"The quick brown fox jumps over the lazy dog. ",
&markup, L"0123456789.", NULL);
pen.y -= markup.font->height;
}
// Create the GLSL program
char * vertex_shader_source = read_shader("./markup.vert");
char * fragment_shader_source = read_shader("./markup.frag");
program = build_program( vertex_shader_source, fragment_shader_source );
texture_location = glGetUniformLocation(program, "texture");
pixel_location = glGetUniformLocation(program, "pixel");
glutMainLoop( );
return 0;
}
static void init(void)
{
static const char *fragShaderText =
"void main() {\n"
" gl_FragColor = gl_Color;\n"
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_FrontColor = gl_Color;\n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
"}\n";
static const char *geoShaderText =
"#version 120\n"
"#extension GL_ARB_geometry_shader4 : enable\n"
"void main()\n"
"{\n"
" for(int i = 0; i < gl_VerticesIn; ++i)\n"
" {\n"
" gl_FrontColor = gl_FrontColorIn[i];\n"
" gl_Position = gl_PositionIn[i];\n"
" EmitVertex();\n"
" }\n"
"}\n";
if (!ShadersSupported())
exit(1);
if (!glutExtensionSupported("GL_ARB_geometry_shader4")) {
printf("This demo requires GL_ARB_geometry_shader4\n");
exit(1);
}
menu_init();
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
load_and_compile_shader(fragShader, fragShaderText);
vertShader = glCreateShader(GL_VERTEX_SHADER);
load_and_compile_shader(vertShader, vertShaderText);
geoShader = glCreateShader(GL_GEOMETRY_SHADER_ARB);
if (filename)
read_shader(geoShader, filename);
else
load_and_compile_shader(geoShader,
geoShaderText);
program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, geoShader);
glAttachShader(program, fragShader);
glProgramParameteriARB(program, GL_GEOMETRY_INPUT_TYPE_ARB,
GL_LINES_ADJACENCY_ARB);
glProgramParameteriARB(program, GL_GEOMETRY_OUTPUT_TYPE_ARB,
GL_LINE_STRIP);
{
int temp;
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,&temp);
glProgramParameteriARB(program,GL_GEOMETRY_VERTICES_OUT_ARB,temp);
}
glLinkProgram(program);
check_link(program);
glUseProgram(program);
SetUniformValues(program, Uniforms);
PrintUniforms(Uniforms);
assert(glGetError() == 0);
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
glVertexPointer( 3, GL_FLOAT, sizeof(vertices[0]), vertices );
glColorPointer( 4, GL_FLOAT, sizeof(color[0]), color );
}
/**
* Called via glShaderSource() and glShaderSourceARB() API functions.
* Basically, concatenate the source code strings into one long string
* and pass it to _mesa_shader_source().
*/
void GLAPIENTRY
_mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
const GLcharARB ** string, const GLint * length)
{
GET_CURRENT_CONTEXT(ctx);
GLint *offsets;
GLsizei i, totalLength;
GLcharARB *source;
GLuint checksum;
if (!shaderObj || string == NULL) {
_mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
return;
}
/*
* This array holds offsets of where the appropriate string ends, thus the
* last element will be set to the total length of the source code.
*/
offsets = (GLint *) malloc(count * sizeof(GLint));
if (offsets == NULL) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
return;
}
for (i = 0; i < count; i++) {
if (string[i] == NULL) {
free((GLvoid *) offsets);
_mesa_error(ctx, GL_INVALID_OPERATION,
"glShaderSourceARB(null string)");
return;
}
if (length == NULL || length[i] < 0)
offsets[i] = strlen(string[i]);
else
offsets[i] = length[i];
/* accumulate string lengths */
if (i > 0)
offsets[i] += offsets[i - 1];
}
/* Total length of source string is sum off all strings plus two.
* One extra byte for terminating zero, another extra byte to silence
* valgrind warnings in the parser/grammer code.
*/
totalLength = offsets[count - 1] + 2;
source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
if (source == NULL) {
free((GLvoid *) offsets);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
return;
}
for (i = 0; i < count; i++) {
GLint start = (i > 0) ? offsets[i - 1] : 0;
memcpy(source + start, string[i],
(offsets[i] - start) * sizeof(GLcharARB));
}
source[totalLength - 1] = '\0';
source[totalLength - 2] = '\0';
if (SHADER_SUBST) {
/* Compute the shader's source code checksum then try to open a file
* named newshader_<CHECKSUM>. If it exists, use it in place of the
* original shader source code. For debugging.
*/
char filename[100];
GLcharARB *newSource;
checksum = _mesa_str_checksum(source);
_mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
newSource = read_shader(filename);
if (newSource) {
fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
shaderObj, checksum, filename);
free(source);
source = newSource;
}
}
shader_source(ctx, shaderObj, source);
if (SHADER_SUBST) {
struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
if (sh)
sh->SourceChecksum = checksum; /* save original checksum */
}
free(offsets);
}
int main(){
std::string vertex_string = read_shader("vertex.glsl");
std::string fragment_string = read_shader("fragment.glsl");
const GLchar* vertexShaderSource = vertex_string.c_str();
const GLchar* fragmentShaderSource = fragment_string.c_str();
// Initializing glfw for window generation
glfwInit();
// Setting window variables
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Generating window instance
GLFWwindow *window = glfwCreateWindow(800, 600, "Hello World",
nullptr, nullptr);
if (window == nullptr){
std::cout << "Window could not be created!" << '\n';
glfwTerminate();
return(-1);
}
glfwMakeContextCurrent(window);
// GLEW manages function pointers for OpenGL
// GL_TRUE gives us a more modern GLEW to work with
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK){
std::cout << "Failed to initialize GLEW" << '\n';
}
// Setting viewport up so OpenGL knows what to draw to and where
int width, height;
glfwGetFramebufferSize(window, &width, &height);
// Read from LL to UR
// Here, we map -1 < x < 1 in x and y to 800 x 600
glViewport(0,0,width,height);
// Registering closing callback function
// glfwPollEvents later should be waiting for key callbacks
glfwSetKeyCallback(window, key_callback);
// Building / compiling shader program
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);
// Check for errors
GLint success;
GLchar infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success){
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout << "ERROR: vertex shader compilation failed!" << '\n';
}
// Now the same for the Fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
// Check for fragment shader errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success){
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cout << "ERROR: fragment shader compilation failed!" << '\n';
}
// Now to link the shaders together
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
// Checking for linking errors
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success){
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
std::cout << "ERROR: program linking failed!" << '\n';
}
// Removing shaders after program is built
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// Rendering a triangle.. first, we need to define the vertices
// Note: GL assumes 3 dimensions, and likely parses the vertices by groups
// of three.
int max_depth = 4;
std::vector<vec> vertices;
vertices.reserve(3 * pow(4,max_depth));
std::vector<triangle> indices;
indices.reserve(pow(4,max_depth));
//create_triangle_vertex(vertices, indices, 4096);
//std::vector<vec> init_corners(3);
vec init_corners[3];
init_corners[0] = vec(0,1,0);
init_corners[1] = vec(-1,-1,-1);
init_corners[2] = vec(1,-1,1);
divide_triangle(init_corners, indices, vertices, max_depth);
// Now to request space on the GPU with Vertex Buffer Objects (VBO)
// VAO is Vertex Array Object
// Buffer has a unique ID
GLuint VBO, VAO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
// Binding VAO first
glBindVertexArray(VAO);
// Specify the type of buffer:
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
// Now to do the copying
// GL_STATIC_DRAW: No changes in vertices expected
// GL_DYNAMIC_DRAW: Regular changes expected
// GL_STREAM_DRAW: Changes expected every step
glBufferData(GL_ARRAY_BUFFER, vertices.size() * 3 * sizeof(float),
vertices.data(), GL_STATIC_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * 3 * sizeof(int),
indices.data(), GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindVertexArray(0);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Called a "game loop" continues until window needs to close
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
// Render
// Clear the color buffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Using the program we created
glUseProgram(shaderProgram);
// Create transformations
glm::mat4 model;
glm::mat4 view;
glm::mat4 projection;
model = glm::rotate(model, -55.0f, glm::vec3(1.0f, 0.0f, 0.0f));
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
projection = glm::perspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);
// Get their uniform location
GLint modelLoc = glGetUniformLocation(shaderProgram, "model");
GLint viewLoc = glGetUniformLocation(shaderProgram, "view");
GLint projLoc = glGetUniformLocation(shaderProgram, "projection");
// Pass them to the shaders
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
// Draw container
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
// Swap the screen buffers
glfwSwapBuffers(window);
}
/*
while (!glfwWindowShouldClose(window)){
glfwPollEvents();
// Setting window color and such:
glClearColor(0.2f, 0.3f, 0.3f, 0.5f);
glClear(GL_COLOR_BUFFER_BIT);
// Using the program we created
glUseProgram(shaderProgram);
glm:: mat4 view, projection, model;
model = glm::rotate(model, 55.0f, glm::vec3(1.0f, 0.0f, 0.0f));
projection = glm::perspective(55.0f,
(float)width / (float)height,
0.1f, 100.0f);
view = glm::translate(view, glm::vec3(0.0f, 0.0f, 3.0f));
GLint modelLoc = glGetUniformLocation(shaderProgram, "model");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
GLint viewLoc = glGetUniformLocation(shaderProgram, "view");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
GLint projLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glBindVertexArray(VAO);
//glDrawArrays(GL_TRIANGLES, 0, 3);
glDrawElements(GL_TRIANGLES, indices.size() * 3, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
*/
// termination
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
glfwTerminate();
}
int main(void) {
if(!glfwInit()) {
fprintf(stderr, "Could not load GLFW, aborting.\n");
return(EXIT_FAILURE);
}
int WIDTH, HEIGHT;
WIDTH = 800;
HEIGHT = 600;
GLFWwindow *window;
window = glfwCreateWindow(WIDTH,HEIGHT,"05 camera.", NULL, NULL);
if(!window) {
fprintf(stderr, "Could not create main window, aborting.\n");
return(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK) {
fprintf(stderr, "Could not initialize GLEW, aborting.\n");
return(EXIT_FAILURE);
}
glEnable(GL_DEPTH_TEST);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
GLuint VAO, VBO, lightVAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
//glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride,
// (GLvoid*)(3*sizeof(GLfloat)));
//glEnableVertexAttribArray(1);
glBindVertexArray(0);
/* LightVAO definition. */
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO); // Same vertex data as cube.
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
char* vertex_source = read_shader("shaders/07.vert");
char* fragment_source = read_shader("shaders/07.frag");
char* lamp_fragment_source = read_shader("shaders/07_lamp.frag");
GLuint shader_program, lamp_program;
shader_program = create_shader_program(vertex_source, fragment_source);
lamp_program = create_shader_program(vertex_source, lamp_fragment_source);
free(vertex_source);
free(fragment_source);
free(lamp_fragment_source);
//GLuint texture;
//glActiveTexture(GL_TEXTURE0);
//glGenTextures(1, &texture);
//glBindTexture(GL_TEXTURE_2D, texture);
//load_texture("textures/02_container.jpg");
//glUniform1i(glGetUniformLocation(shader_program, "texture_sampler"), 0);
//glBindTexture(GL_TEXTURE_2D, 0);
Mat4f *projection, *model, *view, *temp, *temp2;
mat4f_allocate(&projection);
mat4f_allocate(&model);
mat4f_allocate(&view);
mat4f_allocate(&temp);
mat4f_allocate(&temp2);
mat4f_translate(view, 0.0f, 0.0f, -3.0f);
//mat4f_rotate_x(model, -M_PI/4);
mat4f_rotate_x(model, 0.0f);
Vec3f *light_position;
vec3f_allocate(&light_position);
vec3f_allocate(&camera_pos);
vec3f_allocate(&camera_target);
vec3f_allocate(&camera_up);
vec3f_allocate(&camera_front);
vec3f_allocate(&temp_vec3f);
vec3f_set(camera_target, 0.0f, 0.0f, 0.0f);
vec3f_set(camera_up, 0.0f, 1.0f, 0.0f);
vec3f_set(camera_front, 0.0f, 0.0f, -1.0f);
vec3f_set(camera_pos, 0.0f, 0.0f, 3.0f);
vec3f_set(light_position, 1.2f, 1.0f, 2.0f);
/* shader locations */
GLuint model_location, projection_location, view_location, light_position_location,
view_position_location;
glUseProgram(shader_program);
model_location = glGetUniformLocation(shader_program, "model");
projection_location = glGetUniformLocation(shader_program, "perspective");
view_location = glGetUniformLocation(shader_program, "view");
light_position_location = glGetUniformLocation(shader_program, "light_position");
view_position_location = glGetUniformLocation(shader_program, "view_position");
GLuint object_color_location, light_color_location;
object_color_location = glGetUniformLocation(shader_program, "object_color");
light_color_location = glGetUniformLocation(shader_program, "light_color");
glUniform3f(object_color_location, 1.0f, 0.5f, 0.31f);
glUniform3f(light_color_location, 1.0f, 1.0f, 1.0);
glUniform3f(light_position_location, light_position->data[0],
light_position->data[1],
light_position->data[2]);
glUseProgram(0);
glUseProgram(lamp_program);
GLuint lamp_model_location, lamp_projection_location, lamp_view_location;
lamp_model_location = glGetUniformLocation(lamp_program, "model");
lamp_projection_location = glGetUniformLocation(lamp_program, "perspective");
lamp_view_location = glGetUniformLocation(lamp_program, "view");
glUseProgram(0);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
current_frame = 0.0f;
last_frame = 0.0f;
last_x = WIDTH / 2.0f;
last_y = HEIGHT / 2.0f;
fov = M_PI/4;
yaw = -M_PI/2;
pitch = 0.0f;
first_mouse = true;
while(!glfwWindowShouldClose(window)) {
glfwPollEvents();
current_frame = glfwGetTime();
delta_time = current_frame - last_frame;
last_frame = current_frame;
do_movement();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shader_program);
// glActiveTexture(GL_TEXTURE0);
// glBindTexture(GL_TEXTURE_2D, texture);
// cam_x = sinf(time) * radius;
// cam_z = cosf(time) * radius;
vec3f_add(camera_target, camera_pos, camera_front);
mat4f_look_at(view, camera_pos, camera_target, camera_up);
mat4f_perspective(projection, fov, (float)WIDTH/(float)HEIGHT,
0.1f, 100.0f);
//mat4f_rotate_x(model, sinf(time) * M_PI);
glUniformMatrix4fv(model_location, 1, GL_TRUE,
mat4f_pointer(model));
glUniformMatrix4fv(view_location, 1, GL_TRUE,
mat4f_pointer(view));
glUniformMatrix4fv(projection_location, 1, GL_TRUE,
mat4f_pointer(projection));
glUniform3f(view_position_location, camera_pos->data[0],
camera_pos->data[1],
camera_pos->data[2]);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
// glBindTexture(GL_TEXTURE_2D, 0);
glBindVertexArray(0);
glUseProgram(lamp_program);
//glUseProgram(shader_program);
mat4f_scale(temp, 0.2f, 0.2f, 0.2f);
mat4f_mul(temp, temp, model);
mat4f_translate_vec3f(temp2, light_position);
mat4f_mul(temp2, temp2, temp);
//mat4f_print(temp);
glUniformMatrix4fv(lamp_model_location, 1, GL_TRUE,
mat4f_pointer(temp2));
glUniformMatrix4fv(lamp_view_location, 1, GL_TRUE,
mat4f_pointer(view));
glUniformMatrix4fv(lamp_projection_location, 1, GL_TRUE,
mat4f_pointer(projection));
glBindVertexArray(lightVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glfwTerminate();
return(EXIT_SUCCESS);
}
int main(void) {
if (!glfwInit()) {
fprintf(stderr, "Could not initialize GLFW, aborting.\n");
return(EXIT_FAILURE);
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
int WIDTH, HEIGHT;
WIDTH = 800;
HEIGHT = 600;
// Define the viewport dimensions
glViewport(0, 0, WIDTH, HEIGHT);
GLFWwindow* window;
window = glfwCreateWindow(WIDTH, HEIGHT, "04 coordinate systems.", NULL, NULL);
glfwSetKeyCallback(window, key_callback);
if (!window) {
fprintf(stderr, "Could not create window, aborting.\n");
return(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK) {
fprintf(stderr, "Could not initialize GLEW, aborting.\n");
return(EXIT_FAILURE);
}
glEnable(GL_DEPTH_TEST);
GLuint VAO, VBO, EBO;
glGenVertexArrays(1 ,&VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride,
(GLvoid*)(3*sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
GL_STATIC_DRAW);
glBindVertexArray(0);
char *vertex_source = read_shader("shaders/04.vert");
char *fragment_source = read_shader("shaders/04.frag");
GLuint shader_program;
shader_program = create_shader_program(vertex_source, fragment_source);
glUseProgram(shader_program);
GLuint texture;
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
load_texture("textures/02_container.jpg");
glUniform1i(glGetUniformLocation(shader_program, "texture_sampler"), 0);
glBindTexture(GL_TEXTURE_2D, 0);
float rotation_step;
rotation_step = M_PI/6;
Mat4f *model, *view, *projection, *rotation, *temp;
mat4f_allocate(&model);
mat4f_allocate(&view);
mat4f_allocate(&projection);
mat4f_allocate(&rotation);
mat4f_allocate(&temp);
mat4f_translate(view, 0.0f, 0.0f, -3.0f);
mat4f_perspective(projection, (float)M_PI/4, (float)WIDTH/(float)HEIGHT, 0.1f, 100.0f);
GLuint model_location, view_location, projection_location;
model_location = glGetUniformLocation(shader_program, "model");
view_location = glGetUniformLocation(shader_program, "view");
projection_location = glGetUniformLocation(shader_program, "projection");
int num_cubes = 10;
srand (time(NULL));
Vec4f positions[num_cubes];
float a = 4.0f;
for (int i = 0; i < num_cubes; i++) {
Vec4f vector;
for (int j = 0; j < 4; j++) {
if (j == 2) {
vector.data[j] = ((float)rand()/(float)(RAND_MAX/1.0f)-2.0f);
} else {
vector.data[j] = ((float)rand()/(float)(RAND_MAX/a))-2.0f;
//vector.data[j] = 1.0f*i*j;
}
printf("%f, ",vector.data[j]);
}
printf("\n");
positions[i] = vector;
};
glClearColor(1.0f, 0.5f, 1.0f, 1.0f);
while(!glfwWindowShouldClose(window)) {
glfwPollEvents();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindVertexArray(VAO);
float time = glfwGetTime();
for(int i = 0; i < num_cubes; i++) {
float *pos = positions[i].data;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
mat4f_rotate_x(rotation, rotation_step*time*(i+1));
mat4f_rotate_y(temp, rotation_step*time*(i+1));
mat4f_mul(rotation, rotation, temp);
mat4f_translate(temp, pos[0], pos[1], pos[2]);
mat4f_rotate_x(model, -M_PI/4);
mat4f_mul(model, model, temp);
mat4f_mul(model, model, rotation);
glUniformMatrix4fv(model_location, 1, GL_TRUE, mat4f_pointer(model));
glUniformMatrix4fv(view_location, 1, GL_TRUE, mat4f_pointer(view));
glUniformMatrix4fv(projection_location, 1, GL_TRUE, mat4f_pointer(projection));
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindTexture(GL_TEXTURE_2D, 0);
}
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glfwTerminate();
return EXIT_SUCCESS;
}
static void prepare_shaders(void)
{
static const char *fragShaderText =
"void main() {\n"
" gl_FragColor = gl_Color;\n"
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_FrontColor = gl_Color;\n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
"}\n";
static const char *geoShaderText =
"#version 120\n"
"#extension GL_ARB_geometry_shader4 : enable\n"
"void main()\n"
"{\n"
" for(int i = 0; i < gl_VerticesIn; ++i)\n"
" {\n"
" gl_FrontColor = gl_FrontColorIn[i];\n"
" gl_Position = gl_PositionIn[i];\n"
" EmitVertex();\n"
" }\n"
"}\n";
if (!glutExtensionSupported("GL_ARB_geometry_shader4")) {
fprintf(stderr, "needs GL_ARB_geometry_shader4 extension\n");
exit(1);
}
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
load_and_compile_shader(fragShader, fragShaderText);
vertShader = glCreateShader(GL_VERTEX_SHADER);
load_and_compile_shader(vertShader, vertShaderText);
geoShader = glCreateShader(GL_GEOMETRY_SHADER_ARB);
if (filename)
read_shader(geoShader, filename);
else
load_and_compile_shader(geoShader,
geoShaderText);
program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, geoShader);
glAttachShader(program, fragShader);
glProgramParameteriARB(program, GL_GEOMETRY_INPUT_TYPE_ARB, GL_TRIANGLES);
glProgramParameteriARB(program, GL_GEOMETRY_OUTPUT_TYPE_ARB,
GL_TRIANGLE_STRIP);
{
int temp;
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,&temp);
glProgramParameteriARB(program,GL_GEOMETRY_VERTICES_OUT_ARB,temp);
}
glLinkProgram(program);
check_link(program);
glUseProgram(program);
}
