आप ओपनगैल में वायरफ्रेम के रूप में आदिम कैसे प्रस्तुत करते हैं?


220

आप ओपनगैल में वायरफ्रेम के रूप में आदिम कैसे प्रस्तुत करते हैं?

opengl 

2
आपके द्वारा उपयोग किए जा रहे OpenGL संस्करण पर अधिक विशिष्ट रहें।
वर्टेक्वाहन

साथ ModernGL आप Simpli उपयोग कर सकते हैं wireframe की विशेषता प्रसंग वर्ग
स्ज़बोल्क्स Dombi

वायरफ्रेम खींचने के लिए GL_LINES का उपयोग करें
ऑक्सिन

जवाबों:


367
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );

चालू करने के लिए,

glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

वापस जाने के लिए सामान्य करने के लिए।

ध्यान दें कि बनावट-मानचित्रण और प्रकाश जैसी चीजें अभी भी वायरफ्रेम लाइनों पर लागू होंगी यदि वे सक्षम हैं, जो अजीब दिख सकती हैं।


2
मैं तुम्हें पसंद करता हूं। जाने के लिए 4 और।
जो तो

37

से http://cone3d.gamedev.net/cgi-bin/index.pl?page=tutorials/ogladv/tut5

// Turn on wireframe mode
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);

// Draw the box
DrawBox();

// Turn off wireframe mode
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);

75
दो कॉल करना बेमानी है। GL_FRONT_AND_BACK का उपयोग करें
shoosh

6
@ Shoosh की टिप्पणी के परिशिष्ट के रूप में, रेड बुक बताता है कि GL_FRONT और GL_BACK को OpenGL 3.1 और ऊपर से हटा दिया गया है और हटा दिया गया है। अब, आप अभी भी संगतता एक्सटेंशन के माध्यम से उनका उपयोग कर सकते हैं, लेकिन यदि आपके पास आगे-संगत और पिछड़े-संगत के बीच कोई विकल्प है, तो मैं पूर्व के लिए जाने की सलाह दूंगा।
चौदह

1
इस उत्तर में लिंक 404 है।
Ondrej Slinták

1
@ OndrejSlinták यह अब तय हो गया है।
MaxiMouse

24

OpenGL 3 और glPolygonModeउससे आगे के संदर्भ में, आप या तो पहले बताए अनुसार उपयोग कर सकते हैं , लेकिन ध्यान दें कि 1px से अधिक मोटाई वाली लाइनें अब पदावनत हो गई हैं। इसलिए जब आप तार-फ्रेम के रूप में त्रिकोण बना सकते हैं, तो उन्हें बहुत पतला होना चाहिए। ओपनजीएल ईएस में, आप GL_LINESउसी सीमा के साथ उपयोग कर सकते हैं।

ओपनजीएल में आने वाली त्रिकोणों को लेने के लिए ज्यामिति शेड्स का उपयोग करना संभव है, उन्हें अलग करना और मोटी रेखाओं का अनुकरण करते हुए क्वैड्स (त्रिकोण के जोड़े वास्तव में) के रूप में पुनर्संरचना के लिए भेजना। बहुत सरल, वास्तव में, सिवाय इसके कि ज्यामिति के शेड्स खराब प्रदर्शन स्केलिंग के लिए कुख्यात हैं।

आप इसके बजाय क्या कर सकते हैं, और ओपनगेल ईएस में भी क्या काम करेगा टुकड़े टुकड़े करना है । त्रिभुज को तार-फ्रेम त्रिकोण की बनावट लागू करने के बारे में सोचें। सिवाय इसके कि कोई बनावट की आवश्यकता नहीं है, इसे प्रक्रियात्मक रूप से उत्पन्न किया जा सकता है। लेकिन पर्याप्त बात करते हैं, कोड करते हैं। टुकड़े टुकड़े करना:

in vec3 v_barycentric; // barycentric coordinate inside the triangle
uniform float f_thickness; // thickness of the rendered lines

void main()
{
    float f_closest_edge = min(v_barycentric.x,
        min(v_barycentric.y, v_barycentric.z)); // see to which edge this pixel is the closest
    float f_width = fwidth(f_closest_edge); // calculate derivative (divide f_thickness by this to have the line width constant in screen-space)
    float f_alpha = smoothstep(f_thickness, f_thickness + f_width, f_closest_edge); // calculate alpha
    gl_FragColor = vec4(vec3(.0), f_alpha);
}

और वर्टेक्स शेडर:

in vec4 v_pos; // position of the vertices
in vec3 v_bc; // barycentric coordinate inside the triangle

out vec3 v_barycentric; // barycentric coordinate inside the triangle

uniform mat4 t_mvp; // modeview-projection matrix

void main()
{
    gl_Position = t_mvp * v_pos;
    v_barycentric = v_bc; // just pass it on
}

यहां, बैरिकेक्टिक निर्देशांक बस हैं (1, 0, 0), (0, 1, 0)और (0, 0, 1)तीन त्रिभुज कोने के लिए (ऑर्डर वास्तव में कोई फर्क नहीं पड़ता है, जो त्रिकोण स्ट्रिप्स में पैकिंग को आसान बनाता है)।

इस दृष्टिकोण का स्पष्ट नुकसान यह है कि यह कुछ बनावट निर्देशांक खाएगा और आपको अपने शीर्ष सरणी को संशोधित करने की आवश्यकता है। एक बहुत ही सरल ज्यामिति shader के साथ हल किया जा सकता है, लेकिन मुझे अभी भी संदेह है कि यह अधिक डेटा के साथ GPU को खिलाने की तुलना में धीमा होगा।


मैंने सोचा कि यह आशाजनक लग रहा है, हालांकि यह ओपनजीएल 3.2 (गैर-ईएस) के साथ किसी भी क्षमता में काम करने के लिए प्रकट नहीं होता है। यद्यपि यह संभव है कि मैंने कुछ गड़बड़ कर दी है, मैंने इसके साथ बहुत थोड़ा सा खेला है और वास्तव में यह निश्चित नहीं है कि इसका उपयोग कैसे करना है। क्या आप वास्तव में इन shaders के साथ प्रस्तुत करना चाहते हैं पर कोई और जानकारी उपयोगी होगी; मुझे नहीं लगता है कि एक भरण के अलावा कुछ भी उपयोगी कुछ भी कैसे पैदा करेगा, लेकिन यह भी काम नहीं करता है कि gl_FragColor का अल्फा मान पूरी तरह से ओपन 5 जी में नजरअंदाज कर दिया गया ...
user1167662

2
बिलकुल यह करता है। आप stackoverflow.com/questions/7361582/… में एक ही विचार के किसी के कार्यान्वयन का उल्लेख कर सकते हैं ।
सूअर

1
आपके सुझाए गए कार्यान्वयन का उपयोग करने के लिए मुझे जो समस्या है, वह है, मुझे लगता है कि छायाकार को कभी भी वस्तु के बाहर रेखाचित्र नहीं बनाया जाएगा। इसलिए यह उल्लिखित वस्तु की रूपरेखा तैयार करेगा? दूसरे शब्दों में, रूपरेखा तैयार की जाने वाली मूल वस्तु के भीतर विशुद्ध रूप से निहित होगी?
user1167662

1
@BrunoLevy आप वेबजीएल में अतिरिक्त समन्वयन प्राप्त कर सकते हैं, नहीं? यदि आप भाग्यशाली हैं, तो आप टेक्सकोर्ड्स से उन निर्देशांक प्राप्त करने में सक्षम हो सकते हैं यदि आपके पास बहुत सरल मॉडल हैं, लेकिन अन्यथा आपको केवल नए निर्देशांक जोड़ने की आवश्यकता है। बहुत अच्छा होगा अगर यह इसके बिना काम किया :)। आपको केवल एक स्केलर प्रति शीर्षिका को पास करना है (और फिर इसे शीर्ष-क्रम में 3-वेक्टर में विस्तारित करना है)।
सूअर

2
आह, अब मैं देख रहा हूँ ... f_width () मेरा दोस्त है, इस संबंध में। धन्यवाद
नील Gatenby

5

यदि आप निश्चित पाइपलाइन (ओपनजीएल <3.3) या संगतता प्रोफ़ाइल का उपयोग कर रहे हैं

//Turn on wireframe mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

//Draw the scene with polygons as lines (wireframe)
renderScene();

//Turn off wireframe mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

इस स्थिति में आप glLineWidth पर कॉल करके लाइन की चौड़ाई बदल सकते हैं

अन्यथा आपको अपनी ड्रा विधि (glDrawElements, glDrawArrays, आदि) के अंदर बहुभुज मोड को बदलने की आवश्यकता है और आप कुछ मोटे परिणामों के साथ समाप्त हो सकते हैं क्योंकि आपका शीर्ष डेटा त्रिकोण के लिए है और आप लाइनों को आउटपुट कर रहे हैं। सर्वोत्तम परिणामों के लिए ज्योमेट्री शेडर का उपयोग करने या वायरफ्रेम के लिए नया डेटा बनाने पर विचार करें ।


3

सबसे आसान तरीका है कि आदिमों को आकर्षित किया जाए GL_LINE_STRIP

glBegin(GL_LINE_STRIP);
/* Draw vertices here */
glEnd();

नहीं अगर यह GL_TRIANGLES का एक गुच्छा है: तो आप उन दोनों के बीच लाइनें प्राप्त करेंगे। OpenGL 1.x या विरासत में आप glPolygonMode का उपयोग करते हैं। हाल ही के ओपनगैल में आप जियोमेट्री शेडर के साथ खेलते हैं।
फेब्रीस NEYRET

यह उन चीजों को करने का एक प्राचीन तरीका है, जिन्हें पीछे छोड़ने की जरूरत है।
बेनी मैकेनी

2

आधुनिक ओपनजीएल (OpenGL 3.2 और उच्चतर) में, आप इसके लिए ज्योमेट्री शेडर का उपयोग कर सकते हैं:

#version 330

layout (triangles) in;
layout (line_strip /*for lines, use "points" for points*/, max_vertices=3) out;

in vec2 texcoords_pass[]; //Texcoords from Vertex Shader
in vec3 normals_pass[]; //Normals from Vertex Shader

out vec3 normals; //Normals for Fragment Shader
out vec2 texcoords; //Texcoords for Fragment Shader

void main(void)
{
    int i;
    for (i = 0; i < gl_in.length(); i++)
    {
        texcoords=texcoords_pass[i]; //Pass through
        normals=normals_pass[i]; //Pass through
        gl_Position = gl_in[i].gl_Position; //Pass through
        EmitVertex();
    }
    EndPrimitive();
}

नोटिस:


1

आप इस तरह से ग्लूट लाइब्रेरीज़ का उपयोग कर सकते हैं:

  1. एक क्षेत्र के लिए:

    glutWireSphere(radius,20,20);
    
  2. एक सिलेंडर के लिए:

    GLUquadric *quadratic = gluNewQuadric();
    gluQuadricDrawStyle(quadratic,GLU_LINE);
    gluCylinder(quadratic,1,1,1,12,1);
    
  3. एक घन के लिए:

    glutWireCube(1.5);
    

0

गैर-अलियास रेंडर टारगेट पर एंटी-अलियासड रेखाओं को खींचने का एक अच्छा और सरल तरीका एक 1x4 बनावट के साथ 4 पिक्सेल चौड़ाई के आयतों को खींचना है, अल्फा चैनल मानों के साथ {0., 1., 1., 1., 0।}। , और एमआईपी-मैपिंग के साथ रैखिक फ़िल्टरिंग का उपयोग करें। इससे लाइनें 2 पिक्सेल मोटी हो जाएंगी, लेकिन आप अलग-अलग मोटाई के लिए बनावट बदल सकते हैं। यह बैरीमेट्रिक गणनाओं की तुलना में तेज़ और आसान है।


0

इस फ़ंक्शन का उपयोग करें: शून्य glPolygonMode (ग्लीनम फेस, ग्लीनम मोड);

चेहरा: बहुभुज को निर्दिष्ट करता है जो मोड पर लागू होता है। पॉलीगोन के सामने की तरफ GL_FRONT और उसकी पीठ के लिए GL_BACK और दोनों के लिए GL_FRONT_AND_BACK हो सकते हैं।

मोड: तीन मोड परिभाषित हैं और मोड में निर्दिष्ट किए जा सकते हैं:

GL_POINT: एक सीमा किनारे की शुरुआत के रूप में चिह्नित बहुभुज कोने बिंदुओं के रूप में तैयार किए गए हैं।

GL_LINE: बहुभुज की सीमा किनारों को रेखा सेगमेंट के रूप में तैयार किया गया है। (आपका निशाना)

GL_FILL: बहुभुज का आंतरिक भाग भरा हुआ है।

पुनश्च: glPolygonMode ग्राफिक्स पाइपलाइन में रेखांकन के लिए बहुभुज की व्याख्या को नियंत्रित करता है।

अधिक जानकारी के लिए khronos समूह में OpenGL संदर्भ पृष्ठ देखें : https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glPolygonMode.xhtml


-1

यदि यह OpenGL ES 2.0 आपके साथ काम कर रहा है, तो आप इसमें से एक ड्रा मोड स्थिरांक चुन सकते हैं

GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, रेखाएँ बनाना,

GL_POINTS (यदि आपको केवल कोने खींचने की आवश्यकता है), या

GL_TRIANGLE_STRIP, GL_TRIANGLE_FANऔरGL_TRIANGLES भरे हुए त्रिकोणों को आकर्षित करने के लिए

अपने पहले तर्क के रूप में

glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)

या

glDrawArrays(GLenum mode, GLint first, GLsizei count) कहता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.