跨平台二维绘图程序（二）——着色器shader

最新推荐文章于 2024-09-13 08:41:05 发布
最新推荐文章于 2024-09-13 08:41:05 发布
阅读量503 收藏 1
点赞数 1
分类专栏： 二维绘图 文章标签： opengl android gpu gles
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wayright/article/details/76574120
版权

学习使用GLES，首先要写着色器。

      与OpenGL ES1.x渲染管线相比，OpenGL ES 2.0渲染管线中“顶点着色器”取代了OpenGL ES 1.x渲染管线中的“变换和光照”；“片元着色器”取代了OpenGL ES 1.x渲染管线中的“纹理环境和颜色求和”、“雾”以及“Alpha测试”。 这使得开发人员在使用OpenGL ES 2.0API进行开发时，可以通过编写顶点及片元着色器程序，来完成一些顶点变换和纹理颜色计算工作，实现更加灵活、精细化的计算与渲染。


以上内容转载自：

http://blog.sina.com.cn/s/blog_923fdd9b0102vbe0.html

文章对着色器做了一些介绍，在GLES的使用步骤为：glCreateProgram->glAttachShader->glLinkProgram->glUseProgram。在之后使用纹理之后才知道，一个程序里可能同时存在多个program，在绘制不同对象时需要切换使用glUseProgram。在出现错误的时候错误日志非常关键，调试的时候发现同样的shader代码在windows平台可以绘制，但是在ubuntu中就无法显示，错误日志可能提示语言的版本不支持。这些错误与系统GPU有关系。以下为包含着色器的Program封装，包括常规程序和带纹理的程序。


#pragma once

// 矩阵操作
#include <math.h>
#include "glm/mat4x4.hpp"
#include "glm/ext.hpp"

class ShaderId
{
public:
	ShaderId()
	{
		_shaderId = -1;
	}
	int _shaderId;
};

class ProgramId
{
public:
	int         _programId;
	ShaderId    _vertex;
	ShaderId    _fragment;
public:
	ProgramId()
	{
		_programId = -1;
	}
public:
	/**
	*   加载函数
	*/
	virtual bool  createProgram(const char* vertex, const char* fragment)
	{
#ifndef ANDROID
		glewInit(); // android need of not?
#endif

		bool        error = false;
		do
		{
			if (vertex)
			{
				_vertex._shaderId = glCreateShader(GL_VERTEX_SHADER);
				glShaderSource(_vertex._shaderId, 1, &vertex, 0);
				glCompileShader(_vertex._shaderId);

				GLint   compileStatus;
				glGetShaderiv(_vertex._shaderId, GL_COMPILE_STATUS, &compileStatus);
				error = compileStatus == GL_FALSE;
				if (error)
				{
					GLchar messages[256];
					glGetShaderInfoLog(_vertex._shaderId, sizeof(messages), 0, messages);
					GLUtil::instance()->outputString(messages);
					//assert(messages && 0 != 0);
					break;
				}
			}
			if (fragment)
			{
				_fragment._shaderId = glCreateShader(GL_FRAGMENT_SHADER);
				glShaderSource(_fragment._shaderId, 1, &fragment, 0);
				glCompileShader(_fragment._shaderId);

				GLint   compileStatus;
				glGetShaderiv(_fragment._shaderId, GL_COMPILE_STATUS, &compileStatus);
				error = compileStatus == GL_FALSE;

				if (error)
				{
					GLchar messages[256];
					glGetShaderInfoLog(_fragment._shaderId, sizeof(messages), 0, messages);
					GLUtil::instance()->outputString(messages);
					//assert(messages && 0 != 0);
					break;
				}
			}
			_programId = glCreateProgram();

			if (_vertex._shaderId)
			{
				glAttachShader(_programId, _vertex._shaderId);
			}
			if (_fragment._shaderId)
			{
				glAttachShader(_programId, _fragment._shaderId);
			}

			glLinkProgram(_programId);

			GLint linkStatus;
			glGetProgramiv(_programId, GL_LINK_STATUS, &linkStatus);
			if (linkStatus == GL_FALSE)
			{
				GLchar messages[256];
				glGetProgramInfoLog(_programId, sizeof(messages), 0, messages);
				GLUtil::instance()->outputString(messages);
				break;
			}
			glUseProgram(_programId);

		} while (false);

		if (error)
		{
			if (_fragment._shaderId)
			{
				glDeleteShader(_fragment._shaderId);
				_fragment._shaderId = 0;
			}
			if (_vertex._shaderId)
			{
				glDeleteShader(_vertex._shaderId);
				_vertex._shaderId = 0;
			}
			if (_programId)
			{
				glDeleteProgram(_programId);
				_programId = 0;
			}
		}
		return  true;
	}

	virtual void begin(const glm::mat4& mat)
	{
		glUseProgram(_programId);
		
		glm::mat4 matTemp = mat;// *m_view/* * module*/;
		GLfloat *mvp = (GLfloat*)glm::value_ptr(matTemp);

		glUniformMatrix4fv(this->mvp(), 1, GL_FALSE, mvp);

	}

	virtual void end()
	{
		glUseProgram(0);
	}


	virtual bool initialize(){ return false; }

	virtual GLint position() { return -1; }

	virtual GLint color() { return -1; }

	virtual GLint texure() { return -1; }

	virtual GLint mvp() { return -1; }

	virtual GLint uv() { return -1; }
};

class   PROGRAM_P2_AC4 :public ProgramId
{
public:
	typedef int attribute;
	typedef int uniform;
protected:
	attribute   _position;
	attribute   _color;
	uniform     _MVP;
public:
	virtual GLint position() { return _position; }

	virtual GLint color() { return _color; }

	virtual GLint texure() { return -1; }

	virtual GLint mvp() { return _MVP; }

public:
	PROGRAM_P2_AC4()
	{
		_position = -1;
		_color = -1;
		_MVP = -1;
	}
	~PROGRAM_P2_AC4()
	{
	}

	/// 初始化函数
	virtual bool    initialize()
	{
		/*
		const char* vs =
		{
		"precision lowp float; "
		"uniform   mat4 _MVP;"
		"attribute vec3 _position;"
		"attribute vec4 _color;"
		"varying   vec4 _outColor;"

		"void main()"
		"{"
		"   vec4    pos =   vec4(_position, 1.);"
		"   _outColor   =   _color;"
		"   gl_Position =   _MVP * pos;"
		"}"
		};
		const char* ps =
		{
		"precision  lowp float; "
		"varying   vec4 _outColor;"
		"void main()"
		"{"
		"   gl_FragColor   =   _outColor;"
		"}"
		};
		*/
#ifdef ANDROID
		const char* vs =
		{
			"attribute vec3 _position;"
			"attribute vec4 _color;"
			"varying vec4 _outColor;"
			"uniform mat4 _MVP;"

			"void main()"
			"{"
			"   vec4    pos =   vec4(_position, 1.);"
			"   _outColor   =   _color;"
			"   gl_Position =   _MVP * pos;"
			"}"
		};

		const char* ps =
		{
			"precision mediump float;"
			"varying  vec4 _outColor;"

			"void main()"
			"{"
			"   gl_FragColor = _outColor;"
			"}"
		};
#else
		const char* vs =
		{
			"#version 130\n"
			"in vec3 _position;"
			"in vec4 _color;"
			"out vec4 _outColor;"
			"uniform mat4 _MVP;"

			"void main()"
			"{"
			"   vec4    pos =   vec4(_position, 1.);"
			"   _outColor   =   _color;"
			"   gl_Position =   _MVP * pos;"
			"}"
		};
		
		const char* ps =
		{
			"#version 130\n"
			"in vec4 _outColor;"
			"out vec4 FragColor;"
			"void main()"
			"{"
			"   FragColor = _outColor;"
			"}"
		};

#endif

		bool    res = createProgram(vs, ps);
		if (res)
		{
			_position = glGetAttribLocation(_programId, "_position");
			_color = glGetAttribLocation(_programId, "_color");
			_MVP = glGetUniformLocation(_programId, "_MVP");
		}
		return  res;
	}

	/**
	*   使用程序
	*/
	virtual void begin(const glm::mat4& mat)
	{
		ProgramId::begin(mat);
		glEnableVertexAttribArray(_position);
		glEnableVertexAttribArray(_color);
	}
	/**
	*   使用完成
	*/
	virtual void    end()
	{
		glDisableVertexAttribArray(_position);
		glDisableVertexAttribArray(_color);
		glUseProgram(0);
	}
};

class   PROGRAM_P2_UV_AC4 :public PROGRAM_P2_AC4
{
public:
	typedef int attribute;
	typedef int uniform;
protected:
	//attribute   _position;
	//attribute   _color;
	attribute   _uv;
	//uniform     _MVP;
	uniform     _texture;
public:
	PROGRAM_P2_UV_AC4()
	{
		_position = -1;
		_color = -1;
		_uv = -1;
		_texture = -1;
		_MVP = -1;
	}
	~PROGRAM_P2_UV_AC4()
	{
	}

	virtual GLint uv() { return _uv; }

	virtual GLint texure() { return _texture; }

	/// 初始化函数
	virtual bool    initialize()
	{
#ifdef ANDROID
		const char* vs =
		{
			"precision lowp float; "
			"uniform   mat4 _MVP;"
			"attribute vec3 _position;"
			"attribute vec2 _uv;"
			"attribute vec4 _color;"
			"varying   vec4 _outColor;"
			"varying   vec2 _outUV;"

			"void main()"
			"{"
			"   vec4    pos =   vec4(_position, 1.);"
			"   _outColor   =   _color;"
			"   _outUV      =   _uv;"
			"   gl_Position =   _MVP * pos;"
			"}"
		};
		const char* ps =
		{
			"precision  lowp float; "
			"uniform   sampler2D _texture;\n"
			"varying   vec4      _outColor;\n"
			"varying   vec2      _outUV;\n"
			"void main()"
			"{"
			"   vec4    tColor  =   texture2D(_texture,_outUV);\n"
			"   gl_FragColor    =   tColor * _outColor;\n"
			"}"
		};
#else
            const char* vs =
            {
                    "#version 130\n"
                    "in vec3 _position;"
                    "in vec2 _uv;"
                    "in vec4 _color;"
                    "out vec4 _outColor;"
                    "out vec2 _outUV;"
                    "uniform mat4 _MVP;"

                    "void main()"
                    "{"
                    "   vec4    pos =   vec4(_position, 1.);"
                    "   _outColor   =   _color;"
                    "   _outUV   =   _uv;"
                    "   gl_Position =   _MVP * pos;"
                    "}"
            };

            const char* ps =
            {
				"#version 130\n"
				"uniform   sampler2D _texture;"
				"in vec4 _outColor;"
				"in vec2 _outUV;"
				"out vec4 FragColor;"
				"void main()"
				"{"
                "   vec4    tColor  =   texture2D(_texture,_outUV);\n"
                "   FragColor = tColor * _outColor;"
                "}"
            };

#endif

		bool    res = createProgram(vs, ps);
		if (res)
		{
			_position = glGetAttribLocation(_programId, "_position");
			_color = glGetAttribLocation(_programId, "_color");
			_uv = glGetAttribLocation(_programId, "_uv");
			_texture = glGetUniformLocation(_programId, "_texture");
			_MVP = glGetUniformLocation(_programId, "_MVP");
		}
		return  res;
	}

	/**
	*   使用程序
	*/

	virtual void begin(const glm::mat4& mat)
	{
		ProgramId::begin(mat);
		glEnableVertexAttribArray(_position);
		glEnableVertexAttribArray(_uv);
		glEnableVertexAttribArray(_color);
	}

	/**
	*   使用完成
	*/
	virtual void    end()
	{
		glDisableVertexAttribArray(_position);
		glDisableVertexAttribArray(_uv);
		glDisableVertexAttribArray(_color);
		glUseProgram(0);
	}
};

代码编写参考了：

http://blog.youkuaiyun.com/hb707934728/article/details/71486631?locationNum=4&fps=1

主要做的改动：

（1）着色语言，区分android，区分版本，区分坐标——尤其是z坐标引入保证深度测试能够生效（vec4    pos =   vec4(_position, 1.);）；

（2）纹理程序继承自常规程序而非基础程序类；

（3）引入了变换矩阵（用于旋转缩放平移等运算）；



openglesForC++绘制带颜色的四边形
hb707934728的博客
04-26 795
shader操作类： #pragma once #include class ShaderId { public: ShaderId() { _shaderId = -1; } int _shaderId; }; /** * 程序 */ class ProgramId { public: int _programId; ShaderId
条件着色图 (CCPLOT)：绘制条件着色（二维线）图。-matlab开发
06-01
使用基于颜色图的条件着色绘制矢量 Y 与矢量 X。 条件向量 C 与 X 和 Y 的值无关，但大小必须相同。 颜色图 MAP 可以是 Matlab 或用户定义的颜色图。 例子： x = linspace(0,4*pi,50); y = 罪 (x); c = y.^2; 地图 = 颜色图（喷气机）； h = ccplot(x,y,c,map); 设置（h，'标记'，'o'）；
跨平台二维绘图程序（三）——VAO&VBO
wayright的专栏
08-02 793
一、VAO、VBO介绍 随着OpenGL状态和固定管线模式的移除，我们不在用任何glEnable函数调用，而且也不会有glVertex、glColor等函数调用。这就意味着我们需要一种新的方式来将数据传输到图形卡以渲染图形。我们可以采用VBO，或者是在OpenGL3以上版本引入的新的特性，叫做VAO。通过它，我们可以把顶点数据和颜色存储在不同的VBO中，但是在同一个VAO中。对于法线数据
引擎设计跟踪(九.14.2d) [翻译] shader的跨平台方案之2014
weixin_30700977的博客
12-29 120
Origin:http://aras-p.info/blog/2014/03/28/cross-platform-shaders-in-2014/ 简译 translation: 作者在2012年写过一篇shader跨平台的文章, 开始提到了并有链接. 1.手写或者宏替换 使用宏定义将HLSL & GLSL 的不同之处封装, 并让每个开发人员了解他们的不同之处. 例子: ...
探索跨平台Shader系统的未来：pmfx-shader
gitblog_00043的博客
06-08 450
探索跨平台Shader系统的未来：pmfx-shader pmfx-shaderCross platform shader system for HLSL, GLSL, Metal and SPIR-V.项目地址:https://gitcode.com/gh_mirrors/pm/pmfx-shader 项目介绍 pmfx-shader是一个强大的跨平台着色器系统，支持多种GPU和渲染API的离...
探索跨平台着色器转换的利器：CrossShader
gitblog_00064的博客
05-26 426
探索跨平台着色器转换的利器：CrossShader CrossShader⚔️ A tool for cross compiling shaders. Convert between GLSL, HLSL, Metal Shader Language, or older versions of GLSL.项目地址:https://gitcode.com/gh_mirrors/cr/CrossSh...
OpenGL实现二维曲线图的交互操作
OpenGL是一种用于渲染二维和三维矢量图形的跨语言、跨平台的应用程序编程接口(API)。它被设计为高效地绘制复杂的三维场景，从简单的图形元素如点、线、多边形到复杂的模型都可以用OpenGL来绘制。本知识点重点在于...
在VS中实现OpenGL绘制二维自行车教程
OpenGL是一个跨语言、跨平台的编程接口，用于渲染2D和3D矢量图形。它是业界标准的图形库之一，广泛应用于计算机图形学领域。OpenGL提供了丰富的功能，可以帮助开发者实现复杂的图形绘制和渲染。在本例中，我们将重点...
Android 三维程序设计-基于OpenGL ES的图形应用程序设计
02-21
顶点是构成三维图形的点，顶点缓冲用来存储顶点数据，索引缓冲用来高效地引用顶点数据，纹理映射用于在三维模型上贴图，而着色器则是可以运行在GPU上的小程序，用于控制图形渲染过程中的各种计算。开发者需要编写...
OpenGL与VC++应用程序开发教程第二部分
OpenGL是一个跨语言、跨平台的应用程序编程接口（API），用于渲染2D和3D矢量图形。它是由近350个不同的函数调用组成，用以绘制复杂的三维场景，从简单的图形到复杂的图像。VC++（Visual C++）是微软公司推出的一种...
colormap-shaders集合：高效绘制颜色图的着色器工具
OpenGL（Open Graphics Library）是一个跨语言、跨平台的应用程序编程接口（API），用于渲染2D和3D矢量图形。它由Khronos Group维护，广泛应用于计算机图形领域。OpenGL允许开发者编写着色器代码，这些着色器使用...
实验一 OpenGL基本绘制 深大
m0_51779918的博客
09-18 1078
1.OpenGL的环境配置 2.在实验1.2的基础上，绘制二维图形 3不同的图形颜色效果 在其中使用现代OpenGL中的着色器，绘制多个简单的二维图形，形状内容不限，自己发挥。必须有：线、三角形、圆、椭圆、多边形，并且使用的颜色也要多样化
OPenGL--几何着色器的应用（多实例绘制）
先锋小牛
12-29 2751
简述 多实例渲染是一种连续执行多次相同的渲染命令的方法，并且每个渲染命令所产生的结果都会有轻微的差异。这是一种使用少量API来渲染大量几何体的有效方法。 当一个模型需要创建多个实例时，一般地可以在程序中循环调用glDrawArrays()函数完成多次绘制，这样，顶点着色器对每次输入的顶点运行一次，就会从内存中重复提取一次的数据，绘制多次相当于多次运行OPenGL整个管线。给GPU造成了潜在的处
pmfx-shader：跨平台着色器系统的强大工具
最新发布
gitblog_00922的博客
09-13 922
pmfx-shader：跨平台着色器系统的强大工具 pmfx-shader Cross platform shader system for HLSL, GLSL, Metal and SPIR-V. 项目地址: https://...
跨平台shader 编译
颇锐克
04-06 3399
（本文根据我博客上的文章跨平台shader编译的过去、现在和未来改写。知乎编辑器不支持多个级别的标题，以至于我只能用加粗不加粗来区分了。。。） 很多跨平台游戏引擎都有统一shader的需求。比如KlayGE从建立伊始，就强调一份代码跨多个平台，shader代码也不例外。如果需要对不同平台都分别写一遍shader，那样的工作量和可维护性都很糟糕。 既然有这样的需求，就必然会在技术上遇到一个问
Shader入门学习记录⑤——平台差异及语法规范
努力的博客
08-04 666
1. 渲染平台差异 考虑到Unity 其极强的跨平台性，大多时候Unity为我们隐藏实现了很多细节， 但是有时候还是需要我们自己处理他们。 因为OpenGL 和DirectX 的屏幕空间坐标的差异。在水平方向上，两者的数值变化方向是相同的，但是在竖直方向上，两者是相反的。在OpenGL 中，原点（0,0）对应了屏幕的左下角，而在DirectX 中，原点（0,0）对应了屏幕的左上角。 需要注意的是，我们不仅可以吧渲染结果输出到屏幕上，还可以输出到不同的渲染目标中。这时，我们需要使用渲染纹理来保存这些渲染结
Vertex Shader
热门推荐
MyArrow的专栏
07-25 1万+
一、Vertex Shader简介        前面一直有出现Vertex Shader，但Vertex Shader一直犹抱琵琶半遮面的感觉，本文将彻底揭开其面纱，看个清清楚楚、明明白折，以满足自己的好奇心。Vertex Shader在OpenGL ES 2.0的管道中的位置如下图所示：        本节将描述以下内容：        1）Vertex Shader的输入和输出
Shader学习建议
zjz
07-13 5974
作为一名从业六年的游戏开发人员，搭过框架也做过优化。但是对图形渲染这块不了解。而游戏中酷炫逼真的效果又是由shader来控制实现的。所以想要提高自己技能就必须啃下shader这个硬骨头。 以下提供本人学习shader的心路历程。由于每个人学习方式不同，所以下面建议不适应所有人。学习过程如下： 1.作为一名客户端开发人员，首先要会应用shader做出上级分配的任务才是优先级最高的事情。几乎所有游...
OpenGl4.3中切换shader中的子程序的方法
yyww322的博客
08-09 1440
OpenGL中subroutine的使用方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wayright

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值