openGL3

最新推荐文章于 2024-09-13 00:35:51 发布

Circle_list

最新推荐文章于 2024-09-13 00:35:51 发布

阅读量349

点赞数

文章标签： OpenGl

本文链接：https://blog.csdn.net/Circle_list/article/details/123608155

版权

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;

#include "Render.h"

#include "VertexBuffer.h"
#include "IndexBuffer.h"
#include "VertexArray.h"
#include "VertexBufferLayout.h"

#include "Shader.h"

struct ShaderProgramSource
{
std::string VertexSource;
std::string FragementSource;
};
static ShaderProgramSource ParseShader(const std::string filepath)
{

   std::ifstream stream(filepath);
   enum class ShaderType
   {
       NONE = -1,VERTEX = 0,FRAGMENT = 1
   };

std::string line;
std::stringstream ss[2];

ShaderType type = ShaderType::NONE;

   while (getline(stream, line))
   {
       if (line.find("#shader") != std::string::npos)
       {
           if (line.find("vertex") != std::string::npos)
           {
               type = ShaderType::VERTEX;
           }
           else if (line.find("fragment") != std::string::npos)
           {
               type = ShaderType::FRAGMENT;
           }
       }
       else
       {
           ss[int(type)] << line <<'\n';
       }
   }

return { ss[0].str(),ss[1].str() };
}

static unsigned int CompileShader(unsigned int type, const::std::string& source)
{
   unsigned int id = glCreateShader(type);
   const char* src = source.c_str();
   glShaderSource(id, 1, &src, nullptr);

glCompileShader(id);

   int result;
   glGetShaderiv(id, GL_COMPILE_STATUS, &result);
   if (result == GL_FALSE)
   {
       int length = 0;
       glGetShaderiv(id, GL_COMPILE_STATUS, &result);
       char* message = (char*)alloca(length * sizeof(char));
       glGetShaderInfoLog(id, length, &length, message);
       std::cout << "Failed to Compile" << (type == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT") << endl;
       std::cout << message << std::endl;
       glDeleteShader(id);
       return 0;
   }

return id;
}

static unsigned CreateShader(const::std::string& vertexShader,const std::string fragmentShader)
{
   unsigned int program = glCreateProgram();
   unsigned int vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
   unsigned int fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);

   glAttachShader(program, vs);
   glAttachShader(program, fs);
   glLinkProgram(program);
   glValidateProgram(program);

glDeleteShader(vs);
glDeleteShader(fs);

return program;
}

int main(void)
{
GLFWwindow* window;
if (!glfwInit()) return -1;

window = glfwCreateWindow(649, 480, "hello world", NULL, NULL);

   if (!window)
   {
       glfwTerminate();
       return -1;
   }

glfwMakeContextCurrent(window);

   if (glewInit() != GLEW_OK)
   {
       std::cout << "Error！" << std::endl;
   }

   unsigned int buffer;
   float position[] = {
       -0.5,-0.5f,
       0.0,0.5,
       0.5,-0.5
   };

   glGenBuffers(1, &buffer);
   glBindBuffer(GL_ARRAY_BUFFER, buffer);
   glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), position, GL_STATIC_DRAW);

glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

   ShaderProgramSource source = ParseShader("res/shaders/Basic.shader");
   unsigned int shader = CreateShader(source.VertexSource, source.FragementSource);
   glUseProgram(shader);

   /**/
   std::cout << source.VertexSource << endl;
   std::cout << source.FragementSource << endl;

   while (!glfwWindowShouldClose(window))
   {
       glClear(GL_COLOR_BUFFER_BIT);

glDrawArrays(GL_TRIANGLES, 0, 3);

glfwSwapBuffers(window);

       glfwPollEvents();
   }
   glDeleteShader(shader);
   glfwTerminate();

return 0;
}