¿Cómo dibujar un sobre relleno como un cono en OpenGL (usando GLUT)?

Question

Estoy usando freeglut para la representación de opengl ...

Necesito dibujar un sobre que parezca un cono (2D) que se debe rellenar con un poco de color y una cierta transparencia aplicada.

¿El kit de herramientas de freeglut está equipado con tal funcionalidad incorporada para dibujar geometrías rellenas (o algún truco)? o hay alguna otra API que tiene un soporte incorporado para geometrías rellenas ...

Edit1: solo para aclarar lo del cono 2D ... la envoltura es la interpretación gráfica del área de cobertura de una aeronave durante la intercepción (de una aeronave enemiga) ... que se asemeja a un sector de un círculo ... debería haber mencionado el sector en su lugar. .

y glutSolidCone no me ayuda, ya que quiero dibujar un sector lleno de un círculo ... lo que ya he hecho ... lo que queda por hacer es llenarlo con algo de color ... ¿Cómo rellenar geometrías con color en opengl?

Edit2: Todas las respuestas publicadas en estas preguntas pueden funcionar para mi problema de alguna manera ... Pero definitivamente me gustaría saber cómo llenar una geometría con un poco de color. Decir si quiero dibujar una envoltura que es una parábola ... en ese caso, no habría una función de saturación predeterminada para dibujar una parábola rellena (¿o hay alguna?) .. Entonces, para generalizar esta pregunta ... ¿cómo dibujar una geometría personalizada en un color sólido?

Edit3: La respuesta que mstrobl publicó funciona para GL_TRIANGLES pero para dicho código:

glBegin(GL_LINE_STRIP);

glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(200.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(200.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, 0.0);

glEnd();

que dibuja un cuadrado ... solo se dibuja un cuadrado alámbrico ... necesito rellenarlo con color azul.

¿De todos modos para hacerlo?

si pongo algunos comandos de dibujo para una curva cerrada ... como una tarta ... y necesito rellenarlo con un color, hay una manera de hacerlo posible ...

No sé cómo es posible para GL_TRIANGLES ... ¿pero cómo hacerlo para cualquier curva cerrada?

Answer 1

En Edit3: la forma en que entiendo tu pregunta es que deseas que OpenGL dibuje bordes y que todo lo que se encuentre entre ellos esté lleno de colores.

La idea que tenías era correcta, pero una tira de línea es solo eso: una tira de líneas, y no tiene ningún área.

Sin embargo, puede hacer que las líneas se conecten entre sí para definir un polígono. Eso llenará el área del polígono en una base por vértice. Adaptando tu código:

glBegin(GL_POLYGON);

glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(200.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(200.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, 0.0);

glEnd();

Sin embargo, tenga en cuenta que dibujar un polígono de esta manera tiene dos limitaciones:

• El polígono debe ser convexo.
• Esta es una operación lenta.

Pero asumo que solo quieres hacer el trabajo, y esto lo hará. Para el futuro, podrías considerar simplemente triangular tu polígono.

Answer 2

No estoy seguro de lo que quieres decir con " una envoltura " ;, pero un cono es un primitivo que el exceso tiene:

glutSolidCone(radius, height, number_of_slices, number_of_stacks)

La forma más fácil de rellenarlo con color es dibujarlo con color. Como desea que sea un tanto transparente, también necesita un valor alfa:

glColor4f(float red, float green, float blue, float alpha)
// rgb and alpha run from 0.0f to 1.0f; in the example here alpha of 1.0 will
// mean no transparency, 0.0 total transparency. Call before drawing.

Para renderizar de forma translúcida, la fusión debe estar habilitada. Y debes configurar la función de fusión para usar. Lo que quieres hacer probablemente se logrará con lo siguiente. Si desea obtener más información, envíeme un comentario y buscaré algunos buenos consejos. Pero aquí va tu configuración:

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Llame a eso antes de realizar cualquier operación de dibujo, posiblemente durante la inicialización del programa. :)

Answer 3

Ya que reclarificó su pregunta para pedir una tarta: hay una manera fácil de dibujar eso también usando primitivas de opengl:

Dibujarías una esfera sólida usando gluSolidSphere (). Sin embargo, como solo desea dibujar una parte, simplemente recorte las partes no deseadas:

void glClipPlane(GLenum plane, const GLdouble * equation);

Si el plano es GL_CLIPPLANE0 a GL_CLIPPLANEn y la ecuación es una ecuación plana en forma normal (a x + b y + c * z + d = 0 significaría que la ecuación mantendría los valores { a, b, c, d} . Ten en cuenta que son dobles y no flotantes.

Answer 4

Recuerdo que había una subrutina para eso. Pero tampoco es demasiado difícil hacerlo solo.

Pero no entiendo lo 2D. ¿Cono en 2D? ¿No es solo un triángulo?

De todos modos, aquí hay un algoritmo para dibujar un cono en opengl

Primero tome un círculo, subdivídalo uniformemente para que obtenga una buena cantidad de bordes. Ahora escoge el centro del círculo, haz triángulos desde los bordes hasta el centro del círculo. Luego, seleccione un punto sobre el círculo y haga triángulos desde los bordes hasta ese punto.

La forma y la orientación del tamaño dependen de los valores que use para generar el círculo y dos puntos. Cada paso es bastante simple y no debería causarle problemas.

Primero solo subdivisión un valor escalar. Comenzar desde [0-2] -range. Tome el punto medio ((inicio + fin) / 2) y divida el rango con él. Almacena los valores como pares. Por ejemplo, subdividir una vez debe darle: [(0,1), (1,2)] Haga esto recursivamente un par de veces, luego calcule cuáles son esos puntos en el círculo. Trigometría simple, solo recuerde multiplicar los valores con p antes de continuar. Después de esto tienes una cierta cantidad de aristas. 2 ^ n donde n es la cantidad de subdivisiones. Luego puedes simplemente convertirlos en triángulos al darles un punto de vértice más. La cantidad de triángulos termina siendo por lo tanto: 2 ^ (n + 1). (Las cantidades son útiles para saber si lo está haciendo con matrices de tamaño fijo.

Editar: Lo que realmente quieres es un pastel. (Perdón por el juego de palabras)

Es igualmente simple de renderizar. Puedes usar de nuevo solo triángulos. Simplemente selecciona el rango escalar [-0.25 - 0.25], subdivide, proyecta un círculo y genera un conjunto de triángulos.

La proyección del círculo escalar es simple como: x = cos (v * pi) r, y = sin (v pi) * r donde (x, y) es el punto de vértice resultante, r es un radio, y las funciones trigonométricas funcionan en radiancias, no en grados. (Si trabajan con títulos, reemplaza pi por 180)

Use buffers o listas de vértices para representarlo usted mismo.

Editar: Acerca de la pregunta para colorear. glColor4f, si desea que algunas partes de la geometría sean diferentes por su color, puede asignar un color para cada vértice en el búfer de vértice. En este momento no sé todas las llamadas a la API para hacerlo, pero la referencia de la API en opengl es bastante comprensible.

Answer 5

Sobre la edición en colores:

OpenGL es en realidad una máquina de estado. Esto significa que la posición actual del material y / o el color se utiliza al dibujar. Ya que probablemente no usará materiales, ignórelo por ahora. Quieres colores.

glColor3f(float r, float g, float b) // draw with r/g/b color and alpha of 1
glColor4f(float r, float g, float b, float alpha)

Esto afectará los colores de cualquier vértice que dibuje, de cualquier geometría que represente, ya sea de glu o la suya, después de que se haya ejecutado la llamada a glColorXX. Si dibuja una cara con vértices y cambia el color entre las llamadas glVertex3f / glVertex2f, los colores se interpolan.

Prueba esto:

glBegin(GL_TRIANGLES);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(-3.0, 0.0, 0.0);
glColor3f(0.0, 1.0, 0.0);
glVertex3f(0.0, 3.0, 0.0);
glColor3f(1.0, 0.0, 0.0);
glVertex3f(3.0, 0.0, 0.0);
glEnd();

Pero ya señalé glColor4f, así que asumo que quieres configurar los colores por vértice. Y quieres renderizar usando listas de visualización.

Al igual que puede mostrar listas de vértices, también puede hacer que tengan una lista de colores: todo lo que necesita hacer es habilitar las listas de colores y decirle a opengl dónde reside la lista. Por supuesto, necesitan tener el mismo atuendo que la lista de vértices (mismo orden).

Si tuvieras

glEnableClientState(GL_VERTEX_ARRAY);   
glVertexPointer(3, GL_FLOAT, 0, vertices_);
glDisableClientState(GL_VERTEX_ARRAY);

debe agregar colores de esta manera. No necesitan ser flotados; de hecho, le dices qué formato debe tener. Para una lista de colores con 1 byte por canal y 4 canales (R, G, B y A) use esto:

glEnableClientState(GL_VERTEX_ARRAY);   
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices_);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors_);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);

EDITAR: Olvidó agregar que luego tiene que decirle a OpenGL qué elementos dibujar llamando a glDrawElements .