मैं 2 डी इंजन पर काम कर रहा हूं। यह पहले से ही काफी अच्छा काम करता है, लेकिन मुझे पिक्सेल-त्रुटियां मिल रही हैं।ओपनगल पिक्सेल सही 2 डी ड्राइंग
उदाहरण के लिए, मेरी विंडो 960x540 पिक्सेल है, मैं (0, 0) से (95 9, 0) तक एक रेखा खींचता हूं। मैं उम्मीद करता हूं कि स्कैन-लाइन 0 पर प्रत्येक पिक्सेल रंग पर सेट हो जाएगा, लेकिन नहीं: सही-पिक्सेल खींचा नहीं गया है। जब मैं पिक्सेल 539 पर लंबवत रूप से खींचता हूं तो वही समस्या। मुझे इसे खींचने के लिए वास्तव में (960, 0) या (0, 540) आकर्षित करने की आवश्यकता है।
जैसा कि मैं पिक्सेल युग में पैदा हुआ था, मुझे विश्वास है कि यह सही परिणाम नहीं है। जब मेरी स्क्रीन 320x200 पिक्सल बड़ी थी, तो मैं 0 से 319 तक और 0 से 199 तक खींच सकता था, और मेरी स्क्रीन पूरी हो जाएगी। अब मैं एक स्क्रीन के साथ एक दाएं/नीचे पिक्सेल खींचा नहीं है।
यह विभिन्न चीजों के कारण हो सकता है: जहां मुझे उम्मीद है कि ओपनगल लाइन आदिम को पिक्सेल से पिक्सेल तक खींचा जा सकता है, आखिरी पिक्सेल वास्तव में अनन्य है? क्या यही है? मेरा प्रक्षेपण मैट्रिक्स गलत है? मैं झूठी धारणा के तहत हूं कि जब मेरे पास 960x540 का बैकबफर है, तो वास्तव में एक पिक्सल अधिक है? कुछ और?
क्या कोई मेरी मदद कर सकता है? मैं अब इस समस्या को लंबे समय से देख रहा हूं, और हर बार जब मैंने सोचा कि यह ठीक है, तो मैंने थोड़ी देर बाद देखा कि यह वास्तव में नहीं था।
यहां मेरा कुछ कोड है, मैंने जितना संभव हो उतना इसे पट्टी करने की कोशिश की। जब मैं अपना लाइन-फ़ंक्शन कॉल करता हूं, तो प्रत्येक समन्वय को 0.375, 0.375 के साथ जोड़ा जाता है ताकि यह अति और एनवीडिया एडाप्टर दोनों पर सही हो सके।
int width = resX();
int height = resY();
for (int i = 0; i < height; i += 2)
rm->line(0, i, width - 1, i, vec4f(1, 0, 0, 1));
for (int i = 1; i < height; i += 2)
rm->line(0, i, width - 1, i, vec4f(0, 1, 0, 1));
// when I do this, one pixel to the right remains undrawn
void rendermachine::line(int x1, int y1, int x2, int y2, const vec4f &color)
{
... some code to decide what std::vector the coordinates should be pushed into
// m_z is a z-coordinate, I use z-buffering to preserve correct drawing orders
// vec2f(0, 0) is a texture-coordinate, the line is drawn without texturing
target->push_back(vertex(vec3f((float)x1 + 0.375f, (float)y1 + 0.375f, m_z), color, vec2f(0, 0)));
target->push_back(vertex(vec3f((float)x2 + 0.375f, (float)y2 + 0.375f, m_z), color, vec2f(0, 0)));
}
void rendermachine::update(...)
{
... render target object is queried for width and height, in my test it is just the back buffer so the window client resolution is returned
mat4f mP;
mP.setOrthographic(0, (float)width, (float)height, 0, 0, 8000000);
... all vertices are copied to video memory
... drawing
if (there are lines to draw)
glDrawArrays(GL_LINES, (int)offset, (int)lines.size());
...
}
// And the (very simple) shader to draw these lines
// Vertex shader
#version 120
attribute vec3 aVertexPosition;
attribute vec4 aVertexColor;
uniform mat4 mP;
varying vec4 vColor;
void main(void) {
gl_Position = mP * vec4(aVertexPosition, 1.0);
vColor = aVertexColor;
}
// Fragment shader
#version 120
#ifdef GL_ES
precision highp float;
#endif
varying vec4 vColor;
void main(void) {
gl_FragColor = vColor.rgb;
}
मुझे लगता है कि यह "बिंदु विशेष" चीज है जिसके बारे में मैं बात कर रहा हूं। यदि आप पंक्तियों को आकर्षित करने के लिए क्यूटी या सी ++ बिल्डर/डेल्फी या यहां तक कि विंडोज एपीआई का उपयोग करते हैं, तो पिक्सेल अंत-बिंदु को छोड़कर खींचे जाते हैं। तो यह संभव है कि ओपनएल में भी किया जाता है, और शायद त्रिभुजों को चित्रित करते समय भी? जब आप क्यूटी, बिल्डर, ... के साथ एक आयताकार खींचते हैं, तो आपको नीचे दाएं कोने को भी बाहर रखा जाता है ... – scippie
निम्न परीक्षण ऊपर बताए गए समझौते के साथ अनुबंध दिखाता है: जब मैं खिड़की के सभी कोनों पर पिक्सल भरने के लिए जीएल_POINT का उपयोग करता हूं, तो ये निर्देशांक होते हैं क्योंकि मैं उन्हें उम्मीद करता हूं: (0,0), (चौड़ाई -1, ऊंचाई -1)। यह मुझे दिखाता है कि ड्राइंग का मेरा तरीका सही है और उस रेखा (और संभवतः त्रिकोण) में अंत-बिंदु शामिल नहीं होगा। क्या कोई सहमत हो सकता है? – scippie
संबंधित http://stackoverflow.com/questions/5467218/opengl-2d-hud-over-3d –