Falsche Werte zu GLSL Frag Shader

Question

Ich arbeite an was ein einfaches OpenGl 4 Projekt sein soll. Ich möchte nur den Alpha-Wert um den Mauszeiger verändern und verschmelzen. Nach einiger Arbeit gelang es mir, einen Kreis zu bekommen, um Werte zu ändern, aber er ist statisch (bewegt sich nicht mit der Maus) und ist auf (0,512) zentriert, sehr viel nicht der Ort meiner Maus. Ich schicke die Mauswerte durch meine passiveMotionFunc:

Wo MousePos ist nur ein einfacher Schwimmer-Container. Ich habe die print-Anweisung, nur damit ich die Werte meiner Mausposition sehen kann.

meine frag Shader ist einfach:

in vec4 color; 
in vec4 vPosition; 
in vec2 MousePos; 
out vec4 fColor; 

void 
main() 
{ 
     //float x = gl_FragCoord.X; 
     //float y = gl_FragCoord.Y; 
     float distance = sqrt(pow(MousePos.x-gl_FragCoord.x, 2) + pow(MousePos.y-gl_FragCoord.y, 2)); 
     if(distance > 30) 
      fColor = color; 
     else{ 
      float a = .1; 
      fColor = color; 
      fColor.a = a; 
     } 
} 

Ich bin absolut auf diese stecken. Ich gehe davon aus, dass der Frag Shader keine aktualisierten Mauskoordinaten erhält, denn wenn das FragCoord durcheinander gebracht würde, würde es keinen Kreis erzeugen.

EDIT: Ich meine Blending in einer init() - Funktion, die meine GlutDisplay und GlutPassiveFunc in main() vorangestellt.

void 
init() 
{ 
    wall(); 
    redwall(); 
    // Create a vertex array object 
    GLuint vao; 
    glGenVertexArrays(1, &vao); 
    glBindVertexArray(vao); 

    // Create and initialize a buffer object 
    GLuint buffer; 
    glGenBuffers(1, &buffer); 
    glBindBuffer(GL_ARRAY_BUFFER, buffer); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(points) + sizeof(quad_colors), NULL, GL_STATIC_DRAW); 

    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(points), points); 

    glBufferSubData(GL_ARRAY_BUFFER, sizeof(points), sizeof(quad_colors), quad_colors); 


    // Load shaders and use the resulting shader program 
    program = InitShader("p6v.glsl", "p6f.glsl"); 
    glUseProgram(program); 

    // set up vertex arrays 
    GLuint vPosition = glGetAttribLocation(program, "vPosition"); 
    glEnableVertexAttribArray(vPosition); 
    glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, 
       BUFFER_OFFSET(0)); 

    GLuint vColor = glGetAttribLocation(program, "vColor"); 
    glEnableVertexAttribArray(vColor); 
    glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, 
       BUFFER_OFFSET(sizeof(points))); 

    //glEnable(GL_DEPTH_TEST); 
    glEnable(GL_BLEND); 
    glEnable(GL_ALPHA_TEST); 
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
    glDepthMask(false); 

    glClearColor(0.0, 0.5, 1.0, 1.0); 
} 

EDIT2: Hier ist meine vec2 Definition:

struct vec2 { 

    GLfloat x; 
    GLfloat y; 

    // 
    // --- Constructors and Destructors --- 
    // 

    vec2(GLfloat s = GLfloat(0.0)) : 
    x(s), y(s) {} 

    vec2(GLfloat x, GLfloat y) : 
    x(x), y(y) {} 

    vec2(const vec2& v) 
    { x = v.x; y = v.y; } 

    // 
    // --- Indexing Operator --- 
    // 

    GLfloat& operator [] (int i) { return *(&x + i); } 
    const GLfloat operator [] (int i) const { return *(&x + i); } 

    // 
    // --- (non-modifying) Arithematic Operators --- 
    // 

    vec2 operator -() const // unary minus operator 
    { return vec2(-x, -y); } 

    vec2 operator + (const vec2& v) const 
    { return vec2(x + v.x, y + v.y); } 

    vec2 operator - (const vec2& v) const 
    { return vec2(x - v.x, y - v.y); } 

    vec2 operator * (const GLfloat s) const 
    { return vec2(s*x, s*y); } 

    vec2 operator * (const vec2& v) const 
    { return vec2(x*v.x, y*v.y); } 

    friend vec2 operator * (const GLfloat s, const vec2& v) 
    { return v * s; } 

    vec2 operator/(const GLfloat s) const { 
#ifdef DEBUG 
    if (std::fabs(s) < DivideByZeroTolerance) { 
     std::cerr << "[" << __FILE__ << ":" << __LINE__ << "] " 
       << "Division by zero" << std::endl; 
     return vec2(); 
    } 
#endif // DEBUG 

    GLfloat r = GLfloat(1.0)/s; 
    return *this * r; 
    } 

    // 
    // --- (modifying) Arithematic Operators --- 
    // 

    vec2& operator += (const vec2& v) 
    { x += v.x; y += v.y; return *this; } 

    vec2& operator -= (const vec2& v) 
    { x -= v.x; y -= v.y; return *this; } 

    vec2& operator *= (const GLfloat s) 
    { x *= s; y *= s; return *this; } 

    vec2& operator *= (const vec2& v) 
    { x *= v.x; y *= v.y; return *this; } 

    vec2& operator /= (const GLfloat s) { 
#ifdef DEBUG 
    if (std::fabs(s) < DivideByZeroTolerance) { 
     std::cerr << "[" << __FILE__ << ":" << __LINE__ << "] " 
       << "Division by zero" << std::endl; 
    } 
#endif // DEBUG 

    GLfloat r = GLfloat(1.0)/s; 
    *this *= r; 

    return *this; 
    } 

    // 
    // --- Insertion and Extraction Operators --- 
    // 

    friend std::ostream& operator << (std::ostream& os, const vec2& v) { 
    return os << "(" << v.x << ", " << v.y << ")"; 
    } 

    friend std::istream& operator >> (std::istream& is, vec2& v) 
    { return is >> v.x >> v.y ; } 

    // 
    // --- Conversion Operators --- 
    // 

    operator const GLfloat*() const 
    { return static_cast<const GLfloat*>(&x); } 

    operator GLfloat*() 
    { return static_cast<GLfloat*>(&x); } 
}; 

Answer 1

Sie benötigen MousePos als uniform, um zu erklären, sie als eine passieren in. Ihr Fragment-Shader hat es als "in" deklariert.

Auch Sie verwenden den Vektor uniform Upload glUniform2fv von Ihrer vec2 Klasseninstanz MousePos laden. Sie sollten dies in der 2-Arg-Form glUniform2f laden. Das Formular glUniform2fv sucht nach einem Argument, das als letztes Argument einen Zeiger auf einen Block aus 2 Gleitkommawerten darstellt. Sie übergeben es dort MousePos, die eine tatsächliche Klasseninstanz ist, und Sie zählen auf Ihre Casting-Operatoren, um die Aufgabe zu erledigen.