void MeshTexturizer::Imp::allocateTextures(int groupIdx, const TRaster32P &ras, const TRaster32P &aux,
int x, int y, int textureLx, int textureLy,
bool premultiplied)
{
TextureData *data = m_textureDatas[groupIdx].get();
// Test the specified texture allocation
if (testTextureAlloc(textureLx, textureLy)) {
TPointD scale(data->m_geom.getLx() / (double)ras->getLx(),
data->m_geom.getLy() / (double)ras->getLy());
TRectD tileGeom(
TRectD(
scale.x * (x - TOTAL_BORDER), scale.y * (y - TOTAL_BORDER),
scale.x * (x + textureLx + TOTAL_BORDER), scale.y * (y + textureLy + TOTAL_BORDER)) +
data->m_geom.getP00());
GLuint texId = textureAlloc(ras, aux, x, y, textureLx, textureLy, premultiplied);
TextureData::TileData td = {texId, tileGeom};
data->m_tileDatas.push_back(td);
return;
}
if (textureLx <= 1 && textureLy <= 1)
return; // No texture can be allocated
// The texture could not be allocated. Then, bisecate and branch.
if (textureLx > textureLy) {
int textureLx_2 = textureLx >> 1;
allocateTextures(groupIdx, ras, aux, x, y, textureLx_2, textureLy, premultiplied);
allocateTextures(groupIdx, ras, aux, x + textureLx_2, y, textureLx_2, textureLy, premultiplied);
} else {
void TilesManager::setCurrentLayerTextureCount(int newTextureCount)
{
int maxTextureAllocation = getMaxTextureAllocation();
ALOGV("setCurrentLayerTextureCount: %d (current: %d, max:%d)",
newTextureCount, m_currentLayerTextureCount, maxTextureAllocation);
if (!newTextureCount && m_hasLayerTextures) {
double secondsSinceLayersUsed = WTF::currentTime() - m_lastTimeLayersUsed;
if (secondsSinceLayersUsed > LAYER_TEXTURES_DESTROY_TIMEOUT) {
unsigned long long sparedDrawCount = ~0; // by default, spare no textures
bool deleteGLTextures = true;
discardTexturesVector(sparedDrawCount, m_tilesTextures, deleteGLTextures);
m_hasLayerTextures = false;
}
return;
}
m_lastTimeLayersUsed = WTF::currentTime();
if (m_currentLayerTextureCount == maxTextureAllocation ||
newTextureCount <= m_currentLayerTextureCount)
return;
android::Mutex::Autolock lock(m_texturesLock);
m_currentLayerTextureCount = std::min(newTextureCount, maxTextureAllocation);
allocateTextures();
m_hasLayerTextures = true;
}
void apply(RenderDevice* rd) {
rd->push2D();
Rect2D screenRect = rd->getViewport();
allocateTextures(screenRect);
// Read back the depth buffer
depth->copyFromScreen(screenRect, true);
color->copyFromScreen(screenRect, true);
rd->setShader(shader);
Draw::rect2D(screenRect, rd);
rd->pop2D();
}
void TilesManager::setCurrentTextureCount(int newTextureCount)
{
int maxTextureAllocation = getMaxTextureAllocation();
ALOGV("setCurrentTextureCount: %d (current: %d, max:%d)",
newTextureCount, m_currentTextureCount, maxTextureAllocation);
if (m_currentTextureCount == maxTextureAllocation ||
newTextureCount <= m_currentTextureCount)
return;
android::Mutex::Autolock lock(m_texturesLock);
m_currentTextureCount = std::min(newTextureCount, maxTextureAllocation);
allocateTextures();
}
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);
}
