# drivers: Device dependent (DD) XGL components
# tests: XGL tests
add_subdirectory (loader)
-add_subdirectory (main)
add_subdirectory (drivers)
add_subdirectory (tests)
+++ /dev/null
-# Create the XGL library
-
-add_library(libxgl SHARED xglapi.c)
-
+++ /dev/null
-# Copyright © 2012 Intel Corporation
-#
-# 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 (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.
-
-AM_CFLAGS = \
- -I$(top_srcdir)/include \
- -I$(top_srcdir)/src/gbm/main \
- $(DEFINES) \
- $(VISIBILITY_CFLAGS) \
- $(EGL_CFLAGS) \
- -D_EGL_NATIVE_PLATFORM=$(EGL_NATIVE_PLATFORM) \
- -D_EGL_DRIVER_SEARCH_DIR=\"$(EGL_DRIVER_INSTALL_DIR)\" \
- -D_EGL_OS_UNIX=1
-
-lib_LTLIBRARIES = libEGL.la
-
-libEGL_la_SOURCES = \
- eglapi.c \
- eglapi.h \
- eglarray.c \
- eglarray.h \
- eglcompiler.h \
- eglconfig.c \
- eglconfig.h \
- eglcontext.c \
- eglcontext.h \
- eglcurrent.c \
- eglcurrent.h \
- egldefines.h \
- egldisplay.c \
- egldisplay.h \
- egldriver.c \
- egldriver.h \
- eglfallbacks.c \
- eglglobals.c \
- eglglobals.h \
- eglimage.c \
- eglimage.h \
- egllog.c \
- egllog.h \
- eglmisc.c \
- eglmisc.h \
- eglmode.c \
- eglmode.h \
- eglmutex.h \
- eglscreen.c \
- eglscreen.h \
- eglstring.c \
- eglstring.h \
- eglsurface.c \
- eglsurface.h \
- eglsync.c \
- eglsync.h \
- egltypedefs.h
-
-libEGL_la_LIBADD = \
- $(EGL_LIB_DEPS)
-libEGL_la_LDFLAGS = \
- -no-undefined \
- -version-number 1:0 \
- $(BSYMBOLIC) \
- $(GC_SECTIONS) \
- $(LD_NO_UNDEFINED)
-
-if HAVE_EGL_PLATFORM_X11
-AM_CFLAGS += -DHAVE_X11_PLATFORM
-AM_CFLAGS += $(XCB_DRI2_CFLAGS)
-libEGL_la_LIBADD += $(XCB_DRI2_LIBS)
-endif
-
-if HAVE_EGL_PLATFORM_WAYLAND
-AM_CFLAGS += -DHAVE_WAYLAND_PLATFORM
-AM_CFLAGS += $(WAYLAND_CFLAGS)
-libEGL_la_LIBADD += $(WAYLAND_LIBS)
-libEGL_la_LIBADD += $(LIBDRM_LIBS)
-libEGL_la_LIBADD += ../wayland/wayland-drm/libwayland-drm.la
-endif
-
-if HAVE_EGL_PLATFORM_DRM
-AM_CFLAGS += -DHAVE_DRM_PLATFORM
-libEGL_la_LIBADD += ../../gbm/libgbm.la
-endif
-
-if HAVE_EGL_PLATFORM_FBDEV
-AM_CFLAGS += -DHAVE_FBDEV_PLATFORM
-endif
-
-if HAVE_EGL_PLATFORM_NULL
-AM_CFLAGS += -DHAVE_NULL_PLATFORM
-endif
-
-if HAVE_EGL_DRIVER_DRI2
-AM_CFLAGS += -D_EGL_BUILT_IN_DRIVER_DRI2
-AM_CFLAGS += -DHAVE_XCB_DRI2
-libEGL_la_LIBADD += ../drivers/dri2/libegl_dri2.la
-libEGL_la_LIBADD += $(DLOPEN_LIBS) $(LIBDRM_LIBS)
-endif
-
-include $(top_srcdir)/install-lib-links.mk
-
-pkgconfigdir = $(libdir)/pkgconfig
-
-pkgconfig_DATA = egl.pc
-
-khrdir = $(includedir)/KHR
-khr_HEADERS = $(top_srcdir)/include/KHR/khrplatform.h
-
-egldir = $(includedir)/EGL
-egl_HEADERS = \
- $(top_srcdir)/include/EGL/eglext.h \
- $(top_srcdir)/include/EGL/egl.h \
- $(top_srcdir)/include/EGL/eglextchromium.h \
- $(top_srcdir)/include/EGL/eglmesaext.h \
- $(top_srcdir)/include/EGL/eglplatform.h
+++ /dev/null
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, 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 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.
- */
-
-#include <xgl.h>
-#include <xglDbg.h>
-
-XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
- const XGL_APPLICATION_INFO* pAppInfo,
- const XGL_ALLOC_CALLBACKS* pAllocCb,
- XGL_UINT maxGpus,
- XGL_UINT* pGpuCount,
- XGL_PHYSICAL_GPU* pGpus)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetGpuInfo(
- XGL_PHYSICAL_GPU gpu,
- XGL_PHYSICAL_GPU_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateDevice(
- XGL_PHYSICAL_GPU gpu,
- const XGL_DEVICE_CREATE_INFO* pCreateInfo,
- XGL_DEVICE* pDevice)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDestroyDevice(
- XGL_DEVICE device)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetExtensionSupport(
- XGL_PHYSICAL_GPU gpu,
- const XGL_CHAR* pExtName)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetDeviceQueue(
- XGL_DEVICE device,
- XGL_QUEUE_TYPE queueType,
- XGL_UINT queueIndex,
- XGL_QUEUE* pQueue)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglQueueSubmit(
- XGL_QUEUE queue,
- XGL_UINT cmdBufferCount,
- const XGL_CMD_BUFFER* pCmdBuffers,
- XGL_UINT memRefCount,
- const XGL_MEMORY_REF* pMemRefs,
- XGL_FENCE fence)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
- XGL_QUEUE queue,
- XGL_UINT memRefCount,
- const XGL_MEMORY_REF* pMemRefs)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglQueueWaitIdle(
- XGL_QUEUE queue)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDeviceWaitIdle(
- XGL_DEVICE device)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetMemoryHeapCount(
- XGL_DEVICE device,
- XGL_UINT* pCount)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetMemoryHeapInfo(
- XGL_DEVICE device,
- XGL_UINT heapId,
- XGL_MEMORY_HEAP_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglAllocMemory(
- XGL_DEVICE device,
- const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
- XGL_GPU_MEMORY* pMem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglFreeMemory(
- XGL_GPU_MEMORY mem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglSetMemoryPriority(
- XGL_GPU_MEMORY mem,
- XGL_MEMORY_PRIORITY priority)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglMapMemory(
- XGL_GPU_MEMORY mem,
- XGL_FLAGS flags,
- XGL_VOID** ppData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglUnmapMemory(
- XGL_GPU_MEMORY mem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglPinSystemMemory(
- XGL_DEVICE device,
- const XGL_VOID* pSysMem,
- XGL_SIZE memSize,
- XGL_GPU_MEMORY* pMem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(
- XGL_DEVICE device,
- XGL_UINT rangeCount,
- const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
- XGL_UINT preWaitSemaphoreCount,
- const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
- XGL_UINT postSignalSemaphoreCount,
- const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
- XGL_PHYSICAL_GPU gpu0,
- XGL_PHYSICAL_GPU gpu1,
- XGL_GPU_COMPATIBILITY_INFO* pInfo)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglOpenSharedMemory(
- XGL_DEVICE device,
- const XGL_MEMORY_OPEN_INFO* pOpenInfo,
- XGL_GPU_MEMORY* pMem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
- XGL_DEVICE device,
- const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
- XGL_QUEUE_SEMAPHORE* pSemaphore)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglOpenPeerMemory(
- XGL_DEVICE device,
- const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
- XGL_GPU_MEMORY* pMem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglOpenPeerImage(
- XGL_DEVICE device,
- const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
- XGL_IMAGE* pImage,
- XGL_GPU_MEMORY* pMem)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDestroyObject(
- XGL_OBJECT object)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetObjectInfo(
- XGL_BASE_OBJECT object,
- XGL_OBJECT_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglBindObjectMemory(
- XGL_OBJECT object,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateFence(
- XGL_DEVICE device,
- const XGL_FENCE_CREATE_INFO* pCreateInfo,
- XGL_FENCE* pFence)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetFenceStatus(
- XGL_FENCE fence)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglWaitForFences(
- XGL_DEVICE device,
- XGL_UINT fenceCount,
- const XGL_FENCE* pFences,
- XGL_BOOL waitAll,
- XGL_UINT64 timeout)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateQueueSemaphore(
- XGL_DEVICE device,
- const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
- XGL_QUEUE_SEMAPHORE* pSemaphore)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglSignalQueueSemaphore(
- XGL_QUEUE queue,
- XGL_QUEUE_SEMAPHORE semaphore)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglWaitQueueSemaphore(
- XGL_QUEUE queue,
- XGL_QUEUE_SEMAPHORE semaphore)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateEvent(
- XGL_DEVICE device,
- const XGL_EVENT_CREATE_INFO* pCreateInfo,
- XGL_EVENT* pEvent)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetEventStatus(
- XGL_EVENT event)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglSetEvent(
- XGL_EVENT event)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglResetEvent(
- XGL_EVENT event)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateQueryPool(
- XGL_DEVICE device,
- const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
- XGL_QUERY_POOL* pQueryPool)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetQueryPoolResults(
- XGL_QUERY_POOL queryPool,
- XGL_UINT startQuery,
- XGL_UINT queryCount,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetFormatInfo(
- XGL_DEVICE device,
- XGL_FORMAT format,
- XGL_FORMAT_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateImage(
- XGL_DEVICE device,
- const XGL_IMAGE_CREATE_INFO* pCreateInfo,
- XGL_IMAGE* pImage)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
- XGL_IMAGE image,
- const XGL_IMAGE_SUBRESOURCE* pSubresource,
- XGL_SUBRESOURCE_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateImageView(
- XGL_DEVICE device,
- const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
- XGL_IMAGE_VIEW* pView)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateColorAttachmentView(
- XGL_DEVICE device,
- const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
- XGL_COLOR_ATTACHMENT_VIEW* pView)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateDepthStencilView(
- XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_VIEW* pView)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateShader(
- XGL_DEVICE device,
- const XGL_SHADER_CREATE_INFO* pCreateInfo,
- XGL_SHADER* pShader)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
- XGL_DEVICE device,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateComputePipeline(
- XGL_DEVICE device,
- const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglStorePipeline(
- XGL_PIPELINE pipeline,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglLoadPipeline(
- XGL_DEVICE device,
- XGL_SIZE dataSize,
- const XGL_VOID* pData,
- XGL_PIPELINE* pPipeline)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreatePipelineDelta(
- XGL_DEVICE device,
- XGL_PIPELINE p1,
- XGL_PIPELINE p2,
- XGL_PIPELINE_DELTA* delta)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateSampler(
- XGL_DEVICE device,
- const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
- XGL_SAMPLER* pSampler)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateDescriptorSet(
- XGL_DEVICE device,
- const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
- XGL_DESCRIPTOR_SET* pDescriptorSet)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
- XGL_DESCRIPTOR_SET descriptorSet)
-{
-}
-
-XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
- XGL_DESCRIPTOR_SET descriptorSet)
-{
-}
-
-XGL_VOID XGLAPI xglAttachSamplerDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_SAMPLER* pSamplers)
-{
-}
-
-XGL_VOID XGLAPI xglAttachImageViewDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews)
-{
-}
-
-XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews)
-{
-}
-
-XGL_VOID XGLAPI xglAttachNestedDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets)
-{
-}
-
-XGL_VOID XGLAPI xglClearDescriptorSetSlots(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount)
-{
-}
-
-XGL_RESULT XGLAPI xglCreateViewportState(
- XGL_DEVICE device,
- const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
- XGL_VIEWPORT_STATE_OBJECT* pState)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateRasterState(
- XGL_DEVICE device,
- const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
- XGL_RASTER_STATE_OBJECT* pState)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateMsaaState(
- XGL_DEVICE device,
- const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
- XGL_MSAA_STATE_OBJECT* pState)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateColorBlendState(
- XGL_DEVICE device,
- const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
- XGL_COLOR_BLEND_STATE_OBJECT* pState)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateDepthStencilState(
- XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_STATE_OBJECT* pState)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglCreateCommandBuffer(
- XGL_DEVICE device,
- const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
- XGL_CMD_BUFFER* pCmdBuffer)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglBeginCommandBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_FLAGS flags)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglEndCommandBuffer(
- XGL_CMD_BUFFER cmdBuffer)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglResetCommandBuffer(
- XGL_CMD_BUFFER cmdBuffer)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_VOID XGLAPI xglCmdBindPipeline(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_PIPELINE pipeline)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBindPipelineDelta(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_PIPELINE_DELTA delta)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBindStateObject(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_STATE_BIND_POINT stateBindPoint,
- XGL_STATE_OBJECT state)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBindDescriptorSet(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT index,
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT slotOffset)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBindIndexData(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset,
- XGL_INDEX_TYPE indexType)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBindAttachments(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT colorAttachmentCount,
- const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments,
- const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment)
-{
-}
-
-XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT transitionCount,
- const XGL_MEMORY_STATE_TRANSITION* pStateTransitions)
-{
-}
-
-XGL_VOID XGLAPI xglCmdPrepareImages(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT transitionCount,
- const XGL_IMAGE_STATE_TRANSITION* pStateTransitions)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDraw(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT firstVertex,
- XGL_UINT vertexCount,
- XGL_UINT firstInstance,
- XGL_UINT instanceCount)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDrawIndexed(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT firstIndex,
- XGL_UINT indexCount,
- XGL_INT vertexOffset,
- XGL_UINT firstInstance,
- XGL_UINT instanceCount)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDrawIndirect(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset,
- XGL_UINT32 count,
- XGL_UINT32 stride)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset,
- XGL_UINT32 count,
- XGL_UINT32 stride)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDispatch(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT x,
- XGL_UINT y,
- XGL_UINT z)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDispatchIndirect(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset)
-{
-}
-
-XGL_VOID XGLAPI xglCmdCopyMemory(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY srcMem,
- XGL_GPU_MEMORY destMem,
- XGL_UINT regionCount,
- const XGL_MEMORY_COPY* pRegions)
-{
-}
-
-XGL_VOID XGLAPI xglCmdCopyImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE destImage,
- XGL_UINT regionCount,
- const XGL_IMAGE_COPY* pRegions)
-{
-}
-
-XGL_VOID XGLAPI xglCmdCopyMemoryToImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY srcMem,
- XGL_IMAGE destImage,
- XGL_UINT regionCount,
- const XGL_MEMORY_IMAGE_COPY* pRegions)
-{
-}
-
-XGL_VOID XGLAPI xglCmdCopyImageToMemory(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_GPU_MEMORY destMem,
- XGL_UINT regionCount,
- const XGL_MEMORY_IMAGE_COPY* pRegions)
-{
-}
-
-XGL_VOID XGLAPI xglCmdCloneImageData(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_STATE srcImageState,
- XGL_IMAGE destImage,
- XGL_IMAGE_STATE destImageState)
-{
-}
-
-XGL_VOID XGLAPI xglCmdUpdateMemory(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset,
- XGL_GPU_SIZE dataSize,
- const XGL_UINT32* pData)
-{
-}
-
-XGL_VOID XGLAPI xglCmdFillMemory(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset,
- XGL_GPU_SIZE fillSize,
- XGL_UINT32 data)
-{
-}
-
-XGL_VOID XGLAPI xglCmdClearColorImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- const XGL_FLOAT color[4],
- XGL_UINT rangeCount,
- const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
-{
-}
-
-XGL_VOID XGLAPI xglCmdClearColorImageRaw(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- const XGL_UINT32 color[4],
- XGL_UINT rangeCount,
- const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
-{
-}
-
-XGL_VOID XGLAPI xglCmdClearDepthStencil(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- XGL_FLOAT depth,
- XGL_UINT32 stencil,
- XGL_UINT rangeCount,
- const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
-{
-}
-
-XGL_VOID XGLAPI xglCmdResolveImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE destImage,
- XGL_UINT rectCount,
- const XGL_IMAGE_RESOLVE* pRects)
-{
-}
-
-XGL_VOID XGLAPI xglCmdSetEvent(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_EVENT event)
-{
-}
-
-XGL_VOID XGLAPI xglCmdResetEvent(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_EVENT event)
-{
-}
-
-XGL_VOID XGLAPI xglCmdMemoryAtomic(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset,
- XGL_UINT64 srcData,
- XGL_ATOMIC_OP atomicOp)
-{
-}
-
-XGL_VOID XGLAPI xglCmdBeginQuery(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
- XGL_UINT slot,
- XGL_FLAGS flags)
-{
-}
-
-XGL_VOID XGLAPI xglCmdEndQuery(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
- XGL_UINT slot)
-{
-}
-
-XGL_VOID XGLAPI xglCmdResetQueryPool(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
- XGL_UINT startQuery,
- XGL_UINT queryCount)
-{
-}
-
-XGL_VOID XGLAPI xglCmdWriteTimestamp(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_TIMESTAMP_TYPE timestampType,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset)
-{
-}
-
-XGL_VOID XGLAPI xglCmdInitAtomicCounters(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT startCounter,
- XGL_UINT counterCount,
- const XGL_UINT32* pData)
-{
-}
-
-XGL_VOID XGLAPI xglCmdLoadAtomicCounters(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT startCounter,
- XGL_UINT counterCount,
- XGL_GPU_MEMORY srcMem,
- XGL_GPU_SIZE srcOffset)
-{
-}
-
-XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT startCounter,
- XGL_UINT counterCount,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset)
-{
-}
-
-XGL_RESULT XGLAPI xglDbgSetValidationLevel(
- XGL_DEVICE device,
- XGL_VALIDATION_LEVEL validationLevel)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
- XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
- XGL_VOID* pUserData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
- XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDbgSetMessageFilter(
- XGL_DEVICE device,
- XGL_INT msgCode,
- XGL_DBG_MSG_FILTER filter)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDbgSetObjectTag(
- XGL_BASE_OBJECT object,
- XGL_SIZE tagSize,
- const XGL_VOID* pTag)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDbgSetGlobalOption(
- XGL_DBG_GLOBAL_OPTION dbgOption,
- XGL_SIZE dataSize,
- const XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_RESULT XGLAPI xglDbgSetDeviceOption(
- XGL_DEVICE device,
- XGL_DBG_DEVICE_OPTION dbgOption,
- XGL_SIZE dataSize,
- const XGL_VOID* pData)
-{
- return XGL_ERROR_UNAVAILABLE;
-}
-
-XGL_VOID XGLAPI xglCmdDbgMarkerBegin(
- XGL_CMD_BUFFER cmdBuffer,
- const XGL_CHAR* pMarker)
-{
-}
-
-XGL_VOID XGLAPI xglCmdDbgMarkerEnd(
- XGL_CMD_BUFFER cmdBuffer)
-{
-}
+++ /dev/null
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2012-2013 LunarG, 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 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.
- *
- * Authors:
- * Courtney Goeltzenleuchter <courtney@lunarg.com>
- */
-
-#ifndef XGLAPI_INCLUDED
-#define XGLAPI_INCLUDED
-#include "xgl.h"
-
-/**
- * A generic function ptr type
- */
-typedef void (*_XGLProc)(void);
-
-/**
- * Typedefs for all XGL API entrypoint functions.
- */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-// GPU initialization
-
-typedef XGL_RESULT XGLAPI (*InitAndEnumerateGpus_t)(
- const XGL_APPLICATION_INFO* pAppInfo,
- const XGL_ALLOC_CALLBACKS* pAllocCb,
- XGL_UINT maxGpus,
- XGL_UINT* pGpuCount,
- XGL_PHYSICAL_GPU* pGpus);
-
-typedef XGL_RESULT XGLAPI (*GetGpuInfo_t)(
- XGL_PHYSICAL_GPU gpu,
- XGL_PHYSICAL_GPU_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-// Device functions
-
-typedef XGL_RESULT XGLAPI (*CreateDevice_t)(
- XGL_PHYSICAL_GPU gpu,
- const XGL_DEVICE_CREATE_INFO* pCreateInfo,
- XGL_DEVICE* pDevice);
-
-typedef XGL_RESULT XGLAPI (*DestroyDevice_t)(
- XGL_DEVICE device);
-
-// Extension discovery functions
-
-typedef XGL_RESULT XGLAPI (*GetExtensionSupport_t)(
- XGL_PHYSICAL_GPU gpu,
- const XGL_CHAR* pExtName);
-
-// Queue functions
-
-typedef XGL_RESULT XGLAPI (*GetDeviceQueue_t)(
- XGL_DEVICE device,
- XGL_QUEUE_TYPE queueType,
- XGL_UINT queueIndex,
- XGL_QUEUE* pQueue);
-
-typedef XGL_RESULT XGLAPI (*QueueSubmit_t)(
- XGL_QUEUE queue,
- XGL_UINT cmdBufferCount,
- const XGL_CMD_BUFFER* pCmdBuffers,
- XGL_UINT memRefCount,
- const XGL_MEMORY_REF* pMemRefs,
- XGL_FENCE fence);
-
-typedef XGL_RESULT XGLAPI (*QueueSetGlobalMemReferences_t)(
- XGL_QUEUE queue,
- XGL_UINT memRefCount,
- const XGL_MEMORY_REF* pMemRefs);
-
-typedef XGL_RESULT XGLAPI (*QueueWaitIdle_t)(
- XGL_QUEUE queue);
-
-typedef XGL_RESULT XGLAPI (*DeviceWaitIdle_t)(
- XGL_DEVICE device);
-
-// Memory functions
-
-typedef XGL_RESULT XGLAPI (*GetMemoryHeapCount_t)(
- XGL_DEVICE device,
- XGL_UINT* pCount);
-
-typedef XGL_RESULT XGLAPI (*GetMemoryHeapInfo_t)(
- XGL_DEVICE device,
- XGL_UINT heapId,
- XGL_MEMORY_HEAP_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-typedef XGL_RESULT XGLAPI (*AllocMemory_t)(
- XGL_DEVICE device,
- const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
- XGL_GPU_MEMORY* pMem);
-
-typedef XGL_RESULT XGLAPI (*FreeMemory_t)(
- XGL_GPU_MEMORY mem);
-
-typedef XGL_RESULT XGLAPI (*SetMemoryPriority_t)(
- XGL_GPU_MEMORY mem,
- XGL_MEMORY_PRIORITY priority);
-
-typedef XGL_RESULT XGLAPI (*MapMemory_t)(
- XGL_GPU_MEMORY mem,
- XGL_FLAGS flags, // Reserved
- XGL_VOID** ppData);
-
-typedef XGL_RESULT XGLAPI (*UnmapMemory_t)(
- XGL_GPU_MEMORY mem);
-
-typedef XGL_RESULT XGLAPI (*PinSystemMemory_t)(
- XGL_DEVICE device,
- const XGL_VOID* pSysMem,
- XGL_SIZE memSize,
- XGL_GPU_MEMORY* pMem);
-
-typedef XGL_RESULT XGLAPI (*RemapVirtualMemoryPages_t)(
- XGL_DEVICE device,
- XGL_UINT rangeCount,
- const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
- XGL_UINT preWaitSemaphoreCount,
- const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
- XGL_UINT postSignalSemaphoreCount,
- const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
-
-// Multi-device functions
-
-typedef XGL_RESULT XGLAPI (*GetMultiGpuCompatibility_t)(
- XGL_PHYSICAL_GPU gpu0,
- XGL_PHYSICAL_GPU gpu1,
- XGL_GPU_COMPATIBILITY_INFO* pInfo);
-
-typedef XGL_RESULT XGLAPI (*OpenSharedMemory_t)(
- XGL_DEVICE device,
- const XGL_MEMORY_OPEN_INFO* pOpenInfo,
- XGL_GPU_MEMORY* pMem);
-
-typedef XGL_RESULT XGLAPI (*OpenSharedQueueSemaphore_t)(
- XGL_DEVICE device,
- const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
- XGL_QUEUE_SEMAPHORE* pSemaphore);
-
-typedef XGL_RESULT XGLAPI (*OpenPeerMemory_t)(
- XGL_DEVICE device,
- const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
- XGL_GPU_MEMORY* pMem);
-
-typedef XGL_RESULT XGLAPI (*OpenPeerImage_t)(
- XGL_DEVICE device,
- const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
- XGL_IMAGE* pImage,
- XGL_GPU_MEMORY* pMem);
-
-// Generic API object functions
-
-typedef XGL_RESULT XGLAPI (*DestroyObject_t)(
- XGL_OBJECT object);
-
-typedef XGL_RESULT XGLAPI (*GetObjectInfo_t)(
- XGL_BASE_OBJECT object,
- XGL_OBJECT_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-typedef XGL_RESULT XGLAPI (*BindObjectMemory_t)(
- XGL_OBJECT object,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset);
-
-// Fence functions
-
-typedef XGL_RESULT XGLAPI (*CreateFence_t)(
- XGL_DEVICE device,
- const XGL_FENCE_CREATE_INFO* pCreateInfo,
- XGL_FENCE* pFence);
-
-typedef XGL_RESULT XGLAPI (*GetFenceStatus_t)(
- XGL_FENCE fence);
-
-typedef XGL_RESULT XGLAPI (*WaitForFences_t)(
- XGL_DEVICE device,
- XGL_UINT fenceCount,
- const XGL_FENCE* pFences,
- XGL_BOOL waitAll,
- XGL_UINT64 timeout);
-
-// Queue semaphore functions
-
-typedef XGL_RESULT XGLAPI (*CreateQueueSemaphore_t)(
- XGL_DEVICE device,
- const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
- XGL_QUEUE_SEMAPHORE* pSemaphore);
-
-typedef XGL_RESULT XGLAPI (*SignalQueueSemaphore_t)(
- XGL_QUEUE queue,
- XGL_QUEUE_SEMAPHORE semaphore);
-
-typedef XGL_RESULT XGLAPI (*WaitQueueSemaphore_t)(
- XGL_QUEUE queue,
- XGL_QUEUE_SEMAPHORE semaphore);
-
-// Event functions
-
-typedef XGL_RESULT XGLAPI (*CreateEvent_t)(
- XGL_DEVICE device,
- const XGL_EVENT_CREATE_INFO* pCreateInfo,
- XGL_EVENT* pEvent);
-
-typedef XGL_RESULT XGLAPI (*GetEventStatus_t)(
- XGL_EVENT event);
-
-typedef XGL_RESULT XGLAPI (*SetEvent_t)(
- XGL_EVENT event);
-
-typedef XGL_RESULT XGLAPI (*ResetEvent_t)(
- XGL_EVENT event);
-
-// Query functions
-
-typedef XGL_RESULT XGLAPI (*CreateQueryPool_t)(
- XGL_DEVICE device,
- const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
- XGL_QUERY_POOL* pQueryPool);
-
-typedef XGL_RESULT XGLAPI (*GetQueryPoolResults_t)(
- XGL_QUERY_POOL queryPool,
- XGL_UINT startQuery,
- XGL_UINT queryCount,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-// Format capabilities
-
-typedef XGL_RESULT XGLAPI (*GetFormatInfo_t)(
- XGL_DEVICE device,
- XGL_FORMAT format,
- XGL_FORMAT_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-// Image functions
-
-typedef XGL_RESULT XGLAPI (*CreateImage_t)(
- XGL_DEVICE device,
- const XGL_IMAGE_CREATE_INFO* pCreateInfo,
- XGL_IMAGE* pImage);
-
-typedef XGL_RESULT XGLAPI (*GetImageSubresourceInfo_t)(
- XGL_IMAGE image,
- const XGL_IMAGE_SUBRESOURCE* pSubresource,
- XGL_SUBRESOURCE_INFO_TYPE infoType,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-// Image view functions
-
-typedef XGL_RESULT XGLAPI (*CreateImageView_t)(
- XGL_DEVICE device,
- const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
- XGL_IMAGE_VIEW* pView);
-
-typedef XGL_RESULT XGLAPI (*CreateColorAttachmentView_t)(
- XGL_DEVICE device,
- const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
- XGL_COLOR_ATTACHMENT_VIEW* pView);
-
-typedef XGL_RESULT XGLAPI (*CreateDepthStencilView_t)(
- XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_VIEW* pView);
-
-// Shader functions
-
-typedef XGL_RESULT XGLAPI (*CreateShader_t)(
- XGL_DEVICE device,
- const XGL_SHADER_CREATE_INFO* pCreateInfo,
- XGL_SHADER* pShader);
-
-// Pipeline functions
-
-typedef XGL_RESULT XGLAPI (*CreateGraphicsPipeline_t)(
- XGL_DEVICE device,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline);
-
-typedef XGL_RESULT XGLAPI (*CreateComputePipeline_t)(
- XGL_DEVICE device,
- const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline);
-
-typedef XGL_RESULT XGLAPI (*StorePipeline_t)(
- XGL_PIPELINE pipeline,
- XGL_SIZE* pDataSize,
- XGL_VOID* pData);
-
-typedef XGL_RESULT XGLAPI (*LoadPipeline_t)(
- XGL_DEVICE device,
- XGL_SIZE dataSize,
- const XGL_VOID* pData,
- XGL_PIPELINE* pPipeline);
-
-typedef XGL_RESULT XGLAPI (*CreatePipelineDelta_t)(
- XGL_DEVICE device,
- XGL_PIPELINE p1,
- XGL_PIPELINE p2,
- XGL_PIPELINE_DELTA* delta);
-
-// Sampler functions
-
-typedef XGL_RESULT XGLAPI (*CreateSampler_t)(
- XGL_DEVICE device,
- const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
- XGL_SAMPLER* pSampler);
-
-// Descriptor set functions
-
-typedef XGL_RESULT XGLAPI (*CreateDescriptorSet_t)(
- XGL_DEVICE device,
- const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
- XGL_DESCRIPTOR_SET* pDescriptorSet);
-
-typedef XGL_VOID XGLAPI (*BeginDescriptorSetUpdate_t)(
- XGL_DESCRIPTOR_SET descriptorSet);
-
-typedef XGL_VOID XGLAPI (*EndDescriptorSetUpdate_t)(
- XGL_DESCRIPTOR_SET descriptorSet);
-
-typedef XGL_VOID XGLAPI (*AttachSamplerDescriptors_t)(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_SAMPLER* pSamplers);
-
-typedef XGL_VOID XGLAPI (*AttachImageViewDescriptors_t)(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
-
-typedef XGL_VOID XGLAPI (*AttachMemoryViewDescriptors_t)(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
-
-typedef XGL_VOID XGLAPI (*AttachNestedDescriptors_t)(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
-
-typedef XGL_VOID XGLAPI (*ClearDescriptorSetSlots_t)(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount);
-
-// State object functions
-
-typedef XGL_RESULT XGLAPI (*CreateViewportState_t)(
- XGL_DEVICE device,
- const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
- XGL_VIEWPORT_STATE_OBJECT* pState);
-
-typedef XGL_RESULT XGLAPI (*CreateRasterState_t)(
- XGL_DEVICE device,
- const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
- XGL_RASTER_STATE_OBJECT* pState);
-
-typedef XGL_RESULT XGLAPI (*CreateMsaaState_t)(
- XGL_DEVICE device,
- const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
- XGL_MSAA_STATE_OBJECT* pState);
-
-typedef XGL_RESULT XGLAPI (*CreateColorBlendState_t)(
- XGL_DEVICE device,
- const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
- XGL_COLOR_BLEND_STATE_OBJECT* pState);
-
-typedef XGL_RESULT XGLAPI (*CreateDepthStencilState_t)(
- XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
-
-// Command buffer functions
-
-typedef XGL_RESULT XGLAPI (*CreateCommandBuffer_t)(
- XGL_DEVICE device,
- const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
- XGL_CMD_BUFFER* pCmdBuffer);
-
-typedef XGL_RESULT XGLAPI (*BeginCommandBuffer_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_FLAGS flags); // XGL_CMD_BUFFER_BUILD_FLAGS
-
-typedef XGL_RESULT XGLAPI (*EndCommandBuffer_t)(
- XGL_CMD_BUFFER cmdBuffer);
-
-typedef XGL_RESULT XGLAPI (*ResetCommandBuffer_t)(
- XGL_CMD_BUFFER cmdBuffer);
-
-// Command buffer building functions
-
-typedef XGL_VOID XGLAPI (*CmdBindPipeline_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_PIPELINE pipeline);
-
-typedef XGL_VOID XGLAPI (*CmdBindPipelineDelta_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_PIPELINE_DELTA delta);
-
-typedef XGL_VOID XGLAPI (*CmdBindStateObject_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_STATE_BIND_POINT stateBindPoint,
- XGL_STATE_OBJECT state);
-
-typedef XGL_VOID XGLAPI (*CmdBindDescriptorSet_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT index,
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT slotOffset);
-
-typedef XGL_VOID XGLAPI (*CmdBindDynamicMemoryView_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
-
-typedef XGL_VOID XGLAPI (*CmdBindIndexData_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset,
- XGL_INDEX_TYPE indexType);
-
-typedef XGL_VOID XGLAPI (*CmdBindAttachments_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT colorAttachmentCount,
- const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments,
- const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment);
-
-typedef XGL_VOID XGLAPI (*CmdPrepareMemoryRegions_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT transitionCount,
- const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
-
-typedef XGL_VOID XGLAPI (*CmdPrepareImages_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT transitionCount,
- const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
-
-typedef XGL_VOID XGLAPI (*CmdDraw_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT firstVertex,
- XGL_UINT vertexCount,
- XGL_UINT firstInstance,
- XGL_UINT instanceCount);
-
-typedef XGL_VOID XGLAPI (*CmdDrawIndexed_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT firstIndex,
- XGL_UINT indexCount,
- XGL_INT vertexOffset,
- XGL_UINT firstInstance,
- XGL_UINT instanceCount);
-
-typedef XGL_VOID XGLAPI (*CmdDrawIndirect_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset,
- XGL_UINT32 count,
- XGL_UINT32 stride);
-
-typedef XGL_VOID XGLAPI (*CmdDrawIndexedIndirect_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset,
- XGL_UINT32 count,
- XGL_UINT32 stride);
-
-typedef XGL_VOID XGLAPI (*CmdDispatch_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_UINT x,
- XGL_UINT y,
- XGL_UINT z);
-
-typedef XGL_VOID XGLAPI (*CmdDispatchIndirect_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE offset);
-
-typedef XGL_VOID XGLAPI (*CmdCopyMemory_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY srcMem,
- XGL_GPU_MEMORY destMem,
- XGL_UINT regionCount,
- const XGL_MEMORY_COPY* pRegions);
-
-typedef XGL_VOID XGLAPI (*CmdCopyImage_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE destImage,
- XGL_UINT regionCount,
- const XGL_IMAGE_COPY* pRegions);
-
-typedef XGL_VOID XGLAPI (*CmdCopyMemoryToImage_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY srcMem,
- XGL_IMAGE destImage,
- XGL_UINT regionCount,
- const XGL_MEMORY_IMAGE_COPY* pRegions);
-
-typedef XGL_VOID XGLAPI (*CmdCopyImageToMemory_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_GPU_MEMORY destMem,
- XGL_UINT regionCount,
- const XGL_MEMORY_IMAGE_COPY* pRegions);
-
-typedef XGL_VOID XGLAPI (*CmdCloneImageData_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_STATE srcImageState,
- XGL_IMAGE destImage,
- XGL_IMAGE_STATE destImageState);
-
-typedef XGL_VOID XGLAPI (*CmdUpdateMemory_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset,
- XGL_GPU_SIZE dataSize,
- const XGL_UINT32* pData);
-
-typedef XGL_VOID XGLAPI (*CmdFillMemory_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset,
- XGL_GPU_SIZE fillSize,
- XGL_UINT32 data);
-
-typedef XGL_VOID XGLAPI (*CmdClearColorImage_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- const XGL_FLOAT color[4],
-XGL_UINT rangeCount,
-const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-
-typedef XGL_VOID XGLAPI (*CmdClearColorImageRaw_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- const XGL_UINT32 color[4],
-XGL_UINT rangeCount,
-const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-
-typedef XGL_VOID XGLAPI (*CmdClearDepthStencil_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- XGL_FLOAT depth,
- XGL_UINT32 stencil,
- XGL_UINT rangeCount,
- const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-
-typedef XGL_VOID XGLAPI (*CmdResolveImage_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE destImage,
- XGL_UINT rectCount,
- const XGL_IMAGE_RESOLVE* pRects);
-
-typedef XGL_VOID XGLAPI (*CmdSetEvent_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_EVENT event);
-
-typedef XGL_VOID XGLAPI (*CmdResetEvent_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_EVENT event);
-
-typedef XGL_VOID XGLAPI (*CmdMemoryAtomic_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset,
- XGL_UINT64 srcData,
- XGL_ATOMIC_OP atomicOp);
-
-typedef XGL_VOID XGLAPI (*CmdBeginQuery_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
- XGL_UINT slot,
- XGL_FLAGS flags);
-
-typedef XGL_VOID XGLAPI (*CmdEndQuery_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
- XGL_UINT slot);
-
-typedef XGL_VOID XGLAPI (*CmdResetQueryPool_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
- XGL_UINT startQuery,
- XGL_UINT queryCount);
-
-typedef XGL_VOID XGLAPI (*CmdWriteTimestamp_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_TIMESTAMP_TYPE timestampType,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset);
-
-typedef XGL_VOID XGLAPI (*CmdInitAtomicCounters_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT startCounter,
- XGL_UINT counterCount,
- const XGL_UINT32* pData);
-
-typedef XGL_VOID XGLAPI (*CmdLoadAtomicCounters_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT startCounter,
- XGL_UINT counterCount,
- XGL_GPU_MEMORY srcMem,
- XGL_GPU_SIZE srcOffset);
-
-typedef XGL_VOID XGLAPI (*CmdSaveAtomicCounters_t)(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT startCounter,
- XGL_UINT counterCount,
- XGL_GPU_MEMORY destMem,
- XGL_GPU_SIZE destOffset);
-
-/**
- * The API dispatcher jumps through these functions
- */
-struct _xgl_api
-{
- // GPU initialization
-
- InitAndEnumerateGpus_t InitAndEnumerateGpus;
- GetGpuInfo_t GetGpuInfo;
-
- // Device functions
- CreateDevice_t CreateDevice;
- DestroyDevice_t DestroyDevice;
-
- // Extension discovery functions
-
- GetExtensionSupport_t GetExtensionSupport;
-
- // Queue functions
- GetDeviceQueue_t GetDeviceQueue;
- QueueSubmit_t QueueSubmit;
- QueueSetGlobalMemReferences_t QueueSetGlobalMemReferences;
- QueueWaitIdle_t QueueWaitIdle;
- DeviceWaitIdle_t DeviceWaitIdle;
-
- // Memory functions
-
- GetMemoryHeapCount_t GetMemoryHeapCount;
- GetMemoryHeapInfo_t GetMemoryHeapInfo;
- AllocMemory_t AllocMemory;
- FreeMemory_t FreeMemory;
- SetMemoryPriority_t SetMemoryPriority;
- MapMemory_t MapMemory;
- UnmapMemory_t UnmapMemory;
- PinSystemMemory_t PinSystemMemory;
- RemapVirtualMemoryPages_t RemapVirtualMemoryPages;
-
- // Multi-device functions
-
- GetMultiGpuCompatibility_t GetMultiGpuCompatibility;
- OpenSharedMemory_t OpenSharedMemory;
- OpenSharedQueueSemaphore_t OpenSharedQueueSemaphore;
- OpenPeerMemory_t OpenPeerMemory;
- OpenPeerImage_t OpenPeerImage;
-
- // Generic API object functions
-
- DestroyObject_t DestroyObject;
- GetObjectInfo_t GetObjectInfo;
- BindObjectMemory_t BindObjectMemory;
-
- // Fence functions
-
- CreateFence_t CreateFence;
- GetFenceStatus_t GetFenceStatus;
- WaitForFences_t WaitForFences;
-
- // Queue semaphore functions
-
- CreateQueueSemaphore_t CreateQueueSemaphore;
- SignalQueueSemaphore_t SignalQueueSemaphore;
- WaitQueueSemaphore_t WaitQueueSemaphore;
-
- // Event functions
-
- CreateEvent_t CreateEvent;
- GetEventStatus_t GetEventStatus;
- SetEvent_t SetEvent;
- ResetEvent_t ResetEvent;
-
- // Query functions
-
- CreateQueryPool_t CreateQueryPool;
- GetQueryPoolResults_t GetQueryPoolResults;
-
- // Format capabilities
-
- GetFormatInfo_t GetFormatInfo;
-
- // Image functions
-
- CreateImage_t CreateImage;
- GetImageSubresourceInfo_t GetImageSubresourceInfo;
-
- // Image view functions
-
- CreateImageView_t CreateImageView;
- CreateColorAttachmentView_t CreateColorAttachmentView;
- CreateDepthStencilView_t CreateDepthStencilView;
-
- // Shader functions
-
- CreateShader_t CreateShader;
-
- // Pipeline functions
-
- CreateGraphicsPipeline_t CreateGraphicsPipeline;
- CreateComputePipeline_t CreateComputePipeline;
- StorePipeline_t StorePipeline;
- LoadPipeline_t LoadPipeline;
- CreatePipelineDelta_t CreatePipelineDelta;
-
- // Sampler functions
-
- CreateSampler_t CreateSampler;
-
- // Descriptor set functions
-
- CreateDescriptorSet_t CreateDescriptorSet;
- BeginDescriptorSetUpdate_t BeginDescriptorSetUpdate;
- EndDescriptorSetUpdate_t EndDescriptorSetUpdate;
- AttachSamplerDescriptors_t AttachSamplerDescriptors;
- AttachImageViewDescriptors_t AttachImageViewDescriptors;
- AttachMemoryViewDescriptors_t AttachMemoryViewDescriptors;
- AttachNestedDescriptors_t AttachNestedDescriptors;
- ClearDescriptorSetSlots_t ClearDescriptorSetSlots;
-
- // State object functions
-
- CreateViewportState_t CreateViewportState;
- CreateRasterState_t CreateRasterState;
- CreateMsaaState_t CreateMsaaState;
- CreateColorBlendState_t CreateColorBlendState;
- CreateDepthStencilState_t CreateDepthStencilState;
-
- // Command buffer functions
-
- CreateCommandBuffer_t CreateCommandBuffer;
- BeginCommandBuffer_t BeginCommandBuffer;
- EndCommandBuffer_t EndCommandBuffer;
- ResetCommandBuffer_t ResetCommandBuffer;
-
- // Command buffer building functions
-
- CmdBindPipeline_t CmdBindPipeline;
- CmdBindPipelineDelta_t CmdBindPipelineDelta;
- CmdBindStateObject_t CmdBindStateObject;
- CmdBindDescriptorSet_t CmdBindDescriptorSet;
- CmdBindDynamicMemoryView_t CmdBindDynamicMemoryView;
- CmdBindIndexData_t CmdBindIndexData;
- CmdBindAttachments_t CmdBindAttachments;
- CmdPrepareMemoryRegions_t CmdPrepareMemoryRegions;
- CmdPrepareImages_t CmdPrepareImages;
- CmdDraw_t CmdDraw;
- CmdDrawIndexed_t CmdDrawIndexed;
- CmdDrawIndirect_t CmdDrawIndirect;
- CmdDrawIndexedIndirect_t CmdDrawIndexedIndirect;
- CmdDispatch_t CmdDispatch;
- CmdDispatchIndirect_t CmdDispatchIndirect;
- CmdCopyMemory_t CmdCopyMemory;
- CmdCopyImage_t CmdCopyImage;
- CmdCopyMemoryToImage_t CmdCopyMemoryToImage;
- CmdCopyImageToMemory_t CmdCopyImageToMemory;
- CmdCloneImageData_t CmdCloneImageData;
- CmdUpdateMemory_t CmdUpdateMemory;
- CmdFillMemory_t CmdFillMemory;
- CmdClearColorImage_t CmdClearColorImage;
- CmdClearColorImageRaw_t CmdClearColorImageRaw;
- CmdClearDepthStencil_t CmdClearDepthStencil;
- CmdResolveImage_t CmdResolveImage;
- CmdSetEvent_t CmdSetEvent;
- CmdResetEvent_t CmdResetEvent;
- CmdMemoryAtomic_t CmdMemoryAtomic;
- CmdBeginQuery_t CmdBeginQuery;
- CmdEndQuery_t CmdEndQuery;
- CmdResetQueryPool_t CmdResetQueryPool;
- CmdWriteTimestamp_t CmdWriteTimestamp;
- CmdInitAtomicCounters_t CmdInitAtomicCounters;
- CmdLoadAtomicCounters_t CmdLoadAtomicCounters;
- CmdSaveAtomicCounters_t CmdSaveAtomicCounters;
-};
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
-
-#endif /* XGLAPI_INCLUDED */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2008 VMware, Inc.
- * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
- * Copyright 2010-2011 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.
- *
- **************************************************************************/
-
-
-/**
- * Functions for choosing and opening/loading device drivers.
- */
-
-
-#include <assert.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "eglstring.h"
-#include "egldefines.h"
-#include "egldisplay.h"
-#include "egldriver.h"
-#include "egllog.h"
-#include "eglmutex.h"
-
-#if defined(_EGL_OS_UNIX)
-#include <dlfcn.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <unistd.h>
-#endif
-
-
-typedef struct _egl_module {
- char *Path;
- _EGLMain_t BuiltIn;
- void *Handle;
- _EGLDriver *Driver;
-} _EGLModule;
-
-static _EGLMutex _eglModuleMutex = _EGL_MUTEX_INITIALIZER;
-static _EGLArray *_eglModules;
-
-const struct {
- const char *name;
- _EGLMain_t main;
-} _eglBuiltInDrivers[] = {
-#ifdef _EGL_BUILT_IN_DRIVER_GALLIUM
- { "egl_gallium", _eglBuiltInDriverGALLIUM },
-#endif
-#ifdef _EGL_BUILT_IN_DRIVER_DRI2
- { "egl_dri2", _eglBuiltInDriverDRI2 },
-#endif
- { NULL, NULL }
-};
-
-/**
- * Wrappers for dlopen/dlclose()
- */
-#if defined(_EGL_OS_WINDOWS)
-
-
-typedef HMODULE lib_handle;
-
-static HMODULE
-open_library(const char *filename)
-{
- return LoadLibrary(filename);
-}
-
-static void
-close_library(HMODULE lib)
-{
- FreeLibrary(lib);
-}
-
-
-static const char *
-library_suffix(void)
-{
- return ".dll";
-}
-
-
-#elif defined(_EGL_OS_UNIX)
-
-
-typedef void * lib_handle;
-
-static void *
-open_library(const char *filename)
-{
- return dlopen(filename, RTLD_LAZY);
-}
-
-static void
-close_library(void *lib)
-{
- dlclose(lib);
-}
-
-
-static const char *
-library_suffix(void)
-{
- return ".so";
-}
-
-
-#endif
-
-
-/**
- * Open the named driver and find its bootstrap function: _eglMain().
- */
-static _EGLMain_t
-_eglOpenLibrary(const char *driverPath, lib_handle *handle)
-{
- lib_handle lib;
- _EGLMain_t mainFunc = NULL;
- const char *error = "unknown error";
-
- assert(driverPath);
-
- _eglLog(_EGL_DEBUG, "dlopen(%s)", driverPath);
- lib = open_library(driverPath);
-
-#if defined(_EGL_OS_WINDOWS)
- /* XXX untested */
- if (lib)
- mainFunc = (_EGLMain_t) GetProcAddress(lib, "_eglMain");
-#elif defined(_EGL_OS_UNIX)
- if (lib) {
- union {
- _EGLMain_t func;
- void *ptr;
- } tmp = { NULL };
- /* direct cast gives a warning when compiled with -pedantic */
- tmp.ptr = dlsym(lib, "_eglMain");
- mainFunc = tmp.func;
- if (!mainFunc)
- error = dlerror();
- }
- else {
- error = dlerror();
- }
-#endif
-
- if (!lib) {
- _eglLog(_EGL_WARNING, "Could not open driver %s (%s)",
- driverPath, error);
- return NULL;
- }
-
- if (!mainFunc) {
- _eglLog(_EGL_WARNING, "_eglMain not found in %s (%s)",
- driverPath, error);
- if (lib)
- close_library(lib);
- return NULL;
- }
-
- *handle = lib;
- return mainFunc;
-}
-
-
-/**
- * Load a module and create the driver object.
- */
-static EGLBoolean
-_eglLoadModule(_EGLModule *mod)
-{
- _EGLMain_t mainFunc;
- lib_handle lib;
- _EGLDriver *drv;
-
- if (mod->Driver)
- return EGL_TRUE;
-
- if (mod->BuiltIn) {
- lib = (lib_handle) NULL;
- mainFunc = mod->BuiltIn;
- }
- else {
- mainFunc = _eglOpenLibrary(mod->Path, &lib);
- if (!mainFunc)
- return EGL_FALSE;
- }
-
- drv = mainFunc(NULL);
- if (!drv) {
- if (lib)
- close_library(lib);
- return EGL_FALSE;
- }
-
- if (!drv->Name) {
- _eglLog(_EGL_WARNING, "Driver loaded from %s has no name", mod->Path);
- drv->Name = "UNNAMED";
- }
-
- mod->Handle = (void *) lib;
- mod->Driver = drv;
-
- return EGL_TRUE;
-}
-
-
-/**
- * Unload a module.
- */
-static void
-_eglUnloadModule(_EGLModule *mod)
-{
-#if defined(_EGL_OS_UNIX)
- /* destroy the driver */
- if (mod->Driver && mod->Driver->Unload)
- mod->Driver->Unload(mod->Driver);
-
- /*
- * XXX At this point (atexit), the module might be the last reference to
- * libEGL. Closing the module might unmap libEGL and give problems.
- */
-#if 0
- if (mod->Handle)
- close_library(mod->Handle);
-#endif
-#elif defined(_EGL_OS_WINDOWS)
- /* XXX Windows unloads DLLs before atexit */
-#endif
-
- mod->Driver = NULL;
- mod->Handle = NULL;
-}
-
-
-/**
- * Add a module to the module array.
- */
-static _EGLModule *
-_eglAddModule(const char *path)
-{
- _EGLModule *mod;
- EGLint i;
-
- if (!_eglModules) {
- _eglModules = _eglCreateArray("Module", 8);
- if (!_eglModules)
- return NULL;
- }
-
- /* find duplicates */
- for (i = 0; i < _eglModules->Size; i++) {
- mod = _eglModules->Elements[i];
- if (strcmp(mod->Path, path) == 0)
- return mod;
- }
-
- /* allocate a new one */
- mod = calloc(1, sizeof(*mod));
- if (mod) {
- mod->Path = _eglstrdup(path);
- if (!mod->Path) {
- free(mod);
- mod = NULL;
- }
- }
- if (mod) {
- _eglAppendArray(_eglModules, (void *) mod);
- _eglLog(_EGL_DEBUG, "added %s to module array", mod->Path);
- }
-
- return mod;
-}
-
-
-/**
- * Free a module.
- */
-static void
-_eglFreeModule(void *module)
-{
- _EGLModule *mod = (_EGLModule *) module;
-
- _eglUnloadModule(mod);
- free(mod->Path);
- free(mod);
-}
-
-
-/**
- * A loader function for use with _eglPreloadForEach. The loader data is the
- * filename of the driver. This function stops on the first valid driver.
- */
-static EGLBoolean
-_eglLoaderFile(const char *dir, size_t len, void *loader_data)
-{
- char path[1024];
- const char *filename = (const char *) loader_data;
- size_t flen = strlen(filename);
-
- /* make a full path */
- if (len + flen + 2 > sizeof(path))
- return EGL_TRUE;
- if (len) {
- memcpy(path, dir, len);
- path[len++] = '/';
- }
- memcpy(path + len, filename, flen);
- len += flen;
- path[len] = '\0';
-
- if (library_suffix()) {
- const char *suffix = library_suffix();
- size_t slen = strlen(suffix);
- const char *p;
- EGLBoolean need_suffix;
-
- p = filename + flen - slen;
- need_suffix = (p < filename || strcmp(p, suffix) != 0);
- if (need_suffix) {
- /* overflow */
- if (len + slen + 1 > sizeof(path))
- return EGL_TRUE;
- strcpy(path + len, suffix);
- }
- }
-
-#if defined(_EGL_OS_UNIX)
- /* check if the file exists */
- if (access(path, F_OK))
- return EGL_TRUE;
-#endif
-
- _eglAddModule(path);
-
- return EGL_TRUE;
-}
-
-
-/**
- * Run the callback function on each driver directory.
- *
- * The process may end prematurely if the callback function returns false.
- */
-static void
-_eglPreloadForEach(const char *search_path,
- EGLBoolean (*loader)(const char *, size_t, void *),
- void *loader_data)
-{
- const char *cur, *next;
- size_t len;
-
- cur = search_path;
- while (cur) {
- next = strchr(cur, ':');
- len = (next) ? next - cur : strlen(cur);
-
- if (!loader(cur, len, loader_data))
- break;
-
- cur = (next) ? next + 1 : NULL;
- }
-}
-
-
-/**
- * Return a list of colon-separated driver directories.
- */
-static const char *
-_eglGetSearchPath(void)
-{
- static char search_path[1024];
-
-#if defined(_EGL_OS_UNIX) || defined(_EGL_OS_WINDOWS)
- if (search_path[0] == '\0') {
- char *buf = search_path;
- size_t len = sizeof(search_path);
- EGLBoolean use_env;
- char dir_sep;
- int ret;
-
-#if defined(_EGL_OS_UNIX)
- use_env = (geteuid() == getuid() && getegid() == getgid());
- dir_sep = '/';
-#else
- use_env = EGL_TRUE;
- dir_sep = '\\';
-#endif
-
- if (use_env) {
- char *p;
-
- /* extract the dirname from EGL_DRIVER */
- p = getenv("EGL_DRIVER");
- if (p && strchr(p, dir_sep)) {
- ret = _eglsnprintf(buf, len, "%s", p);
- if (ret > 0 && ret < len) {
- p = strrchr(buf, dir_sep);
- *p++ = ':';
-
- len -= p - buf;
- buf = p;
- }
- }
-
- /* append EGL_DRIVERS_PATH */
- p = getenv("EGL_DRIVERS_PATH");
- if (p) {
- ret = _eglsnprintf(buf, len, "%s:", p);
- if (ret > 0 && ret < len) {
- buf += ret;
- len -= ret;
- }
- }
- }
- else {
- _eglLog(_EGL_DEBUG,
- "ignore EGL_DRIVERS_PATH for setuid/setgid binaries");
- }
-
- ret = _eglsnprintf(buf, len, "%s", _EGL_DRIVER_SEARCH_DIR);
- if (ret < 0 || ret >= len)
- search_path[0] = '\0';
-
- _eglLog(_EGL_DEBUG, "EGL search path is %s", search_path);
- }
-#endif /* defined(_EGL_OS_UNIX) || defined(_EGL_OS_WINDOWS) */
-
- return search_path;
-}
-
-
-/**
- * Add the user driver to the module array.
- *
- * The user driver is specified by EGL_DRIVER.
- */
-static EGLBoolean
-_eglAddUserDriver(void)
-{
- const char *search_path = _eglGetSearchPath();
- char *env;
- size_t name_len = 0;
-
- env = getenv("EGL_DRIVER");
-#if defined(_EGL_OS_UNIX)
- if (env && strchr(env, '/')) {
- search_path = "";
- if ((geteuid() != getuid() || getegid() != getgid())) {
- _eglLog(_EGL_DEBUG,
- "ignore EGL_DRIVER for setuid/setgid binaries");
- env = NULL;
- }
- }
- else if (env) {
- char *suffix = strchr(env, '.');
- name_len = (suffix) ? suffix - env : strlen(env);
- }
-#else
- if (env)
- name_len = strlen(env);
-#endif /* _EGL_OS_UNIX */
-
- /*
- * Try built-in drivers first if we know the driver name. This makes sure
- * we do not load the outdated external driver that is still on the
- * filesystem.
- */
- if (name_len) {
- _EGLModule *mod;
- EGLint i;
-
- for (i = 0; _eglBuiltInDrivers[i].name; i++) {
- if (strlen(_eglBuiltInDrivers[i].name) == name_len &&
- !strncmp(_eglBuiltInDrivers[i].name, env, name_len)) {
- mod = _eglAddModule(env);
- if (mod)
- mod->BuiltIn = _eglBuiltInDrivers[i].main;
-
- return EGL_TRUE;
- }
- }
- }
-
- /* otherwise, treat env as a path */
- if (env) {
- _eglPreloadForEach(search_path, _eglLoaderFile, (void *) env);
-
- return EGL_TRUE;
- }
-
- return EGL_FALSE;
-}
-
-
-/**
- * Add egl_gallium to the module array.
- */
-static void
-_eglAddGalliumDriver(void)
-{
-#ifndef _EGL_BUILT_IN_DRIVER_GALLIUM
- void *external = (void *) "egl_gallium";
- _eglPreloadForEach(_eglGetSearchPath(), _eglLoaderFile, external);
-#endif
-}
-
-
-/**
- * Add built-in drivers to the module array.
- */
-static void
-_eglAddBuiltInDrivers(void)
-{
- _EGLModule *mod;
- EGLint i;
-
- for (i = 0; _eglBuiltInDrivers[i].name; i++) {
- mod = _eglAddModule(_eglBuiltInDrivers[i].name);
- if (mod)
- mod->BuiltIn = _eglBuiltInDrivers[i].main;
- }
-}
-
-
-/**
- * Add drivers to the module array. Drivers will be loaded as they are matched
- * to displays.
- */
-static EGLBoolean
-_eglAddDrivers(void)
-{
- if (_eglModules)
- return EGL_TRUE;
-
- if (!_eglAddUserDriver()) {
- /*
- * Add other drivers only when EGL_DRIVER is not set. The order here
- * decides the priorities.
- */
- _eglAddGalliumDriver();
- _eglAddBuiltInDrivers();
- }
-
- return (_eglModules != NULL);
-}
-
-
-/**
- * A helper function for _eglMatchDriver. It finds the first driver that can
- * initialize the display and return.
- */
-static _EGLDriver *
-_eglMatchAndInitialize(_EGLDisplay *dpy)
-{
- _EGLDriver *drv = NULL;
- EGLint i = 0;
-
- if (!_eglAddDrivers()) {
- _eglLog(_EGL_WARNING, "failed to find any driver");
- return NULL;
- }
-
- if (dpy->Driver) {
- drv = dpy->Driver;
- /* no re-matching? */
- if (!drv->API.Initialize(drv, dpy))
- drv = NULL;
- return drv;
- }
-
- while (i < _eglModules->Size) {
- _EGLModule *mod = (_EGLModule *) _eglModules->Elements[i];
-
- if (!_eglLoadModule(mod)) {
- /* remove invalid modules */
- _eglEraseArray(_eglModules, i, _eglFreeModule);
- continue;
- }
-
- if (mod->Driver->API.Initialize(mod->Driver, dpy)) {
- drv = mod->Driver;
- break;
- }
- else {
- i++;
- }
- }
-
- return drv;
-}
-
-
-/**
- * Match a display to a driver. The display is initialized unless test_only is
- * true. The matching is done by finding the first driver that can initialize
- * the display.
- */
-_EGLDriver *
-_eglMatchDriver(_EGLDisplay *dpy, EGLBoolean test_only)
-{
- _EGLDriver *best_drv;
-
- assert(!dpy->Initialized);
-
- _eglLockMutex(&_eglModuleMutex);
-
- /* set options */
- dpy->Options.TestOnly = test_only;
- dpy->Options.UseFallback = EGL_FALSE;
-
- best_drv = _eglMatchAndInitialize(dpy);
- if (!best_drv) {
- dpy->Options.UseFallback = EGL_TRUE;
- best_drv = _eglMatchAndInitialize(dpy);
- }
-
- _eglUnlockMutex(&_eglModuleMutex);
-
- if (best_drv) {
- _eglLog(_EGL_DEBUG, "the best driver is %s%s",
- best_drv->Name, (test_only) ? " (test only) " : "");
- if (!test_only) {
- dpy->Driver = best_drv;
- dpy->Initialized = EGL_TRUE;
- }
- }
-
- return best_drv;
-}
-
-
-__eglMustCastToProperFunctionPointerType
-_eglGetDriverProc(const char *procname)
-{
- EGLint i;
- _EGLProc proc = NULL;
-
- if (!_eglModules) {
- /* load the driver for the default display */
- EGLDisplay egldpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
- _EGLDisplay *dpy = _eglLookupDisplay(egldpy);
- if (!dpy || !_eglMatchDriver(dpy, EGL_TRUE))
- return NULL;
- }
-
- for (i = 0; i < _eglModules->Size; i++) {
- _EGLModule *mod = (_EGLModule *) _eglModules->Elements[i];
-
- if (!mod->Driver)
- break;
- proc = mod->Driver->API.GetProcAddress(mod->Driver, procname);
- if (proc)
- break;
- }
-
- return proc;
-}
-
-
-/**
- * Unload all drivers.
- */
-void
-_eglUnloadDrivers(void)
-{
- /* this is called at atexit time */
- if (_eglModules) {
- _eglDestroyArray(_eglModules, _eglFreeModule);
- _eglModules = NULL;
- }
-}
-
-
-/**
- * Invoke a callback function on each EGL search path.
- *
- * The first argument of the callback function is the name of the search path.
- * The second argument is the length of the name.
- */
-void
-_eglSearchPathForEach(EGLBoolean (*callback)(const char *, size_t, void *),
- void *callback_data)
-{
- const char *search_path = _eglGetSearchPath();
- _eglPreloadForEach(search_path, callback, callback_data);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2008 VMware, Inc.
- * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
- * Copyright 2010-2011 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.
- *
- **************************************************************************/
-
-
-#ifndef EGLDRIVER_INCLUDED
-#define EGLDRIVER_INCLUDED
-
-
-#include "egltypedefs.h"
-#include "eglapi.h"
-#include <stddef.h>
-
-/**
- * Define an inline driver typecast function.
- *
- * Note that this macro defines a function and should not be ended with a
- * semicolon when used.
- */
-#define _EGL_DRIVER_TYPECAST(drvtype, egltype, code) \
- static INLINE struct drvtype *drvtype(const egltype *obj) \
- { return (struct drvtype *) code; }
-
-
-/**
- * Define the driver typecast functions for _EGLDriver, _EGLDisplay,
- * _EGLContext, _EGLSurface, and _EGLConfig.
- *
- * Note that this macro defines several functions and should not be ended with
- * a semicolon when used.
- */
-#define _EGL_DRIVER_STANDARD_TYPECASTS(drvname) \
- _EGL_DRIVER_TYPECAST(drvname ## _driver, _EGLDriver, obj) \
- /* note that this is not a direct cast */ \
- _EGL_DRIVER_TYPECAST(drvname ## _display, _EGLDisplay, obj->DriverData) \
- _EGL_DRIVER_TYPECAST(drvname ## _context, _EGLContext, obj) \
- _EGL_DRIVER_TYPECAST(drvname ## _surface, _EGLSurface, obj) \
- _EGL_DRIVER_TYPECAST(drvname ## _config, _EGLConfig, obj)
-
-
-typedef _EGLDriver *(*_EGLMain_t)(const char *args);
-
-
-/**
- * Base class for device drivers.
- */
-struct _egl_driver
-{
- const char *Name; /**< name of this driver */
-
- /**
- * Release the driver resource.
- *
- * It is called before dlclose().
- */
- void (*Unload)(_EGLDriver *drv);
-
- _EGLAPI API; /**< EGL API dispatch table */
-};
-
-
-extern _EGLDriver *
-_eglBuiltInDriverGALLIUM(const char *args);
-
-
-extern _EGLDriver *
-_eglBuiltInDriverDRI2(const char *args);
-
-
-extern _EGLDriver *
-_eglBuiltInDriverGLX(const char *args);
-
-
-PUBLIC _EGLDriver *
-_eglMain(const char *args);
-
-
-extern _EGLDriver *
-_eglMatchDriver(_EGLDisplay *dpy, EGLBoolean test_only);
-
-
-extern __eglMustCastToProperFunctionPointerType
-_eglGetDriverProc(const char *procname);
-
-
-extern void
-_eglUnloadDrivers(void);
-
-
-/* defined in eglfallbacks.c */
-PUBLIC void
-_eglInitDriverFallbacks(_EGLDriver *drv);
-
-
-PUBLIC void
-_eglSearchPathForEach(EGLBoolean (*callback)(const char *, size_t, void *),
- void *callback_data);
-
-
-#endif /* EGLDRIVER_INCLUDED */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2008 VMware, Inc.
- * 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.
- *
- **************************************************************************/
-
-
-#ifndef EGLTYPEDEFS_INCLUDED
-#define EGLTYPEDEFS_INCLUDED
-
-#define EGL_EGLEXT_PROTOTYPES
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-
-#include "eglcompiler.h"
-
-typedef struct _egl_api _EGLAPI;
-
-typedef struct _egl_array _EGLArray;
-
-typedef struct _egl_config _EGLConfig;
-
-typedef struct _egl_context _EGLContext;
-
-typedef struct _egl_display _EGLDisplay;
-
-typedef struct _egl_driver _EGLDriver;
-
-typedef struct _egl_extensions _EGLExtensions;
-
-typedef struct _egl_image _EGLImage;
-
-typedef struct _egl_image_attribs _EGLImageAttribs;
-
-typedef struct _egl_mode _EGLMode;
-
-typedef struct _egl_resource _EGLResource;
-
-typedef struct _egl_screen _EGLScreen;
-
-typedef struct _egl_surface _EGLSurface;
-
-typedef struct _egl_sync _EGLSync;
-
-typedef struct _egl_thread_info _EGLThreadInfo;
-
-#endif /* EGLTYPEDEFS_INCLUDED */
projects / platform / upstream / Vulkan-Tools.git / commitdiff