ओपनजीएल ईएस 2.0 पीएनजी अल्फा चैनल

Question

मैं एंड्रॉइड के लिए ओपनजीएल ईएस 2.0 के साथ काम करना सीख रहा हूं। मैं बस स्क्रीन के बीच में एक बनावट प्रदर्शित करने की कोशिश कर रहा हूं, जो काफी आसान था, लेकिन मुझे लगता है कि पीएनजी अल्फा ठीक से काम करने के लिए प्रतीत नहीं होता है। छवि या तो काले रंग की पृष्ठभूमि के साथ दिखाई देगी, या पूरी छवि को पृष्ठभूमि सेटिंग्स में मिश्रित किया जाएगा, जो सेटिंग्स मैं उपयोग करता हूं उसके आधार पर।

इस बिंदु तक पहुंचने के लिए मैंने जो वास्तविक ट्यूटोरियल का पालन किया है, वह पारदर्शिता के साथ कभी काम नहीं करता है, इसलिए मैंने कोड में काम करने की कोशिश की है जिसे मैंने चारों ओर खोजकर पाया है, और संभवतः एक महत्वपूर्ण कदम से चूक गया है। मैंने इस समस्या को हल करने के लिए काफी कुछ खोजा है, और मैंने कोई जवाब नहीं देखा है जिसमें मेरा सेटअप कुछ नहीं था। मैंने glblendFunc के हर संयोजन की कोशिश की है और कोई भाग्य नहीं है।

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

EDIT :: यहां मेरा टुकड़ा शेडर है, जो मुझे लगता है कि यह कारण है। यह एकमात्र ऐसा हिस्सा है जिसे मैंने कभी पारदर्शिता के साथ काम करने के लिए एक सभ्य उदाहरण नहीं मिला है, और बाकी सब कुछ जो मैंने कहीं और देखा है उससे मेल खाता है।

 final String fragmentShader =   
     "precision mediump float;  \n" 
     + "varying vec2 v_Color;   \n"  
     + "uniform sampler2D s_baseMap; \n" 
     + "void main()     \n"  
     + "{        \n" 
     + " vec4 baseColor;    \n" 
     + " baseColor = texture2D(s_baseMap, v_Color); \n" 
     + " gl_FragColor = baseColor;  \n"  
     + "}        \n"; 

यह कभी नहीं करता है अल्फा स्पष्ट रूप से कुछ भी, यह एक उदाहरण है कि यह सब के बाद का उपयोग नहीं करता से है, लेकिन मैं अभी भी टुकड़ा shaders के बारे में ज्यादा पता नहीं है और क्योंकि यह लग रहा था करने के लिए "एक तरह से" जब यह पृष्ठभूमि में छवि को मिश्रित करता है, तो मुझे लगता है कि यह कुछ रूपों में अल्फा के साथ काम कर रहा था और मैंने अभी कुछ गलत सेट किया था।

EDIT :: यहां "लोडटेक्चर" विधि है। यह लगभग ओपनजीएल ईएस 2.0 पुस्तक के उदाहरण जैसा ही है, जिसे मैं सीखने की कोशिश कर रहा हूं, कुछ बदलावों के साथ जो छवि को ठीक से काम करने के करीब लगती हैं।

private int loadTexture (InputStream is) 
{ 
    int[] textureId = new int[1]; 
    Bitmap bitmap; 
    bitmap = BitmapFactory.decodeStream(is); 
    byte[] buffer = new byte[bitmap.getWidth() * bitmap.getHeight() * 4]; 

    for (int y = 0; y < bitmap.getHeight(); y++) 
     for (int x = 0; x < bitmap.getWidth(); x++) 
     { 
      int pixel = bitmap.getPixel(x, y); 
      buffer[(y * bitmap.getWidth() + x) * 4 + 0] = (byte)((pixel >> 16) & 0xFF); 
      buffer[(y * bitmap.getWidth() + x) * 4 + 1] = (byte)((pixel >> 8) & 0xFF); 
      buffer[(y * bitmap.getWidth() + x) * 4 + 2] = (byte)((pixel >> 0) & 0xFF); 
     } 

    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(bitmap.getWidth() * bitmap.getHeight() * 4); 
    byteBuffer.put(buffer).position(0); 

    GLES20.glGenTextures (1, textureId, 0); 
    GLES20.glBindTexture (GLES20.GL_TEXTURE_2D, textureId[0]); 

    GLES20.glTexImage2D (GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, bitmap.getWidth(), bitmap.getHeight(), 0, 
          GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, byteBuffer); 

    GLES20.glTexParameteri (GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR); 
    GLES20.glTexParameteri (GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR); 
    GLES20.glTexParameteri (GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE); 
    GLES20.glTexParameteri (GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE); 

    return textureId[0]; 
} 

मैं समझता हूँ कि क्या कोड क्या कर रहा है, लेकिन बेशक यह अभी भी मुझे ज्ञान की मेरी कमी के कारण एक सा तो मैं बस कुछ स्पष्ट गायब हो सकता है confuses।

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

Answer 1

आप संभवतः glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) को मिश्रण समारोह के रूप में उपयोग करना चाहते हैं और आपको gl_FragColor खंड शतरंज आउटपुट चर में बनावट के अल्फा मान को भी लिखना है।

आपके अपलोड किए गए बनावट डेटा को काम करने के लिए सभी को अल्फा मान होना चाहिए और आपने अल्फा चैनल (आरजीबीए, आरजीबीए 8 इत्यादि) का समर्थन करने वाले एक बनावट प्रारूप का उपयोग किया होगा।

आप आरजीबी रंग घटकों को अल्फा मान को रूट करके और आपको प्राप्त होने वाली छवि का निरीक्षण करके इसे सत्यापित कर सकते हैं।

संपादित करें:

अपनी छवि लोड हो रहा है कोड में आप अल्फ़ा चैनल पर कॉपी करने भूलना! सुझाव दें कि डेवबाइट देता है।

Answer 2

आपका प्रारंभिक शेडर ठीक है। अल्फा रंग ops में अंतर्निहित है, यह मिश्रण/मोड/आदि के आधार पर लागू नहीं किया जा सकता है।

यह देखते हुए कि यदि आप fragcolor = base.aaa करते हैं तो आपका बनावट काला हो जाता है, जिसका अर्थ है कि आपका बनावट डेटा 'खराब' है।

अपने बनावट लोड को देखते हुए, हाँ, यह गलत है। आप अल्फा, बस आरजीबी पर कभी कॉपी नहीं करते हैं। मानते हुए कि जावा बाइट सरणी को 0s पर साफ़ करता है, सभी अल्फा शून्य होंगे, जो आपको अपना ब्लैक बॉक्स प्राप्त करेंगे, जिससे आप अल्फा ब्लेंडिंग सक्षम करते समय छवि को 'गायब' कर देंगे।

अपने जीवन को आसान बनाने के लिए, सभी हाथ नकल और सामान के बजाय, आप बस सामान्य रूप से बिटमैप लोड और बजाय सीधे glTexImage2d का उपयोग कर के अपलोड करने के लिए GLUtils सहायक का उपयोग कर सकते हैं:

bitmap = BitmapFactory.decodeStream(is); 
    GLES20.glGenTextures (1, textureId, 0); 
    GLES20.glBindTexture (GLES20.GL_TEXTURE_2D, textureId[0]); 
    GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0); 

कुछ ऐसे ही। फिर मिश्रण को सक्षम करें, अगर preultiplied नहीं है, तो src + invsrc मिश्रण मोड का उपयोग करें, और प्रस्तुत करें, आपको वांछित परिणाम प्राप्त करना चाहिए।

Answer 3

बदलें

for (int y = 0; y < bitmap.getHeight(); y++) 
    for (int x = 0; x < bitmap.getWidth(); x++) 
    { 
     int pixel = bitmap.getPixel(x, y); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 0] = (byte)((pixel >> 16) & 0xFF); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 1] = (byte)((pixel >> 8) & 0xFF); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 2] = (byte)((pixel >> 0) & 0xFF); 
    } 

for (int y = 0; y < bitmap.getHeight(); y++) 
    for (int x = 0; x < bitmap.getWidth(); x++) 
    { 
     int pixel = bitmap.getPixel(x, y); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 0] = (byte)((pixel >> 16) & 0xFF); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 1] = (byte)((pixel >> 8) & 0xFF); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 2] = (byte)((pixel >> 0) & 0xFF); 
     buffer[(y * bitmap.getWidth() + x) * 4 + 3] = (byte)((pixel >> 24) & 0xFF); 
    } 

में अल्फा जानकारी शामिल करने के तो बस

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

जोड़ने सही इससे पहले कि आप बनावट आकर्षित। एक बार पूरा होने के बाद GL_BLEND को अक्षम करना याद रखें।