Cómo usar un temporizador dentro de un sombreador de vértices para animar tamaños de punto en OpenGL

timer shader

Question

Estoy tratando de implementar una nube de puntos donde los diferentes puntos variarán en tamaño en función de un valor de incertidumbre asociado a ellos. Digamos, si este valor es cero, el tamaño debe ser constante, si se acerca a 1, el radio de esos puntos debería variar más y más. Primero, los puntos deben ganar tamaño y después de alcanzar un máximo, deben disminuir hasta un mínimo, y así sucesivamente. Una función para describir este fenómeno podría ser:

pointSize = x +/- c * pointUncertainty, where x = standard point size 
                                              c = scaling constant

Por lo que he leído, esto podría lograrse al pasar una variable de temporizador uniforme a mi sombreador de vértices y calcular el tamaño del punto allí. Sin embargo, todos los puntos deben variar al mismo tiempo, lo que significa que un punto que tiene una incertidumbre de 1 y un punto que tiene una incertidumbre de 0.5 deben alcanzar su valor mínimo y máximo de pointSize al mismo tiempo. Además, todo el proceso no debe depender de la velocidad de fotogramas.

No estoy seguro de cuál es la mejor manera de hacerlo, cómo se puede implementar mejor el patrón increase-decrease-increase-y dónde colocar los comandos necesarios de OpenGL (4.2).

EDITAR: Todavía espero obtener una respuesta a esta pregunta, ya que todo el proceso de cómo se podría lograr un efecto de animación no está claro para mí.

Answer 1

Antes que nada ... gracias por tu respuesta. He resuelto cosas usando solo un sombreador de vértices. Supongo que esta era la solución que esperaba obtener. Tal vez las personas con el mismo problema puedan beneficiarse de esto:

Parte de mi sombreador de vértices se ve así:

 ... 
 "  float standardPointSize = 100.0;"
 "  float timeScale = standardPointSize / my_loopDuration;"
 "  float currentTime = mod(my_time, my_loopDuration);"
 "  float offset = currentTime * timeScale * in_uncertainty;"
 "  if(currentTime < my_loopDuration / 4)"
 "  {"
 "      gl_PointSize = standardPointSize - 4 * offset;"
 "  }"
 "  else if(currentTime >= my_loopDuration / 4 && currentTime < my_loopDuration / 2)"
 "  {"
 "      gl_PointSize = standardPointSize - standardPointSize * in_uncertainty + 4 * offset - 1 * in_uncertainty * standardPointSize;"
 "  }"
 "  else if(currentTime >= my_loopDuration / 2 && currentTime < 3 * my_loopDuration / 4)"
 "  {"
 "      gl_PointSize = standardPointSize + 4 * offset - 2 * in_uncertainty * standardPointSize;"
 "  }"
 "  else if(currentTime >= 3 * my_loopDuration / 4 && currentTime <= my_loopDuration)"
 "  {"
 "      gl_PointSize = standardPointSize + standardPointSize * in_uncertainty - 4 * offset + 3 * in_uncertainty * standardPointSize;"
 "  }"
 ...

my_time y my_loopDuration son variables uniformes. El primero se establece con glutGet (GLUT_ELASED_TIME) y el segundo es un número arbitrario.

Answer 2

Puede pasar un texture1D con los valores de cada punto. Luego use texelFetch () para recuperar los valores. Puede usar un contador atómico (si usa OpenGL 4.2), o gl_vertexID para hacerlo. También eche un vistazo a esta pregunta y esto uno, la respuesta aceptada también sugiere soluciones adicionales como UBO. Aunque si tu nube de puntos es bastante grande, entonces Buffer Textures es lo que necesitas.

Tomemos el enfoque de texturas Buffer :

• Usted crea un buffer de textura y lo llena con valores que van a definir su tamaño de objetivo de puntos. (Lea en los enlaces que puse arriba cómo configurarlo).

• En el sombreador de vértices accede a esos valores a través del muestreo texelFetch. Como he dicho, puede usar gl_VertexID para muestrear por el vértice actual (algo como esto):

  muestreador uniformeBuffer pointsBuffer;

  void main () {float destSize = texelFetch (pointsBuffer, gl_VertexID) .x; ...}

• Ahora, es probable que desee interpolar el tamaño del punto del valor predeterminado al tamaño objetivo en función de una cierta cantidad. La entrada del temporizador que oscila entre 0 y 1 puede hacer el trabajo. Utilice el método incorporado mix () para interpolar el tamaño del punto desde el valor predeterminado es el destino. Para obtener más diversión, pase el tiempo basado en sin () o cos () :)

• Como mencionó OpenGL superbible, tiene un capítulo que explica cómo funcionan los amortiguadores de textura. Vuelva a leerlo. Lo que está tratando de hacer no es una ciencia espacial sino un nivel de principiante tampoco. Tenga paciencia, lo cual siempre es un buen consejo cuando trabajando con OpenGL.