From 5f5ecede5d6b4bdc3cb1ed90fe5413b0580f17c3 Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Fri, 1 Aug 2014 12:43:08 -0600 Subject: [PATCH] xgl: remove unused driver files --- CMakeLists.txt | 1 - main/CMakeLists.txt | 4 - main/Makefile.am | 131 -------- main/xglapi.c | 931 ---------------------------------------------------- main/xglapi.h | 833 ---------------------------------------------- main/xgldriver.c | 711 --------------------------------------- main/xgldriver.h | 125 ------- main/xgltypedefs.h | 71 ---- 8 files changed, 2807 deletions(-) delete mode 100644 main/CMakeLists.txt delete mode 100644 main/Makefile.am delete mode 100644 main/xglapi.c delete mode 100644 main/xglapi.h delete mode 100644 main/xgldriver.c delete mode 100644 main/xgldriver.h delete mode 100644 main/xgltypedefs.h diff --git a/CMakeLists.txt b/CMakeLists.txt index cec4275..3a854d6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -24,6 +24,5 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall") # drivers: Device dependent (DD) XGL components # tests: XGL tests add_subdirectory (loader) -add_subdirectory (main) add_subdirectory (drivers) add_subdirectory (tests) diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt deleted file mode 100644 index 67ee29f..0000000 --- a/main/CMakeLists.txt +++ /dev/null @@ -1,4 +0,0 @@ -# Create the XGL library - -add_library(libxgl SHARED xglapi.c) - diff --git a/main/Makefile.am b/main/Makefile.am deleted file mode 100644 index 38758a0..0000000 --- a/main/Makefile.am +++ /dev/null @@ -1,131 +0,0 @@ -# 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 diff --git a/main/xglapi.c b/main/xglapi.c deleted file mode 100644 index d4ab27c..0000000 --- a/main/xglapi.c +++ /dev/null @@ -1,931 +0,0 @@ -/* - * 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 -#include - -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) -{ -} diff --git a/main/xglapi.h b/main/xglapi.h deleted file mode 100644 index 3c660b0..0000000 --- a/main/xglapi.h +++ /dev/null @@ -1,833 +0,0 @@ -/* - * 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 - */ - -#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 */ diff --git a/main/xgldriver.c b/main/xgldriver.c deleted file mode 100644 index 78d8130..0000000 --- a/main/xgldriver.c +++ /dev/null @@ -1,711 +0,0 @@ -/************************************************************************** - * - * Copyright 2008 VMware, Inc. - * Copyright 2009-2010 Chia-I Wu - * 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 -#include -#include -#include - -#include "eglstring.h" -#include "egldefines.h" -#include "egldisplay.h" -#include "egldriver.h" -#include "egllog.h" -#include "eglmutex.h" - -#if defined(_EGL_OS_UNIX) -#include -#include -#include -#include -#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); -} diff --git a/main/xgldriver.h b/main/xgldriver.h deleted file mode 100644 index e34f19f..0000000 --- a/main/xgldriver.h +++ /dev/null @@ -1,125 +0,0 @@ -/************************************************************************** - * - * Copyright 2008 VMware, Inc. - * Copyright 2009-2010 Chia-I Wu - * 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 - -/** - * 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 */ diff --git a/main/xgltypedefs.h b/main/xgltypedefs.h deleted file mode 100644 index e90959a..0000000 --- a/main/xgltypedefs.h +++ /dev/null @@ -1,71 +0,0 @@ -/************************************************************************** - * - * Copyright 2008 VMware, Inc. - * Copyright 2009-2010 Chia-I Wu - * 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 -#include - -#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 */ -- 2.7.4