OpenGL-实战篇--Breakout--RenderingSprites--46

最新推荐文章于 2022-06-21 14:52:21 发布
最新推荐文章于 2022-06-21 14:52:21 发布
阅读量173 收藏
点赞数
分类专栏： OpenGL学习笔记 文章标签： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41155760/article/details/121180570
版权

学习链接：中文------英语原文

头文件：
Game:

#pragma once

#include <GLFW/glfw3.h>

// 代表了游戏的当前状态
enum GameState {
    GAME_ACTIVE,
    GAME_MENU,
    GAME_WIN
};

class Game
{
public:
    GameState state;
    GLboolean keys[1024];
    GLuint width, height;
    Game(GLuint w, GLuint h);
    ~Game();

    void Init();

    void ProcessInput(GLfloat dt);
    void Update(GLfloat dt);
    void Render();
};

Shader:

#pragma once

//这里第一个包含glad/glad.h
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class Shader
{
public:
    // State
    GLuint ID;
    // Constructor
    Shader() { }
    // Sets the current shader as active
    Shader& Use();
    void DelteShader();
    // Compiles the shader from given source code
    void    Compile(const GLchar* vertexSource, const GLchar* fragmentSource, const GLchar* geometrySource = nullptr); // Note: geometry source code is optional 
    // Utility functions
    void    SetFloat(const GLchar* name, GLfloat value, GLboolean useShader = false);
    void    SetInteger(const GLchar* name, GLint value, GLboolean useShader = false);
    void    SetVector2f(const GLchar* name, GLfloat x, GLfloat y, GLboolean useShader = false);
    void    SetVector2f(const GLchar* name, const glm::vec2& value, GLboolean useShader = false);
    void    SetVector3f(const GLchar* name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader = false);
    void    SetVector3f(const GLchar* name, const glm::vec3& value, GLboolean useShader = false);
    void    SetVector4f(const GLchar* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader = false);
    void    SetVector4f(const GLchar* name, const glm::vec4& value, GLboolean useShader = false);
    void    SetMatrix4(const GLchar* name, const glm::mat4& matrix, GLboolean useShader = false);
private:
    // Checks if compilation or linking failed and if so, print the error logs
    void    CheckCompileErrors(GLuint object, std::string type);
};

Texture2D:

#pragma once
#include <GLFW/glfw3.h>

class Texture2D
{
public:
    // Holds the ID of the texture object, used for all texture operations to reference to this particlar texture
    GLuint ID;
    // Texture image dimensions
    GLuint Width, Height; // Width and height of loaded image in pixels
    // Texture Format
    GLuint Internal_Format; // Format of texture object
    GLuint Image_Format; // Format of loaded image
    // Texture configuration
    GLuint Wrap_S; // Wrapping mode on S axis
    GLuint Wrap_T; // Wrapping mode on T axis
    GLuint Filter_Min; // Filtering mode if texture pixels < screen pixels
    GLuint Filter_Max; // Filtering mode if texture pixels > screen pixels
    // Constructor (sets default texture modes)
    Texture2D();
    // Generates texture from image data
    void Generate(GLuint width, GLuint height, unsigned char* data);
    // Binds the texture as the current active GL_TEXTURE_2D texture object
    void Bind() const;
};

ResourceManager:

#pragma once

#include <map>
//shader.h里包含的有glad.h，要放在前面，语言本身的头文件（比如map）不影响
#include "Shader.h"
#include <GLFW/glfw3.h>
#include "Texture2D.h"

class ResourceManager
{
public:
    // Resource storage
    static std::map<std::string, Shader>    Shaders;
    static std::map<std::string, Texture2D> Textures;
    // Loads (and generates) a shader program from file loading vertex, fragment (and geometry) shader's source code. If gShaderFile is not nullptr, it also loads a geometry shader
    static Shader& LoadShader(const GLchar* vShaderFile, const GLchar* fShaderFile, const GLchar* gShaderFile, std::string name);
    // Retrieves a stored sader
    static Shader& GetShader(std::string name);
    // Loads (and generates) a texture from file
    static Texture2D& LoadTexture(const GLchar* file, GLboolean alpha, std::string name);
    // Retrieves a stored texture
    static Texture2D& GetTexture(std::string name);
    // Properly de-allocates all loaded resources
    static void      Clear();
private:
    // Private constructor, that is we do not want any actual resource manager objects. Its members and functions should be publicly available (static).
    ResourceManager() { }
    // Loads and generates a shader from file
    static Shader    loadShaderFromFile(const GLchar* vShaderFile, const GLchar* fShaderFile, const GLchar* gShaderFile = nullptr);
    // Loads a single texture from file
    static Texture2D loadTextureFromFile(const GLchar* file, GLboolean alpha);
};

SpriteRenderer:

#pragma once

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include "Shader.h"
#include "Texture2D.h"

class SpriteRenderer
{
public:
	SpriteRenderer(Shader& shader);
	~SpriteRenderer();
	void DrawSprite(Texture2D& texture, glm::vec2 position, glm::vec2 size = glm::vec2(10, 10), GLfloat rotate = 0.0f, glm::vec3 color = glm::vec3(1.0f));
private:
	Shader shader;
	GLuint quadVAO;
	void InitRenderData();
};

CPP源码：
Program.cpp:

//确保#include <glad/glad.h>被第一个包含，不然报错,其他头文件需要也要第一个包含

#include "ResourceManager.h"
#include <GLFW/glfw3.h>
#include "Game.h"

void key_callback(GLFWwindow* window, int key, int scancode, int action, int code);

const GLuint SCREEN_WIDTH = 800;
const GLuint SCREEN_HEIGHT = 600;

Game breakout(SCREEN_WIDTH, SCREEN_HEIGHT);

int main(int argc, char* argv[])
{
	// glfw: initialize and configure	
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_SAMPLES, 4);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

	// glfw window creation	
	GLFWwindow* window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "hehehe...", NULL, NULL);
	if (window == NULL)
	{
		std::cout << "Failed to create GLFW window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);
	glfwSetKeyCallback(window, key_callback);

	// tell GLFW to capture our mouse
	//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

	// glad: load all OpenGL function pointers	
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return -1;
	}

	// configure global opengl state
	// -----------------------------
	glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
	glEnable(GL_CULL_FACE);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	//init game
	breakout.Init();

	// DeltaTime variables
	GLfloat deltaTime = 0.0f;
	GLfloat lastFrame = 0.0f;

	// Start Game within Menu State
	breakout.state = GAME_ACTIVE;

	while (!glfwWindowShouldClose(window))
	{
		// Calculate delta time
		GLfloat currentFrame = glfwGetTime();
		deltaTime = currentFrame - lastFrame;
		lastFrame = currentFrame;
		glfwPollEvents();
		
		// Manage user input
		breakout.ProcessInput(deltaTime);

		// Update Game state
		breakout.Update(deltaTime);

		// Render
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		breakout.Render();

		glfwSwapBuffers(window);
	}

	// Delete all resources as loaded using the resource manager
	ResourceManager::Clear();

	glfwTerminate();
	return 0;
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	// When a user presses the escape key, we set the WindowShouldClose property to true, closing the application
	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
		glfwSetWindowShouldClose(window, GL_TRUE);
	if (key >= 0 && key < 1024)
	{
		if (action == GLFW_PRESS)
			breakout.keys[key] = GL_TRUE;
		else if (action == GLFW_RELEASE)
			breakout.keys[key] = GL_FALSE;
	}
}

Game.cpp:

//这里一样：ResourceManager.h（包含有Shader.h,shader.h包含的有glad.h）包含的有glad.h所以要放前面
#include "ResourceManager.h"
#include "Game.h"
#include "SpriteRenderer.h"

SpriteRenderer* renderer;

Game::Game(GLuint w, GLuint h) :state(GAME_ACTIVE), keys(), width(w), height(h)
{
}

Game::~Game()
{
}

void Game::Init()
{
	//load shader
	ResourceManager::LoadShader("Shaders/Breakout/Sprite.vs", "Shaders/Breakout/Sprite.fs", nullptr, "sprite");
	//config shader
	glm::mat4 projection = glm::ortho(0.0f, static_cast<GLfloat>(this->width), static_cast<GLfloat>(this->height), 0.0f, -1.0f, 1.0f);
	ResourceManager::GetShader("sprite").Use().SetInteger("image", 0);
	ResourceManager::GetShader("sprite").SetMatrix4("projection", projection);
	//setup render control
	renderer = new SpriteRenderer(ResourceManager::GetShader("sprite"));
	//load texture
	ResourceManager::LoadTexture("Images/Test.jpg", GL_TRUE, "face");
}

void Game::ProcessInput(GLfloat dt)
{
}

void Game::Update(GLfloat dt)
{
}

void Game::Render()
{
	renderer->DrawSprite(ResourceManager::GetTexture("face"), glm::vec2(200, 200), glm::vec2(200, 200), 45.0f, glm::vec3(0.0f, 1.0f, 0.0f));
}

Shader.cpp:

#include "Shader.h"

//#include <iostream>

Shader& Shader::Use()
{
	glUseProgram(this->ID);
	return *this;
}

void Shader::DelteShader()
{
    glDeleteShader(ID);
}


void Shader::Compile(const GLchar* vertexSource, const GLchar* fragmentSource, const GLchar* geometrySource)
{
    GLuint sVertex, sFragment, gShader;
    // Vertex Shader
    sVertex = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(sVertex, 1, &vertexSource, NULL);
    glCompileShader(sVertex);
    CheckCompileErrors(sVertex, "VERTEX");
    // Fragment Shader
    sFragment = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(sFragment, 1, &fragmentSource, NULL);
    glCompileShader(sFragment);
    CheckCompileErrors(sFragment, "FRAGMENT");
    // If geometry shader source code is given, also compile geometry shader
    if (geometrySource != nullptr)
    {
        gShader = glCreateShader(GL_GEOMETRY_SHADER);
        glShaderSource(gShader, 1, &geometrySource, NULL);
        glCompileShader(gShader);
        CheckCompileErrors(gShader, "GEOMETRY");
    }
    // Shader Program
    this->ID = glCreateProgram();
    glAttachShader(this->ID, sVertex);
    glAttachShader(this->ID, sFragment);
    if (geometrySource != nullptr)
        glAttachShader(this->ID, gShader);
    glLinkProgram(this->ID);
    CheckCompileErrors(this->ID, "PROGRAM");
    // Delete the shaders as they're linked into our program now and no longer necessery
    glDeleteShader(sVertex);
    glDeleteShader(sFragment);
    if (geometrySource != nullptr)
        glDeleteShader(gShader);
}

void Shader::SetFloat(const GLchar* name, GLfloat value, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform1f(glGetUniformLocation(this->ID, name), value);
}
void Shader::SetInteger(const GLchar* name, GLint value, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform1i(glGetUniformLocation(this->ID, name), value);
}
void Shader::SetVector2f(const GLchar* name, GLfloat x, GLfloat y, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform2f(glGetUniformLocation(this->ID, name), x, y);
}
void Shader::SetVector2f(const GLchar* name, const glm::vec2& value, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform2f(glGetUniformLocation(this->ID, name), value.x, value.y);
}
void Shader::SetVector3f(const GLchar* name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform3f(glGetUniformLocation(this->ID, name), x, y, z);
}
void Shader::SetVector3f(const GLchar* name, const glm::vec3& value, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform3f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z);
}
void Shader::SetVector4f(const GLchar* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform4f(glGetUniformLocation(this->ID, name), x, y, z, w);
}
void Shader::SetVector4f(const GLchar* name, const glm::vec4& value, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniform4f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z, value.w);
}
void Shader::SetMatrix4(const GLchar* name, const glm::mat4& matrix, GLboolean useShader)
{
    if (useShader)
        this->Use();
    glUniformMatrix4fv(glGetUniformLocation(this->ID, name), 1, GL_FALSE, glm::value_ptr(matrix));
}

void Shader::CheckCompileErrors(GLuint object, std::string type)
{
    GLint success;
    GLchar infoLog[1024];
    if (type != "PROGRAM")
    {
        glGetShaderiv(object, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(object, 1024, NULL, infoLog);
            std::cout << "| ERROR::SHADER: Compile-time error: Type: " << type << "\n"
                << infoLog << "\n -- --------------------------------------------------- -- "
                << std::endl;
        }
    }
    else
    {
        glGetProgramiv(object, GL_LINK_STATUS, &success);
        if (!success)
        {
            glGetProgramInfoLog(object, 1024, NULL, infoLog);
            std::cout << "| ERROR::Shader: Link-time error: Type: " << type << "\n"
                << infoLog << "\n -- --------------------------------------------------- -- "
                << std::endl;
        }
    }
}

Texture2d.cpp:

#include "Texture2D.h"

Texture2D::Texture2D() : Width(0), Height(0), Internal_Format(GL_RGB), Image_Format(GL_RGB), Wrap_S(GL_REPEAT), Wrap_T(GL_REPEAT), Filter_Min(GL_LINEAR), Filter_Max(GL_LINEAR)
{
	glGenTextures(1, &this->ID);
}

void Texture2D::Generate(GLuint width, GLuint height, unsigned char* data)
{
    this->Width = width;
    this->Height = height;
    // Create Texture
    glBindTexture(GL_TEXTURE_2D, this->ID);
    glTexImage2D(GL_TEXTURE_2D, 0, this->Internal_Format, width, height, 0, this->Image_Format, GL_UNSIGNED_BYTE, data);
    // Set Texture wrap and filter modes
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, this->Wrap_S);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, this->Wrap_T);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, this->Filter_Min);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, this->Filter_Max);
    // Unbind texture
    glBindTexture(GL_TEXTURE_2D, 0);
}

void Texture2D::Bind() const
{
    glBindTexture(GL_TEXTURE_2D, this->ID);
}

ResourceManager.cpp:

#include "ResourceManager.h"
#include <stb_image.h>

// Instantiate static variables
std::map<std::string, Texture2D>    ResourceManager::Textures;
std::map<std::string, Shader>      ResourceManager::Shaders;

Shader& ResourceManager::LoadShader(const GLchar* vShaderFile, const GLchar* fShaderFile, const GLchar* gShaderFile, std::string name)
{
	Shaders[name] = loadShaderFromFile(vShaderFile, fShaderFile, gShaderFile);
	return Shaders[name];
}

Shader& ResourceManager::GetShader(std::string name)
{
	return Shaders[name];
}

Texture2D& ResourceManager::LoadTexture(const GLchar* file, GLboolean alpha, std::string name)
{
	Textures[name] = loadTextureFromFile(file, alpha);
	return Textures[name];
}

Texture2D& ResourceManager::GetTexture(std::string name)
{
	return Textures[name];
}

void ResourceManager::Clear()
{
	// (Properly) delete all shaders	
	for (auto iter : Shaders)
		glDeleteProgram(iter.second.ID);
	// (Properly) delete all textures
	for (auto iter : Textures)
		glDeleteTextures(1, &iter.second.ID);
}

Shader ResourceManager::loadShaderFromFile(const GLchar* vShaderFile, const GLchar* fShaderFile, const GLchar* gShaderFile)
{
    // 1. Retrieve the vertex/fragment source code from filePath
    std::string vertexCode;
    std::string fragmentCode;
    std::string geometryCode;
    try
    {
        // Open files
        std::ifstream vertexShaderFile(vShaderFile);
        std::ifstream fragmentShaderFile(fShaderFile);
        std::stringstream vShaderStream, fShaderStream;
        // Read file's buffer contents into streams
        vShaderStream << vertexShaderFile.rdbuf();
        fShaderStream << fragmentShaderFile.rdbuf();
        // close file handlers
        vertexShaderFile.close();
        fragmentShaderFile.close();
        // Convert stream into string
        vertexCode = vShaderStream.str();
        fragmentCode = fShaderStream.str();
        // If geometry shader path is present, also load a geometry shader
        if (gShaderFile != nullptr)
        {
            std::ifstream geometryShaderFile(gShaderFile);
            std::stringstream gShaderStream;
            gShaderStream << geometryShaderFile.rdbuf();
            geometryShaderFile.close();
            geometryCode = gShaderStream.str();
        }
    }
    catch (std::exception e)
    {
        std::cout << "ERROR::SHADER: Failed to read shader files" << std::endl;
    }
    const GLchar* vShaderCode = vertexCode.c_str();
    const GLchar* fShaderCode = fragmentCode.c_str();
    const GLchar* gShaderCode = geometryCode.c_str();
    // 2. Now create shader object from source code
    Shader shader;
    shader.Compile(vShaderCode, fShaderCode, gShaderFile != nullptr ? gShaderCode : nullptr);
    return shader;
}

Texture2D ResourceManager::loadTextureFromFile(const GLchar* file, GLboolean alpha)
{
    // Create Texture object
    Texture2D texture;
    if (alpha)
    {
        texture.Internal_Format = GL_RGBA;
        texture.Image_Format = GL_RGBA;
    }

    int width, height, nrComponents;
    unsigned char* data = stbi_load(file, &width, &height, &nrComponents, 0);

    if (data)
    {       
        if (nrComponents == 1)
        {           
            texture.Internal_Format = GL_RED;
            texture.Image_Format = GL_RED;
        }          
        else if (nrComponents == 3)
        {
           
            texture.Internal_Format = GL_RGB;
            texture.Image_Format = GL_RGB;
        }
        else if (nrComponents == 4)
        {           
            if (alpha)
            {
                texture.Internal_Format = GL_RGBA;
                texture.Image_Format = GL_RGBA;
            }
            else 
            {
                texture.Internal_Format = GL_RGB;
                texture.Image_Format = GL_RGB;
            }
        }

        texture.Generate(width, height, data);       

        stbi_image_free(data);
    }
  
    return texture;
}

SpriteRenderer.cpp:

#include "SpriteRenderer.h"

SpriteRenderer::SpriteRenderer(Shader& shader)
{
	this->shader = shader;
	this->InitRenderData();
}

SpriteRenderer::~SpriteRenderer()
{
	glDeleteVertexArrays(1, &this->quadVAO);
}

void SpriteRenderer::DrawSprite(Texture2D& texture, glm::vec2 position, glm::vec2 size, GLfloat rotate, glm::vec3 color)
{	
	this->shader.Use();
	glm::mat4 model = glm::mat4(1.0);
	
	//下面这段代码主要是处理变换：代码写的顺序和实际的变换顺序相反的
		
	// First translate(transformations are : scale happens first, then rotation and then finall translation happens; reversed order)	
	model = glm::translate(model, glm::vec3(position, 0.0f));
	//由于原点再图片左上角	
	//这里代码上是把原点移动到图片的中心，再旋转
	// Move origin of rotation to center of quad
	model = glm::translate(model, glm::vec3(0.5f * size.x, 0.5f * size.y, 0.0f));
	// Then rotate
	model = glm::rotate(model, glm::radians(rotate), glm::vec3(0.0f, 0.0f, 1.0f));	
	// Move origin back
	model = glm::translate(model, glm::vec3(-0.5f * size.x, -0.5f * size.y, 0.0f));

	model = glm::scale(model, glm::vec3(size, 1.0f));
	//实际：倒着看：先缩放，再反向移动，再旋转，再正向移动，最后平移
	this->shader.SetMatrix4("model", model);
	this->shader.SetVector3f("spriteColor", color);

	glActiveTexture(GL_TEXTURE0);
	texture.Bind();

	glBindVertexArray(this->quadVAO);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glBindVertexArray(0);
}

void SpriteRenderer::InitRenderData()
{
	//config VAO VBO
	GLuint VBO;
	GLfloat vertices[] = {
		// 位置     // 纹理
	   0.0f, 1.0f, 0.0f, 1.0f,
	   1.0f, 0.0f, 1.0f, 0.0f,
	   0.0f, 0.0f, 0.0f, 0.0f,

	   0.0f, 1.0f, 0.0f, 1.0f,
	   1.0f, 1.0f, 1.0f, 1.0f,
	   1.0f, 0.0f, 1.0f, 0.0f
	};

	glGenVertexArrays(1, &this->quadVAO);
	glGenBuffers(1, &VBO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	glBindVertexArray(this->quadVAO);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);
}
牛神自
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
breakout-frontend:网络前端
05-14
使用docker启动mongodb： docker run --name breakout-mongo -p "27017:27017" -d mongo 可选：启动Breakout-backend实例（需要更多文档） 运行npm i以安装节点软件包（适用于npm版本6和节点版本12） 运行npm ...
小羊的OpenGL学习笔记（一）
cjdd101的博客
03-25 198
1、glsl代码放在const GLchar* 字符串中，使用 glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); 在运行程序时进行动态编译。 2、关于glGenBuffers()和glBindBuffer()的理解，这篇博客说的非常好 https...
OpenGL笔记
yhhwatl的专栏
03-28 405
译序 早前学OpenGL的时候还是1.x版本，用的都是glVertex,glNorma等固定管线API。 openGL ES 2.0 版本开始不再支持固定管线，只支持可编程管线。 准备 1.The OpenGL Extension Wrangler(GLEW) 是用来访问OpenGL 3.2 API函数的。  不能简单的使用gl.h来访问OpenGL接口，除非你相用旧
OpenGL函数详解用法
Terlxho的博客
06-21 873
OpenGL函数大全，详解作用及参数注解，结合渲染管线会更容易理解
第三课，OpenGL的着色器
Elsa的迷弟
06-16 236
优化 首先将着色器的编译链接进行优化 //Shader.h #pragma once #include <glad/glad.h> class Shader{ public: //程序ID unsigned int ID; //构造器读取并构建着色器 Shader(const GLchar*, const GLchar*); //使用、激活程序 void use(); //uniform工具函数 void setBool(const std::string& name,
u-center v22.07
最新发布
03-14
【压缩包子文件的文件名称列表】"GPS_RTK_Breakout_Software-main" 暗示了压缩包内可能包含的核心内容，即与GPS实时动态定位相关的软件开发或者扩展工具。"main"通常代表主目录或者主要代码库，意味着这可能是软件的...
Breakout-phaser：PhaserJS的游戏突破
02-04
《Breakout-phaser：PhaserJS游戏开发深度解析》 PhaserJS，一款基于HTML5和JavaScript的游戏开发框架，以其强大的功能和易用性在Web游戏开发者中备受青睐。"Breakout-phaser"项目，正是利用PhaserJS实现的经典游戏...
Pantsu-Breakout-Game：Phaser网络游戏
02-05
Pantsu突破游戏 移相器网页游戏 您可以在上播放最新的最低可行产品，或者在上播放最新版本... 因此，由于我不想重构当前编写的所有内容，因此我将停止Pantsu Breakout Game的开发，而将其保留在最低可行的产品编号5上。
怎样使用MQ-3酒精传感器
04-28
MQ-3 酒精传感器 Breakout 板有四个引脚：VCC、GND、AOUT 和 DOUT。AOUT 引脚是模拟输出引脚，用于输出酒精浓度的电压信号。因此，我们可以将 AOUT 引脚连接到 Arduino 或 PIC 微控制器的模拟输入引脚，以读取酒精...
OpenGL中shader使用
weixin_30559481的博客
08-28 411
学了接近一个月的OpenGL，终于要排上用场了...好吧，就从学到的shader（着色器）开刀吧。 先简单的介绍shader，shader其实是显卡的功能，就是利用显卡的GPU去做图像处理的工作，而不是CPU，这样可以在一些复杂的大程序中释放CPU空间而提高效率。这篇文章只是简单的介绍shader的使用，并没有介绍着色语言的语法结构等方面内容。后面等自己研究好了继...
OpenGL Point Sprites work in Android
记录点滴
05-20 688
gl.glEnable(GL11.GL_POINT_SPRITE_OES); gl.glTexEnvf(GL11.GL_POINT_SPRITE_OES, GL11.GL_COORD_REPLACE_OES, GL11.GL_TRUE); gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); // 2 dimensional array, (x1,y1, x2
OpenGl中使用着色器的基本步骤及GLSL渲染简单示例
热门推荐
牧野的博客
12-14 2万+
OpenGL着色语言（OpenGL Shading Language，GLSL）是用来在OpenGL中着色编程的语言，是一种具有C/C++风格的高级过程语言，同样也以main函数开始，只不过执行是在GPU上。GLSL中着色器主要分为顶点着色器（Vertex Shader）和片段着色器（Fragment Shader）两部分，代替了固定渲染管线的一部分，使渲染管线中不同层次具有可编程性，程序控制更加
OpenGL+WebGL——绘制三角形
大太阳
08-30 1637
编写C++代码main.cpp实现一个三角形的绘制，该程序中包括创建顶点缓冲区glGenBuffers（） ；创建并编译顶点着色器与片段着色器glCreateShader（）；glCompileShader（）和三角形绘制glDrawArrays（） #include <functional> #include <emscripten.h> #include <S...
现代OpenGL（一）：我的第一个OpenGL程序
给永远比拿愉快
12-10 1万+
OpenGL简介OpenGL是一种应用程序编程接口（Application Programming Interface，API）它是一种可以对图形硬件设备特征进行访问的软件库。 在OpenGL 3.0以前的版本或者使用兼容模式的OpenGL环境，OpenGL包含一个固定管线（fixed-function pipeline），它可以在不使用着色器的环境下处理几何与像素数据。我们看到的glBegin(
GLSL的简介(下)
Quixote实验室
08-15 1633
着色器例子 到目前为止我们已经学习了一些关于GLSL的东西。但是着色器到底长什么样，下面是一些简单的例子： 环境光着色器 环境光着色器毫无疑问是最简单的着色器，每一个被渲染的像素都有一个具体的颜色： 顶点着色器： void main()  {      // Transforming The Vertex      gl_Position = gl_ModelViewProject
opengl wrapping mode
laijingquan的专栏
01-16 606
摘抄一些opengl的笔记，非原创！ 在进行纹理贴图的时候，图像会出现在物体表面上的（ｕ，ｖ）位置上，而这些值在［０,０,１.０］范围内。但是，如果超出这个值域，会发僧什么情况呢？这由纹理的映射函数来决定的。在opengl中，这类映射函数称为“Texture Wrapping Mode”；在D3D中，称为“Texture Addresing Mode”。常见的方式有下面几种： 1.重复（GL_
GLES2.0中文API-glGetShaderSource
flycatdeng的专栏
12-03 935
名称 glGetShaderSource - 从着色器对象返回源代码字符串 C规范 void glGetShaderSource(    GLuint shader,      GLsizei bufSize,      GLsizei *length,      GLchar *source); 参数 shader 指定要查询的着色器对象。 bufSize 指定用于存储返回的源代...
基于c++，OpenGL渲染的碰撞游戏
Javalllq的博客
06-22 1478
基于c++，OpenGL渲染的碰撞 标明（本文章并非完全原创，整理自（https://learnopengl.com） 一：准备工作： 安装opengl渲染库，SQIL库，并且进行相关文件路径设置工作，具体过程就不详细叙述了。 写好基本框架： 首先定义一个游戏类，它会包含所有相关的渲染和游戏代码 游戏类封装了一个初始化函数，一个更新函数，一个处理输入函数以及一个渲染函数 class Game { public: // 游戏状态 GameState Sta
Apple II: 1978 Reference Manual - Loading Programs & Basic Functions
5. 游戏和演示：手册中提到的《星际旅行》（16K Startrek）和Breakout及Color Demos磁带，不仅展示了程序的应用，还提供了相应的程序清单和玩法指导，如《星际旅行》的游戏运行方法和《Breakout》和《Color Demos》...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值