bool
OsdCLKernelBundle::Compile(cl_context clContext,
int numVertexElements, int numVaryingElements) {
cl_int ciErrNum;
_numVertexElements = numVertexElements;
_numVaryingElements = numVaryingElements;
char constantDefine[256];
snprintf(constantDefine, sizeof(constantDefine),
"#define NUM_VERTEX_ELEMENTS %d\n"
"#define NUM_VARYING_ELEMENTS %d\n",
numVertexElements, numVaryingElements);
const char *sources[] = { constantDefine, clSource };
_clProgram = clCreateProgramWithSource(clContext, 2, sources, 0, &ciErrNum);
CL_CHECK_ERROR(ciErrNum, "clCreateProgramWithSource\n");
ciErrNum = clBuildProgram(_clProgram, 0, NULL, NULL, NULL, NULL);
if (ciErrNum != CL_SUCCESS) {
OsdError(OSD_CL_PROGRAM_BUILD_ERROR, "CLerr=%d", ciErrNum);
cl_int numDevices = 0;
clGetContextInfo(clContext, CL_CONTEXT_NUM_DEVICES,
sizeof(cl_uint), &numDevices, NULL);
cl_device_id *devices = new cl_device_id[numDevices];
clGetContextInfo(clContext, CL_CONTEXT_DEVICES,
sizeof(cl_device_id)*numDevices, devices, NULL);
for (int i = 0; i < numDevices; ++i) {
char cBuildLog[10240];
clGetProgramBuildInfo(_clProgram, devices[i], CL_PROGRAM_BUILD_LOG,
sizeof(cBuildLog), cBuildLog, NULL);
OsdError(OSD_CL_PROGRAM_BUILD_ERROR, cBuildLog);
}
delete[] devices;
return false;
}
_clBilinearEdge = buildKernel(_clProgram, "computeBilinearEdge");
_clBilinearVertex = buildKernel(_clProgram, "computeBilinearVertex");
_clCatmarkFace = buildKernel(_clProgram, "computeFace");
_clCatmarkEdge = buildKernel(_clProgram, "computeEdge");
_clCatmarkVertexA = buildKernel(_clProgram, "computeVertexA");
_clCatmarkVertexB = buildKernel(_clProgram, "computeVertexB");
_clLoopEdge = buildKernel(_clProgram, "computeEdge");
_clLoopVertexA = buildKernel(_clProgram, "computeVertexA");
_clLoopVertexB = buildKernel(_clProgram, "computeLoopVertexB");
_clVertexEditAdd = buildKernel(_clProgram, "editVertexAdd");
return true;
}
void
OsdCudaGLVertexBuffer::map() {
if (_devicePtr) return;
size_t num_bytes;
void *ptr;
cudaError_t err = cudaGraphicsMapResources(1, &_cudaResource, 0);
if (err != cudaSuccess)
OsdError(OSD_CUDA_GL_ERROR, "OsdCudaGLVertexBuffer::map failed.\n%s\n", cudaGetErrorString(err));
err = cudaGraphicsResourceGetMappedPointer(&ptr, &num_bytes, _cudaResource);
if (err != cudaSuccess)
OsdError(OSD_CUDA_GL_ERROR, "OsdCudaGLVertexBuffer::map failed.\n%s\n", cudaGetErrorString(err));
_devicePtr = ptr;
}
bool
OsdCudaD3D11VertexBuffer::allocate(ID3D11Device *device) {
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.ByteWidth = _numElements * _numVertices * sizeof(float);
hBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_SHADER_RESOURCE;
hBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float);
HRESULT hr;
hr = device->CreateBuffer(&hBufferDesc, NULL, &_d3d11Buffer);
if(FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Fail in CreateBuffer\n");
return false;
}
// register d3d11buffer as cuda resource
cudaError_t err = cudaGraphicsD3D11RegisterResource(
&_cudaResource, _d3d11Buffer, cudaGraphicsRegisterFlagsNone);
if (err != cudaSuccess) return false;
return true;
}
bool
OsdCLD3D11VertexBuffer::allocate(cl_context clContext, ID3D11Device *device) {
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.ByteWidth = _numElements * _numVertices * sizeof(float);
hBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_SHADER_RESOURCE;
hBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float);
HRESULT hr;
hr = device->CreateBuffer(&hBufferDesc, NULL, &_d3d11Buffer);
if(FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR, "Fail in CreateBuffer\n");
return false;
}
// register d3d11buffer as cl memory
cl_int err;
_clMemory = clCreateFromD3D11BufferKHR(clContext, CL_MEM_READ_WRITE, _d3d11Buffer, &err);
if (err != CL_SUCCESS) return false;
return true;
}
void
OsdD3D11VertexBuffer::UpdateData(const float *src, int startVertex, int numVertices,
void *param) {
ID3D11DeviceContext * pd3dDeviceContext =
static_cast<ID3D11DeviceContext*>(param);
assert(pd3dDeviceContext);
D3D11_MAPPED_SUBRESOURCE resource;
HRESULT hr = pd3dDeviceContext->Map(_uploadBuffer, 0,
D3D11_MAP_WRITE_DISCARD, 0, &resource);
if (FAILED(hr)) {
OsdError(OSD_D3D11_BUFFER_MAP_ERROR, "Failed to map buffer\n");
return;
}
int size = GetNumElements() * numVertices * sizeof(float);
memcpy((float*)resource.pData + startVertex * _numElements, src, size);
pd3dDeviceContext->Unmap(_uploadBuffer, 0);
D3D11_BOX srcBox = { 0, 0, 0, size, 1, 1 };
pd3dDeviceContext->CopySubresourceRegion(_buffer, 0, 0, 0, 0,
_uploadBuffer, 0, &srcBox);
}
bool
OsdD3D11VertexBuffer::allocate(ID3D11Device *device) {
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.ByteWidth = _numElements * _numVertices * sizeof(float);
hBufferDesc.Usage = D3D11_USAGE_DEFAULT;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
hBufferDesc.CPUAccessFlags = 0;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float);
HRESULT hr = device->CreateBuffer(&hBufferDesc, NULL, &_buffer);
if (FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Failed to create vertex buffer\n");
return false;
}
hBufferDesc.ByteWidth = _numElements * _numVertices * sizeof(float);
hBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_SHADER_RESOURCE;
hBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float);
hr = device->CreateBuffer(&hBufferDesc, NULL, &_uploadBuffer);
if (FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Failed to create upload vertex buffer\n");
return false;
}
D3D11_UNORDERED_ACCESS_VIEW_DESC uavd;
ZeroMemory(&uavd, sizeof(uavd));
uavd.Format = DXGI_FORMAT_R32_FLOAT;
uavd.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
uavd.Buffer.FirstElement = 0;
uavd.Buffer.NumElements = _numElements * _numVertices;
hr = device->CreateUnorderedAccessView(_buffer, &uavd, &_uav);
if (FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Failed to create unordered access resource view\n");
return false;
}
return true;
}
OsdCudaGLVertexBuffer *
OsdCudaGLVertexBuffer::Create(int numElements, int numVertices) {
OsdCudaGLVertexBuffer *instance =
new OsdCudaGLVertexBuffer(numElements, numVertices);
if (instance->allocate()) return instance;
OsdError(OSD_CUDA_GL_ERROR,"OsdCudaGLVertexBuffer::Create failed.\n");
delete instance;
return NULL;
}
void
OsdCudaGLVertexBuffer::unmap() {
if (_devicePtr == NULL) return;
cudaError_t err = cudaGraphicsUnmapResources(1, &_cudaResource, 0);
if (err != cudaSuccess)
OsdError(OSD_CUDA_GL_ERROR, "OsdCudaGLVertexBuffer::unmap failed.\n%s\n", cudaGetErrorString(err));
_devicePtr = NULL;
}
static cl_kernel buildKernel(cl_program prog, const char * name) {
cl_int ciErr;
cl_kernel k = clCreateKernel(prog, name, &ciErr);
if (ciErr != CL_SUCCESS) {
OsdError(OSD_CL_KERNEL_CREATE_ERROR);
}
return k;
}
static ID3D11Buffer *
genTextureBuffer(ID3D11DeviceContext *deviceContext, int size, void const * data) {
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.ByteWidth = size;
hBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_SHADER_RESOURCE;
hBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float);
HRESULT hr;
ID3D11Buffer *buffer;
ID3D11Device *device;
deviceContext->GetDevice(&device);
hr = device->CreateBuffer(&hBufferDesc, NULL, &buffer);
if (FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Fail in CreateBuffer\n");
return 0;
}
D3D11_MAPPED_SUBRESOURCE resource;
hr = deviceContext->Map(buffer, 0,
D3D11_MAP_WRITE_DISCARD, 0, &resource);
if (FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Fail in Map buffer\n");
buffer->Release();
return 0;
}
memcpy(resource.pData, data, size);
deviceContext->Unmap(buffer, 0);
return buffer;
}
ID3D11Buffer *
OsdCpuD3D11VertexBuffer::BindD3D11Buffer(ID3D11DeviceContext *deviceContext) {
assert(deviceContext);
D3D11_MAPPED_SUBRESOURCE resource;
HRESULT hr = deviceContext->Map(_d3d11Buffer, 0,
D3D11_MAP_WRITE_DISCARD, 0, &resource);
if (FAILED(hr)) {
OsdError(OSD_D3D11_BUFFER_MAP_ERROR, "Fail to map buffer\n");
return NULL;
}
int size = _numElements * _numVertices * sizeof(float);
memcpy(resource.pData, _cpuBuffer, size);
deviceContext->Unmap(_d3d11Buffer, 0);
return _d3d11Buffer;
}
bool
OsdCpuD3D11VertexBuffer::allocate(ID3D11Device *device) {
_cpuBuffer = new float[_numElements * _numVertices];
// XXX: should move this constructor to factory for error handling
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.ByteWidth = _numElements * _numVertices * sizeof(float);
hBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_SHADER_RESOURCE;
hBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float); // XXX ?
HRESULT hr;
hr = device->CreateBuffer(&hBufferDesc, NULL, &_d3d11Buffer);
if (FAILED(hr)) {
OsdError(OSD_D3D11_VERTEX_BUFFER_CREATE_ERROR,
"Fail in CreateBuffer\n");
return false;
}
return true;
}
