基于cocos2dx 2.x做的一些shader效果Demo

最新推荐文章于 2020-12-22 23:13:40 发布
最新推荐文章于 2020-12-22 23:13:40 发布
阅读量483 收藏
点赞数

适合：

1：想初步学习shader的同学可以了解下。
2：想用cocos2dx做点效果的同学可以了解下。
请直接下载当前页面附件的rar包就可以了。

如果需要直接运行程序的可以到百度盘下载：http://pan.baidu.com/s/1jGoRCmM

http://pan.baidu.com/s/1u9jEA




代码预览：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //--------------------------------------------------------  
  2. // 模糊效果  
  3. static const GLchar* s_szBlurFSH =  
  4.     "                                                               \n\  
  5.     precision mediump float;                                        \n\  
  6.     uniform sampler2D u_Texture;                                    \n\  
  7.     uniform vec2 u_TextureCoordOffset[25];                          \n\  
  8.     varying vec2 v_texCoord;                                        \n\  
  9.     varying vec4 v_fragmentColor;                                   \n\  
  10.                                                                     \n\  
  11.     void main(void)                                                 \n\  
  12.     {                                                               \n\  
  13.         vec4 sample[25];                                                \n\  
  14.                                                                         \n\  
  15.         for (int i = 0; i < 25; i++)                                 \n\  
  16.         {                                                               \n\  
  17.         sample[i] = texture2D(u_Texture,                                \n\  
  18.         v_texCoord.st + u_TextureCoordOffset[i]);                       \n\  
  19.         }                                                               \n\  
  20.         //--------------------------------------------------------      \n\  
  21.         //   1 3 1                                                      \n\  
  22.         //   3 1 3   / 11                                               \n\  
  23.         //   1 3 1                                                      \n\  
  24.                                                                         \n\  
  25.         //gl_FragColor = (sample[0] + (3.0*sample[1]) + sample[2] +     \n\  
  26.         //  (3.0*sample[3]) + sample[4] + (3.0*sample[5]) +             \n\  
  27.         //  sample[6] + (3.0*sample[7]) + sample[8]) / 11.0;            \n\  
  28.         //--------------------------------------------------------      \n\  
  29.         // Gaussian weighting:                                          \n\  
  30.         // 1  4  7  4 1                                                 \n\  
  31.         // 4 16 26 16 4                                                 \n\  
  32.         // 7 26 41 26 7 / 273 (i.e. divide by total of weightings)      \n\  
  33.         // 4 16 26 16 4                                                 \n\  
  34.         // 1  4  7  4 1                                                 \n\  
  35.                                                                         \n\  
  36.         gl_FragColor = (                                                \n\  
  37.         (1.0  * (sample[0] + sample[4]  + sample[20] + sample[24])) +   \n\  
  38.         (4.0  * (sample[1] + sample[3]  + sample[5]  + sample[9] +      \n\  
  39.             sample[15] + sample[19] + sample[21] + sample[23])) +       \n\  
  40.         (7.0  * (sample[2] + sample[10] + sample[14] + sample[22])) +   \n\  
  41.         (16.0 * (sample[6] + sample[8]  + sample[16] + sample[18])) +   \n\  
  42.         (26.0 * (sample[7] + sample[11] + sample[13] + sample[17])) +   \n\  
  43.         (41.0 * sample[12])                                             \n\  
  44.         ) / 273.0;                                                      \n\  
  45.     }";  
  46. //--------------------------------------------------------  
  47. // 磨砂  
  48. static const GLchar* s_szSharpenFSH =  
  49.     "                                                               \n\  
  50.     precision mediump float;                                        \n\  
  51.     uniform sampler2D u_Texture;                                    \n\  
  52.     uniform vec2 u_TextureCoordOffset[25];                          \n\  
  53.     varying vec2 v_texCoord;                                        \n\  
  54.     varying vec4 v_fragmentColor;                                   \n\  
  55.                                                                     \n\  
  56.     void main(void)                                                 \n\  
  57.     {                                                               \n\  
  58.         vec4 sample[25];                                            \n\  
  59.                                                                     \n\  
  60.         for (int i = 0; i < 25; i++)                             \n\  
  61.         {                                                           \n\  
  62.             sample[i] = texture2D(u_Texture,                        \n\  
  63.                 v_texCoord.st + u_TextureCoordOffset[i]);           \n\  
  64.         }                                                           \n\  
  65.         //--------------------------------------------------------  \n\  
  66.         //   -1 -1 -1                                               \n\  
  67.         //   -1  9 -1                                               \n\  
  68.         //   -1 -1 -1                                               \n\  
  69.                                                                     \n\  
  70.         //gl_FragColor = (sample[4] * 9.0) -                        \n\  
  71.         //  (sample[0] + sample[1] + sample[2] +                    \n\  
  72.         //  sample[3] + sample[5] +                                 \n\  
  73.         //  sample[6] + sample[7] + sample[8]);                     \n\  
  74.         //--------------------------------------------------------  \n\  
  75.         // Sharpen weighting:                                       \n\  
  76.         //  0 -1 -1 -1  0                                           \n\  
  77.         // -1  2 -4  2 -1                                           \n\  
  78.         // -1 -4 13 -4 -1                                           \n\  
  79.         // -1  2 -4  2 -1                                           \n\  
  80.         //  0 -1 -1 -1  0                                           \n\  
  81.                                                                     \n\  
  82.         //gl_FragColor = (                                          \n\  
  83.         //(-1.0  * ( sample[1] + sample[2]  + sample[3] + sample[5] +   \n\  
  84.         //sample[9] + sample[10] + sample[14] + sample[15] +            \n\  
  85.         //sample[19] + sample[21] + sample[22] + sample[23]) ) +        \n\  
  86.         //(2.0 * (sample[6] + sample[8] + sample[16] + sample[18])) +   \n\  
  87.         //(-4.0 *(sample[7] + sample[11] + sample[13] + sample[17]))+   \n\  
  88.         //( 13.0 * sample[12] )                                     \n\  
  89.         //);                                                            \n\  
  90.                                                                                         \n\  
  91.         // 1  1  1  1  1                                                                \n\  
  92.         // 1  1  1  1  1                                                                \n\  
  93.         // 1  1 -14 1  1                                                                \n\  
  94.         // 1  1  1  1  1                                                                \n\  
  95.         // 1  1  1  1  1                                                                \n\  
  96.                                                                                         \n\  
  97.         gl_FragColor = -14.0 * sample[12];                                              \n\  
  98.                                                                                         \n\  
  99.         for (int i = 0; i < 25; i++)                                                 \n\  
  100.         {                                                                               \n\  
  101.         if (i != 12)                                                                    \n\  
  102.         gl_FragColor += sample[i];                                                      \n\  
  103.         }                                                                               \n\  
  104.         gl_FragColor /= 14.0;                                                           \n\  
  105.     }";  
  106. //--------------------------------------------------------           
  107. // 膨胀  
  108. static const GLchar* s_szDilateFSH =  
  109.     "                                                               \n\  
  110.     precision mediump float;                                        \n\  
  111.     uniform sampler2D u_Texture;                                    \n\  
  112.     uniform vec2 u_TextureCoordOffset[25];                          \n\  
  113.     varying vec2 v_texCoord;                                        \n\  
  114.     varying vec4 v_fragmentColor;                                   \n\  
  115.                                                                     \n\  
  116.     void main(void)                                                 \n\  
  117.     {                                                               \n\  
  118.     vec4 sample[25];                                                \n\  
  119.     vec4 maxValue = vec4(0.0);                                                          \n\  
  120.                                                                                         \n\  
  121.     for (int i = 0; i < 25; i++)                                                     \n\  
  122.     {                                                                                   \n\  
  123.         // Sample a grid around and including our texel                                 \n\  
  124.         sample[i] = texture2D(u_Texture, v_texCoord.st + u_TextureCoordOffset[i]);      \n\  
  125.         // Keep the maximum value                                                       \n\  
  126.         maxValue = max(sample[i], maxValue);                                            \n\  
  127.     }                                                                                   \n\  
  128.                                                                                         \n\  
  129.     gl_FragColor = maxValue;                                                            \n\  
  130.     }";   
  131. //--------------------------------------------------------    
  132. // 侵蚀效果  
  133. static const GLchar* s_szErodeFSH =  
  134.     "                                                               \n\  
  135.     precision mediump float;                                        \n\  
  136.     uniform sampler2D u_Texture;                                    \n\  
  137.     uniform vec2 u_TextureCoordOffset[25];                          \n\  
  138.     varying vec2 v_texCoord;                                        \n\  
  139.     varying vec4 v_fragmentColor;                                   \n\  
  140.                                                                     \n\  
  141.     void main(void)                                                 \n\  
  142.     {                                                               \n\  
  143.     vec4 sample[25];                                                                \n\  
  144.     vec4 minValue = vec4(1.0);                                                      \n\  
  145.                                                                                     \n\  
  146.     for (int i = 0; i < 25; i++)                                                 \n\  
  147.     {                                                                               \n\  
  148.         // Sample a grid around and including our texel                             \n\  
  149.         sample[i] = texture2D(u_Texture, v_texCoord.st + u_TextureCoordOffset[i]);  \n\  
  150.         // Keep the minimum value                                                   \n\  
  151.         minValue = min(sample[i], minValue);                                        \n\  
  152.     }                                                                               \n\  
  153.                                                                                     \n\  
  154.     gl_FragColor = minValue;                                                        \n\  
  155.     }";   
  156. //--------------------------------------------------------  
  157. // Laplacian描边效果   
  158. static const GLchar* s_szLaplacianEdgeDetectionFSH =  
  159.     "                                                               \n\  
  160.     precision mediump float;                                        \n\  
  161.     uniform sampler2D u_Texture;                                    \n\  
  162.     uniform vec2 u_TextureCoordOffset[25];                          \n\  
  163.     varying vec2 v_texCoord;                                        \n\  
  164.     varying vec4 v_fragmentColor;                                   \n\  
  165.                                                                     \n\  
  166.     void main(void)                                                 \n\  
  167.     {                                                               \n\  
  168.     vec4 sample[25];                                                                \n\  
  169.                                                                                     \n\  
  170.     for (int i = 0; i < 25; i++)                                                 \n\  
  171.     {                                                                               \n\  
  172.         // Sample a grid around and including our texel                             \n\  
  173.         sample[i] = texture2D(u_Texture, v_texCoord.st + u_TextureCoordOffset[i]);  \n\  
  174.     }                                                                               \n\  
  175.                                                                                     \n\  
  176.     // Laplacian weighting:                                                         \n\  
  177.     // -1 -1 -1 -1 -1                                                               \n\  
  178.     // -1 -1 -1 -1 -1                                                               \n\  
  179.     // -1 -1 24 -1 -1                                                               \n\  
  180.     // -1 -1 -1 -1 -1                                                               \n\  
  181.     // -1 -1 -1 -1 -1                                                               \n\  
  182.                                                                                     \n\  
  183.     gl_FragColor = 24.0 * sample[12];                                               \n\  
  184.                                                                                     \n\  
  185.     for (int i = 0; i < 25; i++)                                                 \n\  
  186.     {                                                                               \n\  
  187.         if (i != 12)                                                                \n\  
  188.             gl_FragColor -= sample[i];                                              \n\  
  189.     }                                                                               \n\  
  190.     }";  
  191. //--------------------------------------------------------  
  192. // Sobel边缘检测  
  193. static const GLchar* s_szSobelEdgeDetectionFSH =  
  194.     "                                                                   \n\  
  195.     precision mediump float;                                            \n\  
  196.     uniform sampler2D u_Texture;                                        \n\  
  197.     uniform vec2 u_TextureCoordOffset[25];                              \n\  
  198.     varying vec2 v_texCoord;                                            \n\  
  199.     varying vec4 v_fragmentColor;                                       \n\  
  200.                                                                         \n\  
  201.     void main(void)                                                     \n\  
  202.     {                                                                   \n\  
  203.         vec4 sample[25];                                                \n\  
  204.                                                                         \n\  
  205.         for (int i = 0; i < 25; i++)                                 \n\  
  206.         {                                                               \n\  
  207.         sample[i] = texture2D(u_Texture,                                \n\  
  208.         v_texCoord.st + u_TextureCoordOffset[i]);                       \n\  
  209.         }                                                               \n\  
  210.         // Sobel x:                                                     \n\  
  211.         // 1  2  0 -2 -1                                                \n\  
  212.         // 4  8  0 -8 -4                                                \n\  
  213.         // 6 12  0 -12-6    / 12                                        \n\  
  214.         // 4  8  0 -8 -4                                                \n\  
  215.         // 1  2  0 -2 -1                                                \n\  
  216.         // Sobel y:                                                     \n\  
  217.         // -1 -4 -6 -4 -1                                               \n\  
  218.         // -2 -8 -12-8 -2                                               \n\  
  219.         //  0  0  0  0  0   / 12                                        \n\  
  220.         //  2  8 12  8  2                                               \n\  
  221.         //  1  4  6  4  1                                               \n\  
  222.                                                                         \n\  
  223.         vec4 vertEdge = sample[0] + 4.0 * sample[1] +                   \n\  
  224.         6.0 * sample[2] + 4.0 * sample[3] + sample[4] +                 \n\  
  225.         2.0 * sample[5] + 8.0 * sample[6] + 12.0 * sample[7] +          \n\  
  226.         8.0 * sample[8] + 2.0 * sample[9] - 2.0 * sample[15] -          \n\  
  227.         8.0 * sample[16] - 12.0 * sample[17] - 8.0 * sample[18] -       \n\  
  228.         2.0 * sample[19] - sample[20] - 4.0 * sample[21] -              \n\  
  229.         6.0 * sample[22] - 4.0 * sample[23] - sample[24];               \n\  
  230.                                                                         \n\  
  231.         vec4 horizEdge = - sample[0] - 2.0 * sample[1] +                \n\  
  232.         2.0 * sample[3] + sample[4] - 4.0 * sample[5] -                 \n\  
  233.         8.0 * sample[6] + 8.0 * sample[8] + 4.0 * sample[9] -           \n\  
  234.         6.0 * sample[10] - 12.0 * sample[11] + 12.0 * sample[13] +      \n\  
  235.         6.0 * sample[14] - 4.0 * sample[15] - 8.0 * sample[16] +        \n\  
  236.         8.0 * sample[18] + 4.0 * sample[19] - sample[20] -              \n\  
  237.         2.0 * sample[21] + 2.0 * sample[23] + sample[24];               \n\  
  238.                                                                         \n\  
  239.         //gl_FragColor.rgb = sqrt(horizEdge.rgb) + sqrt(vertEdge.rgb);  \n\  
  240.         gl_FragColor.rgb = sqrt((horizEdge.rgb * horizEdge.rgb) +       \n\  
  241.             (vertEdge.rgb * vertEdge.rgb)) / 12.0f;                     \n\  
  242.         gl_FragColor.a = 1.0;                                           \n\  
  243.     }";  
  244. //--------------------------------------------------------  
原文地址： http://www.oschina.net/code/piece_full?code=38156&piece=56414#56414
游戏编程初学者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cocos shader demo 演示
02-14
cocos shader demo 演示,里面有多个sharder 特效粒子，可参考
CocosCreator v2.1.2 Shader使用demo
08-23
CocosCreator v2.1.2版本Effect、Material使用demo，包含5个效果 扫光、圆、颜色替换、溶解、小草。
cocos2dx shader
一个字
11-06 543
在测试过程中，发现shader如果有错误，那么在material创建的时候就会报错。这是检查shader的一个好方法，但是不会告诉具体哪个条出错。         在cocos2dx中，u_color要用，但是什么作用不太清楚，以后要弄明白。所以现在的shader中，我只是把它乘给某个变量。
cocos2dx3.x_shader
07-14
cocos2dx3.x_shader仅供学习
cocos2dx3.x游戏开发之旅电子版
12-26
《Cocos2d-x 3.x游戏开发之旅》是一本深度探讨Cocos2dx 3.x框架的游戏开发专著，适合对游戏编程有兴趣并有一定基础的开发者。Cocos2dx是一个开源的游戏开发框架，它基于C++，同时支持多种语言，如Lua和JavaScript，...
基于Cocos2dX-3.X版本开发的塔防游戏源码+项目说明（还原经典塔防《KingdomRush》）.zip
最新发布
02-28
基于Cocos2dX-3.X版本开发的塔防游戏源码+项目说明（还原经典塔防《KingdomRush》）.zip 1、该资源内项目代码经过严格调试，下载即用确保可以运行！ 2、该资源适合计算机相关专业(如计科、人工智能、大数据、数学、...
[cocos2d-x] 《我所理解的Cocos2d-x》上机实验2-动态设置着色器参数
FiveKM的博客
04-10 327
第四章 8.2.2动态设置着色器参数 这个例子看得时候很流畅，本以为会很容易调通。结果发现参数总是传不进去，卡了很久。最后请教了一位很有经验的同事，才找到问题所在。还是看实际代码介绍吧。 顶点着色器： dynamic_shader.vert attribute vec4 a_position; attribute vec4 a_color; uniform vec3 u_cente...
cocos2dx uv动画溢出_cocos2dx 编写shader 遇到 溢出问题
weixin_39953618的博客
12-22 162
在 编程语言中，不论什么 数据类型 都有 各种 的 局限，无法 表示 现实世界中的 不论什么 情况。 比如 int ,char 会 溢出，float 会 有 溢出 以及 精度 不准确的 情况。所以 我们 在 开发 中 须要 特别 注意 这些事。近期 须要 在 cocos2dx(2.1.4) 引擎下 用 shader 做一些 效果。遇到 一些 在 windows 上 没有问题，可是 移植到 andr...
cocos2dx替换颜色shader（把紫色替换成灰色）
01-14
一个替换紫色为灰色的shader，也可以改成别的颜色，新手学习用吧
cocos来实现液体流动效果.zip
05-29
cocos实现液体流动的思路！具体可以研究下
cocos2dx C++ 横向2d水波浪效果,连续波浪
10-30
使用 cocos2dx 的 drawnode 绘制水波浪效果代码，在游戏开发中需要用到，网上找了很久没有找到，自己写了一个，drawnode 绘制节点绘制，用到了 sin ，封装了一个水浪效果层, 但用一个小问题就是边缘有点锯齿. 待后续更新。游戏开发完后补上.
cocos2dx-shaders:Cocos2d-X 的着色器示例
07-15
cocos2dx 着色器
Cocos2dx特效 水纹特效1
Dionysos_lai的专栏
05-15 4294
Cocos2dx特效水纹特效1 DionysosLai 2014-5-15        判断一个小游戏是否能够很好的吸引人，除了游戏本身的核心玩法吸引人之外。很多时候，是要靠一些小细节来体现。比方说一个打枪类游戏,玩家随便朝四周射击，子弹打到墙壁上面。玩家的随意操作，其实都包含着一种期望的心里。如果游戏能给出子弹打到墙壁的效果，比方说音效、弹痕等，玩家的心里得到满足，自然而然就对游戏的评价更
cocos2dx Shader的使用
afei198409的专栏
01-27 1197
资料来自网络收集 着色器 着色器(shader)应用于计算机图形学领域,指一组供计算机图形资源在执行渲染任务时使用的指令.程序员将着色器应用于图形处理(GPU)的可编程流水线,来实现三维应用程序.这样的图形处理器有别于传统的固定流水线处理器,为GPU编程带来更高的灵活性和适应性. opengl es的着色器有.vsh和.fsh两个文件.这两文件在被编译和链接后就可以产生可执行程序与GPU交互
cocos2dx之如何实现视差效果
Lampard的博客
02-28 496
cocos2dx之实现视差效果 大家好，我是Lampard 今天与大家探讨一下简单的实现视差效果 首先什么是视差效果？ 视差效果是游戏中非常流行的一种效果，在视差效果中，前景的速度移动得比较快，后景的视差移动得比较慢，从而造成立 体感和运动错觉。什么？没听懂？简单来说就...
7. cocos-2dx Shader(三) 实例应用
中苑
05-20 173
Mark～　 HSV and HLS color systems are problematic for a number of reasons. I talked with a color scientist about this recently, and his recommendation was to convert to YIQ or YCbCr space and adjust...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值