पारदर्शी पृष्ठभूमि के साथ एक OpenGL प्रतिपादन संदर्भ कैसे बनाएं?

Question

प्रतिपादन संदर्भों की पृष्ठभूमि पर आमतौर पर एक ठोस रंग होता है (काला या जो भी हो, नीचे दी गई छवि देखें):

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

यह भ्रम देगा कि त्रिकोण स्क्रीन पर तैर रहा है। पारदर्शी पृष्ठभूमि आपको डेस्कटॉप या अन्य अनुप्रयोगों को देखने की अनुमति दे सकती है जो इसके पीछे हो सकते हैं।

क्या आप कृपया स्रोत कोड के साथ अनुकरण कर सकते हैं?

प्लेटफ़ॉर्म: Windows (केवल win32)

Answer 1

इस मुद्दे पर कुछ मदद पाने के लिए एक असफल इनाम पर कुछ प्रतिष्ठा खर्च करने के बाद , मुझे आखिरकार एहसास हुआ कि जिस समस्या में मेरी दिलचस्पी थी वह कितनी जटिल थी।

इस कार्य को पूरा करने वाले कुछ व्यक्ति अधिक साझा नहीं करते हैं । अपने शोध के दौरान मैंने जो कुछ भी पाया उसकी प्राप्ति के लिए मैंने अलग-अलग तरीके खोजे। सबसे दिलचस्प में से एक AeroGL है , और यह एक ऐसी तकनीक का उपयोग करके कोड के स्निपेट दिखाता है जो अब तक उल्लेख नहीं किया गया था, जो ग्राफिक्स को एक डिवाइस-स्वतंत्र बिटमैप (DIB) के लिए प्रस्तुत कर रहा है।

इस धागे को स्थायी रूप से बंद करने के लिए, स्रोत कोड उस तकनीक को लागू करता है। कोड स्वयं यहां प्रस्तुत एक आवेदन का एक मामूली संशोधन है ( आंद्रेई सैप्रोनोव वाई के लिए बड़ा धन्यवाद )।

अंतिम परिणाम नीचे दी गई छवि में देखा जा सकता है:

कोड का परीक्षण विंडोज एक्सपी (32-बिट) और विंडोज 8.1 (32-बिट) पर किया गया है। का आनंद लें!

#define _WIN32_WINNT 0x0500

#include <windows.h>
#include <windowsx.h>
#include <GL/gl.h>
#include <GL/glu.h>

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glu32.lib")

#include <assert.h>
#include <tchar.h>

#ifdef  assert
#define verify(expr) if(!expr) assert(0)
#else verify(expr) expr
#endif

const TCHAR szAppName[]=_T("TransparentGL");
const TCHAR wcWndName[]=_T("WS_EX_LAYERED OpenGL");

HDC hDC;            
HGLRC m_hrc;        
int w(240);
int h(240); 

HDC pdcDIB;                 
HBITMAP hbmpDIB;            
void *bmp_cnt(NULL);        
int cxDIB(0); 
int cyDIB(0);   
BITMAPINFOHEADER BIH;       


BOOL initSC()
{
    glEnable(GL_ALPHA_TEST);        
    glEnable(GL_DEPTH_TEST);        
    glEnable(GL_COLOR_MATERIAL);

    glEnable(GL_LIGHTING);          
    glEnable(GL_LIGHT0);            

    glEnable(GL_BLEND);             
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(0, 0, 0, 0);

    return 0;
}

void resizeSC(int width,int height)
{
    glViewport(0,0,width,height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glMatrixMode(GL_MODELVIEW );
    glLoadIdentity();
}

BOOL renderSC()
{   
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glPushMatrix();

    glColor3f(0, 1, 1);
    glBegin(GL_TRIANGLES);                              // Drawing Using Triangles
        glColor3f(1.0f,0.0f,0.0f);                      // Set The Color To Red
        glVertex3f( 0.0f, 1.0f, 0.0f);                  // Top
        glColor3f(0.0f,1.0f,0.0f);                      // Set The Color To Green
        glVertex3f(-1.0f,-1.0f, 0.0f);                  // Bottom Left
        glColor3f(0.0f,0.0f,1.0f);                      // Set The Color To Blue
        glVertex3f( 1.0f,-1.0f, 0.0f);                  // Bottom Right
    glEnd();

    glPopMatrix();
    glFlush();

    return 0;
}

// DIB -> hDC
void draw(HDC pdcDest)
{
    assert(pdcDIB);

    verify(BitBlt(pdcDest, 0, 0, w, h, pdcDIB, 0, 0, SRCCOPY));
}

void CreateDIB(int cx, int cy)
{
    assert(cx > 0); 
    assert(cy > 0);

    cxDIB = cx ;
    cyDIB = cy ;

    int iSize = sizeof(BITMAPINFOHEADER);   
    memset(&BIH, 0, iSize);

    BIH.biSize = iSize;
    BIH.biWidth = cx;   
    BIH.biHeight = cy;  
    BIH.biPlanes = 1;   
    BIH.biBitCount = 24;    
    BIH.biCompression = BI_RGB;

    if(pdcDIB) 
        verify(DeleteDC(pdcDIB));

    pdcDIB = CreateCompatibleDC(NULL);
    assert(pdcDIB);

    if(hbmpDIB) 
        verify(DeleteObject(hbmpDIB));

    hbmpDIB = CreateDIBSection(
        pdcDIB,         
        (BITMAPINFO*)&BIH,  
        DIB_RGB_COLORS,     
        &bmp_cnt,       
        NULL,
        0);

    assert(hbmpDIB);
    assert(bmp_cnt);

    if(hbmpDIB)
        SelectObject(pdcDIB, hbmpDIB);
}

BOOL CreateHGLRC()
{
    DWORD dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_BITMAP;

    PIXELFORMATDESCRIPTOR pfd ;
    memset(&pfd,0, sizeof(PIXELFORMATDESCRIPTOR)) ;
    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); 
    pfd.nVersion = 1;                       
    pfd.dwFlags =  dwFlags ;                
    pfd.iPixelType = PFD_TYPE_RGBA ;        
    pfd.cColorBits = 24 ;                   
    pfd.cDepthBits = 32 ;                   
    pfd.iLayerType = PFD_MAIN_PLANE ;       

   int PixelFormat = ChoosePixelFormat(pdcDIB, &pfd);
   if (PixelFormat == 0){
      assert(0);
      return FALSE ;
   }

   BOOL bResult = SetPixelFormat(pdcDIB, PixelFormat, &pfd);
   if (bResult==FALSE){
      assert(0);
      return FALSE ;
   }

   m_hrc = wglCreateContext(pdcDIB);
   if (!m_hrc){
      assert(0);
      return FALSE;
   }

   return TRUE;
}

LRESULT CALLBACK WindowFunc(HWND hWnd,UINT msg, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;

    switch(msg) 
    {
        case WM_ERASEBKGND:
            return 0;
        break;

        case WM_CREATE:
        break;

        case WM_DESTROY:
            if(m_hrc)
            {
                wglMakeCurrent(NULL, NULL);
                wglDeleteContext(m_hrc) ;
            }
            PostQuitMessage(0) ;
        break;

        case WM_PAINT:
            hDC = BeginPaint(hWnd, &ps);
            renderSC(); // OpenGL -> DIB
            draw(hDC);  // DIB -> hDC
            EndPaint(hWnd, &ps);
        break;

        case WM_SIZE:
            w = LOWORD(lParam); h = HIWORD(lParam);         
            wglMakeCurrent(NULL, NULL);
            wglDeleteContext(m_hrc);

            CreateDIB(w, h);
            CreateHGLRC();
            verify(wglMakeCurrent(pdcDIB, m_hrc));

            initSC();
            resizeSC(w, h);
            renderSC();
        break;

        default: 
            return DefWindowProc(hWnd,msg,wParam,lParam);
    }

    return 0;
}

int WINAPI _tWinMain(HINSTANCE hThisInst, HINSTANCE hPrevInst, LPSTR str,int nWinMode)
{   
    WNDCLASSEX wc;
    memset(&wc, 0, sizeof(wc));
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = (WNDPROC)WindowFunc;
    wc.cbClsExtra  = 0;
    wc.cbWndExtra  = 0;
    wc.hInstance = hThisInst;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) (COLOR_WINDOW);
    wc.lpszClassName = szAppName;

    if(!RegisterClassEx(&wc))
    {
        MessageBox(NULL, _T("RegisterClassEx - failed"), _T("Error"), MB_OK | MB_ICONERROR);
        return FALSE;
    }

    HWND hWnd = CreateWindowEx(WS_EX_LAYERED, szAppName, wcWndName,
                    WS_VISIBLE | WS_POPUP, 200, 150, w, h,
                    NULL, NULL, hThisInst, NULL);
    if(!hWnd){
        MessageBox(NULL, _T("CreateWindowEx - failed"), _T("Error"), MB_OK | MB_ICONERROR);
        return FALSE;
    }

    verify(SetLayeredWindowAttributes(hWnd, 0x0, 0, LWA_COLORKEY));

    MSG msg;
    while(1) 
    {
        while (PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)){
            if (GetMessage(&msg, NULL, 0, 0))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
            else return 0;
        }
    } 

    return (FALSE); 
}

Comments

यह कहने योग्य है कि यह तकनीक जटिल प्रतिपादन और ग्राफिक्स एनिमेशन के लिए व्यावहारिक नहीं है। प्रत्येक फ्रेम के लिए रैम को GPU डेटा की प्रतिलिपि बनाना सीपीयू पर बहुत मांग है, जिसके परिणामस्वरूप कम एफपीएस है। इस उत्तर पर टिप्पणियों की जाँच करें: stackoverflow.com/questions/4780756/…

— karlphillip

ध्यान दें कि विंडोज विस्टा और विंडोज 7 में आप नीचे दिए गए मेरे x11argb डेमो के समान प्रभाव प्राप्त कर सकते हैं। PIXELFORMATDESCRIPTOR रचना को सक्षम करने के लिए एक नए ध्वज का समर्थन करता है। मैंने अभी तक इसके लिए डेमो नहीं बनाया है, हालांकि। अप्रैल तक होने वाला नहीं है, हालांकि, जब मुझे उसके लिए फिर से समय मिला है।

— डेटेनवॉल्फ

Answer 2

चूंकि अब तक दिए गए सभी उत्तर केवल विंडोज को लक्षित करते हैं, लेकिन निश्चित रूप से X11 पर एक कंपोजिट विंडो मैनेजर के साथ ऐसा करने की भी मांग है, संदर्भ के लिए मैं यहां अपना उदाहरण कोड पोस्ट करता हूं ( https://github.com/datenwolf पर भी पाया जा सकता है) /codesamples/blob/master/samples/OpenGL/x11argb_opengl/x11argb_opengl.c

/*------------------------------------------------------------------------
 * A demonstration of OpenGL in a  ARGB window 
 *    => support for composited window transparency
 *
 * (c) 2011 by Wolfgang 'datenwolf' Draxinger
 *     See me at comp.graphics.api.opengl and StackOverflow.com

 * License agreement: This source code is provided "as is". You
 * can use this source code however you want for your own personal
 * use. If you give this source code to anybody else then you must
 * leave this message in it.
 *
 * This program is based on the simplest possible 
 * Linux OpenGL program by FTB (see info below)

  The simplest possible Linux OpenGL program? Maybe...

  (c) 2002 by FTB. See me in comp.graphics.api.opengl

  --
  <\___/>
  / O O \
  \_____/  FTB.

------------------------------------------------------------------------*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include <GL/gl.h>
#include <GL/glx.h>
#include <GL/glxext.h>
#include <X11/Xatom.h>
#include <X11/extensions/Xrender.h>
#include <X11/Xutil.h>

#define USE_CHOOSE_FBCONFIG

static void fatalError(const char *why)
{
    fprintf(stderr, "%s", why);
    exit(0x666);
}

static int Xscreen;
static Atom del_atom;
static Colormap cmap;
static Display *Xdisplay;
static XVisualInfo *visual;
static XRenderPictFormat *pict_format;
static GLXFBConfig *fbconfigs, fbconfig;
static int numfbconfigs;
static GLXContext render_context;
static Window Xroot, window_handle;
static GLXWindow glX_window_handle;
static int width, height;

static int VisData[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_DOUBLEBUFFER, True,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 16,
None
};

static int isExtensionSupported(const char *extList, const char *extension)
{

  const char *start;
  const char *where, *terminator;

  /* Extension names should not have spaces. */
  where = strchr(extension, ' ');
  if ( where || *extension == '\0' )
    return 0;

  /* It takes a bit of care to be fool-proof about parsing the
     OpenGL extensions string. Don't be fooled by sub-strings,
     etc. */
  for ( start = extList; ; ) {
    where = strstr( start, extension );

    if ( !where )
      break;

    terminator = where + strlen( extension );

    if ( where == start || *(where - 1) == ' ' )
      if ( *terminator == ' ' || *terminator == '\0' )
        return 1;

    start = terminator;
  }
  return 0;
}

static Bool WaitForMapNotify(Display *d, XEvent *e, char *arg)
{    
    return d && e && arg && (e->type == MapNotify) && (e->xmap.window == *(Window*)arg);
}

static void describe_fbconfig(GLXFBConfig fbconfig)
{
    int doublebuffer;
    int red_bits, green_bits, blue_bits, alpha_bits, depth_bits;

    glXGetFBConfigAttrib(Xdisplay, fbconfig, GLX_DOUBLEBUFFER, &doublebuffer);
    glXGetFBConfigAttrib(Xdisplay, fbconfig, GLX_RED_SIZE, &red_bits);
    glXGetFBConfigAttrib(Xdisplay, fbconfig, GLX_GREEN_SIZE, &green_bits);
    glXGetFBConfigAttrib(Xdisplay, fbconfig, GLX_BLUE_SIZE, &blue_bits);
    glXGetFBConfigAttrib(Xdisplay, fbconfig, GLX_ALPHA_SIZE, &alpha_bits);
    glXGetFBConfigAttrib(Xdisplay, fbconfig, GLX_DEPTH_SIZE, &depth_bits);

    fprintf(stderr, "FBConfig selected:\n"
        "Doublebuffer: %s\n"
        "Red Bits: %d, Green Bits: %d, Blue Bits: %d, Alpha Bits: %d, Depth Bits: %d\n",
        doublebuffer == True ? "Yes" : "No", 
        red_bits, green_bits, blue_bits, alpha_bits, depth_bits);
}

static void createTheWindow()
{
    XEvent event;
    int x,y, attr_mask;
    XSizeHints hints;
    XWMHints *startup_state;
    XTextProperty textprop;
    XSetWindowAttributes attr = {0,};
    static char *title = "FTB's little OpenGL example - ARGB extension by WXD";

    Xdisplay = XOpenDisplay(NULL);
    if (!Xdisplay) {
        fatalError("Couldn't connect to X server\n");
    }
    Xscreen = DefaultScreen(Xdisplay);
    Xroot = RootWindow(Xdisplay, Xscreen);

    fbconfigs = glXChooseFBConfig(Xdisplay, Xscreen, VisData, &numfbconfigs);
    fbconfig = 0;
    for(int i = 0; i<numfbconfigs; i++) {
        visual = (XVisualInfo*) glXGetVisualFromFBConfig(Xdisplay, fbconfigs[i]);
        if(!visual)
            continue;

        pict_format = XRenderFindVisualFormat(Xdisplay, visual->visual);
        if(!pict_format)
            continue;

        fbconfig = fbconfigs[i];
        if(pict_format->direct.alphaMask > 0) {
            break;
        }
    }

    if(!fbconfig) {
        fatalError("No matching FB config found");
    }

    describe_fbconfig(fbconfig);

    /* Create a colormap - only needed on some X clients, eg. IRIX */
    cmap = XCreateColormap(Xdisplay, Xroot, visual->visual, AllocNone);

    attr.colormap = cmap;
    attr.background_pixmap = None;
    attr.border_pixmap = None;
    attr.border_pixel = 0;
    attr.event_mask =
        StructureNotifyMask |
        EnterWindowMask |
        LeaveWindowMask |
        ExposureMask |
        ButtonPressMask |
        ButtonReleaseMask |
        OwnerGrabButtonMask |
        KeyPressMask |
        KeyReleaseMask;

    attr_mask = 
        CWBackPixmap|
        CWColormap|
        CWBorderPixel|
        CWEventMask;

    width = DisplayWidth(Xdisplay, DefaultScreen(Xdisplay))/2;
    height = DisplayHeight(Xdisplay, DefaultScreen(Xdisplay))/2;
    x=width/2, y=height/2;

    window_handle = XCreateWindow(  Xdisplay,
                    Xroot,
                    x, y, width, height,
                    0,
                    visual->depth,
                    InputOutput,
                    visual->visual,
                    attr_mask, &attr);

    if( !window_handle ) {
        fatalError("Couldn't create the window\n");
    }

#if USE_GLX_CREATE_WINDOW
    int glXattr[] = { None };
    glX_window_handle = glXCreateWindow(Xdisplay, fbconfig, window_handle, glXattr);
    if( !glX_window_handle ) {
        fatalError("Couldn't create the GLX window\n");
    }
#else
    glX_window_handle = window_handle;
#endif

    textprop.value = (unsigned char*)title;
    textprop.encoding = XA_STRING;
    textprop.format = 8;
    textprop.nitems = strlen(title);

    hints.x = x;
    hints.y = y;
    hints.width = width;
    hints.height = height;
    hints.flags = USPosition|USSize;

    startup_state = XAllocWMHints();
    startup_state->initial_state = NormalState;
    startup_state->flags = StateHint;

    XSetWMProperties(Xdisplay, window_handle,&textprop, &textprop,
            NULL, 0,
            &hints,
            startup_state,
            NULL);

    XFree(startup_state);

    XMapWindow(Xdisplay, window_handle);
    XIfEvent(Xdisplay, &event, WaitForMapNotify, (char*)&window_handle);

    if ((del_atom = XInternAtom(Xdisplay, "WM_DELETE_WINDOW", 0)) != None) {
        XSetWMProtocols(Xdisplay, window_handle, &del_atom, 1);
    }
}

static int ctxErrorHandler( Display *dpy, XErrorEvent *ev )
{
    fputs("Error at context creation", stderr);
    return 0;
}

static void createTheRenderContext()
{
    int dummy;
    if (!glXQueryExtension(Xdisplay, &dummy, &dummy)) {
        fatalError("OpenGL not supported by X server\n");
    }

#if USE_GLX_CREATE_CONTEXT_ATTRIB
    #define GLX_CONTEXT_MAJOR_VERSION_ARB       0x2091
    #define GLX_CONTEXT_MINOR_VERSION_ARB       0x2092
    render_context = NULL;
    if( isExtensionSupported( glXQueryExtensionsString(Xdisplay, DefaultScreen(Xdisplay)), "GLX_ARB_create_context" ) ) {
        typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
        glXCreateContextAttribsARBProc glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc)glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );
        if( glXCreateContextAttribsARB ) {
            int context_attribs[] =
            {
                GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
                GLX_CONTEXT_MINOR_VERSION_ARB, 0,
                //GLX_CONTEXT_FLAGS_ARB        , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
                None
            };

            int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);

            render_context = glXCreateContextAttribsARB( Xdisplay, fbconfig, 0, True, context_attribs );

            XSync( Xdisplay, False );
            XSetErrorHandler( oldHandler );

            fputs("glXCreateContextAttribsARB failed", stderr);
        } else {
            fputs("glXCreateContextAttribsARB could not be retrieved", stderr);
        }
    } else {
            fputs("glXCreateContextAttribsARB not supported", stderr);
    }

    if(!render_context)
    {
#else
    {
#endif
        render_context = glXCreateNewContext(Xdisplay, fbconfig, GLX_RGBA_TYPE, 0, True);
        if (!render_context) {
            fatalError("Failed to create a GL context\n");
        }
    }

    if (!glXMakeContextCurrent(Xdisplay, glX_window_handle, glX_window_handle, render_context)) {
        fatalError("glXMakeCurrent failed for window\n");
    }
}

static int updateTheMessageQueue()
{
    XEvent event;
    XConfigureEvent *xc;

    while (XPending(Xdisplay))
    {
        XNextEvent(Xdisplay, &event);
        switch (event.type)
        {
        case ClientMessage:
            if (event.xclient.data.l[0] == del_atom)
            {
                return 0;
            }
        break;

        case ConfigureNotify:
            xc = &(event.xconfigure);
            width = xc->width;
            height = xc->height;
            break;
        }
    }
    return 1;
}

/*  6----7
   /|   /|
  3----2 |
  | 5--|-4
  |/   |/
  0----1

*/

GLfloat cube_vertices[][8] =  {
    /*  X     Y     Z   Nx   Ny   Nz    S    T */
    {-1.0, -1.0,  1.0, 0.0, 0.0, 1.0, 0.0, 0.0}, // 0
    { 1.0, -1.0,  1.0, 0.0, 0.0, 1.0, 1.0, 0.0}, // 1
    { 1.0,  1.0,  1.0, 0.0, 0.0, 1.0, 1.0, 1.0}, // 2
    {-1.0,  1.0,  1.0, 0.0, 0.0, 1.0, 0.0, 1.0}, // 3

    { 1.0, -1.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0}, // 4
    {-1.0, -1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.0}, // 5
    {-1.0,  1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 1.0}, // 6
    { 1.0,  1.0, -1.0, 0.0, 0.0, -1.0, 0.0, 1.0}, // 7

    {-1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0}, // 5
    {-1.0, -1.0,  1.0, -1.0, 0.0, 0.0, 1.0, 0.0}, // 0
    {-1.0,  1.0,  1.0, -1.0, 0.0, 0.0, 1.0, 1.0}, // 3
    {-1.0,  1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 1.0}, // 6

    { 1.0, -1.0,  1.0,  1.0, 0.0, 0.0, 0.0, 0.0}, // 1
    { 1.0, -1.0, -1.0,  1.0, 0.0, 0.0, 1.0, 0.0}, // 4
    { 1.0,  1.0, -1.0,  1.0, 0.0, 0.0, 1.0, 1.0}, // 7
    { 1.0,  1.0,  1.0,  1.0, 0.0, 0.0, 0.0, 1.0}, // 2

    {-1.0, -1.0, -1.0,  0.0, -1.0, 0.0, 0.0, 0.0}, // 5
    { 1.0, -1.0, -1.0,  0.0, -1.0, 0.0, 1.0, 0.0}, // 4
    { 1.0, -1.0,  1.0,  0.0, -1.0, 0.0, 1.0, 1.0}, // 1
    {-1.0, -1.0,  1.0,  0.0, -1.0, 0.0, 0.0, 1.0}, // 0

    {-1.0, 1.0,  1.0,  0.0,  1.0, 0.0, 0.0, 0.0}, // 3
    { 1.0, 1.0,  1.0,  0.0,  1.0, 0.0, 1.0, 0.0}, // 2
    { 1.0, 1.0, -1.0,  0.0,  1.0, 0.0, 1.0, 1.0}, // 7
    {-1.0, 1.0, -1.0,  0.0,  1.0, 0.0, 0.0, 1.0}, // 6
};

static void draw_cube(void)
{
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glVertexPointer(3, GL_FLOAT, sizeof(GLfloat) * 8, &cube_vertices[0][0]);
    glNormalPointer(GL_FLOAT, sizeof(GLfloat) * 8, &cube_vertices[0][3]);
    glTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat) * 8, &cube_vertices[0][6]);

    glDrawArrays(GL_QUADS, 0, 24);
}

float const light0_dir[]={0,1,0,0};
float const light0_color[]={78./255., 80./255., 184./255.,1};

float const light1_dir[]={-1,1,1,0};
float const light1_color[]={255./255., 220./255., 97./255.,1};

float const light2_dir[]={0,-1,0,0};
float const light2_color[]={31./255., 75./255., 16./255.,1};

static void redrawTheWindow()
{
    float const aspect = (float)width / (float)height;

    static float a=0;
    static float b=0;
    static float c=0;

    glDrawBuffer(GL_BACK);

    glViewport(0, 0, width, height);

    // Clear with alpha = 0.0, i.e. full transparency
        glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-aspect, aspect, -1, 1, 2.5, 10);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);

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

    glLightfv(GL_LIGHT0, GL_POSITION, light0_dir);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);

    glLightfv(GL_LIGHT1, GL_POSITION, light1_dir);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_color);

    glLightfv(GL_LIGHT2, GL_POSITION, light2_dir);
    glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_color);

    glTranslatef(0., 0., -5.);

    glRotatef(a, 1, 0, 0);
    glRotatef(b, 0, 1, 0);
    glRotatef(c, 0, 0, 1);

    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);
    glEnable(GL_LIGHTING);

    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

    glColor4f(1., 1., 1., 0.5);

    glCullFace(GL_FRONT);
    draw_cube();
    glCullFace(GL_BACK);
    draw_cube();

    a = fmod(a+0.1, 360.);
    b = fmod(b+0.5, 360.);
    c = fmod(c+0.25, 360.);

    glXSwapBuffers(Xdisplay, glX_window_handle);
}

int main(int argc, char *argv[])
{
    createTheWindow();
    createTheRenderContext();

    while (updateTheMessageQueue()) {
        redrawTheWindow();
    }

    return 0;
}

मुख्य चाल सही FBConfig हो रही है। आपको एक अल्फा चैनल के लिए पूछने औरXRenderPictFormat एक अल्फा मास्क की उपस्थिति के लिए संबंधित परीक्षण करने की आवश्यकता है ।

Comments

Uowwww! अतुल्य! मैंने इसे संकलित किया g++ gl_transparent.cpp -o gl_transparent -lGL -lX11 -lXext -lXrender:। यह एक सामुदायिक विकी बन सकता है, अगर हम इन दिनों भी ऐसा कर रहे हैं।

— कार्लफिलिप

@karlphillip: मेरे गितुब भंडार में आपको एक मेकफाइल मिला होगा। और इस डेमो का एक संस्करण जो एक लहर प्रभाव को जोड़ने के लिए एक टुकड़ा shader का उपयोग करता है - सिर्फ आईकैंडी के लिए। दुर्भाग्यवश "पृष्ठभूमि" को छायादार प्रभाव में शामिल करना संभव नहीं है, क्योंकि पूरी पृष्ठभूमि केवल कंपोजिटर द्वारा बनाई गई है क्योंकि सभी विंडो ने अपनी सामग्री खींची है।

— डेटेनवॉल्फ

मै समझता हुँ। सर उठाने के लिए धन्यवाद।

— karlphillip

@datenwolf I मूल रूप से सहायता के लिए पूछ रहा था लेकिन मैं आपके कोड को आधुनिक OpenGL में परिवर्तित करने में सफल रहा। मैं भविष्य के संदर्भ के लिए अपना समाधान यहां थोड़ा सा पोस्ट करूंगा।

— syk435

ट्यूटोरियल के लिए बहुत बहुत धन्यवाद। मैं भी इसे बिना सीमा के चाहता हूं। मैं opengl का उपयोग करके एक रबरबैंड (स्क्रीन पर आयत बनाना) बनाना चाहता हूं लेकिन मुझे इसका कोई उदाहरण नहीं मिला।

— kenn

Answer 3

मुझे पता है कि यह विंडोज 7 के साथ संभव है, पहले के संस्करणों के बारे में निश्चित नहीं है।

विंडो बॉर्डर से छुटकारा पाने के लिए आपको विंडो WS_OVERLAPPEDWINDOWसे स्टाइल हटाने और स्टाइल जोड़ने की जरूरत WS_POPUPहै:

DWORD style = ::GetWindowLong(hWnd, GWL_STYLE);
style &= ~WS_OVERLAPPEDWINDOW;
style |= WS_POPUP;
::SetWindowLong(hWnd, GWL_STYLE, style);

OpenGL विंडो की पृष्ठभूमि को पारदर्शी बनाने के लिए, आपको DwmEnableBlurBehindWindowफ़ंक्शन का उपयोग करना होगा :

DWM_BLURBEHIND bb = {0};
bb.dwFlags = DWM_BB_ENABLE;
bb.fEnable = true;
bb.hRgnBlur = NULL;
DwmEnableBlurBehindWindow(hWnd, &bb);

कॉल करते समय आपको अल्फा वैल्यू के लिए 0 भी बताना होगा glClearColor।

glClearColor(0.0f,0.0f,0.0f,0.0f);

इसके अलावा, जब आपका OpenGL संदर्भ बनाते हैं, तो सुनिश्चित करें कि आप एक अल्फा चैनल आवंटित करते हैं।

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

Comments

धन्यवाद, लेकिन ड्वेमनेबल ब्लड़बाइंडविंडो () DWM का एक हिस्सा है, जो Win32 API से संबंधित नहीं है। यह समाधान विंडोज विस्टा और इसके बाद के संस्करण के लिए काम करता है।

— कार्लफिलिप

@karlphilip: पूर्व-विस्टा विंडोज: es में डेस्कटॉप कंपोज़िंग नहीं है, इसलिए मुझे यकीन नहीं है कि आप इसे अच्छी तरह से कर सकते हैं।

— मैके

@karlphilip। क्षमा करें, मुझे व्यक्तिगत रूप से XP के साथ काम करने वाली पारदर्शी OpenGL विंडो नहीं मिली हैं, लेकिन मुझे इसके बारे में OpenGL मंच पर पोस्ट देखकर याद है। अधिक जानकारी के लिए निम्नलिखित खोज परिणामों के माध्यम से देखने की कोशिश कर रहा है: google.com/…

— Flash

यह वास्तव में सहायक था, लेकिन मैं निम्नलिखित जोड़ना चाहता हूं: मेरे लिए उपरोक्त विधि ने डिफ़ॉल्ट Win7 कलंक और नकली प्रकाश प्रतिबिंब के साथ पृष्ठभूमि के सभी प्रदान किए। कलंक से छुटकारा पाने के लिए और एक completeley पारदर्शी खिड़की पाने के लिए, मैं सेट bb.hRgnBlurकरने के लिए पैरामीटर CreateRectRgn(0, 0, 1, 1);और bb.dwFlagsकरने के लिए DWM_BB_ENABLE | DWM_BB_BLURREGION;। यह बिल्कुल एक पिक्सेल को धुंधला कर देगा और बाकी विंडो (जहां क्लीयर के साथ साफ किया गया है) को पूरी तरह से पारदर्शी दिखाएगा।

— फोलज

जब मैं यह कोशिश करता हूं, मुझे मिलता है identifier "DWM_BLURBEHIND" is undefined। वहाँ एक पुस्तकालय मैं शामिल करने की आवश्यकता है?

— स्टेविसीक

Answer 4

यह एक पुराना सवाल है, लेकिन चूंकि विंडोज के नए संस्करणों में कंपोजिटिंग और सपोर्ट है, जैसा कि डेटाेनवुल्फ संकेत देता है, ओपेंग्ल के लिए, हम इसे पूरा करने के लिए उस विशेष सॉस में से कुछ का उपयोग कर सकते हैं। हालाँकि यह DirectX (गो फिगर ...) के साथ भी तुच्छ है लेकिन Microsoft ने opengl संदर्भों के लिए कंपोजिट संकेत जोड़े थे। याय एंटी-ट्रस्ट डर!

इसलिए एक अकुशल कॉपी-टू-फिजिकल-मेमोरी एक्शन के बजाय, हम कंपोज़िटिंग इंजन को बस समझ सकते हैं कि ओपेंगल संदर्भ का उपयोग कैसे करें।

तो, आपको एक पिक्सेलफॉर्म के साथ एक ओपेंगल संदर्भ बनाना होगा जो एक अल्फा चैनल को निर्दिष्ट करता है और इसे रचना (लाइन 82) का उपयोग करना चाहिए। फिर, आप एक पूरी तरह से अमान्य क्षेत्र के साथ एक धुंधली खिड़की (लाइन 179) को सक्षम करने के लिए DwmApi.h दिनचर्या का उपयोग करते हैं, जो कुछ भी धुंधला नहीं करेगा और खिड़की को पारदर्शी छोड़ देगा। (आपको विंडो क्लास पर एक काले + पारदर्शी ब्रश को निर्दिष्ट करने की आवश्यकता है! अजीब तरह से!) फिर, आप वास्तव में ओपेंगल का उपयोग करते हैं क्योंकि आप इसका उपयोग करने के लिए उपयोग किए जाते हैं। इवेंट लूप में, आपको मिलने वाला हर मौका, आप बफ़र्स को आकर्षित और स्वैप कर सकते हैं (लाइन 201) और GL_BLEND को सक्षम करना याद रखें! :)

कृपया समीक्षा करें / कांटा https://gist.github.com/3644466 या केवल इस तकनीक के साथ ओपी के स्वयं के उत्तर के आधार पर निम्नलिखित कोड स्निपेट देखें (आप इसे खाली प्रोजेक्ट में प्लॉप कर सकते हैं):

#define _WIN32_WINNT 0x0500

#include <windows.h>
#include <windowsx.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include <dwmapi.h>

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glu32.lib")

#pragma comment (lib, "dwmapi.lib")

#include <assert.h>
#include <tchar.h>

#ifdef  assert
#define verify(expr) if(!expr) assert(0)
#else verify(expr) expr
#endif

const TCHAR szAppName[]=_T("TransparentGL");
const TCHAR wcWndName[]=_T("TransparentGL");

HDC hDC;            
HGLRC m_hrc;        
int w = 240;
int h = 240;

BOOL initSC() {
    glEnable(GL_ALPHA_TEST);        
    glEnable(GL_DEPTH_TEST);        
    glEnable(GL_COLOR_MATERIAL);

    glEnable(GL_LIGHTING);          
    glEnable(GL_LIGHT0);            

    glEnable(GL_BLEND);             
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(0, 0, 0, 0);

    return 0;
}

void resizeSC(int width,int height) {
    glViewport(0,0,width,height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glMatrixMode(GL_MODELVIEW );
    glLoadIdentity();
}

BOOL renderSC() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glPushMatrix();

    glColor3f(0, 1, 1);
    glBegin(GL_TRIANGLES);                              // Drawing Using Triangles
        glColor3f(1.0f,0.0f,0.0f);                      // Set The Color To Red
        glVertex3f( 0.0f, 1.0f, 0.0f);                  // Top
        glColor3f(0.0f,1.0f,0.0f);                      // Set The Color To Green
        glVertex3f(-1.0f,-1.0f, 0.0f);                  // Bottom Left
        glColor3f(0.0f,0.0f,1.0f);                      // Set The Color To Blue
        glVertex3f( 1.0f,-1.0f, 0.0f);                  // Bottom Right
    glEnd();

    glPopMatrix();
    glFlush();

    return 0;
}

BOOL CreateHGLRC(HWND hWnd) {
    PIXELFORMATDESCRIPTOR pfd = {
      sizeof(PIXELFORMATDESCRIPTOR),
      1,                                // Version Number
      PFD_DRAW_TO_WINDOW      |         // Format Must Support Window
      PFD_SUPPORT_OPENGL      |         // Format Must Support OpenGL
      PFD_SUPPORT_COMPOSITION |         // Format Must Support Composition
      PFD_DOUBLEBUFFER,                 // Must Support Double Buffering
      PFD_TYPE_RGBA,                    // Request An RGBA Format
      32,                               // Select Our Color Depth
      0, 0, 0, 0, 0, 0,                 // Color Bits Ignored
      8,                                // An Alpha Buffer
      0,                                // Shift Bit Ignored
      0,                                // No Accumulation Buffer
      0, 0, 0, 0,                       // Accumulation Bits Ignored
      24,                               // 16Bit Z-Buffer (Depth Buffer)
      8,                                // Some Stencil Buffer
      0,                                // No Auxiliary Buffer
      PFD_MAIN_PLANE,                   // Main Drawing Layer
      0,                                // Reserved
      0, 0, 0                           // Layer Masks Ignored
   };     

   HDC hdc = GetDC(hWnd);
   int PixelFormat = ChoosePixelFormat(hdc, &pfd);
   if (PixelFormat == 0) {
      assert(0);
      return FALSE ;
   }

   BOOL bResult = SetPixelFormat(hdc, PixelFormat, &pfd);
   if (bResult==FALSE) {
      assert(0);
      return FALSE ;
   }

   m_hrc = wglCreateContext(hdc);
   if (!m_hrc){
      assert(0);
      return FALSE;
   }

   ReleaseDC(hWnd, hdc);

   return TRUE;
}

LRESULT CALLBACK WindowFunc(HWND hWnd,UINT msg, WPARAM wParam, LPARAM lParam) {
    PAINTSTRUCT ps;

    switch(msg) {
        case WM_CREATE:
        break;

        case WM_DESTROY:
            if(m_hrc) {
                wglMakeCurrent(NULL, NULL);
                wglDeleteContext(m_hrc) ;
            }
            PostQuitMessage(0) ;
        break;

        default: 
            return DefWindowProc(hWnd,msg,wParam,lParam);
    }

    return 0;
}

int WINAPI _tWinMain(HINSTANCE hThisInst, HINSTANCE hPrevInst, LPSTR str,int nWinMode) {
    WNDCLASSEX wc;
    memset(&wc, 0, sizeof(wc));
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = (WNDPROC)WindowFunc;
    wc.cbClsExtra  = 0;
    wc.cbWndExtra  = 0;
    wc.hInstance = hThisInst;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)CreateSolidBrush(0x00000000);
    wc.lpszClassName = szAppName;

    if(!RegisterClassEx(&wc)) {
        MessageBox(NULL, _T("RegisterClassEx - failed"), _T("Error"), MB_OK | MB_ICONERROR);
        return FALSE;
    }

    HWND hWnd = CreateWindowEx(WS_EX_APPWINDOW, szAppName, wcWndName,
                    WS_VISIBLE | WS_POPUP, 200, 150, w, h,
                    NULL, NULL, hThisInst, NULL);

    if(!hWnd) {
        MessageBox(NULL, _T("CreateWindowEx - failed"), _T("Error"), MB_OK | MB_ICONERROR);
        return FALSE;
    }

    DWM_BLURBEHIND bb = {0};
    HRGN hRgn = CreateRectRgn(0, 0, -1, -1);
    bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;
    bb.hRgnBlur = hRgn;
    bb.fEnable = TRUE;
    DwmEnableBlurBehindWindow(hWnd, &bb);

    CreateHGLRC(hWnd);

    HDC hdc = GetDC(hWnd);
    wglMakeCurrent(hdc, m_hrc);
    initSC();
    resizeSC(w, h);
    ReleaseDC(hWnd, hdc);

    MSG msg;  
    while(1) {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else {
            HDC hdc = GetDC(hWnd);
            wglMakeCurrent(hdc, m_hrc);

            renderSC();

            SwapBuffers(hdc);
            ReleaseDC(hWnd, hdc);
        }
    } 

    return (FALSE); 
}

Comments

विन 7 पर बहुत अच्छा काम करता है। जब मैंने खिड़की का आकार स्क्रीन के आकार के बिल्कुल बराबर कर दिया, तो पृष्ठभूमि पारदर्शी होने के बजाय काली हो गई (जैसे कि एयरो मानता है कि खिड़की फुलस्क्रीन है, हालांकि यह वास्तव में नहीं है)। मैं स्क्रीन के मुकाबले खिड़की को 1 पिक्सेल लंबा बनाकर इसके चारों ओर काम करने में सक्षम था, अर्थात window_x = 0, window_y = -1, window_width = screen_width, window_height = screen_height + 1CreateWindowEx को दिए गए मानों का उपयोग करें, फिर glViewport(0, 0, screen_width, screen_height)हमेशा की तरह कॉल करें ।

— जॉन मेलोर

शानदार जवाब! ठीक वैसा ही जैसा मुझे चाहिए था। अन्य सभी उत्तर एक ऑफ़स्क्रीन बफर और फिर बिटब्ल्ट () को ड्राइंग के दृष्टिकोण को एक दृश्यमान ड्राइंग संदर्भ में दिखाते हैं जो सुपर स्लो है और किसी भी गंभीर एप्लिकेशन के लिए काम नहीं करता है।

— जुरेली

Answer 5

यह बहुत आसान होगा यदि ओपनजीएल खिड़कियों को स्तरित करने की अनुमति दी गई थी। लेकिन वे नहीं हैं, इसलिए आपको कुछ और करना होगा।

पारदर्शिता के लिए हैंडल करने के लिए आप एक लेयर्ड विंडो (WS_EX_LAYERED + SetLayeredWindowAttributes () - Google 'em यदि आप उन्हें नहीं जानते हैं) और रेंडरिंग के लिए एक ओपन ओपन विंडो बना सकते हैं। OpenGL दृश्य को एक ऑफ-स्क्रीन बफर में रेंडर करें, इसे वापस पढ़ें और इसे स्तरित विंडो के साथ साझा करें, फिर इसे स्तरित विंडो पर bitblt (GDI फ़ंक्शन) करें।

यह बहुत ही जटिल सामान के लिए बहुत धीमा हो सकता है, लेकिन आपको वह प्रभाव देगा जो आप पूछ रहे हैं, और विंडोज 2000 और इसके बाद के संस्करण पर काम करें।

संपादित करें: जब वास्तविक ऑफ-स्क्रीन बफर बनाने की बात आती है, तो फ्रेमबफ़र ऑब्जेक्ट्स (FBOs) शायद आपका सबसे अच्छा दांव हैं। आप बस छिपे हुए OpenGL विंडो पर आकर्षित कर सकते हैं, हालांकि मुझे लगता है कि मुझे लगता है कि किसी को उस के साथ परेशानियों के बारे में पोस्ट करने की याद है, क्योंकि पिक्सेल स्वामित्व - FBOs की सिफारिश की जाती है। आप पिक्सेल बफ़र्स (pbuffers) का भी उपयोग कर सकते हैं, लेकिन ये एक प्रकार की पुरानी (मुद्रांकित "विरासत") हैं, और FBO को ऐसा करने का आधुनिक तरीका माना जाता है। FBO को आपको हार्डवेयर त्वरण (यदि समर्थित है) देना चाहिए, और आपको खुद को एक विशिष्ट OpenGL संस्करण तक सीमित नहीं करना चाहिए। इसका उपयोग करने के लिए आपको एक OpenGL संदर्भ की आवश्यकता होगी, इसलिए आपको उस छिपी OpenGL विंडो को बनाना होगा और वहां से FBO सेट करना होगा।

FBO पर यहां कुछ संसाधन दिए गए हैं:
विकिपीडिया
FBO
Gamedev लेख
गाइड (मैक के लिए, लेकिन उपयोगी हो सकता है)

Comments

यह मेरे सुझाव के समान है। मेमोरी (FBO या समान) के लिए अपने OpenGL दृश्य को रेंडर करें और फिर बिटमैप ऑब्जेक्ट में संग्रहीत करने के लिए glReadPixels का उपयोग करें। तब आप अपने पारदर्शी रंग को चुन सकते हैं और इसे GDI का उपयोग करके स्क्रीन पर कर सकते हैं।

— गियावा

Answer 6

स्रोत के साथ डेमो का शानदार सेट आपको कदम से कदम मिलाकर:

http://www.dhpoware.com/demos/index.html

Comments

"OpenGL लेयर्ड विंडोज" डेमो मूल रूप से इसे करने का सबसे अच्छा तरीका है, एक pbuffer सीधे DIB में रेंडर करने की तुलना में बहुत तेज है। DIB आमतौर पर सॉफ्टवेयर रेंडरर का उपयोग कर रहा है जहां pbuffer त्वरित है

— क्रिस्टोफर लॉयड

Answer 7

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

#include <gtk/gtk.h>
#include <gdk/gdkscreen.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkgl.h>
#include <GL/gl.h>
#include <GL/glu.h>

static gboolean supports_alpha = FALSE;

/***
 *** Configure the OpenGL framebuffer.
***/
static GdkGLConfig* configure_gl(void)
{
    GdkGLConfig* glconfig;

    /* Try double-buffered visual */
    glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA |
        GDK_GL_MODE_ALPHA |
        GDK_GL_MODE_DEPTH |
        GDK_GL_MODE_DOUBLE);
    if (glconfig == NULL)
    {
        printf("Cannot find the double-buffered visual.\n");
        printf("No appropriate OpenGL-capable visual found.\n");
        exit(1);
    }
    printf("Find GLConfig with alpha channel.\n");
    return glconfig;
}

static void screen_changed(GtkWidget* widget, GdkScreen* old_screen, gpointer userdata)
{
    /* To check if the display supports alpha channels, get the colormap */
    GdkScreen* screen = gtk_widget_get_screen(widget);
    GdkColormap* colormap = gdk_screen_get_rgba_colormap(screen);

    if (!colormap)
    {
        printf("Your screen does not support alpha channels!\n");
        colormap = gdk_screen_get_rgb_colormap(screen);
        supports_alpha = FALSE;
    }
    else
    {
        printf("Your screen supports alpha channels!\n");
        supports_alpha = TRUE;
    }

    gtk_widget_set_colormap(widget, colormap);
}

static gboolean expose(GtkWidget* widget, GdkEventExpose* event, gpointer userdata)
{
    GdkGLContext* glcontext = gtk_widget_get_gl_context(widget);
    GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable(widget);

    if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
    {
        return FALSE;
    }

    glDrawBuffer(GL_BACK);

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);

    glBegin(GL_QUADS);
    glColor4f(1.0f, 0.0f, 0.0f, 0.3f);
    glVertex3f(-0.5f, -0.5f, 0);
    glVertex3f(+0.5f, -0.5f, 0);
    glVertex3f(+0.5f, +0.5f, 0);
    glVertex3f(-0.5f, +0.5f, 0);
    glEnd();

    gdk_gl_drawable_swap_buffers(gldrawable);

    gdk_gl_drawable_gl_end(gldrawable);
    return TRUE;
}

int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    /* Added to config GLConfig */
    GdkGLConfig* glconfig = configure_gl();
    gtk_widget_set_gl_capability(window,
        glconfig,
        NULL,
        TRUE,
        GDK_GL_RGBA_TYPE);

    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window), 400, 400);
    gtk_window_set_title(GTK_WINDOW(window), "Alpha Demo");
    g_signal_connect(G_OBJECT(window), "delete-event", gtk_main_quit, NULL);

    gtk_widget_set_app_paintable(window, TRUE);

    g_signal_connect(G_OBJECT(window), "expose-event", G_CALLBACK(expose), NULL);
    g_signal_connect(G_OBJECT(window), "screen-changed", G_CALLBACK(screen_changed), NULL);

    screen_changed(window, NULL, NULL);

    gtk_widget_show_all(window);
    gtk_main();

    return 0;
}

के साथ संकलित किया gcc main.c -o main `pkg-config --libs --cflags gtk+-2.0 gtkglext-1.0`। उबंटू 18.04 पर परीक्षण किया गया (gtk के अलावा, आपको इंस्टॉल करने की आवश्यकता होगी libgtkglext1-dev)।

संपादित करें

मैंने प्रतिपादन कोड को केवल एक glClearसे एक आयत में बदल दिया ।

कोड इस प्रश्न का एक संशोधित संस्करण है और यह प्रश्न भी है ।

Comments

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

— कर्लफिलिप

ओह क्षमा करें क्योंकि यद्यपि मैं ढेर सारी चीजों का उपयोग करता हूं (Google से), मैंने अपना पासवर्ड खो दिया है और लंबे समय तक लॉग इन नहीं किया है। मैं भविष्य में ऐसा करूंगा। अन्य उत्तर के लिए भी धन्यवाद।

— वू झेनवेई

और सलाह के लिए धन्यवाद। मैं सुधार करने के लिए एक स्क्रीनशॉट जोड़ने की कोशिश करूंगा, लेकिन यह अभी भी आपकी अपनी पसंद है कि इसे वोट करना है या नहीं। @Klphillip

— वू

वह स्क्रीनशॉट आपके उत्तर के लिए बहुत अधिक मूल्य जोड़ देगा।

— कार्लफिलिप

Answer 8

आप एक pbuffer के लिए 3 डी दृश्य प्रस्तुत कर सकते हैं और इसे एक रंग कुंजी का उपयोग करके स्क्रीन पर ब्लिट कर सकते हैं।

Answer 9

ClanLib खेल SDK यह करता है।

यदि आपको केवल एक स्थिर पारदर्शी सीमा की आवश्यकता है, तो निम्न तकनीक का उपयोग करें:

5 विंडो बनाता है

AAAAA

बी ### सी

बी ### सी

DDDDD

ए, बी, सी, डी स्तरित खिड़कियां हैं

"#" मुख्य विंडो है।

नीचे के चित्र देखें - http://clanlib.org/wiki/ClanLib_2.2.9_Release_Notes

Comments

धन्यवाद, लेकिन सवाल विशेष रूप से पूछता है कि इस प्रभाव को केवल Win32 एपीआई का उपयोग करके कैसे किया जाए ।

— कार्लाफिलिप