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

最新推荐文章于 2024-05-26 09:46:48 发布
最新推荐文章于 2024-05-26 09:46:48 发布
阅读量431 收藏 1
点赞数 1
分类专栏： 二维绘图 文章标签： opengl android gpu gles
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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.csdn.net/hb707934728/article/details/71486631?locationNum=4&fps=1

主要做的改动：

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

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

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



wayright
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
unity Shader 入门精要 EX
xinghaikongmeng的博客
10-19 4327
1、shader概念 Shader，中文名为着色器。 Shader其实就是专门用来渲染图形的一种技术，通过shader，我们可以自定义显卡渲染画面的算法，使画面达到我们想要的效果。 2、shader分类 Shader分为两类 ： 顶点Shader（3D图形都是由一个个三角面片组成的，顶点Shader就是计算每个三角面片上的顶点，并为最终像素渲染做准备）。 像素Shader，顾名思义，就是以像素为单位，计算光照、颜色的一系列算法。 几个不同的图形API都有各自的Shader语言 在DirectX中，顶点sha
OpenGL学习笔记：2、OpenGL简介
weixin_44546625的博客
11-02 1756
OpenGL（全称：Open Graphics Library，译名：开放图形库或者“开放式图形库”）是用于渲染2D、3D矢量图形的跨语言、跨平台的一种应用程序编程接口（API）。一种可以对图形硬件设备特性进行访问的软件库，也就是一种是个专业的图形程序接口，是一个功能强大，调用方便的底层图形库。包含了超过500个不同函数调用，可以用于设置所需对象、图像、操作。总的来说，OpenGL就是一个开放的图形应用编程接口，有一堆函数组成，以实现对于图形应用程序的开发。
条件着色图 (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 682
一、VAO、VBO介绍 随着OpenGL状态和固定管线模式的移除，我们不在用任何glEnable函数调用，而且也不会有glVertex、glColor等函数调用。这就意味着我们需要一种新的方式来将数据传输到图形卡以渲染图形。我们可以采用VBO，或者是在OpenGL3以上版本引入的新的特性，叫做VAO。通过它，我们可以把顶点数据和颜色存储在不同的VBO中，但是在同一个VAO中。对于法线数据
引擎设计跟踪(九.14.2d) [翻译] shader的跨平台方案之2014
weixin_30700977的博客
12-29 89
Origin:http://aras-p.info/blog/2014/03/28/cross-platform-shaders-in-2014/ 简译 translation: 作者在2012年写过一篇shader跨平台的文章, 开始提到了并有链接. 1.手写或者宏替换 使用宏定义将HLSL & GLSL 的不同之处封装, 并让每个开发人员了解他们的不同之处. 例子: ...
探索跨平台着色器转换的利器：CrossShader
最新发布
gitblog_00064的博客
05-26 328
探索跨平台着色器转换的利器：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基本绘制 深大
m0_51779918的博客
09-18 978
1.OpenGL的环境配置 2.在实验1.2的基础上，绘制二维图形 3不同的图形颜色效果 在其中使用现代OpenGL中的着色器，绘制多个简单的二维图形，形状内容不限，自己发挥。必须有：线、三角形、圆、椭圆、多边形，并且使用的颜色也要多样化
Android 三维程序设计-基于OpenGL ES的图形应用程序设计
02-21
顶点是构成三维图形的点，顶点缓冲用来存储顶点数据，索引缓冲用来高效地引用顶点数据，纹理映射用于在三维模型上贴图，而着色器则是可以运行在GPU上的小程序，用于控制图形渲染过程中的各种计算。开发者需要编写...
OpenGL.rar_opengl 三维软件
09-21
OpenGL是计算机图形学领域广泛应用的一种跨语言、跨平台的编程接口，它允许程序员直接控制显卡硬件进行高性能的三维图形渲染。本资源“OpenGL.rar”包含了一份关于OpenGL的详细帮助文档，特别适用于C++环境下的三维...
OpenGL学习（二）渲染流水线与三角形绘制
AKGWSB 's blog
11-22 3304
目录前言渲染流水线顶点与图元光栅化着色器渲染流水线小结向GPU传递数据vbovao开始绘制三角形使用GLuint进行对象引用加载着色器程序编写init函数着色器代码编写顶点着色器片元着色器编写display函数完整c++代码代码运行结果总结 前言 上一篇回顾：OpenGL学习（一） freeglut / GLEW 环境搭建与窗口创建 在上一篇博客中我们实现了环境的配置，但是我们只创建了白色的窗口，并未绘制任何图形，于是今天我们来绘制最基本的图形 ---- 三角形。 在开始之前，我们必须首先了解OpenGL的
opengles实现画中画功能
hb707934728的博客
05-11 1854
实现画中画的关键步骤 //画中画功能实现 glBindTexture(GL_TEXTURE_2D, _texDynamic); //从帧缓存区GL_READ_BUFFER读取一块像素矩形,并替换一个现有的纹理数组的一部分或全部. //本例中替换 _texDynamic表示的纹理,从而实现了画中画的功能 glCopyTexSubImage2D(GL_TEXTU
OPenGL--几何着色器的应用（多实例绘制）
先锋小牛
12-29 2608
简述 多实例渲染是一种连续执行多次相同的渲染命令的方法，并且每个渲染命令所产生的结果都会有轻微的差异。这是一种使用少量API来渲染大量几何体的有效方法。 当一个模型需要创建多个实例时，一般地可以在程序中循环调用glDrawArrays()函数完成多次绘制，这样，顶点着色器对每次输入的顶点运行一次，就会从内存中重复提取一次的数据，绘制多次相当于多次运行OPenGL整个管线。给GPU造成了潜在的处
RHI_Shader Compare(HLSL、GLSL、MSL 、WGSL、OpenCL) & Debug All
qq_35312463的博客
12-31 1967
常用着色器用法对比与着色器调试工具介绍
跨平台shader 编译
颇锐克
04-06 3242
（本文根据我博客上的文章跨平台shader编译的过去、现在和未来改写。知乎编辑器不支持多个级别的标题，以至于我只能用加粗不加粗来区分了。。。） 很多跨平台游戏引擎都有统一shader的需求。比如KlayGE从建立伊始，就强调一份代码跨多个平台，shader代码也不例外。如果需要对不同平台都分别写一遍shader，那样的工作量和可维护性都很糟糕。 既然有这样的需求，就必然会在技术上遇到一个问
OpenGL ES 学习教程(二) 可编程管线，Shader，一个彩色三角形！
Hello Captain
11-30 2699
顶点程序、片元程序字样，就是说，这两个过程是可编程的，要我们自己写代码去控制。 顶点程序就是常说的 顶点 Shader ，后缀一般是vsh ， 片元程序 就是常说的 片段Shader，后缀一般是 fsh 。
Opengl es2.0 学习笔记（三）shader的使用
weixin_30247159的博客
11-15 344
文章目录一.shader二.API三.调用说明四.撸代码 一.shader Opengl es渲染管线中有两处可以编程，一个是顶点着色器 一个是像素着色器/片圆着色器 不清楚的可以 看看OpenGLes 渲染管线 二.API //创建shader,返回shader Id //param: //GL_VERTEX_SHADER 定点shader /...
切换到shader模式
子扉居
09-28 968
在OpenGL整个程序的初始化阶段（一般是init()函数），做以下工作。 1、顶点着色程序的源代码和片段作色程序的源代码要分别保存到一个字符数组里面； 2、使用glCreateshader()分别创建一个顶点着色器对象和一个片段着色器对象； 3、使用glShad
shader实现二维CT图像效果
八块腹肌的博客
10-29 939
        首先需要根据医院提供的数据生成Texture3D,然后在shader中使用内置函数tex3D进行3D纹理采样，最后通过lightCT封装的算法过滤颜色通道，只取单个通道。shader代码如下，效果如图。 Shader "Custom/CT" {     Properties     {         _Volume ("Texture3D", 3D) = "" {}     ...
八、WebGL入门，纹理贴图
a23366192007的博客
04-27 8139
本节我们来讲WebGL里面很重要的纹理 纹理贴图在游戏开发中十分常见，但是纹理不单单只是一张贴图那么简单。 在WebGL中，纹理有多种，一维纹理：就是一条线；二维纹理：一张二维图片；二维纹理数组：由多张二维图片组成；还有三维纹理，立体纹理，本节主要介绍二维纹理 在早期的OpenGL中，只支持图片大小为2^n的纹理，但现在支持，但是最好用大小为2^n的纹理，这样效率会比较高 先看
CAD三维制图：入门教程——着色与消隐技巧
"着色与消隐是CAD三维制图中的重要技术，它能够帮助用户更好地理解和观察复杂的三维模型。本课程分为课前导读、课堂讲解和实践环节，旨在教授初学者如何处理和编辑三维模型。 课前导言部分，首先介绍基础知识，涵盖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wayright

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

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

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

打赏作者

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

抵扣说明：

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

余额充值