सही glsl affine बनावट मानचित्रण

Question

मैं जीएलएसएल में सही 2 डी एफ़िन बनावट मैपिंग कोड करने की कोशिश कर रहा हूं।

स्पष्टीकरण:

... इस छवियों से कोई भी मेरी प्रयोजनों के लिए सही है। दाएं (सही लेबल लेबल) में परिप्रेक्ष्य सुधार है जो मैं नहीं चाहता हूं। तो यह: Getting to know the Q texture coordinate समाधान (आगे के सुधार के बिना) वह नहीं है जिसे मैं ढूंढ रहा हूं।

मैं बस "खिंचाव" बनावट चतुर्भुज के अंदर, कुछ इस तरह करना चाहते हैं:

लेकिन दो त्रिकोण से बना। कोई सलाह (जीएलएसएल) कृपया?

Answer 1

जवाब के लिए धन्यवाद, लेकिन प्रयोग करने के बाद मैं एक समाधान मिल गया। बाईं तरफ

दो त्रिकोण यूवी (strq) के अनुसार सही पर this और दो त्रिकोण इस परिप्रेक्ष्य सुधार के संस्करण modifed कर रहे हैं।

नंबर और शेडर:

tri1 = [Vec2(-0.5, -1), Vec2(0.5, -1), Vec2(1, 1)] 
tri2 = [Vec2(-0.5, -1), Vec2(1, 1), Vec2(-1, 1)] 

d1 = length of top edge = 2 
d2 = length of bottom edge = 1 

tri1_uv = [Vec4(0, 0, 0, d2/d1), Vec4(d2/d1, 0, 0, d2/d1), Vec4(1, 1, 0, 1)] 
tri2_uv = [Vec4(0, 0, 0, d2/d1), Vec4(1, 1, 0, 1), Vec4(0, 1, 0, 1)] 

केवल समकोण त्रिकोण इस GLSL शेडर का उपयोग कर गाया जाता है (बाईं ओर निश्चित पाइपलाइन है):

void main() 
{ 
    gl_FragColor = texture2D(colormap, vec2(gl_TexCoord[0].x/glTexCoord[0].w, gl_TexCoord[0].y); 
} 

तो .. केवल यू परिप्रेक्ष्य है और वी रेखीय है ।

Answer 2

यह तब तक अच्छी तरह से काम करता है जब तक आपके पास ट्रैपेज़ॉयड होता है, और इसके समांतर किनारों को स्थानीय अक्षों में से एक के साथ गठबंधन किया जाता है। मैं अपने Unity package के साथ खेलने की सलाह देते हैं।

GLSL:

varying vec2 shiftedPosition, width_height; 

#ifdef VERTEX 
void main() { 
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; 
    shiftedPosition = gl_MultiTexCoord0.xy; // left and bottom edges zeroed. 
    width_height = gl_MultiTexCoord1.xy; 
} 
#endif 

#ifdef FRAGMENT 
uniform sampler2D _MainTex; 
void main() { 
    gl_FragColor = texture2D(_MainTex, shiftedPosition/width_height); 
} 
#endif 

सी #:

// Zero out the left and bottom edges, 
// leaving a right trapezoid with two sides on the axes and a vertex at the origin. 
var shiftedPositions = new Vector2[] { 
    Vector2.zero, 
    new Vector2(0, vertices[1].y - vertices[0].y), 
    new Vector2(vertices[2].x - vertices[1].x, vertices[2].y - vertices[3].y), 
    new Vector2(vertices[3].x - vertices[0].x, 0) 
}; 
mesh.uv = shiftedPositions; 

var widths_heights = new Vector2[4]; 
widths_heights[0].x = widths_heights[3].x = shiftedPositions[3].x; 
widths_heights[1].x = widths_heights[2].x = shiftedPositions[2].x; 
widths_heights[0].y = widths_heights[1].y = shiftedPositions[1].y; 
widths_heights[2].y = widths_heights[3].y = shiftedPositions[2].y; 
mesh.uv2 = widths_heights; 

Answer 3

मैं हाल ही में किसी भी प्रकार के चतुर्भुज के लिए इस समस्या के सामान्य समाधान के साथ आने में कामयाब रहा। गणना और जीएलएसएल शायद मदद की। जावा (जो एंड्रॉइड पर चलता है) में एक कामकाजी डेमो है, लेकिन कॉम्पैक्ट और पठनीय है और इसे एकता या आईओएस के लिए आसानी से पोर्टेबल होना चाहिए: http://www.bitlush.com/posts/arbitrary-quadrilaterals-in-opengl-es-2-0

Answer 4

टेस्सेलेशन इस समस्या को हल करता है। उप-विभाजित क्वाड वर्टेक्स पिक्सल को इंटरपोल करने के लिए संकेत जोड़ता है।

इस लिंक को देखें। https://www.youtube.com/watch?v=8TleepxIORU&feature=youtu.be