Como desenhar um envelope cheio como um cone em OpenGL (usando GLUT)?
https://stackoverflow.com/questions/237899
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu estou usando freeglut para renderização OpenGL ...
Eu preciso desenhar um envelope parecendo um cone (2D) que tem de ser preenchido com alguma cor e alguma transparência aplicada.
É o kit de ferramentas freeglut equipado com uma funcionalidade tal embutido para desenhar geometrias preenchidos (ou algum truque)? ou há alguma outra API que tem um suporte embutido para preenchidos geometrias ..
Edit1: só para esclarecer a coisa cone 2D ... o envelope é a interpretação gráfica da área de cobertura de uma aeronave durante a interceptação (de um avião inimigo) ... que se assemelha a um setor de um circle..i deveria ter mencionado o setor em seu lugar. .
e glutSolidCone doesnot me ajudar como eu quero desenhar um setor cheio de um círculo ... que eu já fiz ... o que resta a fazer é preenchê-lo com um pouco de cor ... como preencher geometrias com cor em OpenGL?
Edit2: Todas as respostas enviadas para esta pergunta pode trabalhar para o meu problema de uma forma .. Mas eu definitivamente gostaria de saber uma maneira como preencher uma geometria com alguma cor. Dizer se eu quero desenhar um envelope que é uma parábola ... nesse caso não haveria nenhuma função excesso padrão para realmente desenhar uma parábola cheia (ou existe alguma?) .. Então, para generalizar esta pergunta ... como desenhar uma geometria personalizada em alguma cor sólida?
Edit3: A resposta que mstrobl postou obras para GL_TRIANGLES mas para tal 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 desenha um quadrado ... apenas uma praça com fio é desenhado ... eu preciso preenchê-lo com a cor azul.
de qualquer maneira para fazê-lo?
Se eu colocar alguns comandos de desenho para uma fechada curve..like um pie..and eu preciso preenchê-lo com uma cor se existe uma maneira de torná-lo possível ...
Eu não sei como seu possível para GL_TRIANGLES ... mas como fazê-lo para qualquer curva fechada?
Solução
Em Edit3:. A maneira que eu entendi sua pergunta é que você quer ter OpenGL desenhar fronteiras e nada entre eles deve ser preenchido com cores
A ideia que tinha era certo, mas uma tira de linha é apenas isso -. Uma faixa de linhas, e ele não tem qualquer área
Você pode, no entanto, têm as linhas se conectam entre si para definir um polígono. Isso vai preencher a área do polígono em uma base per-vertex. Adaptar o seu 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();
Por favor, note no entanto, que desenhar um polígono dessa maneira tem duas limitações:
- O polígono deve ser convexo.
- Esta é uma operação lenta.
Mas eu suponho que você só quer fazer o trabalho, e isso vai fazê-lo. Para o futuro que você pode considerar apenas triangulação seu polígono.
Outras dicas
Eu não tenho certeza do que você quer dizer com "um envelope", mas um cone é um primitivo que excesso tem:
glutSolidCone(radius, height, number_of_slices, number_of_stacks)
A maneira mais fácil para preenchê-lo com a cor é desenhá-la com a cor. Desde que você quer para torná-lo um pouco transparente, você precisa de um valor alfa demasiado:
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 tornar translucently, mistura tem que ser ativado. E você deve definir a função de mistura para usar. O que você quer fazer provavelmente será alcançado com o seguinte. Se você quiser saber mais, mande-me um comentário e eu vou olhar para algumas boas indicações. Mas aqui vai a sua configuração:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Chamada que antes de fazer qualquer operação de desenho, possivelmente na inicialização do programa. :)
Uma vez que você novamente clarificado a sua pergunta para pedir uma torta: há uma maneira fácil de desenhar que também utilizando primitivas OpenGL:
Você iria desenhar uma esfera sólida usando gluSolidSphere (). No entanto, desde que você só quer chamar a parte dela, você só cortar as partes indesejadas longe:
void glClipPlane(GLenum plane, const GLdouble * equation);
Com plano sendo GL_CLIPPLANE0 para GL_CLIPPLANEn e equação sendo uma equação de plano em forma normal (uma x + b y + c * z + d = 0 significaria equação iria realizar o { a, b, c, d } valores. Por favor note que aqueles duplos e não flutua.
Eu lembro que havia uma sub-rotina para isso. Mas é nem muito difícil de fazer por si mesmo.
Mas eu não entendo o 2D -coisa. Cone em 2D? Não é apenas um triângulo?
De qualquer forma, aqui está um algoritmo para desenhar um cone em OpenGL
Primeiro dê um círculo, subdivisão-lo uniformemente para que você obtenha uma boa quantidade de arestas. Agora escolher o centro do círculo, fazer triângulos a partir das bordas para o centro do círculo. Em seguida, selecione um ponto sobre o círculo e fazer triângulos a partir das bordas a esse ponto.
A forma tamanho e orientação depende sobre os valores que você usa para gerar o círculo e dois pontos. Cada passo é bastante simples e não deve causar problemas para você.
Em primeiro lugar apenas subdivisão um valor escalar. Iniciar a partir de [0-2] -range. Tomar o ponto médio ((+ iniciar final) / 2) e dividir o intervalo com ele. Armazenar os valores como pares. Por exemplo, subdividindo uma vez deve dar-lhe: [(0,1), (1,2)] Faça isso casal recursiva de vezes, em seguida, calcular o que esses pontos estão no círculo. trigonometria simples, basta lembrar-se de multiplicar os valores com p antes de prosseguir. Após isso, você tem uma certa quantidade de bordas. 2 ^ n em que n é a quantidade de subdivisões. Então você pode simplesmente transformá-los em triângulos, dando-lhes um ponto de vértice mais. Quantidade de triângulos acaba sendo, por conseguinte,: 2 ^ (n + 1). (Os valores são úteis para saber se você está fazendo isso com matrizes de tamanho fixo.
Editar: O que você realmente quer é uma torta. (Desculpe o trocadilho)
É igualmente simples para processar. Você pode voltar a usar apenas triângulos. Basta selecionar gama escalar [-0.25 - 0,25]., Subdivida, projeto para círculo, e gerar um conjunto de triângulos
O escalar - projecção círculo é simples como: x = cos (v * pi) r, y = sin (v pi) * r em que (x, y) é o ponto de vértice, resultante, r é um raio, e funções trigonométricas trabalham em radiâncias, não graus. (Se eles trabalham com graus, substitua pi com 180)
Utilize buffers de vértice ou listas para torná-lo a si mesmo.
Edit: Sobre a questão coloração. glColor4f, se você quiser algumas partes da geometria a ser diferente por sua cor, você pode atribuir uma cor para cada vértice em vértice tampão si. Eu não agora conhecer todas as chamadas de API para fazê-lo, mas de referência API em OpenGL é bastante compreensível.
Na edição de cores:
OpenGL é realmente uma máquina de estado. Isto significa que a posição do material e / ou cor de corrente é utilizada para desenhar. Como você provavelmente não estará usando materiais, ignorar que, por enquanto. Você quer cores.
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)
Isso afetará as cores de quaisquer vértices que você desenha, de qualquer geometria que render - seja ele glu de ou o seu próprio - após a chamada glColorXX foi executado. Se você desenhar um rosto com vértices e mudar a cor inbetween as chamadas glVertex3f / glVertex2f, as cores são interpoladas.
Tente isto:
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();
Mas eu apontou para glColor4f já, então eu suponho que você quer definir as cores em uma base per-vertex. E você quiser renderizar usando listas de exibição.
Assim como você pode exibir listas de vértices, você pode também fazer com que tenham uma lista de cores: tudo que você precisa fazer é permitir que as listas de cores e dizer OpenGL onde a lista reside. Claro, eles precisam ter a mesma roupa como a lista de vértices (mesma ordem).
Se você tivesse
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices_);
glDisableClientState(GL_VERTEX_ARRAY);
você deve adicionar cores desta forma. Eles não precisa ser flutuante; na verdade, você diga a ele que formato ele deve ser. Para uma lista de cor com um byte por canal e 4 canais (R, G, B e A) utilizar o seguinte:
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);
EDIT: Esqueci de acrescentar que você então tem que dizer OpenGL quais elementos para desenhar chamando glDrawElements .
