ri_body.append('int xglReplay::init(glv_replay::Display & disp)')
ri_body.append('{')
ri_body.append(' int err;')
- ri_body.append('#if defined _WIN64')
- ri_body.append(' HMODULE handle = LoadLibrary("xgl64.dll" );')
- ri_body.append('#elif defined _WIN32')
- ri_body.append(' HMODULE handle = LoadLibrary("xgl32.dll" );')
- ri_body.append('#elif defined PLATFORM_LINUX')
+ ri_body.append('#if defined PLATFORM_LINUX')
ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')
+ ri_body.append('#else')
+ ri_body.append(' HMODULE handle = LoadLibrary("xgl.dll" );')
ri_body.append('#endif\n')
ri_body.append(' if (handle == NULL) {')
ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')
def _gen_replay_wsi_associate_connection(self):
wac_body = []
+ wac_body.append('#ifdef WIN32')
+ wac_body.append(' //TBD')
+ wac_body.append(' replayResult = XGL_SUCCESS;')
+ wac_body.append('#else')
wac_body.append(' //associate with the replayers Wsi connection rather than tracers')
wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')
+ wac_body.append('#endif')
return "\n".join(wac_body)
def _gen_replay_wsi_get_msc(self):
wgm_body = []
+ wgm_body.append('#ifdef WIN32')
+ wgm_body.append(' //TBD')
+ wgm_body.append(' replayResult = XGL_SUCCESS;')
+ wgm_body.append('#else')
wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')
wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')
+ wgm_body.append('#endif')
return "\n".join(wgm_body)
def _gen_replay_wsi_create_presentable_image(self):
cpi_body = []
+ cpi_body.append('#ifdef WIN32')
+ cpi_body.append(' //TBD')
+ cpi_body.append(' replayResult = XGL_SUCCESS;')
+ cpi_body.append('#else')
cpi_body.append(' XGL_IMAGE img;')
cpi_body.append(' XGL_GPU_MEMORY mem;')
cpi_body.append(' m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);')
cpi_body.append(' m_display->imageHandles.push_back(img);')
cpi_body.append(' m_display->imageMemory.push_back(mem);')
cpi_body.append(' }')
+ cpi_body.append('#endif')
return "\n".join(cpi_body)
def _gen_replay_wsi_queue_present(self):
wqp_body = []
+ wqp_body.append('#ifdef WIN32')
+ wqp_body.append(' //TBD')
+ wqp_body.append(' replayResult = XGL_SUCCESS;')
+ wqp_body.append('#else')
wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')
wqp_body.append(' std::vector<int>::iterator it;')
wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
wqp_body.append(' }')
wqp_body.append(' }')
wqp_body.append(' }')
+ wqp_body.append('#endif')
wqp_body.append(' m_display->m_frameNumber++;')
return "\n".join(wqp_body)
header_txt = []
header_txt.append('#pragma once\n')
header_txt.append('#include "xgl.h"')
+ header_txt.append('#if defined(PLATFORM_LINUX)')
header_txt.append('#include "xglWsiX11Ext.h"\n')
+ header_txt.append('#else')
+ header_txt.append('#include "xglWsiWinExt.h"')
+ header_txt.append('#endif')
header_txt.append('void AttachHooks_xglwsix11ext();')
header_txt.append('void DetachHooks_xglwsix11ext();')
return "\n".join(header_txt)
def generate_header(self):
header_txt = []
header_txt.append('#pragma once\n')
+ header_txt.append('#if defined(PLATFORM_LINUX)')
header_txt.append('#include "xglWsiX11Ext.h"')
+ header_txt.append('#else')
+ header_txt.append('#include "xglWsiWinExt.h"')
+ header_txt.append('#endif')
header_txt.append('#include "glv_trace_packet_utils.h"\n')
return "\n".join(header_txt)
header_txt.append('#include <map>')
header_txt.append('#include <vector>')
header_txt.append('#include <string>')
+ header_txt.append('#if defined(PLATFORM_LINUX)')
header_txt.append('#include <xcb/xcb.h>\n')
+ header_txt.append('#endif')
header_txt.append('#include "glvreplay_window.h"')
header_txt.append('#include "glvreplay_factory.h"')
header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
header_txt.append('#include "xgl.h"')
header_txt.append('#include "xglDbg.h"')
+ header_txt.append('#if defined(PLATFORM_LINUX)')
header_txt.append('#include "xglWsiX11Ext.h"')
+ header_txt.append('#else')
+ header_txt.append('#include "xglWsiWinExt.h"')
+ header_txt.append('#endif')
return "\n".join(header_txt)
def generate_body(self):
*/
#include "nulldrv.h"
+#include <stdio.h>
+
+#if 0
+#define NULLDRV_LOG_FUNC \
+ do { \
+ fflush(stdout); \
+ fflush(stderr); \
+ printf("null driver: %s\n", __FUNCTION__); \
+ fflush(stdout); \
+ } while (0)
+#else
+ #define NULLDRV_LOG_FUNC do { } while (0)
+#endif
+// The null driver supports all WSI extenstions ... for now ...
static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
-#ifdef ENABLE_WSI_X11
[NULLDRV_EXT_WSI_X11] = "XGL_WSI_X11",
-#endif
-#ifdef ENABLE_WSI_WINDOWS
- [NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS",
-#endif
+ [NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS"
};
static struct nulldrv_base *nulldrv_base(XGL_BASE_OBJECT base)
return XGL_SUCCESS;
}
+static struct nulldrv_buf *nulldrv_buf(XGL_BUFFER buf)
+{
+ return (struct nulldrv_buf *) buf;
+}
+
+static XGL_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev,
+ const XGL_BUFFER_VIEW_CREATE_INFO *info,
+ struct nulldrv_buf_view **view_ret)
+{
+ struct nulldrv_buf *buf = nulldrv_buf(info->buffer);
+ struct nulldrv_buf_view *view;
+
+ view = (struct nulldrv_buf_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_BUFFER_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ view->buf = buf;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
//*********************************************
// Driver entry points
const XGL_BUFFER_CREATE_INFO* pCreateInfo,
XGL_BUFFER* pBuffer)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer);
const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
XGL_CMD_BUFFER* pCmdBuffer)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_cmd_create(dev, pCreateInfo,
XGL_CMD_BUFFER cmdBuffer,
const XGL_CMD_BUFFER_BEGIN_INFO *info)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(
XGL_CMD_BUFFER cmdBuffer)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(
XGL_CMD_BUFFER cmdBuffer)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
uint32_t counterCount,
const uint32_t* pData)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdLoadAtomicCounters(
XGL_BUFFER srcBuffer,
XGL_GPU_SIZE srcOffset)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdSaveAtomicCounters(
XGL_BUFFER destBuffer,
XGL_GPU_SIZE destOffset)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDbgMarkerBegin(
XGL_CMD_BUFFER cmdBuffer,
const char* pMarker)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDbgMarkerEnd(
XGL_CMD_BUFFER cmdBuffer)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
uint32_t regionCount,
const XGL_BUFFER_COPY* pRegions)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdCopyImage(
uint32_t regionCount,
const XGL_IMAGE_COPY* pRegions)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
uint32_t regionCount,
const XGL_BUFFER_IMAGE_COPY* pRegions)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
uint32_t regionCount,
const XGL_BUFFER_IMAGE_COPY* pRegions)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdCloneImageData(
XGL_IMAGE destImage,
XGL_IMAGE_LAYOUT destImageLayout)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdUpdateBuffer(
XGL_GPU_SIZE dataSize,
const uint32_t* pData)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdFillBuffer(
XGL_GPU_SIZE fillSize,
uint32_t data)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdClearColorImage(
uint32_t rangeCount,
const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdClearColorImageRaw(
uint32_t rangeCount,
const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
uint32_t rangeCount,
const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdResolveImage(
uint32_t rectCount,
const XGL_IMAGE_RESOLVE* pRects)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBeginQuery(
uint32_t slot,
XGL_FLAGS flags)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdEndQuery(
XGL_QUERY_POOL queryPool,
uint32_t slot)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdResetQueryPool(
uint32_t startQuery,
uint32_t queryCount)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdSetEvent(
XGL_EVENT event_,
XGL_SET_EVENT pipeEvent)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdResetEvent(
XGL_CMD_BUFFER cmdBuffer,
XGL_EVENT event_)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdWriteTimestamp(
XGL_BUFFER destBuffer,
XGL_GPU_SIZE destOffset)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBindPipeline(
XGL_PIPELINE_BIND_POINT pipelineBindPoint,
XGL_PIPELINE pipeline)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
XGL_PIPELINE_BIND_POINT pipelineBindPoint,
XGL_PIPELINE_DELTA delta)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
XGL_STATE_BIND_POINT stateBindPoint,
XGL_DYNAMIC_STATE_OBJECT state)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBindDescriptorSet(
XGL_DESCRIPTOR_SET descriptorSet,
const uint32_t* pUserData)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBindVertexBuffer(
XGL_GPU_SIZE offset,
uint32_t binding)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdBindIndexBuffer(
XGL_GPU_SIZE offset,
XGL_INDEX_TYPE indexType)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDraw(
uint32_t firstInstance,
uint32_t instanceCount)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
uint32_t firstInstance,
uint32_t instanceCount)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDrawIndirect(
uint32_t count,
uint32_t stride)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(
uint32_t count,
uint32_t stride)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDispatch(
uint32_t y,
uint32_t z)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdDispatchIndirect(
XGL_BUFFER buffer,
XGL_GPU_SIZE offset)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdWaitEvents(
XGL_CMD_BUFFER cmdBuffer,
const XGL_EVENT_WAIT_INFO* pWaitInfo)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdPipelineBarrier(
XGL_CMD_BUFFER cmdBuffer,
const XGL_PIPELINE_BARRIER* pBarrier)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT XGL_RESULT XGLAPI xglCreateDevice(
const XGL_DEVICE_CREATE_INFO* pCreateInfo,
XGL_DEVICE* pDevice)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_);
return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice);
}
ICD_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(
XGL_DEVICE device)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
uint32_t queueIndex,
XGL_QUEUE* pQueue)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
*pQueue = dev->queues[0];
return XGL_SUCCESS;
ICD_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(
XGL_DEVICE device)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_DEVICE device,
XGL_VALIDATION_LEVEL validationLevel)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
int32_t msgCode,
XGL_DBG_MSG_FILTER filter)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t dataSize,
const void* pData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_EVENT_CREATE_INFO* pCreateInfo,
XGL_EVENT* pEvent)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(
XGL_EVENT event_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglSetEvent(
XGL_EVENT event_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglResetEvent(
XGL_EVENT event_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_FENCE_CREATE_INFO* pCreateInfo,
XGL_FENCE* pFence)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_fence_create(dev, pCreateInfo,
ICD_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(
XGL_FENCE fence_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
bool32_t waitAll,
uint64_t timeout)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t* pDataSize,
void* pData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t* pDataSize,
void* pData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_PHYSICAL_GPU gpu_,
const char* pExtName)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_PHYSICAL_GPU gpu1_,
XGL_GPU_COMPATIBILITY_INFO* pInfo)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_IMAGE* pImage,
XGL_GPU_MEMORY* pMem)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_IMAGE_CREATE_INFO* pCreateInfo,
XGL_IMAGE* pImage)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_img_create(dev, pCreateInfo, false,
size_t* pDataSize,
void* pData)
{
+ NULLDRV_LOG_FUNC;
const struct nulldrv_img *img = nulldrv_img(image);
XGL_RESULT ret = XGL_SUCCESS;
XGL_IMAGE image,
const float color[4])
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_IMAGE image,
float depth)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
XGL_GPU_MEMORY* pMem)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem);
ICD_EXPORT XGL_RESULT XGLAPI xglFreeMemory(
XGL_GPU_MEMORY mem_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_GPU_MEMORY mem_,
XGL_MEMORY_PRIORITY priority)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_FLAGS flags,
void** ppData)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_mem *mem = nulldrv_mem(mem_);
void *ptr = nulldrv_mem_map(mem, flags);
ICD_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(
XGL_GPU_MEMORY mem_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t memSize,
XGL_GPU_MEMORY* pMem)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_MEMORY_OPEN_INFO* pOpenInfo,
XGL_GPU_MEMORY* pMem)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
XGL_GPU_MEMORY* pMem)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_ALLOC_CALLBACKS* pAllocCb,
XGL_INSTANCE* pInstance)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_instance *inst;
inst = (struct nulldrv_instance *) nulldrv_base_create(NULL, sizeof(*inst),
ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
XGL_INSTANCE pInstance)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
uint32_t* pGpuCount,
XGL_PHYSICAL_GPU* pGpus)
{
+ NULLDRV_LOG_FUNC;
XGL_RESULT ret;
struct nulldrv_gpu *gpu;
*pGpuCount = 1;
char* const* pOutLayers,
void* pReserved)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
void* pUserData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t dataSize,
const void* pData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
XGL_OBJECT object)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t* pDataSize,
void* pData)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_base *base = nulldrv_base(object);
return base->get_info(base, infoType, pDataSize, pData);
XGL_GPU_MEMORY mem_,
XGL_GPU_SIZE memOffset)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_GPU_MEMORY mem,
XGL_GPU_SIZE memOffset)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_GPU_MEMORY mem,
XGL_GPU_SIZE memOffset)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t tagSize,
const void* pTag)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
XGL_PIPELINE* pPipeline)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return graphics_pipeline_create(dev, pCreateInfo,
const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
XGL_PIPELINE* pPipeline)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t* pDataSize,
void* pData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const void* pData,
XGL_PIPELINE* pPipeline)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_PIPELINE p2,
XGL_PIPELINE_DELTA* delta)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
XGL_QUERY_POOL* pQueryPool)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
size_t* pDataSize,
void* pData)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
uint32_t memRefCount,
const XGL_MEMORY_REF* pMemRefs)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(
XGL_QUEUE queue_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_MEMORY_REF* pMemRefs,
XGL_FENCE fence_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
XGL_QUEUE_SEMAPHORE* pSemaphore)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
XGL_QUEUE_SEMAPHORE* pSemaphore)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_QUEUE queue,
XGL_QUEUE_SEMAPHORE semaphore)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_QUEUE queue,
XGL_QUEUE_SEMAPHORE semaphore)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
XGL_SAMPLER* pSampler)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_sampler_create(dev, pCreateInfo,
const XGL_SHADER_CREATE_INFO* pCreateInfo,
XGL_SHADER* pShader)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader);
const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
XGL_DYNAMIC_VP_STATE_OBJECT* pState)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_viewport_state_create(dev, pCreateInfo,
const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
XGL_DYNAMIC_RS_STATE_OBJECT* pState)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_raster_state_create(dev, pCreateInfo,
const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
XGL_DYNAMIC_CB_STATE_OBJECT* pState)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_blend_state_create(dev, pCreateInfo,
const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
XGL_DYNAMIC_DS_STATE_OBJECT* pState)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_ds_state_create(dev, pCreateInfo,
const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
XGL_BUFFER_VIEW* pView)
{
- return XGL_SUCCESS;
+ NULLDRV_LOG_FUNC;
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_buf_view_create(dev, pCreateInfo,
+ (struct nulldrv_buf_view **) pView);
}
ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
XGL_IMAGE_VIEW* pView)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_img_view_create(dev, pCreateInfo,
const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
XGL_COLOR_ATTACHMENT_VIEW* pView)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_rt_view_create(dev, pCreateInfo,
const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
XGL_DEPTH_STENCIL_VIEW* pView)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_ds_view_create(dev, pCreateInfo,
const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
struct nulldrv_desc_layout *prior_layout = nulldrv_desc_layout(priorSetLayout);
XGL_DEVICE device,
XGL_DESCRIPTOR_UPDATE_MODE updateMode)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_DEVICE device,
XGL_CMD_BUFFER cmd_)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo,
XGL_DESCRIPTOR_REGION* pDescriptorRegion)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_desc_region_create(dev, regionUsage, maxSets, pCreateInfo,
ICD_EXPORT XGL_RESULT XGLAPI xglClearDescriptorRegion(
XGL_DESCRIPTOR_REGION descriptorRegion)
{
+ NULLDRV_LOG_FUNC;
return XGL_SUCCESS;
}
XGL_DESCRIPTOR_SET* pDescriptorSets,
uint32_t* pCount)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_desc_region *region = nulldrv_desc_region(descriptorRegion);
struct nulldrv_dev *dev = region->dev;
XGL_RESULT ret = XGL_SUCCESS;
uint32_t count,
const XGL_DESCRIPTOR_SET* pDescriptorSets)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglUpdateDescriptors(
XGL_DESCRIPTOR_SET descriptorSet,
const void* pUpdateChain)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
const XGL_FRAMEBUFFER_CREATE_INFO* info,
XGL_FRAMEBUFFER* fb_ret)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_fb_create(dev, info, (struct nulldrv_framebuffer **) fb_ret);
const XGL_RENDER_PASS_CREATE_INFO* info,
XGL_RENDER_PASS* rp_ret)
{
+ NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
return nulldrv_render_pass_create(dev, info, (struct nulldrv_render_pass **) rp_ret);
XGL_CMD_BUFFER cmdBuffer,
XGL_RENDER_PASS renderPass)
{
+ NULLDRV_LOG_FUNC;
}
ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
XGL_CMD_BUFFER cmdBuffer,
XGL_RENDER_PASS renderPass)
{
+ NULLDRV_LOG_FUNC;
}
--- /dev/null
+;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; XGL
+;
+; Copyright (C) 2015 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.
+;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The following is required on Windows, for exporting symbols from the DLL
+
+LIBRARY XGL
+EXPORTS
+ xglCreateInstance
+ xglDestroyInstance
+ xglEnumerateGpus
+ xglGetGpuInfo
+ xglGetProcAddr
+ xglCreateDevice
+ xglDestroyDevice
+ xglGetExtensionSupport
+ xglEnumerateLayers
+ xglGetDeviceQueue
+ xglQueueSubmit
+ xglQueueSetGlobalMemReferences
+ xglQueueWaitIdle
+ xglDeviceWaitIdle
+ xglAllocMemory
+ xglFreeMemory
+ xglSetMemoryPriority
+ xglMapMemory
+ xglUnmapMemory
+ xglPinSystemMemory
+ xglGetMultiGpuCompatibility
+ xglOpenSharedMemory
+ xglOpenSharedQueueSemaphore
+ xglOpenPeerMemory
+ xglOpenPeerImage
+ xglDestroyObject
+ xglGetObjectInfo
+ xglBindObjectMemory
+ xglBindObjectMemoryRange
+ xglBindImageMemoryRange
+ xglCreateFence
+ xglGetFenceStatus
+ xglWaitForFences
+ xglCreateQueueSemaphore
+ xglSignalQueueSemaphore
+ xglWaitQueueSemaphore
+ xglCreateEvent
+ xglGetEventStatus
+ xglSetEvent
+ xglResetEvent
+ xglCreateQueryPool
+ xglGetQueryPoolResults
+ xglGetFormatInfo
+ xglCreateBuffer
+ xglCreateBufferView
+ xglCreateImage
+ xglSetFastClearColor
+ xglSetFastClearDepth
+ xglGetImageSubresourceInfo
+ xglCreateImageView
+ xglCreateColorAttachmentView
+ xglCreateDepthStencilView
+ xglCreateShader
+ xglCreateGraphicsPipeline
+ xglCreateComputePipeline
+ xglStorePipeline
+ xglLoadPipeline
+ xglCreatePipelineDelta
+ xglCreateSampler
+ xglCreateDescriptorSetLayout
+ xglBeginDescriptorRegionUpdate
+ xglEndDescriptorRegionUpdate
+ xglCreateDescriptorRegion
+ xglClearDescriptorRegion
+ xglAllocDescriptorSets
+ xglClearDescriptorSets
+ xglUpdateDescriptors
+ xglCreateDynamicViewportState
+ xglCreateDynamicRasterState
+ xglCreateDynamicColorBlendState
+ xglCreateDynamicDepthStencilState
+ xglCreateCommandBuffer
+ xglBeginCommandBuffer
+ xglEndCommandBuffer
+ xglResetCommandBuffer
+ xglCmdBindPipeline
+ xglCmdBindPipelineDelta
+ xglCmdBindDynamicStateObject
+ xglCmdBindDescriptorSet
+ xglCmdBindVertexBuffer
+ xglCmdBindIndexBuffer
+ xglCmdDraw
+ xglCmdDrawIndexed
+ xglCmdDrawIndirect
+ xglCmdDrawIndexedIndirect
+ xglCmdDispatch
+ xglCmdDispatchIndirect
+ xglCmdCopyBuffer
+ xglCmdCopyImage
+ xglCmdCopyBufferToImage
+ xglCmdCopyImageToBuffer
+ xglCmdCloneImageData
+ xglCmdUpdateBuffer
+ xglCmdFillBuffer
+ xglCmdClearColorImage
+ xglCmdClearColorImageRaw
+ xglCmdClearDepthStencil
+ xglCmdResolveImage
+ xglCmdSetEvent
+ xglCmdResetEvent
+ xglCmdWaitEvents
+ xglCmdPipelineBarrier
+ xglCmdBeginQuery
+ xglCmdEndQuery
+ xglCmdResetQueryPool
+ xglCmdWriteTimestamp
+ xglCmdInitAtomicCounters
+ xglCmdLoadAtomicCounters
+ xglCmdSaveAtomicCounters
+ xglCreateFramebuffer
+ xglCreateRenderPass
+ xglCmdBeginRenderPass
+ xglCmdEndRenderPass
+ xglDbgSetValidationLevel
+ xglDbgRegisterMsgCallback
+ xglDbgUnregisterMsgCallback
+ xglDbgSetMessageFilter
+ xglDbgSetObjectTag
+ xglDbgSetGlobalOption
+ xglDbgSetDeviceOption
+ xglCmdDbgMarkerBegin
+ xglCmdDbgMarkerEnd
projects / platform / upstream / Vulkan-Tools.git / commitdiff