标签: fragment-shader

我在片段着色器中有以下代码:

precision lowp float;

varying vec2 v_texCoord;
uniform sampler2D s_texture;

uniform bool color_tint;
uniform float color_tint_amount;
uniform vec4 color_tint_color;

void main(){
    float gradDistance;
    vec4 texColor, gradColor;
    texColor = texture2D(s_texture, v_texCoord);
    if (color_tint){
        gradColor = color_tint_color;
        gradColor.a = texColor.a;
        texColor = gradColor * color_tint_amount + texColor * (1.0 - color_tint_amount);
    }
    gl_FragColor = texColor;
}

代码工作正常,但有趣的是,即使color_tint我传入的所有内容都是错误的,上面的代码仍然会导致严重的性能拖累.比较时:

void main(){
    float gradDistance;
    vec4 texColor, gradColor;
    texColor = texture2D(s_texture, v_texCoord);
    if (false){
        gradColor = color_tint_color;
        gradColor.a = texColor.a;
        texColor = gradColor * …

我尝试在1个片段着色器中访问2个纹理.

为此我有2个纹理,我用以下代码设置:

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glVertexPointer(2, GL_FLOAT, 0, vbuff);
glTexCoordPointer(2, GL_FLOAT, 0, tbuff);

glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, texture0);
glEnable(GL_TEXTURE_2D);

glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, texture1); 
glEnable(GL_TEXTURE_2D);

我尝试将它们与以下片段着色器结合使用:

uniform sampler2D tex0;
uniform sampler2D tex1;
void main()
{
    vec4 texval1 = texture2D(tex0, TextureCoordOut);
    vec4 texval2 = texture2D(tex1, TextureCoordOut);
    gl_FragColor = 0.5*(texval1 + texval2)
}

不知何故,这不起作用,它只显示第二个纹理.

PS:我正在开发Windows7上的着色器,但是想在Android设备上使用C++代码和Android NDK上的着色器.

编辑:我得到它的工作,我在这里发布代码,以便其他人可以从中受益:

顶点着色器

varying vec2 TextureCoordOut;
void main()
{
    gl_Position = ftransform();
    TextureCoordOut = vec2(gl_MultiTexCoord0);
}

片段着色器

varying mediump vec2 TextureCoordOut;
uniform sampler2D tex0;
uniform sampler2D tex1;
void main()
{
    gl_FragColor = …

在阅读OpenGL SuperBible时,我在理解最基本(平面)着色器示例中的一行时遇到了一些问题.

在第6章,清单6.4和6.5中,它介绍了以下两个非常基本的着色器.

6.4 顶点着色器:

// Flat Shader
// Vertex Shader
// Richard S. Wright Jr.
// OpenGL SuperBible
#version 130

// Transformation Matrix
uniform mat4    mvpMatrix;

// Incoming per vertex
in vec4 vVertex;

void main(void) 
    { 
    // This is pretty much it, transform the geometry
    gl_Position = mvpMatrix * vVertex;
    }

6.5 片段着色器:

// Flat Shader
// Fragment Shader
// Richard S. Wright Jr.
// OpenGL SuperBible
#version 130

// Make geometry solid
uniform vec4 vColorValue;

// …

我正在使用GLSL着色器开发一个程序.我用2种不同的方法编写了两种不同的方法来计算ADS(环境+漫反射+镜面反射)着色.为了正确地完成工作,我使用子程序来使用一种或另一种方法来计算ADS着色.

这是一段片段着色器代码:

subroutine vec3 LightShadingEffectType(int idx, vec3 normal, vec3 lightDir);
subroutine uniform LightShadingEffectType LightShadingEffect;

subroutine (LightShadingEffectType)
vec3 Basic_ADS_Shading(int idx, vec3 normal, vec3 lightDir)
{
    vec3 reflectDir = reflect(-lightDir, normal);
    vec3 viewDir = normalize(-Position.xyz);

    vec3 Ambient = LightInfos[idx].La * MaterialInfos.Ka;
    vec3 Diffuse = LightInfos[idx].Ld * MaterialInfos.Kd * max(dot(lightDir, normal), 0.0f);
    vec3 Specular = LightInfos[idx].Ls * MaterialInfos.Ks * pow(max(dot(reflectDir, viewDir), 0.0f), MaterialInfos.Shininess);
    vec3 Emissive = MaterialInfos.Ke;

    return (Ambient + Diffuse + Specular + Emissive);
}

subroutine (LightShadingEffectType)
vec3 Phong_ADS_Shading(int idx, vec3 normal, …

使用Three.js,我编写了一个顶点着色器,根据渲染像素的屏幕的象限,为平面中的每个点着色.

// vertex shader
uniform float width;
uniform float height;
varying float x;
varying float y;
void main() 
{ 
    vec4 v = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
    x = v.x; 
    y = v.y;
    gl_Position = v;
}

// fragment shader
varying float x;
varying float y;
void main() 
{
    gl_FragColor = vec4(x, y, 0.0, 1.0);
}  

jsFiddle的实例:http://jsfiddle.net/Stemkoski/ST4aM/

我想修改这个着色器,使其x在屏幕左侧等于0,在屏幕右侧y等于1 ,同样在顶部等于0,在底部等于1.我(错误地)认为,这将涉及改变的值x,并y以x = v.x / width和y …

我创建了一个基于游戏模板的新项目,其中SceneKit作为游戏技术,Swift作为语言.我尝试使用自定义着色器.这是设置代码:

var material = SCNMaterial()
var program = SCNProgram()

// Read the vertex shader file and set its content as our vertex shader
if let vertexShaderPath = NSBundle.mainBundle().pathForResource("VertexShader", ofType:"vsh") {
    let vertexShaderAsAString = NSString(contentsOfFile: vertexShaderPath, encoding: NSUTF8StringEncoding, error: nil)
    program.vertexShader = vertexShaderAsAString
}

// Read the fragment shader file and set its content as our fragment shader
if let fragmentShaderPath = NSBundle.mainBundle().pathForResource("FragmentShader", ofType:"fsh") {
    let fragmentShaderAsAString = NSString(contentsOfFile: fragmentShaderPath, encoding: NSUTF8StringEncoding, error: nil)
    program.fragmentShader = fragmentShaderAsAString
}

// Give a …

我知道如果某个uniform变量没有主动为管道输出做出贡献,那么它会被优化并返回-1.考虑下面的片段着色器.

const char fShader[] =  "precision mediump float;                                               \n"

    "uniform float  uGlobalTime;                                            \n"

    "const int iMaxIterations = 6;                                          \n"
    "float fCircleSize = 1.0 / (3.0 * pow(2.0, float(iMaxIterations)));     \n"

    "vec2 Rotate(vec2 uv, float a)                                          \n"
    "{                                                                      \n"
        "return vec2(uv.x * cos(a) - uv.y * sin(a), uv.y * cos(a) + uv.x * sin(a));  \n"
    "}                                                                      \n";


    "void main()                                                    \n"
    "{                                                              \n"
        "vec2 uv = vec2(1280.0, 720.0);                                             \n"
        "uv = -0.5 * (uv - 2.0 * gl_FragCoord.xy) / uv.x;           \n" …

我真的不明白片段着色器是如何工作的.

我知道

• 顶点着色器每个顶点运行一次
• 片段着色器每个片段运行一次

由于片段着色器每个顶点不起作用,但每个片段如何将数据发送到片段着色器？顶点数量和碎片数量不相等.

如何确定哪个片段属于哪个顶点？

几个星期以来，我在著名的http://learnopengl.com上学习OpenGL，并且对组织多种材料（着色器）有疑问。在本教程中，将使用Shader类，该类将从vert / frag着色器列表中构成Shader程序：

Shader shader("vert.glsl", "frag.glsl");

之后，为着色器创建制服：

    glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
    glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
etc.

最后，我们收到一个Shader程序。在这种情况下，如何制作多个着色器？我尝试使：

Shader shader("vertDiff.glsl", "fragDiff.glsl");
Shader shaderGlass ("vertGlass.glsl", "fragGlass.glsl");
Shader shaderLight("vertLight.glsl", "fragLight.glsl")

之后，我为每个着色器制作.glsl的制服：

glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(glGetUniformLocation(shaderGlass.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));

但是阴影无法正常工作。每个着色器需要声明几次相同的制服，这会使程序不正确。如何正确制作这部分？谢谢你，很抱歉我的愚蠢问题。

我试图在webgl中编写一个简单的高斯模糊着色器。我已经对此进行了很多搜索，我想我理解它背后的想法。给定这个3X3内核。如何将其应用于我的顶点着色器？

这是我目前的输出

[ 0.0625  0.125  0.0625 ]
[ 0.125   0.25   0.125  ]
[ 0.0625  0.125  0.0625 ]

特别是如何获取相邻像素？

这种逻辑甚至有意义吗？

precision mediump float;
varying vec2 vUV;

uniform sampler2D uTexture;

void main(){
     gl_FragColor = texture2D(uTexture, vUV + vec2(????,????)*0.0625;


}

我应该在上面的vec2（）中放什么？说如果我想获得内核的左上角纹理值。假设我应该写vUv为（20,20）以获得（19,19）

     gl_FragColor = vec4(0.0);
     gl_FragColor += texture2D(uTexture, vUV  +  vec2(vUV.x-1.0,vUV.y-1.0))*0.0625;
     gl_FragColor += texture2D(uTexture, vUV + vec2(vUV.x,vUV.y-1.0))*0.125;    
     gl_FragColor += texture2D(uTexture, vUV + vec2(vUV.x+1.0,vUV.y-1.0))*0.0625;

     gl_FragColor += texture2D(uTexture, vUV  +  vec2(vUV.x-1.0,vUV.y))*0.125;
     gl_FragColor += texture2D(uTexture, vUV + vec2(vUV.x,vUV.y))*0.25; 
     gl_FragColor += texture2D(uTexture, vUV …