[deb_xorg-server.git] / hw / xquartz / GL / capabilities.c

/*
 * Copyright (c) 2008-2012 Apple Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define Cursor Mac_Cursor
#define BOOL   Mac_BOOL
#include <OpenGL/OpenGL.h>
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <OpenGL/glext.h>
#include <ApplicationServices/ApplicationServices.h>
#undef Cursor
#undef BOOL

#include "capabilities.h"

#include "os.h"

static void
handleBufferModes(struct glCapabilitiesConfig *c, GLint bufferModes)
{
    if (bufferModes & kCGLStereoscopicBit) {
        c->stereo = true;
    }

    if (bufferModes & kCGLDoubleBufferBit) {
        c->buffers = 2;
    }
    else {
        c->buffers = 1;
    }
}

static void
handleStencilModes(struct glCapabilitiesConfig *c, GLint smodes)
{
    int offset = 0;

    if (kCGL0Bit & smodes)
        c->stencil_bit_depths[offset++] = 0;

    if (kCGL1Bit & smodes)
        c->stencil_bit_depths[offset++] = 1;

    if (kCGL2Bit & smodes)
        c->stencil_bit_depths[offset++] = 2;

    if (kCGL3Bit & smodes)
        c->stencil_bit_depths[offset++] = 3;

    if (kCGL4Bit & smodes)
        c->stencil_bit_depths[offset++] = 4;

    if (kCGL5Bit & smodes)
        c->stencil_bit_depths[offset++] = 5;

    if (kCGL6Bit & smodes)
        c->stencil_bit_depths[offset++] = 6;

    if (kCGL8Bit & smodes)
        c->stencil_bit_depths[offset++] = 8;

    if (kCGL10Bit & smodes)
        c->stencil_bit_depths[offset++] = 10;

    if (kCGL12Bit & smodes)
        c->stencil_bit_depths[offset++] = 12;

    if (kCGL16Bit & smodes)
        c->stencil_bit_depths[offset++] = 16;

    if (kCGL24Bit & smodes)
        c->stencil_bit_depths[offset++] = 24;

    if (kCGL32Bit & smodes)
        c->stencil_bit_depths[offset++] = 32;

    if (kCGL48Bit & smodes)
        c->stencil_bit_depths[offset++] = 48;

    if (kCGL64Bit & smodes)
        c->stencil_bit_depths[offset++] = 64;

    if (kCGL96Bit & smodes)
        c->stencil_bit_depths[offset++] = 96;

    if (kCGL128Bit & smodes)
        c->stencil_bit_depths[offset++] = 128;

    assert(offset < GLCAPS_STENCIL_BIT_DEPTH_BUFFERS);

    c->total_stencil_bit_depths = offset;
}

static int
handleColorAndAccumulation(struct glColorBufCapabilities *c,
                           GLint cmodes, int forAccum)
{
    int offset = 0;

    /*1*/
    if (kCGLRGB444Bit & cmodes) {
        c[offset].r = 4;
        c[offset].g = 4;
        c[offset].b = 4;
        ++offset;
    }

    /*2*/
    if (kCGLARGB4444Bit & cmodes) {
        c[offset].a = 4;
        c[offset].r = 4;
        c[offset].g = 4;
        c[offset].b = 4;
        c[offset].is_argb = true;
        ++offset;
    }

    /*3*/
    if (kCGLRGB444A8Bit & cmodes) {
        c[offset].r = 4;
        c[offset].g = 4;
        c[offset].b = 4;
        c[offset].a = 8;
        ++offset;
    }

    /*4*/
    if (kCGLRGB555Bit & cmodes) {
        c[offset].r = 5;
        c[offset].g = 5;
        c[offset].b = 5;
        ++offset;
    }

    /*5*/
    if (kCGLARGB1555Bit & cmodes) {
        c[offset].a = 1;
        c[offset].r = 5;
        c[offset].g = 5;
        c[offset].b = 5;
        c[offset].is_argb = true;
        ++offset;
    }

    /*6*/
    if (kCGLRGB555A8Bit & cmodes) {
        c[offset].r = 5;
        c[offset].g = 5;
        c[offset].b = 5;
        c[offset].a = 8;
        ++offset;
    }

    /*7*/
    if (kCGLRGB565Bit & cmodes) {
        c[offset].r = 5;
        c[offset].g = 6;
        c[offset].b = 5;
        ++offset;
    }

    /*8*/
    if (kCGLRGB565A8Bit & cmodes) {
        c[offset].r = 5;
        c[offset].g = 6;
        c[offset].b = 5;
        c[offset].a = 8;
        ++offset;
    }

    /*9*/
    if (kCGLRGB888Bit & cmodes) {
        c[offset].r = 8;
        c[offset].g = 8;
        c[offset].b = 8;
        ++offset;
    }

    /*10*/
    if (kCGLARGB8888Bit & cmodes) {
        c[offset].a = 8;
        c[offset].r = 8;
        c[offset].g = 8;
        c[offset].b = 8;
        c[offset].is_argb = true;
        ++offset;
    }

    /*11*/
    if (kCGLRGB888A8Bit & cmodes) {
        c[offset].r = 8;
        c[offset].g = 8;
        c[offset].b = 8;
        c[offset].a = 8;
        ++offset;
    }

    if (forAccum) {
        //#if 0
        /* FIXME
         * Disable this path, because some part of libGL, X, or Xplugin
         * doesn't work with sizes greater than 8.
         * When this is enabled and visuals are chosen using depths
         * such as 16, the result is that the windows don't redraw
         * and are often white, until a resize.
         */

        /*12*/
        if (kCGLRGB101010Bit & cmodes) {
            c[offset].r = 10;
            c[offset].g = 10;
            c[offset].b = 10;
            ++offset;
        }

        /*13*/
        if (kCGLARGB2101010Bit & cmodes) {
            c[offset].a = 2;
            c[offset].r = 10;
            c[offset].g = 10;
            c[offset].b = 10;
            c[offset].is_argb = true;
            ++offset;
        }

        /*14*/
        if (kCGLRGB101010_A8Bit & cmodes) {
            c[offset].r = 10;
            c[offset].g = 10;
            c[offset].b = 10;
            c[offset].a = 8;
            ++offset;
        }

        /*15*/
        if (kCGLRGB121212Bit & cmodes) {
            c[offset].r = 12;
            c[offset].g = 12;
            c[offset].b = 12;
            ++offset;
        }

        /*16*/
        if (kCGLARGB12121212Bit & cmodes) {
            c[offset].a = 12;
            c[offset].r = 12;
            c[offset].g = 12;
            c[offset].b = 12;
            c[offset].is_argb = true;
            ++offset;
        }

        /*17*/
        if (kCGLRGB161616Bit & cmodes) {
            c[offset].r = 16;
            c[offset].g = 16;
            c[offset].b = 16;
            ++offset;
        }

        /*18*/
        if (kCGLRGBA16161616Bit & cmodes) {
            c[offset].r = 16;
            c[offset].g = 16;
            c[offset].b = 16;
            c[offset].a = 16;
            ++offset;
        }
    }
    //#endif

    /* FIXME should we handle the floating point color modes, and if so, how? */

    return offset;
}

static void
handleColorModes(struct glCapabilitiesConfig *c, GLint cmodes)
{
    c->total_color_buffers = handleColorAndAccumulation(c->color_buffers,
                                                        cmodes, 0);

    assert(c->total_color_buffers < GLCAPS_COLOR_BUFFERS);
}

static void
handleAccumulationModes(struct glCapabilitiesConfig *c, GLint cmodes)
{
    c->total_accum_buffers = handleColorAndAccumulation(c->accum_buffers,
                                                        cmodes, 1);
    assert(c->total_accum_buffers < GLCAPS_COLOR_BUFFERS);
}

static void
handleDepthModes(struct glCapabilitiesConfig *c, GLint dmodes)
{
    int offset = 0;
#define DEPTH(flag, value) do { \
        if (dmodes & flag) { \
            c->depth_buffers[offset++] = value; \
        } \
} while (0)

    /*1*/
    DEPTH(kCGL0Bit, 0);
    /*2*/
    DEPTH(kCGL1Bit, 1);
    /*3*/
    DEPTH(kCGL2Bit, 2);
    /*4*/
    DEPTH(kCGL3Bit, 3);
    /*5*/
    DEPTH(kCGL4Bit, 4);
    /*6*/
    DEPTH(kCGL5Bit, 5);
    /*7*/
    DEPTH(kCGL6Bit, 6);
    /*8*/
    DEPTH(kCGL8Bit, 8);
    /*9*/
    DEPTH(kCGL10Bit, 10);
    /*10*/
    DEPTH(kCGL12Bit, 12);
    /*11*/
    DEPTH(kCGL16Bit, 16);
    /*12*/
    DEPTH(kCGL24Bit, 24);
    /*13*/
    DEPTH(kCGL32Bit, 32);
    /*14*/
    DEPTH(kCGL48Bit, 48);
    /*15*/
    DEPTH(kCGL64Bit, 64);
    /*16*/
    DEPTH(kCGL96Bit, 96);
    /*17*/
    DEPTH(kCGL128Bit, 128);

#undef DEPTH

    c->total_depth_buffer_depths = offset;
    assert(c->total_depth_buffer_depths < GLCAPS_DEPTH_BUFFERS);
}

/* Return non-zero if an error occured. */
static CGLError
handleRendererDescriptions(CGLRendererInfoObj info, GLint r,
                           struct glCapabilitiesConfig *c)
{
    CGLError err;
    GLint accelerated = 0, flags = 0, aux = 0, samplebufs = 0, samples = 0;

    err = CGLDescribeRenderer(info, r, kCGLRPAccelerated, &accelerated);

    if (err)
        return err;

    c->accelerated = accelerated;

    /* Buffering modes: single/double, stereo */
    err = CGLDescribeRenderer(info, r, kCGLRPBufferModes, &flags);

    if (err)
        return err;

    handleBufferModes(c, flags);

    /* AUX buffers */
    err = CGLDescribeRenderer(info, r, kCGLRPMaxAuxBuffers, &aux);

    if (err)
        return err;

    c->aux_buffers = aux;

    /* Depth buffer size */
    err = CGLDescribeRenderer(info, r, kCGLRPDepthModes, &flags);

    if (err)
        return err;

    handleDepthModes(c, flags);

    /* Multisample buffers */
    err = CGLDescribeRenderer(info, r, kCGLRPMaxSampleBuffers, &samplebufs);

    if (err)
        return err;

    c->multisample_buffers = samplebufs;

    /* Multisample samples per multisample buffer */
    err = CGLDescribeRenderer(info, r, kCGLRPMaxSamples, &samples);

    if (err)
        return err;

    c->multisample_samples = samples;

    /* Stencil bit depths */
    err = CGLDescribeRenderer(info, r, kCGLRPStencilModes, &flags);

    if (err)
        return err;

    handleStencilModes(c, flags);

    /* Color modes (RGB/RGBA depths supported */
    err = CGLDescribeRenderer(info, r, kCGLRPColorModes, &flags);

    if (err)
        return err;

    handleColorModes(c, flags);

    err = CGLDescribeRenderer(info, r, kCGLRPAccumModes, &flags);

    if (err)
        return err;

    handleAccumulationModes(c, flags);

    return kCGLNoError;
}

static void
initCapabilities(struct glCapabilities *cap)
{
    cap->configurations = NULL;
    cap->total_configurations = 0;
}

static void
initConfig(struct glCapabilitiesConfig *c)
{
    int i;

    c->accelerated = false;
    c->stereo = false;
    c->aux_buffers = 0;
    c->buffers = 0;

    c->total_depth_buffer_depths = 0;

    for (i = 0; i < GLCAPS_DEPTH_BUFFERS; ++i) {
        c->depth_buffers[i] = GLCAPS_INVALID_DEPTH_VALUE;
    }

    c->multisample_buffers = 0;
    c->multisample_samples = 0;

    c->total_stencil_bit_depths = 0;

    for (i = 0; i < GLCAPS_STENCIL_BIT_DEPTH_BUFFERS; ++i) {
        c->stencil_bit_depths[i] = GLCAPS_INVALID_STENCIL_DEPTH;
    }

    c->total_color_buffers = 0;

    for (i = 0; i < GLCAPS_COLOR_BUFFERS; ++i) {
        c->color_buffers[i].r = c->color_buffers[i].g =
                                    c->color_buffers[i].b =
                                        c->color_buffers[i].a =
                                            GLCAPS_COLOR_BUF_INVALID_VALUE;
        c->color_buffers[i].is_argb = false;
    }

    c->total_accum_buffers = 0;

    for (i = 0; i < GLCAPS_COLOR_BUFFERS; ++i) {
        c->accum_buffers[i].r = c->accum_buffers[i].g =
                                    c->accum_buffers[i].b =
                                        c->accum_buffers[i].a =
                                            GLCAPS_COLOR_BUF_INVALID_VALUE;
        c->accum_buffers[i].is_argb = false;
    }

    c->next = NULL;
}

void
freeGlCapabilities(struct glCapabilities *cap)
{
    struct glCapabilitiesConfig *conf, *next;

    conf = cap->configurations;

    while (conf) {
        next = conf->next;
        free(conf);
        conf = next;
    }

    cap->configurations = NULL;
}

/*Return true if an error occured. */
bool
getGlCapabilities(struct glCapabilities *cap)
{
    CGLRendererInfoObj info;
    CGLError err;
    GLint numRenderers = 0, r;

    initCapabilities(cap);

    err = CGLQueryRendererInfo((GLuint) - 1, &info, &numRenderers);
    if (err) {
        ErrorF("CGLQueryRendererInfo error: %s\n", CGLErrorString(err));
        return err;
    }

    for (r = 0; r < numRenderers; r++) {
        struct glCapabilitiesConfig tmpconf, *conf;

        initConfig(&tmpconf);

        err = handleRendererDescriptions(info, r, &tmpconf);
        if (err) {
            ErrorF("handleRendererDescriptions returned error: %s\n",
                   CGLErrorString(
                       err));
            ErrorF("trying to continue...\n");
            continue;
        }

        conf = malloc(sizeof(*conf));
        if (NULL == conf) {
            FatalError("Unable to allocate memory for OpenGL capabilities\n");
        }

        /* Copy the struct. */
        *conf = tmpconf;

        /* Now link the configuration into the list. */
        conf->next = cap->configurations;
        cap->configurations = conf;
    }

    CGLDestroyRendererInfo(info);

    /* No error occured.  We are done. */
    return kCGLNoError;
}
Commit	Line	Data
a09e091a JB	1	/*
	2	* Copyright (c) 2008-2012 Apple Inc.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	17	* THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
	18	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	19	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	20	* DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#ifdef HAVE_DIX_CONFIG_H
	24	#include <dix-config.h>
	25	#endif
	26
	27	#include <stdio.h>
	28	#include <stdlib.h>
	29	#include <assert.h>
	30
	31	#define Cursor Mac_Cursor
	32	#define BOOL Mac_BOOL
	33	#include <OpenGL/OpenGL.h>
	34	#include <OpenGL/gl.h>
	35	#include <OpenGL/glu.h>
	36	#include <OpenGL/glext.h>
	37	#include <ApplicationServices/ApplicationServices.h>
	38	#undef Cursor
	39	#undef BOOL
	40
	41	#include "capabilities.h"
	42
	43	#include "os.h"
	44
	45	static void
	46	handleBufferModes(struct glCapabilitiesConfig *c, GLint bufferModes)
	47	{
	48	if (bufferModes & kCGLStereoscopicBit) {
	49	c->stereo = true;
	50	}
	51
	52	if (bufferModes & kCGLDoubleBufferBit) {
	53	c->buffers = 2;
	54	}
	55	else {
	56	c->buffers = 1;
	57	}
	58	}
	59
	60	static void
	61	handleStencilModes(struct glCapabilitiesConfig *c, GLint smodes)
	62	{
	63	int offset = 0;
	64
65	if (kCGL0Bit & smodes)
66	c->stencil_bit_depths[offset++] = 0;
67
68	if (kCGL1Bit & smodes)
69	c->stencil_bit_depths[offset++] = 1;
70
71	if (kCGL2Bit & smodes)
72	c->stencil_bit_depths[offset++] = 2;
73
74	if (kCGL3Bit & smodes)
75	c->stencil_bit_depths[offset++] = 3;
76
77	if (kCGL4Bit & smodes)
78	c->stencil_bit_depths[offset++] = 4;
79
80	if (kCGL5Bit & smodes)
81	c->stencil_bit_depths[offset++] = 5;
82
83	if (kCGL6Bit & smodes)
84	c->stencil_bit_depths[offset++] = 6;
85
86	if (kCGL8Bit & smodes)
87	c->stencil_bit_depths[offset++] = 8;
88
89	if (kCGL10Bit & smodes)
90	c->stencil_bit_depths[offset++] = 10;
91
92	if (kCGL12Bit & smodes)
93	c->stencil_bit_depths[offset++] = 12;
94
95	if (kCGL16Bit & smodes)
96	c->stencil_bit_depths[offset++] = 16;
97
98	if (kCGL24Bit & smodes)
99	c->stencil_bit_depths[offset++] = 24;
100
101	if (kCGL32Bit & smodes)
102	c->stencil_bit_depths[offset++] = 32;
103
104	if (kCGL48Bit & smodes)
105	c->stencil_bit_depths[offset++] = 48;
106
107	if (kCGL64Bit & smodes)
108	c->stencil_bit_depths[offset++] = 64;
109
110	if (kCGL96Bit & smodes)
111	c->stencil_bit_depths[offset++] = 96;
112
113	if (kCGL128Bit & smodes)
114	c->stencil_bit_depths[offset++] = 128;
115
116	assert(offset < GLCAPS_STENCIL_BIT_DEPTH_BUFFERS);
117
118	c->total_stencil_bit_depths = offset;
119	}
120
121	static int
122	handleColorAndAccumulation(struct glColorBufCapabilities *c,
123	GLint cmodes, int forAccum)
124	{
125	int offset = 0;
126
127	/1/
128	if (kCGLRGB444Bit & cmodes) {
129	c[offset].r = 4;
130	c[offset].g = 4;
131	c[offset].b = 4;
132	++offset;
133	}
134
135	/2/
136	if (kCGLARGB4444Bit & cmodes) {
137	c[offset].a = 4;
138	c[offset].r = 4;
139	c[offset].g = 4;
140	c[offset].b = 4;
141	c[offset].is_argb = true;
142	++offset;
143	}
144
145	/3/
146	if (kCGLRGB444A8Bit & cmodes) {
147	c[offset].r = 4;
148	c[offset].g = 4;
149	c[offset].b = 4;
150	c[offset].a = 8;
151	++offset;
152	}
153
154	/4/
155	if (kCGLRGB555Bit & cmodes) {
156	c[offset].r = 5;
157	c[offset].g = 5;
158	c[offset].b = 5;
159	++offset;
160	}
161
162	/5/
163	if (kCGLARGB1555Bit & cmodes) {
164	c[offset].a = 1;
165	c[offset].r = 5;
166	c[offset].g = 5;
167	c[offset].b = 5;
168	c[offset].is_argb = true;
169	++offset;
170	}
171
172	/6/
173	if (kCGLRGB555A8Bit & cmodes) {
174	c[offset].r = 5;
175	c[offset].g = 5;
176	c[offset].b = 5;
177	c[offset].a = 8;
178	++offset;
179	}
180
181	/7/
182	if (kCGLRGB565Bit & cmodes) {
183	c[offset].r = 5;
184	c[offset].g = 6;
185	c[offset].b = 5;
186	++offset;
187	}
188
189	/8/
190	if (kCGLRGB565A8Bit & cmodes) {
191	c[offset].r = 5;
192	c[offset].g = 6;
193	c[offset].b = 5;
194	c[offset].a = 8;
195	++offset;
196	}
197
198	/9/
199	if (kCGLRGB888Bit & cmodes) {
200	c[offset].r = 8;
201	c[offset].g = 8;
202	c[offset].b = 8;
203	++offset;
204	}
205
206	/10/
207	if (kCGLARGB8888Bit & cmodes) {
208	c[offset].a = 8;
209	c[offset].r = 8;
210	c[offset].g = 8;
211	c[offset].b = 8;
212	c[offset].is_argb = true;
213	++offset;
214	}
215
216	/11/
217	if (kCGLRGB888A8Bit & cmodes) {
218	c[offset].r = 8;
219	c[offset].g = 8;
220	c[offset].b = 8;
221	c[offset].a = 8;
222	++offset;
223	}
224
225	if (forAccum) {
226	//#if 0
227	/* FIXME
228	* Disable this path, because some part of libGL, X, or Xplugin
229	* doesn't work with sizes greater than 8.
230	* When this is enabled and visuals are chosen using depths
231	* such as 16, the result is that the windows don't redraw
232	* and are often white, until a resize.
233	*/
234
235	/12/
236	if (kCGLRGB101010Bit & cmodes) {
237	c[offset].r = 10;
238	c[offset].g = 10;
239	c[offset].b = 10;
240	++offset;
241	}
242
243	/13/
244	if (kCGLARGB2101010Bit & cmodes) {
245	c[offset].a = 2;
246	c[offset].r = 10;
247	c[offset].g = 10;
248	c[offset].b = 10;
249	c[offset].is_argb = true;
250	++offset;
251	}
252
253	/14/
254	if (kCGLRGB101010_A8Bit & cmodes) {
255	c[offset].r = 10;
256	c[offset].g = 10;
257	c[offset].b = 10;
258	c[offset].a = 8;
259	++offset;
260	}
261
262	/15/
263	if (kCGLRGB121212Bit & cmodes) {
264	c[offset].r = 12;
265	c[offset].g = 12;
266	c[offset].b = 12;
267	++offset;
268	}
269
270	/16/
271	if (kCGLARGB12121212Bit & cmodes) {
272	c[offset].a = 12;
273	c[offset].r = 12;
274	c[offset].g = 12;
275	c[offset].b = 12;
276	c[offset].is_argb = true;
277	++offset;
278	}
279
280	/17/
281	if (kCGLRGB161616Bit & cmodes) {
282	c[offset].r = 16;
283	c[offset].g = 16;
284	c[offset].b = 16;
285	++offset;
286	}
287
288	/18/
289	if (kCGLRGBA16161616Bit & cmodes) {
290	c[offset].r = 16;
291	c[offset].g = 16;
292	c[offset].b = 16;
293	c[offset].a = 16;
294	++offset;
295	}
296	}
297	//#endif
298
299	/* FIXME should we handle the floating point color modes, and if so, how? */
300
301	return offset;
302	}
303
304	static void
305	handleColorModes(struct glCapabilitiesConfig *c, GLint cmodes)
306	{
307	c->total_color_buffers = handleColorAndAccumulation(c->color_buffers,
308	cmodes, 0);
309
310	assert(c->total_color_buffers < GLCAPS_COLOR_BUFFERS);
311	}
312
313	static void
314	handleAccumulationModes(struct glCapabilitiesConfig *c, GLint cmodes)
315	{
316	c->total_accum_buffers = handleColorAndAccumulation(c->accum_buffers,
317	cmodes, 1);
318	assert(c->total_accum_buffers < GLCAPS_COLOR_BUFFERS);
319	}
320
321	static void
322	handleDepthModes(struct glCapabilitiesConfig *c, GLint dmodes)
323	{
324	int offset = 0;
325	#define DEPTH(flag, value) do { \
326	if (dmodes & flag) { \
327	c->depth_buffers[offset++] = value; \
328	} \
329	} while (0)
330
331	/1/
332	DEPTH(kCGL0Bit, 0);
333	/2/
334	DEPTH(kCGL1Bit, 1);
335	/3/
336	DEPTH(kCGL2Bit, 2);
337	/4/
338	DEPTH(kCGL3Bit, 3);
339	/5/
340	DEPTH(kCGL4Bit, 4);
341	/6/
342	DEPTH(kCGL5Bit, 5);
343	/7/
344	DEPTH(kCGL6Bit, 6);
345	/8/
346	DEPTH(kCGL8Bit, 8);
347	/9/
348	DEPTH(kCGL10Bit, 10);
349	/10/
350	DEPTH(kCGL12Bit, 12);
351	/11/
352	DEPTH(kCGL16Bit, 16);
353	/12/
354	DEPTH(kCGL24Bit, 24);
355	/13/
356	DEPTH(kCGL32Bit, 32);
357	/14/
358	DEPTH(kCGL48Bit, 48);
359	/15/
360	DEPTH(kCGL64Bit, 64);
361	/16/
362	DEPTH(kCGL96Bit, 96);
363	/17/
364	DEPTH(kCGL128Bit, 128);
365
366	#undef DEPTH
367
368	c->total_depth_buffer_depths = offset;
369	assert(c->total_depth_buffer_depths < GLCAPS_DEPTH_BUFFERS);
370	}
371
372	/* Return non-zero if an error occured. */
373	static CGLError
374	handleRendererDescriptions(CGLRendererInfoObj info, GLint r,
375	struct glCapabilitiesConfig *c)
376	{
377	CGLError err;
378	GLint accelerated = 0, flags = 0, aux = 0, samplebufs = 0, samples = 0;
379
380	err = CGLDescribeRenderer(info, r, kCGLRPAccelerated, &accelerated);
381
382	if (err)
383	return err;
384
385	c->accelerated = accelerated;
386
387	/* Buffering modes: single/double, stereo */
388	err = CGLDescribeRenderer(info, r, kCGLRPBufferModes, &flags);
389
390	if (err)
391	return err;
392
393	handleBufferModes(c, flags);
394
395	/* AUX buffers */
396	err = CGLDescribeRenderer(info, r, kCGLRPMaxAuxBuffers, &aux);
397
398	if (err)
399	return err;
400
401	c->aux_buffers = aux;
402
403	/* Depth buffer size */
404	err = CGLDescribeRenderer(info, r, kCGLRPDepthModes, &flags);
405
406	if (err)
407	return err;
408
409	handleDepthModes(c, flags);
410
411	/* Multisample buffers */
412	err = CGLDescribeRenderer(info, r, kCGLRPMaxSampleBuffers, &samplebufs);
413
414	if (err)
415	return err;
416
417	c->multisample_buffers = samplebufs;
418
419	/* Multisample samples per multisample buffer */
420	err = CGLDescribeRenderer(info, r, kCGLRPMaxSamples, &samples);
421
422	if (err)
423	return err;
424
425	c->multisample_samples = samples;
426
427	/* Stencil bit depths */
428	err = CGLDescribeRenderer(info, r, kCGLRPStencilModes, &flags);
429
430	if (err)
431	return err;
432
433	handleStencilModes(c, flags);
434
435	/* Color modes (RGB/RGBA depths supported */
436	err = CGLDescribeRenderer(info, r, kCGLRPColorModes, &flags);
437
438	if (err)
439	return err;
440
441	handleColorModes(c, flags);
442
443	err = CGLDescribeRenderer(info, r, kCGLRPAccumModes, &flags);
444
445	if (err)
446	return err;
447
448	handleAccumulationModes(c, flags);
449
450	return kCGLNoError;
451	}
452
453	static void
454	initCapabilities(struct glCapabilities *cap)
455	{
456	cap->configurations = NULL;
457	cap->total_configurations = 0;
458	}
459
460	static void
461	initConfig(struct glCapabilitiesConfig *c)
462	{
463	int i;
464
465	c->accelerated = false;
466	c->stereo = false;
467	c->aux_buffers = 0;
468	c->buffers = 0;
469
470	c->total_depth_buffer_depths = 0;
471
472	for (i = 0; i < GLCAPS_DEPTH_BUFFERS; ++i) {
473	c->depth_buffers[i] = GLCAPS_INVALID_DEPTH_VALUE;
474	}
475
476	c->multisample_buffers = 0;
477	c->multisample_samples = 0;
478
479	c->total_stencil_bit_depths = 0;
480
481	for (i = 0; i < GLCAPS_STENCIL_BIT_DEPTH_BUFFERS; ++i) {
482	c->stencil_bit_depths[i] = GLCAPS_INVALID_STENCIL_DEPTH;
483	}
484
485	c->total_color_buffers = 0;
486
487	for (i = 0; i < GLCAPS_COLOR_BUFFERS; ++i) {
488	c->color_buffers[i].r = c->color_buffers[i].g =
489	c->color_buffers[i].b =
490	c->color_buffers[i].a =
491	GLCAPS_COLOR_BUF_INVALID_VALUE;
492	c->color_buffers[i].is_argb = false;
493	}
494
495	c->total_accum_buffers = 0;
496
497	for (i = 0; i < GLCAPS_COLOR_BUFFERS; ++i) {
498	c->accum_buffers[i].r = c->accum_buffers[i].g =
499	c->accum_buffers[i].b =
500	c->accum_buffers[i].a =
501	GLCAPS_COLOR_BUF_INVALID_VALUE;
502	c->accum_buffers[i].is_argb = false;
503	}
504
505	c->next = NULL;
506	}
507
508	void
509	freeGlCapabilities(struct glCapabilities *cap)
510	{
511	struct glCapabilitiesConfig conf, next;
512
513	conf = cap->configurations;
514
515	while (conf) {
516	next = conf->next;
517	free(conf);
518	conf = next;
519	}
520
521	cap->configurations = NULL;
522	}
523
524	/Return true if an error occured. /
525	bool
526	getGlCapabilities(struct glCapabilities *cap)
527	{
528	CGLRendererInfoObj info;
529	CGLError err;
530	GLint numRenderers = 0, r;
531
532	initCapabilities(cap);
533
534	err = CGLQueryRendererInfo((GLuint) - 1, &info, &numRenderers);
535	if (err) {
536	ErrorF("CGLQueryRendererInfo error: %s\n", CGLErrorString(err));
537	return err;
538	}
539
540	for (r = 0; r < numRenderers; r++) {
541	struct glCapabilitiesConfig tmpconf, *conf;
542
543	initConfig(&tmpconf);
544
545	err = handleRendererDescriptions(info, r, &tmpconf);
546	if (err) {
547	ErrorF("handleRendererDescriptions returned error: %s\n",
548	CGLErrorString(
549	err));
550	ErrorF("trying to continue...\n");
551	continue;
552	}
553
554	conf = malloc(sizeof(*conf));
555	if (NULL == conf) {
556	FatalError("Unable to allocate memory for OpenGL capabilities\n");
557	}
558
559	/* Copy the struct. */
560	*conf = tmpconf;
561
562	/* Now link the configuration into the list. */
563	conf->next = cap->configurations;
564	cap->configurations = conf;
565	}
566
567	CGLDestroyRendererInfo(info);
568
569	/* No error occured. We are done. */
570	return kCGLNoError;
571	}