Para empezar, permítanme quejarme de que "saludable" es una palabra terrible para ser expulsada del diccionario.
Bueno, quitando la piedra del alma, pasamos a las explicaciones. Greeble son pequeños detalles repetidos agregados a un modelo para darle un sentido de escala y una cierta estética. Los hongos se han vuelto populares gracias a las películas clásicas de ciencia ficción, en las que la escultura física era a menudo el "modelo":
Si ya sabe en mi
tutorial de extrusión cómo extruir mallas de procedimiento, entonces comprende cómo agregar hongos. La adición de
hongos simples a la malla se puede lograr al
extruir todos los polígonos de malla a una
longitud aleatoria .
Sin embargo, es posible que haya notado que el tutorial presentado anteriormente solo trata con triángulos de extrusión, mientras que en la imagen al comienzo del artículo los hongos son cuadrados. Tuve que ajustar la malla para que se dividiera en cuadrángulos, y muchas mallas a menudo consisten en polígonos con más de tres índices. Por lo tanto, en este tutorial aprenderemos cómo
extruir un polígono con n índices y aplicar este algoritmo a toda la malla para crear hongos. También aprendemos un par de formas de hacer variaciones en el algoritmo de proliferación para obtener resultados menos uniformes.
Superficie normal
Primero, veamos cómo se calcula la normalidad de un polígono con n índices arbitrarios. Si podemos suponer que este polígono es
plano , es decir, todos sus vértices están en el mismo plano, entonces el proceso no difiere del cálculo de la normalidad de un polígono con tres índices.
La superficie normal es la perpendicular a la cara del polígono, que se puede calcular tomando el
producto vectorial de dos vectores que apuntan a lo largo del borde del polígono .
Luego
normalizamos este vector para que su longitud sea 1, ya que de lo normal a la superficie solo necesitamos dirección, no longitud.
función getFaceNormal (mesh, poly)
Vec3 v1 = mesh: getVertex (poly [1])
Vec3 v2 = mesh: getVertex (poly [2])
Vec3 v3 = mesh: getVertex (poly [3])
Vec3 e1 = v2 - v1
Vec3 e2 = v3 - v2
Vec3 normal = e1: cruzado (e2)
volver normal: normalizar ()
fin
Si no podemos asumir con seguridad que el polígono es plano, entonces el algoritmo presentado anteriormente prefiere el plano en el que se ubican los dos primeros índices. Para obtener una representación más precisa de la dirección en la que apunta el polígono, podemos tomar el
promedio de todos los productos vectoriales de los bordes :
función getFaceNormal (mesh, poly)
Vec3 n = Vec3 (0, 0, 0)
para i = 1, #poly -2 do
Vec3 v1 = mesh: getVertex (poly [1])
Vec3 v2 = mesh: getVertex (poly [1+ i])
Vec3 v3 = mesh: getVertex (poly [2+ i])
n: agregar ((v2 - v1): cruzar (v3 - v1))
fin
return n: normalizar ()
fin
Un ejemplo que muestra la extrusión de un cuadrángulo plano.Extrusión
Ahora que tenemos información sobre la superficie normal, estamos listos para extruir el polígono en la dirección normal. En pocas palabras, para extruir el polígono, creamos nuevos vértices moviendo los vértices antiguos en la dirección de la superficie normal.
Más detalles:
- Cree nuevos picos "por encima" de los antiguos en la dirección normal.
Los nuevos vértices se pueden calcular de la siguiente manera:
(posición del pico anterior) + (dirección normal)
Esto "desplaza" la posición anterior en la dirección de la superficie normal.
Por ejemplo, mire la imagen de arriba, en ella v1 se mueve en la dirección normal a v5. - Crea cuadrángulos para conectar los vértices nuevos y viejos.
Cabe señalar que para cada índice en el nuevo polígono, se crea un nuevo cuadrilátero.
Por ejemplo, eche un vistazo a un quad creado a partir de v8, v7, v3 y v4 . - Reemplace el antiguo polígono con un nuevo polígono creado por nuevos vértices. Por ejemplo, eche un vistazo a un quad creado a partir de v5, v6, v7 y v8.
función extrudePoly (mesh, polyIndex, length)
int [] poly = mesh.polys [polyIndex]
int [] newPoly = []
Vec3 n = getFaceNormal (malla, poli)
- (1) Crear verts extruidos
para j = 1, #poly do
local p = mesh: getVertex (poly [j])
newPoly [#newPoly + 1] = # mesh.verts
- longitud determina la longitud de la extrusión
mesh: addVertex (p + (n * length))
fin
- (2) Coser los lados de extrusión con quads
para j0 = 1, #poly do
local j1 = j0% #poly + 1
mesh: addQuad (
poli [j0],
poli [j1],
newPoly [j1],
nuevoPoly [j0]
)
fin
- (3) Mover la cara existente a las vértices extruidas
para j = 1, #poly do
mesh.polys [pi] [j] = newPoly [j]
fin
fin
Setas uniformes.Todas las setas de malla
Ahora que tenemos la función getSurfaceNormal () y la función extrude (), ¡la proliferación es muy fácil! Simplemente
aplicamos la función extrude () a cada polígono de malla . Usamos extrudir con una
longitud aleatoria para que cada polígono extruido tenga un tamaño ligeramente diferente, lo que crea una sensación de textura. El algoritmo que se muestra a continuación se aplica al cubo presentado anteriormente, que consiste completamente en cuadrángulos.
función greeble (mesh)
para i = 1, # mesh.polys do
- estos valores aleatorios son arbitrarios: p
longitud flotante = aleatorio: getUniformRange (0.1, 1.0)
extrudePoly (mesh, i, length)
fin
malla de retorno
fin
Felicitaciones, nuestro crecimiento ha ganado. ¡Pero podemos hacer más! Ahora la proliferación es bastante uniforme. Aquí hay dos ejemplos de modificaciones para hacerlo más interesante.
Modificación 1: la presencia de fungling depende del azar
Es bastante simple: simplemente tira el dado para determinar si se debe aplicar un hongo a cada polígono. Gracias a esto, la proliferación de hongos se vuelve menos uniforme. El algoritmo que se muestra a continuación se aplica al cubo de arriba.
para i = 1, # mesh.polys do
<strong> si es aleatorio: probabilidad (0.33) entonces </strong>
longitud flotante = aleatorio (0.1, 1.0)
extrudePoly (mesh, i, length)
fin
fin
malla de retorno
fin
Modificación 2: Agregar escala de extrusión
Esto requiere cambiar el algoritmo de extrusión. Cuando creamos los vértices de un polígono extruido, podemos
reducirlos hacia el centro del polígono mediante un valor aleatorio para que el objeto se vea más interesante.
Para empezar, nuestra función extrude () debe recibir un parámetro adicional que determine la cantidad de estrechamiento del nuevo polígono. Lo definiremos como Vec3 llamado
scale . Para mover un vértice hacia el centro,
interpolamos la posición del vértice entre su
posición original y el
centro del polígono por el valor de la
scale .
(Si necesita conocer el algoritmo para encontrar el centro de un polígono, le recomiendo ir rápidamente al
tutorial sobre triangulación y leer sobre la triangulación del punto medio (triangulación centroide)).
- encontrar el centro de la poli
Vec3 c = mesh: getFaceCentroid (poli)
para j = 1, #poly do
local p = mesh: getVertex (poly [j])
newPoly [#newPoly + 1] = # mesh.verts
self: addVertex (
math.lerp (cx, px, scale.x) + nx * longitud,
math.lerp (cy, py, scale.y) + ny * length,
math.lerp (cz, pz, scale.z) + nz * longitud
)
mesh: addVertex (p + (n * length))
fin
Ahora puede usarlo en el algoritmo de multiplicación escalando por un valor aleatorio para cada polígono. Entonces obtenemos la imagen que se muestra arriba.
función greeble (mesh)
para i = 1, # mesh.polys do
longitud flotante = aleatorio: getUniformRange (0.1, 1.0)
Escala Vec3 = (aleatorio: getUniformRange (0.1, 1.0),
aleatorio: getUniformRange (0.1, 1.0),
aleatorio: getUniformRange (0.1, 1.0))
extrudePoly (mesh, i, length, scale)
fin
malla de retorno
fin
El final
¡Genial, llegamos al final! Espero que este tutorial te haya sido útil.