标签: fragment-shader

我正在尝试在Unity中创建线框顶点/片段着色器.根据这篇论文,似乎有可能.一般的想法似乎是您将在顶点着色器中计算的距离向量传递给片段着色器中的每个片段,它可以用来根据多边形中的位置确定绘制线框线的亮度.

但是,从我读过的其他内容来看,您似乎只能访问顶点着色器中的单个顶点.我需要访问多边形中的所有相邻顶点以获得ecah顶点.该论文似乎暗示几何着色器不是必需的,这很好,因为Unity还不支持它们.

我错过了什么？是否永远不可能访问顶点着色器中的相邻顶点？没有几何着色器,我正在尝试做什么？

我正在使用OpenGL ES 2.0 GLSL功能来处理图像。我要实现的是从片段着色器中的纹理中获取样本时选择特定的细节级别（LOD）。显然texture2DLod()，OpenGL ES 2.0中的片段着色器不支持此功能（但GL_EXT_shader_texture_lod可以选择提供扩展名。）

但是，默认texture2D()功能提供了第三个可选参数偏差。据我了解，该参数应该是添加到当前LOD的偏移量。

在测试中，我绘制的是屏幕大小的四分之一，并且通过缩放样本坐标来放大纹理。我已使用GL_LINEAR_MIPMAP_LINEAR作为缩小过滤器为纹理启用了mipmapping。下图显示了在ARM Mali-400 GPU上使用非零偏差参数进行采样时的结果。

根据ISTM，某些像素使用缩小滤镜，而其他像素则使用放大滤镜。

如何控制？以及在使用偏置时如何确定初始LOD？可以从顶点着色器进行调整吗？

一个相关的问题是以下问题：

GLSL采样器如何确定纹理的缩小程度，从而确定纹理的mipmap级别？

更新：我注意到，如果我对纹理进行采样以使其覆盖屏幕，那么它似乎可以进行正确的mipmap查找（即使已放大）。现在，如果我向采样坐标添加一个小的偏移量，则我将开始看到在上图中看到的条带（甚至进一步放大了）。如果不使用bias参数，则根本看不到任何条带。

我正在尝试渲染一个混合了全透明像素和完全不透明像素的纹理.看起来我唯一的选择就是将它们从后向前渲染(在所有完全不透明的多边形之后),因为即使是完全透明的像素也会更新深度缓冲区,但我不确定它是否准确.是吗？

似乎片段着色器可以被告知单独留下深度缓冲区用于透明像素,但显然不是.我错过了什么吗？

还有其他一些明智的方法来渲染高度不规则形状的图像,而不是我想不到的许多多边形吗？

我有另一个OpenGL ES驱动程序错误.这次我正在尝试编译以下行:

precision mediump float; 
varying highp vec2 textureCoordinate; 


void main() { 
 highp vec4 color = texture2D(input0, textureCoordinate); 


vec3 color3 = color.rgb;

vec2 tc = (2.0 * textureCoordinate) - 1.0;
float d = dot(tc, tc);
vec2 lookup = vec2(d, color3.r);

..   
..
}

但是我正在接受这条线:

GLES20.glLinkProgram(program);

本机崩溃:"致命信号11(SIGDEV)在0x00000060(代码= 1),线程1231"我猜它发生是因为LG nexus 4使用GPU Adreno,它也在我崩溃,错误代码14在另一个崩溃 - 使用太多宏.

我有一个像这样实现阴影贴图的着色器:

#version 430 core

out vec4 color;

in VS_OUT {
    vec3 N;
    vec3 L;
    vec3 V;
    vec4 shadow_coord;
} fs_in;

layout(binding = 0) uniform sampler2DShadow shadow_tex;

uniform vec3 light_ambient_albedo = vec3(1.0);
uniform vec3 light_diffuse_albedo = vec3(1.0);
uniform vec3 light_specular_albedo = vec3(1.0);

uniform vec3 ambient_albedo = vec3(0.1, 0.1, 0.2);
uniform vec3 diffuse_albedo = vec3(0.4, 0.4, 0.8);
uniform vec3 specular_albedo = vec3(0.0, 0.0, 0.0);
uniform float specular_power = 128.0;

void main(void) {
    //color = vec4(0.4, 0.4, 0.8, 1.0);

    //normalize
    vec3 N = …

我需要将2个(或更多)纹理传递给一个着色器.此外,我必须在渲染方法中绑定纹理,因为我使用FrameBuffer并尝试在飞行中绑定纹理.所以,我的代码如下:

@Override
public void show () {
      fbo = new FrameBuffer(Format.RGB565, Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), false);

      shader = new ShaderProgram(Gdx.files.internal("shaders/vertex.glsl"), Gdx.files.internal("shaders/test_fragment.glsl"));
    ...
}

@Override
public void render(float delta) {

    fbo.begin();        
    Gdx.graphics.getGL20().glClearColor( 0.0f, 0.0f, 0.0f, 1f );
    Gdx.graphics.getGL20().glClear( GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT );      

    cam.update();

    spriteBatch.setProjectionMatrix(cam.combined);

    spriteBatch.begin();        
    spriteBatch.draw(someImage, 0, 0, width, height);                   
    spriteBatch.end();
    fbo.end();

    Texture texture = fbo.getColorBufferTexture();

    time+=Gdx.graphics.getDeltaTime();      

    shader.begin();

     shader.setUniformMatrix(u_wview, cam.projection);
     Gdx.graphics.getGL20().glActiveTexture(GL20.GL_TEXTURE0);
     texture.bind(0);

     shader.setUniformi("u_texture", 0); //passing first texture!!!

     Gdx.graphics.getGL20().glActiveTexture(GL20.GL_TEXTURE1);       
     tex2.bind(1);
     shader.setUniformi("u_texture2", 1); //passing second texture!!!


    shader.setUniformf(u_res, new Vector2(Gdx.graphics.getWidth(),Gdx.graphics.getHeight())); 
    shader.setUniformf(u_time, time);


    mesh.render(shader, GL20.GL_TRIANGLES); …

我的目标是将一个点数组传递给着色器,计算它们与碎片的距离,并用一个渐变的圆圈绘制它们,这个圆形取决于该计算.

例如:

(从我在着色器玩具上设置的工作示例)

不幸的是,我不清楚如何计算和转换在着色器内传递的处理坐标.

我目前正在尝试将两个浮点数 - 一个用于x位置,一个用于每个点的y位置 - 通过一个制服传递到着色器.然后在着色器中迭代遍历每个点,如下所示:

#ifdef GL_ES
precision mediump float;
precision mediump int;
#endif

uniform float sourceX[100];
uniform float sourceY[100];
uniform vec2 resolution;

in vec4 gl_FragCoord;

varying vec4 vertColor;
varying vec2 center;
varying vec2 pos;

void main()
{
    float intensity = 0.0;

    for(int i=0; i<100; i++)
    {
        vec2 source = vec2(sourceX[i],sourceY[i]);
        vec2 position = ( gl_FragCoord.xy / resolution.xy );
        float d = distance(position, source);
        intensity += exp(-0.5*d*d);
    }

    intensity=3.0*pow(intensity,0.02);

    if (intensity<=1.0) 
        gl_FragColor=vec4(0.0,intensity*0.5,0.0,1.0); …

我想将片段着色器中的计算值保存在某个变量中，以便下次可以使用它。

目前，我正在使用一个巨大的算法准备图像，我想将其保存到一些vec4中，再次请求时，我只想获取该vec4，应该说

gl_FragColor = vec4(previously saved variable)

这个问题与我也问过的另一个问题有关，但是我觉得如果这个问题有答案，那么我可以轻松地破解另一个问题。

有什么建议么 ？

我使用的是webgl 1.0。

我想知道，如果我将顶点设置在-1〜1范围之外，则片段着色器是否在屏幕外（也可以在帧缓冲区外）运行。

[示例]
如果我设置如下。
绘制类型：gl.LINES
顶点：[-100000,-100000, 100000, 100000]<--- 1点2点制

我认为在设置
顶点时显示结果是相同的：（[-1,-1, 1, 1]
两个结果都是从左下到右上显示1条直线。）

我想知道第一个示例是由于运行大量片段着色器而导致性能降低。

Let's consider this mcve:

from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
import textwrap
from string import Template


def compile(shader_type, source):
    identifier = glCreateShader(shader_type)
    glShaderSource(identifier, source)
    glCompileShader(identifier)

    if not glGetShaderiv(identifier, GL_COMPILE_STATUS):
        for i, l in enumerate(source.splitlines()):
            print(f"{i+1}: {l}")
        raise Exception(glGetShaderInfoLog(identifier).decode("utf-8"))

    return identifier


def create_program(vs, fs):
    vs_identifier = compile(GL_VERTEX_SHADER, vs)
    fs_identifier = compile(GL_FRAGMENT_SHADER, fs)

    program = glCreateProgram()
    glAttachShader(program, vs_identifier)
    glAttachShader(program, fs_identifier)
    glLinkProgram(program)
    if not glGetProgramiv(program, GL_LINK_STATUS):
        raise RuntimeError(glGetProgramInfoLog(program))

    return program


def set_uniform1f(prog, name, v0):
    # print("set_uniform1f", name, …