void Scene::initGeometry(const char *filename) { /// Open a DRONE file if (!filename || drn_open( &m_cache, filename, DRN_READ_MMAP) < 0) { fprintf( stderr, "\"%s\" is an invalid filename.\n", filename); exit( EXIT_FAILURE ); } m_bFileLoaded = true; /// Check if it matches the 'DRONE scene' format if (0 != strcmp(drn_get_description(&m_cache), DRN_SCENE_CACHE_DESCRIPTION)) { fprintf( stderr, "\"%s\" is an invalid drone scene file.\n", filename); exit( EXIT_FAILURE ); } /// Retrieve the scene chunk id drn_chunk_id_t sceneEntryId; { uint64_t status; status = drn_get_matching_chunks( &m_cache, drn_get_map_id( &m_cache, DRN_SCENE_CHUNK_TYPE_TAG), DRN_SCENE_CHUNK_TAG_TYPE_VALUE, 1, &sceneEntryId); if (1u != status) { fprintf( stderr, "Error: could not retrieve the scene chunk id.\n", filename); exit( EXIT_FAILURE ); } } /// Retrieve scene datas drn_scene::resolveScene(&m_cache, &m_drnScene, drn_get_chunk(&m_cache, sceneEntryId)); m_bSceneResolved = true; /// Resize global buffers m_meshInit.resize(m_drnScene.numMeshes, false); m_primitives.resize(m_drnScene.numMeshes); //--------------- cubewire::setup( m_cubeWire ); //-------------- glGenVertexArrays( 1, &m_screenmappingVAO); }
int32_t drn_open(drn_t * cache, const char * filename, int mode) { int fd = OPEN(filename, OPEN_MODE); if (fd <=0) { return -1; } cache->fd = fd; cache->mmap_size = drn_fsize(fd); cache->mode = mode; if (mode == DRN_READ_NOLOAD) { uint64_t i; size_t bytes; drn_desc_t hashes_desc; drn_map_container_t * map_containers; cache->mmap_start = 0; cache->data = 0; cache->header = ALLOCATE(sizeof(drn_header_container_t)); bytes = READ(fd, cache->header, sizeof(drn_header_container_t)); assert(bytes == sizeof(drn_header_container_t)); if (drn_get_version(cache) != DRN_WRITER_VERSION) return 1; cache->descriptors = ALLOCATE(cache->header->chunk_count * sizeof(drn_desc_t)); LSEEK(fd, cache->header->index_offset, SEEK_SET); bytes = READ(fd, cache->descriptors, READ_COUNT_CAST ((size_t) cache->header->chunk_count) * sizeof(drn_desc_t)); assert(bytes == cache->header->chunk_count * sizeof(drn_desc_t)); hashes_desc = drn_get_desc(cache, cache->header->maps_chunk_id); cache->map_count = hashes_desc.size / sizeof(drn_map_container_t); cache->maps = ALLOCATE(sizeof(drn_map_t) * (size_t) cache->map_count); map_containers = ALLOCATE(hashes_desc.size); drn_read_chunk(cache, cache->header->maps_chunk_id, map_containers); for (i = 0; i < cache->map_count; ++i) { drn_desc_t d; const drn_map_container_t * c = map_containers + i; drn_map_t * h = cache->maps + i; h->hash = ALLOCATE(drn_get_desc(cache, c->hash_chunk_id).size); drn_read_chunk(cache, c->hash_chunk_id, (void *) h->hash); h->name = ALLOCATE(drn_get_desc(cache, c->name_chunk_id).size); drn_read_chunk(cache, c->name_chunk_id, (void *) h->name); d = drn_get_desc(cache, c->descriptors_chunk_id); h->chunk_count = d.size / sizeof(drn_hash_desc_t); h->descriptors = ALLOCATE(d.size); drn_read_chunk(cache, c->descriptors_chunk_id, (void *) h->descriptors); h->value_strings = ALLOCATE(drn_get_desc(cache, c->value_strings_chunk_id).size); drn_read_chunk(cache, c->value_strings_chunk_id, (void *)h->value_strings); } FREE(map_containers); } else { uint64_t i; drn_desc_t maps_desc; drn_map_container_t * map_containers; if (mode == DRN_READ_MMAP) { #ifdef _MSC_VER wchar_t * w_filename; size_t bytes; CLOSE(fd); w_filename = ALLOCATE((strlen(filename)+1) * sizeof(wchar_t)); bytes = mbstowcs(w_filename, filename, strlen(filename)+1); //cache->w_fhandle = CreateFile(L"test.drn", GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0); cache->w_fhandle = CreateFile(w_filename, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0); FREE(w_filename); if ((int) cache->w_fhandle == HFILE_ERROR) { DWORD err = GetLastError(); printf("ERROR %Ld\n", err); return -1; } cache->w_mhandle = CreateFileMapping(cache->w_fhandle, NULL, PAGE_READONLY, 0, 0, NULL); if (cache->w_mhandle == NULL) { DWORD err = GetLastError(); return -1; } cache->mmap_start = MapViewOfFile(cache->w_mhandle, FILE_MAP_READ, 0, 0, (size_t) cache->mmap_size); if (cache->mmap_start == NULL) { DWORD err = GetLastError(); return -1; } #else cache->mmap_start = mmap(0, cache->mmap_size, PROT_READ, MAP_PRIVATE, fd, 0); CLOSE(fd); #endif } else if (mode == DRN_READ_LOAD) { size_t bytes; cache->mmap_start = ALLOCATE(cache->mmap_size); bytes = READ(fd, cache->mmap_start, READ_COUNT_CAST (size_t) cache->mmap_size); assert(bytes == cache->mmap_size); CLOSE(fd); } cache->data = (char *) cache->mmap_start + sizeof(drn_header_container_t); cache->header = (drn_header_container_t *) cache->mmap_start; if (drn_get_version(cache) != DRN_WRITER_VERSION) return 1; cache->descriptors = (drn_desc_t *) ((char *)cache->mmap_start + cache->header->index_offset); maps_desc = drn_get_desc(cache, cache->header->maps_chunk_id); cache->map_count = maps_desc.size / sizeof(drn_map_container_t); map_containers = (drn_map_container_t *) drn_get_chunk(cache, cache->header->maps_chunk_id); cache->maps = ALLOCATE(sizeof(drn_map_t) * (size_t) cache->map_count); for (i = 0; i < cache->map_count; ++i) { drn_desc_t d; const drn_map_container_t * c = map_containers + i; drn_map_t * h = cache->maps + i; h->hash = drn_get_chunk(cache, c->hash_chunk_id); h->name = drn_get_chunk(cache, c->name_chunk_id); d = drn_get_desc(cache, c->descriptors_chunk_id); h->chunk_count = d.size / sizeof(drn_hash_desc_t); h->descriptors = drn_get_chunk(cache, c->descriptors_chunk_id); h->value_strings = drn_get_chunk(cache, c->value_strings_chunk_id); } } return 0; }
size_t loadInMemory(std::vector<Chunk>& memory, bool* loadedLeaf, Leaf l, double distance, uint16_t nbSub_lvl2, size_t freeMemory){ drn_t cache; /* check if we can load the leaf - enough size in the memory */ uint32_t lengthVoxelArray = nbSub_lvl2*nbSub_lvl2*nbSub_lvl2; uint32_t leafBytesSize = lengthVoxelArray*VOXELDATA_BYTES_SIZE + l.nbVertices_lvl2*3*sizeof(double); //~ std::cout<<"//-> LeafBytesSize : "<<leafBytesSize<<std::endl; while(leafBytesSize > freeMemory && memory.size()>0){ freeMemory += freeInMemory(memory, loadedLeaf); } /* load the voxel data */ uint32_t test_cache = drn_open(&cache, "./voxels_data/voxel_intersec_1.data", DRN_READ_NOLOAD); if(test_cache <0){ throw std::runtime_error("unable to open data file"); } VoxelData* voxArray = NULL; voxArray = new VoxelData[lengthVoxelArray]; test_cache = drn_read_chunk(&cache, 2*l.id + CONFIGCHUNK_OFFSET, voxArray); if(test_cache <0){ throw std::runtime_error("unable to read data file"); } test_cache = drn_close(&cache); if(test_cache <0){ throw std::runtime_error("unable to close data file"); } /* load the mesh */ test_cache = drn_open(&cache, "./voxels_data/voxel_intersec_1.data", DRN_READ_MMAP); if(test_cache <0){ throw std::runtime_error("unable to open data file in MMAP mode"); } const void* pMesh = drn_get_chunk(&cache, 2*l.id + 1 + CONFIGCHUNK_OFFSET); if(NULL == pMesh){ throw std::runtime_error("unable to get a chunk pointer"); } GLuint meshVBO = 0; glGenBuffers(1, &meshVBO); glBindBuffer(GL_ARRAY_BUFFER, meshVBO); glBufferData(GL_ARRAY_BUFFER, l.nbVertices_lvl2*sizeof(Vertex), pMesh, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); test_cache = drn_close(&cache); if(test_cache <0){ throw std::runtime_error("unable to close data file"); } /* setting the mesh */ GLuint meshVAO = 0; glGenVertexArrays(1, &meshVAO); glBindVertexArray(meshVAO); glEnableVertexAttribArray(POSITION_LOCATION); glEnableVertexAttribArray(NORMAL_LOCATION); glEnableVertexAttribArray(BENDING_LOCATION); glEnableVertexAttribArray(DRAIN_LOCATION); glEnableVertexAttribArray(GRADIENT_LOCATION); glEnableVertexAttribArray(SURFACE_LOCATION); glBindBuffer(GL_ARRAY_BUFFER, meshVBO); glVertexAttribPointer(POSITION_LOCATION, 3, GL_DOUBLE, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(0)); glVertexAttribPointer(NORMAL_LOCATION, 3, GL_DOUBLE, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(3*sizeof(GLdouble))); glVertexAttribPointer(BENDING_LOCATION, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(6*sizeof(GLdouble))); glVertexAttribPointer(DRAIN_LOCATION, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(6*sizeof(GLdouble)+sizeof(GLfloat))); glVertexAttribPointer(GRADIENT_LOCATION, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(6*sizeof(GLdouble)+2*sizeof(GLfloat))); glVertexAttribPointer(SURFACE_LOCATION, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(6*sizeof(GLdouble)+3*sizeof(GLfloat))); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); //add the new chunk to the vector Chunk newChunk; newChunk.voxels = voxArray; newChunk.pos = l.pos; newChunk.idxLeaf = l.id; newChunk.d = distance; newChunk.vao = meshVAO; newChunk.vbo = meshVBO; newChunk.byteSize = leafBytesSize; memory.push_back(newChunk); //~ std::cout<<"//-> Leaf "<<l.id<<" loaded."<<std::endl; loadedLeaf[l.id] = true; freeMemory -= leafBytesSize; return freeMemory; }