bool VolumeRenderer::bindVolumes(tgt::Shader* shader, const std::vector<VolumeStruct>& volumes,
const tgt::Camera* camera, const tgt::vec4& lightPosition) {
shader->setIgnoreUniformLocationError(true);
bool success = true;
for (size_t i=0; i < volumes.size(); ++i) {
const VolumeStruct& volumeStruct = volumes[i];
const VolumeGL* volumeGL = volumeStruct.volume_->getRepresentation<VolumeGL>();
if (!volumeGL || !volumeGL->getTexture()) {
LWARNING("No volume texture while binding volumes");
continue;
}
const TextureUnit* texUnit = volumeStruct.texUnit_;
if (!texUnit) {
LERROR("No texture unit while binding volumes");
continue;
}
success &= bindVolumeTexture(volumeStruct.volume_, texUnit, volumeStruct.filterMode_, volumeStruct.wrapMode_, volumeStruct.borderColor_);
// set volume meta-data
setUniform(shader, volumeStruct.volumeIdentifier_, volumeStruct.volumeStructIdentifier_, volumeStruct.volume_, texUnit, camera, lightPosition);
LGL_ERROR;
}
shader->setIgnoreUniformLocationError(false);
LGL_ERROR;
return success;
}
void CMarchingCubes::InitMC(int _width, int _height, int _depth, ElemType* _pVolume)
{
// Data Array A[:, :, 1], A[:, :, 2], ... , A[:, : , n]
//m_GridSize = make_uint3(_depth, _width, _height);
m_GridSize = make_uint3(_width, _height, _depth);
m_NumVoxels = m_GridSize.x * m_GridSize.y * m_GridSize.z;
m_MaxVerts = m_GridSize.x * m_GridSize.y * 30; // Num of MaxVerts need change
#ifdef _DEBUG
printf("grids: %d * %d * %d = %d voxels\n", m_GridSize.x, m_GridSize.y, m_GridSize.z, m_NumVoxels);
#endif // _DEBUG
// needed change
int size = m_GridSize.x * m_GridSize.y * m_GridSize.z * sizeof(float);
//////////////////////////////////////////////////////////////////////////
int len = m_GridSize.x * m_GridSize.y * m_GridSize.z * 3;
float *pVolTemp = new float[len];
for (int i = 0; i < len; i++)
pVolTemp[i] = _pVolume[i];
//////////////////////////////////////////////////////////////////////////
cutilSafeCall(cudaMalloc((void**) &m_pdVolume, size * 3));
cutilSafeCall(cudaMemcpy(m_pdVolume, pVolTemp, size * 3, cudaMemcpyHostToDevice) );
bindVolumeTexture(m_pdVolume); // map the coordinates to the texture directly
delete []pVolTemp;
// allocate textures
allocateTextures( &m_pdEdgeTable, &m_pdTriTable, &m_pdNumVertsTable );
// allocate device memory
unsigned int memSize = sizeof(uint) * m_NumVoxels;
cutilSafeCall(cudaMalloc((void**) &m_pdVoxelVerts, memSize));
cutilSafeCall(cudaMalloc((void**) &m_pdVoxelVertsScan, memSize));
cutilSafeCall(cudaMalloc((void**) &m_pdVoxelOccupied, memSize));
cutilSafeCall(cudaMalloc((void**) &m_pdVoxelOccupiedScan, memSize));
cutilSafeCall(cudaMalloc((void**) &m_pdCompactedVoxelArray, memSize));
// initialize CUDPP scan
CUDPPConfiguration config;
config.algorithm = CUDPP_SCAN;
config.datatype = CUDPP_UINT;
config.op = CUDPP_ADD;
config.options = CUDPP_OPTION_FORWARD | CUDPP_OPTION_EXCLUSIVE;
cudppPlan(&m_Scanplan, config, m_NumVoxels, 1, 0);
}
////////////////////////////////////////////////////////////////////////////////
// initialize marching cubes
////////////////////////////////////////////////////////////////////////////////
void
initMC(int argc, char** argv)
{
// parse command line arguments
int n;
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "grid", &n)) {
gridSizeLog2.x = gridSizeLog2.y = gridSizeLog2.z = n;
}
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "gridx", &n)) {
gridSizeLog2.x = n;
}
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "gridy", &n)) {
gridSizeLog2.y = n;
}
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "gridz", &n)) {
gridSizeLog2.z = n;
}
char *filename;
if (cutGetCmdLineArgumentstr( argc, (const char**) argv, "file", &filename)) {
volumeFilename = filename;
}
gridSize = make_uint3(1<<gridSizeLog2.x, 1<<gridSizeLog2.y, 1<<gridSizeLog2.z);
gridSizeMask = make_uint3(gridSize.x-1, gridSize.y-1, gridSize.z-1);
gridSizeShift = make_uint3(0, gridSizeLog2.x, gridSizeLog2.x+gridSizeLog2.y);
numVoxels = gridSize.x*gridSize.y*gridSize.z;
voxelSize = make_float3(2.0f / gridSize.x, 2.0f / gridSize.y, 2.0f / gridSize.z);
maxVerts = gridSize.x*gridSize.y*100;
printf("grid: %d x %d x %d = %d voxels\n", gridSize.x, gridSize.y, gridSize.z, numVoxels);
printf("max verts = %d\n", maxVerts);
#if SAMPLE_VOLUME
// load volume data
char* path = cutFindFilePath(volumeFilename, argv[0]);
if (path == 0) {
fprintf(stderr, "Error finding file '%s'\n", volumeFilename);
cudaThreadExit();
exit(EXIT_FAILURE);
}
int size = gridSize.x*gridSize.y*gridSize.z*sizeof(uchar);
uchar *volume = loadRawFile(path, size);
cutilSafeCall(cudaMalloc((void**) &d_volume, size));
cutilSafeCall(cudaMemcpy(d_volume, volume, size, cudaMemcpyHostToDevice) );
free(volume);
bindVolumeTexture(d_volume);
#endif
if (g_bQAReadback) {
cudaMalloc((void **)&(d_pos), maxVerts*sizeof(float)*4);
cudaMalloc((void **)&(d_normal), maxVerts*sizeof(float)*4);
} else {
// create VBOs
createVBO(&posVbo, maxVerts*sizeof(float)*4);
// DEPRECATED: cutilSafeCall( cudaGLRegisterBufferObject(posVbo) );
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_posvbo_resource, posVbo,
cudaGraphicsMapFlagsWriteDiscard));
createVBO(&normalVbo, maxVerts*sizeof(float)*4);
// DEPRECATED: cutilSafeCall(cudaGLRegisterBufferObject(normalVbo));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_normalvbo_resource, normalVbo,
cudaGraphicsMapFlagsWriteDiscard));
}
// allocate textures
allocateTextures( &d_edgeTable, &d_triTable, &d_numVertsTable );
// allocate device memory
unsigned int memSize = sizeof(uint) * numVoxels;
cutilSafeCall(cudaMalloc((void**) &d_voxelVerts, memSize));
cutilSafeCall(cudaMalloc((void**) &d_voxelVertsScan, memSize));
cutilSafeCall(cudaMalloc((void**) &d_voxelOccupied, memSize));
cutilSafeCall(cudaMalloc((void**) &d_voxelOccupiedScan, memSize));
cutilSafeCall(cudaMalloc((void**) &d_compVoxelArray, memSize));
// initialize CUDPP scan
CUDPPConfiguration config;
config.algorithm = CUDPP_SCAN;
config.datatype = CUDPP_UINT;
config.op = CUDPP_ADD;
config.options = CUDPP_OPTION_FORWARD | CUDPP_OPTION_EXCLUSIVE;
cudppPlan(&scanplan, config, numVoxels, 1, 0);
}
