2011-07-02 09:57:30 +01:00
|
|
|
/**************************************************************************
|
|
|
|
*
|
s/Tungsten Graphics/VMware/
Tungsten Graphics Inc. was acquired by VMware Inc. in 2008. Leaving the
old copyright name is creating unnecessary confusion, hence this change.
This was the sed script I used:
$ cat tg2vmw.sed
# Run as:
#
# git reset --hard HEAD && find include scons src -type f -not -name 'sed*' -print0 | xargs -0 sed -i -f tg2vmw.sed
#
# Rename copyrights
s/Tungsten Gra\(ph\|hp\)ics,\? [iI]nc\.\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./g
/Copyright/s/Tungsten Graphics\(,\? [iI]nc\.\)\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./
s/TUNGSTEN GRAPHICS/VMWARE/g
# Rename emails
s/alanh@tungstengraphics.com/alanh@vmware.com/
s/jens@tungstengraphics.com/jowen@vmware.com/g
s/jrfonseca-at-tungstengraphics-dot-com/jfonseca-at-vmware-dot-com/
s/jrfonseca\?@tungstengraphics.com/jfonseca@vmware.com/g
s/keithw\?@tungstengraphics.com/keithw@vmware.com/g
s/michel@tungstengraphics.com/daenzer@vmware.com/g
s/thomas-at-tungstengraphics-dot-com/thellstom-at-vmware-dot-com/
s/zack@tungstengraphics.com/zackr@vmware.com/
# Remove dead links
s@Tungsten Graphics (http://www.tungstengraphics.com)@Tungsten Graphics@g
# C string src/gallium/state_trackers/vega/api_misc.c
s/"Tungsten Graphics, Inc"/"VMware, Inc"/
Reviewed-by: Brian Paul <brianp@vmware.com>
2014-01-17 16:27:50 +00:00
|
|
|
* Copyright 2008 VMware, Inc.
|
2011-07-02 09:57:30 +01:00
|
|
|
* Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
|
|
|
|
* Copyright 2010 LunarG, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* 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, sub license, 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 (including the
|
|
|
|
* next paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
|
|
|
|
*
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
#ifndef EGLSURFACE_INCLUDED
|
|
|
|
#define EGLSURFACE_INCLUDED
|
|
|
|
|
|
|
|
#include "egltypedefs.h"
|
2010-01-24 12:32:34 +00:00
|
|
|
#include "egldisplay.h"
|
2005-04-22 22:09:39 +01:00
|
|
|
|
|
|
|
|
2015-05-13 23:13:37 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2018-04-05 11:02:36 +01:00
|
|
|
struct _egl_xy
|
|
|
|
{
|
|
|
|
EGLint x;
|
|
|
|
EGLint y;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _egl_hdr_metadata
|
|
|
|
{
|
|
|
|
struct _egl_xy display_primary_r;
|
|
|
|
struct _egl_xy display_primary_g;
|
|
|
|
struct _egl_xy display_primary_b;
|
|
|
|
struct _egl_xy white_point;
|
|
|
|
EGLint max_luminance;
|
|
|
|
EGLint min_luminance;
|
|
|
|
EGLint max_cll;
|
|
|
|
EGLint max_fall;
|
|
|
|
};
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
/**
|
|
|
|
* "Base" class for device driver surfaces.
|
|
|
|
*/
|
|
|
|
struct _egl_surface
|
|
|
|
{
|
2010-01-24 12:32:34 +00:00
|
|
|
/* A surface is a display resource */
|
|
|
|
_EGLResource Resource;
|
2009-07-17 18:48:27 +01:00
|
|
|
|
2010-01-30 14:45:54 +00:00
|
|
|
/* The context that is currently bound to the surface */
|
|
|
|
_EGLContext *CurrentContext;
|
2005-04-22 22:09:39 +01:00
|
|
|
|
2009-08-03 18:34:37 +01:00
|
|
|
_EGLConfig *Config;
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
EGLint Type; /* one of EGL_WINDOW_BIT, EGL_PIXMAP_BIT or EGL_PBUFFER_BIT */
|
2010-01-31 09:56:30 +00:00
|
|
|
|
2017-05-05 01:46:33 +01:00
|
|
|
/* The native surface is lost. The EGL spec requires certain functions
|
|
|
|
* to generate EGL_BAD_NATIVE_WINDOW when given this surface.
|
|
|
|
*/
|
|
|
|
EGLBoolean Lost;
|
|
|
|
|
2010-01-31 09:56:30 +00:00
|
|
|
/* attributes set by attribute list */
|
2005-04-22 22:09:39 +01:00
|
|
|
EGLint Width, Height;
|
2010-01-31 09:56:30 +00:00
|
|
|
EGLenum TextureFormat;
|
|
|
|
EGLenum TextureTarget;
|
|
|
|
EGLBoolean MipmapTexture;
|
|
|
|
EGLBoolean LargestPbuffer;
|
egl: Simplify queries for EGL_RENDER_BUFFER
There exist *two* queryable EGL_RENDER_BUFFER states in EGL:
eglQuerySurface(EGL_RENDER_BUFFER) and
eglQueryContext(EGL_RENDER_BUFFER).
These changes eliminate potentially very fragile code in the upcoming
EGL_KHR_mutable_render_buffer implementation.
* eglQuerySurface(EGL_RENDER_BUFFER)
The implementation of eglQuerySurface(EGL_RENDER_BUFFER) contained
abstruse logic which required comprehending the specification
complexities of how the two EGL_RENDER_BUFFER states interact. The
function sometimes returned _EGLContext::WindowRenderBuffer, sometimes
_EGLSurface::RenderBuffer. Why? The function tried to encode the
actual logic from the EGL spec. When did the function return which
variable? Go study the EGL spec, hope you understand it, then hope
Mesa mutated the EGL_RENDER_BUFFER state in all the correct places.
Have fun.
To simplify eglQuerySurface(EGL_RENDER_BUFFER), and to improve
confidence in its correctness, flatten its indirect logic. For pixmap
and pbuffer surfaces, simply return a hard-coded literal value, as the
spec suggests. For window surfaces, simply return
_EGLSurface::RequestedRenderBuffer. Nothing difficult here.
* eglQueryContext(EGL_RENDER_BUFFER)
The implementation of this suffered from the same issues as
eglQuerySurface, and the solution is the same. confidence in its
correctness, flatten its indirect logic. For pixmap and pbuffer
surfaces, simply return a hard-coded literal value, as the spec
suggests. For window surfaces, simply return
_EGLSurface::ActiveRenderBuffer.
Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2018-04-07 22:23:48 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Value of EGL_RENDER_BUFFER selected at creation.
|
|
|
|
*
|
|
|
|
* The user may select, for window surfaces, the EGL_RENDER_BUFFER through
|
|
|
|
* the attribute list of eglCreateWindowSurface(). The EGL spec allows the
|
|
|
|
* implementation to ignore request, though; hence why we maintain both
|
|
|
|
* RequestedRenderBuffer and ActiveRenderBuffer. For pbuffer and pixmap
|
|
|
|
* surfaces, the EGL spec hard-codes the EGL_RENDER_BUFFER value and the
|
|
|
|
* user must not provide it in the attribute list.
|
|
|
|
*
|
2018-05-01 06:32:25 +01:00
|
|
|
* Normally, the attribute is immutable and after surface creation.
|
|
|
|
* However, EGL_KHR_mutable_render_buffer allows the user to change it in
|
|
|
|
* window surfaces via eglSurfaceAttrib, in which case
|
|
|
|
* eglQuerySurface(EGL_RENDER_BUFFER) will immediately afterwards return
|
|
|
|
* the requested value but the actual render buffer used by the context
|
|
|
|
* does not change until completion of the next eglSwapBuffers call.
|
|
|
|
*
|
|
|
|
* From the EGL_KHR_mutable_render_buffer spec (v12):
|
|
|
|
*
|
|
|
|
* Querying EGL_RENDER_BUFFER returns the buffer which client API
|
|
|
|
* rendering is requested to use. For a window surface, this is the
|
|
|
|
* attribute value specified when the surface was created or last set
|
|
|
|
* via eglSurfaceAttrib.
|
|
|
|
*
|
egl: Simplify queries for EGL_RENDER_BUFFER
There exist *two* queryable EGL_RENDER_BUFFER states in EGL:
eglQuerySurface(EGL_RENDER_BUFFER) and
eglQueryContext(EGL_RENDER_BUFFER).
These changes eliminate potentially very fragile code in the upcoming
EGL_KHR_mutable_render_buffer implementation.
* eglQuerySurface(EGL_RENDER_BUFFER)
The implementation of eglQuerySurface(EGL_RENDER_BUFFER) contained
abstruse logic which required comprehending the specification
complexities of how the two EGL_RENDER_BUFFER states interact. The
function sometimes returned _EGLContext::WindowRenderBuffer, sometimes
_EGLSurface::RenderBuffer. Why? The function tried to encode the
actual logic from the EGL spec. When did the function return which
variable? Go study the EGL spec, hope you understand it, then hope
Mesa mutated the EGL_RENDER_BUFFER state in all the correct places.
Have fun.
To simplify eglQuerySurface(EGL_RENDER_BUFFER), and to improve
confidence in its correctness, flatten its indirect logic. For pixmap
and pbuffer surfaces, simply return a hard-coded literal value, as the
spec suggests. For window surfaces, simply return
_EGLSurface::RequestedRenderBuffer. Nothing difficult here.
* eglQueryContext(EGL_RENDER_BUFFER)
The implementation of this suffered from the same issues as
eglQuerySurface, and the solution is the same. confidence in its
correctness, flatten its indirect logic. For pixmap and pbuffer
surfaces, simply return a hard-coded literal value, as the spec
suggests. For window surfaces, simply return
_EGLSurface::ActiveRenderBuffer.
Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2018-04-07 22:23:48 +01:00
|
|
|
* eglQueryContext(EGL_RENDER_BUFFER) ignores this.
|
|
|
|
*/
|
|
|
|
EGLenum RequestedRenderBuffer;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The EGL_RENDER_BUFFER in use by the context.
|
|
|
|
*
|
|
|
|
* This is valid only when bound as the draw surface. This may differ from
|
|
|
|
* the RequestedRenderBuffer.
|
|
|
|
*
|
|
|
|
* Refer to eglQueryContext(EGL_RENDER_BUFFER) in the EGL spec.
|
|
|
|
* eglQuerySurface(EGL_RENDER_BUFFER) ignores this.
|
2018-05-01 06:32:25 +01:00
|
|
|
*
|
|
|
|
* If a window surface is bound as the draw surface and has a pending,
|
|
|
|
* user-requested change to EGL_RENDER_BUFFER, then the next eglSwapBuffers
|
|
|
|
* will flush the pending change. (The flush of EGL_RENDER_BUFFER state may
|
|
|
|
* occur without the implicit glFlush induced by eglSwapBuffers). The spec
|
|
|
|
* requires that the flush occur at that time and nowhere else. During the
|
|
|
|
* state-flush, we copy RequestedRenderBuffer to ActiveRenderBuffer.
|
|
|
|
*
|
|
|
|
* From the EGL_KHR_mutable_render_buffer spec (v12):
|
|
|
|
*
|
|
|
|
* If [...] there is a pending change to the EGL_RENDER_BUFFER
|
|
|
|
* attribute, eglSwapBuffers performs an implicit flush operation on the
|
|
|
|
* context and effects the attribute change.
|
egl: Simplify queries for EGL_RENDER_BUFFER
There exist *two* queryable EGL_RENDER_BUFFER states in EGL:
eglQuerySurface(EGL_RENDER_BUFFER) and
eglQueryContext(EGL_RENDER_BUFFER).
These changes eliminate potentially very fragile code in the upcoming
EGL_KHR_mutable_render_buffer implementation.
* eglQuerySurface(EGL_RENDER_BUFFER)
The implementation of eglQuerySurface(EGL_RENDER_BUFFER) contained
abstruse logic which required comprehending the specification
complexities of how the two EGL_RENDER_BUFFER states interact. The
function sometimes returned _EGLContext::WindowRenderBuffer, sometimes
_EGLSurface::RenderBuffer. Why? The function tried to encode the
actual logic from the EGL spec. When did the function return which
variable? Go study the EGL spec, hope you understand it, then hope
Mesa mutated the EGL_RENDER_BUFFER state in all the correct places.
Have fun.
To simplify eglQuerySurface(EGL_RENDER_BUFFER), and to improve
confidence in its correctness, flatten its indirect logic. For pixmap
and pbuffer surfaces, simply return a hard-coded literal value, as the
spec suggests. For window surfaces, simply return
_EGLSurface::RequestedRenderBuffer. Nothing difficult here.
* eglQueryContext(EGL_RENDER_BUFFER)
The implementation of this suffered from the same issues as
eglQuerySurface, and the solution is the same. confidence in its
correctness, flatten its indirect logic. For pixmap and pbuffer
surfaces, simply return a hard-coded literal value, as the spec
suggests. For window surfaces, simply return
_EGLSurface::ActiveRenderBuffer.
Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2018-04-07 22:23:48 +01:00
|
|
|
*/
|
|
|
|
EGLenum ActiveRenderBuffer;
|
|
|
|
|
2010-01-31 09:56:30 +00:00
|
|
|
EGLenum VGAlphaFormat;
|
|
|
|
EGLenum VGColorspace;
|
2015-06-10 01:49:29 +01:00
|
|
|
EGLenum GLColorspace;
|
2010-01-31 09:56:30 +00:00
|
|
|
|
|
|
|
/* attributes set by eglSurfaceAttrib */
|
|
|
|
EGLint MipmapLevel;
|
|
|
|
EGLenum MultisampleResolve;
|
|
|
|
EGLenum SwapBehavior;
|
|
|
|
|
|
|
|
EGLint HorizontalResolution, VerticalResolution;
|
|
|
|
EGLint AspectRatio;
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
EGLint SwapInterval;
|
|
|
|
|
2017-06-09 15:43:34 +01:00
|
|
|
/* EGL_KHR_partial_update
|
|
|
|
* True if the damage region is already set
|
|
|
|
* between frame boundaries.
|
|
|
|
*/
|
|
|
|
EGLBoolean SetDamageRegionCalled;
|
|
|
|
|
|
|
|
/* EGL_KHR_partial_update
|
|
|
|
* True if the buffer age is read by the client
|
|
|
|
* between frame boundaries.
|
|
|
|
*/
|
|
|
|
EGLBoolean BufferAgeRead;
|
|
|
|
|
2010-01-30 14:45:54 +00:00
|
|
|
/* True if the surface is bound to an OpenGL ES texture */
|
|
|
|
EGLBoolean BoundToTexture;
|
2011-12-14 20:24:09 +00:00
|
|
|
|
|
|
|
EGLBoolean PostSubBufferSupportedNV;
|
2018-04-05 11:02:36 +01:00
|
|
|
|
2020-05-11 17:26:30 +01:00
|
|
|
EGLBoolean ProtectedContent;
|
|
|
|
|
2021-08-02 21:16:34 +01:00
|
|
|
EGLBoolean PresentOpaque;
|
|
|
|
|
2018-04-05 11:02:36 +01:00
|
|
|
struct _egl_hdr_metadata HdrMetadata;
|
2019-05-01 23:42:26 +01:00
|
|
|
|
|
|
|
void *NativeSurface;
|
2005-04-22 22:09:39 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-02-28 17:20:01 +00:00
|
|
|
extern EGLBoolean
|
2019-02-02 11:38:45 +00:00
|
|
|
_eglInitSurface(_EGLSurface *surf, _EGLDisplay *disp, EGLint type,
|
2019-05-01 23:42:26 +01:00
|
|
|
_EGLConfig *config, const EGLint *attrib_list,
|
|
|
|
void *native_surface);
|
2005-04-22 22:09:39 +01:00
|
|
|
|
|
|
|
|
|
|
|
extern EGLBoolean
|
2018-04-22 15:48:15 +01:00
|
|
|
_eglQuerySurface(_EGLDisplay *disp, _EGLSurface *surf, EGLint attribute, EGLint *value);
|
2005-04-22 22:09:39 +01:00
|
|
|
|
|
|
|
|
|
|
|
extern EGLBoolean
|
2020-08-03 16:08:27 +01:00
|
|
|
_eglSurfaceAttrib(_EGLDisplay *disp, _EGLSurface *surf, EGLint attribute, EGLint value);
|
2005-04-22 22:09:39 +01:00
|
|
|
|
|
|
|
|
2015-02-28 17:20:01 +00:00
|
|
|
extern EGLBoolean
|
2018-04-22 15:48:15 +01:00
|
|
|
_eglBindTexImage(_EGLDisplay *disp, _EGLSurface *surf, EGLint buffer);
|
2005-04-22 22:09:39 +01:00
|
|
|
|
2015-02-28 17:20:01 +00:00
|
|
|
extern EGLBoolean
|
2018-04-22 15:48:15 +01:00
|
|
|
_eglReleaseTexImage(_EGLDisplay *disp, _EGLSurface *surf, EGLint buffer);
|
2014-02-18 03:04:03 +00:00
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
|
2018-05-01 06:32:25 +01:00
|
|
|
extern EGLBoolean
|
|
|
|
_eglSurfaceHasMutableRenderBuffer(_EGLSurface *surf);
|
|
|
|
|
|
|
|
extern EGLBoolean
|
|
|
|
_eglSurfaceInSharedBufferMode(_EGLSurface *surf);
|
2005-04-22 22:09:39 +01:00
|
|
|
|
2010-10-23 04:59:03 +01:00
|
|
|
/**
|
|
|
|
* Increment reference count for the surface.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLSurface *
|
2010-10-23 04:59:03 +01:00
|
|
|
_eglGetSurface(_EGLSurface *surf)
|
|
|
|
{
|
|
|
|
if (surf)
|
|
|
|
_eglGetResource(&surf->Resource);
|
|
|
|
return surf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Decrement reference count for the surface.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline EGLBoolean
|
2010-10-23 04:59:03 +01:00
|
|
|
_eglPutSurface(_EGLSurface *surf)
|
|
|
|
{
|
|
|
|
return (surf) ? _eglPutResource(&surf->Resource) : EGL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-24 12:32:34 +00:00
|
|
|
/**
|
2010-10-22 17:37:19 +01:00
|
|
|
* Link a surface to its display and return the handle of the link.
|
2010-01-24 12:32:34 +00:00
|
|
|
* The handle can be passed to client directly.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline EGLSurface
|
2010-10-22 17:37:19 +01:00
|
|
|
_eglLinkSurface(_EGLSurface *surf)
|
2010-01-23 14:57:23 +00:00
|
|
|
{
|
2010-10-22 17:37:19 +01:00
|
|
|
_eglLinkResource(&surf->Resource, _EGL_RESOURCE_SURFACE);
|
2010-01-24 12:32:34 +00:00
|
|
|
return (EGLSurface) surf;
|
2010-01-23 14:57:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-24 12:32:34 +00:00
|
|
|
/**
|
|
|
|
* Unlink a linked surface from its display.
|
|
|
|
* Accessing an unlinked surface should generate EGL_BAD_SURFACE error.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline void
|
2010-01-24 12:32:34 +00:00
|
|
|
_eglUnlinkSurface(_EGLSurface *surf)
|
|
|
|
{
|
|
|
|
_eglUnlinkResource(&surf->Resource, _EGL_RESOURCE_SURFACE);
|
|
|
|
}
|
2010-01-23 14:57:23 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Lookup a handle to find the linked surface.
|
|
|
|
* Return NULL if the handle has no corresponding linked surface.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLSurface *
|
2019-02-02 11:38:45 +00:00
|
|
|
_eglLookupSurface(EGLSurface surface, _EGLDisplay *disp)
|
2010-01-23 14:57:23 +00:00
|
|
|
{
|
|
|
|
_EGLSurface *surf = (_EGLSurface *) surface;
|
2019-02-02 11:38:45 +00:00
|
|
|
if (!disp || !_eglCheckResource((void *) surf, _EGL_RESOURCE_SURFACE, disp))
|
2010-01-23 14:57:23 +00:00
|
|
|
surf = NULL;
|
|
|
|
return surf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the handle of a linked surface, or EGL_NO_SURFACE.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline EGLSurface
|
2010-01-23 14:57:23 +00:00
|
|
|
_eglGetSurfaceHandle(_EGLSurface *surf)
|
|
|
|
{
|
2010-01-24 12:32:34 +00:00
|
|
|
_EGLResource *res = (_EGLResource *) surf;
|
|
|
|
return (res && _eglIsResourceLinked(res)) ?
|
|
|
|
(EGLSurface) surf : EGL_NO_SURFACE;
|
2010-01-23 14:57:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-13 23:13:37 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
#endif /* EGLSURFACE_INCLUDED */
|