bool writeMeshContainerInCache(drn_writer_t * cache, DRNTDagNode & node, drn_scene::MeshContainer * meshContainer, drn_scene::MeshDynamicDataContainer * dynContainers, unsigned int frameCount, MeshExportMode mode) { int32_t status; status = drn_writer_add_chunk(cache, dynContainers, frameCount * sizeof (drn_scene::MeshDynamicDataContainer)); meshContainer->dynamicData = drn_writer_get_last_chunk_id(cache); status = drn_writer_add_chunk(cache, meshContainer, sizeof(drn_scene::MeshContainer)); node.container = drn_writer_get_last_chunk_id(cache); status = drn_writer_add_chunk(cache, node.dagPath.fullPathName().asChar(), node.dagPath.fullPathName().length() + 1); node.fullPath = drn_writer_get_last_chunk_id(cache); return status; }
bool writeMeshStaticDataInCache(drn_writer_t * cache, DRNTDagNode & node, drn_scene::MeshContainer * meshContainer, DRNTHardEdge & he, MeshExportMode mode) { uint32_t drnStatus = 0; MStatus status; MFnMesh mesh(node.dagPath); if (mode == MESH_EXPORT_FULL_TOPOLOGY) { meshContainer->numPolygons = mesh.numPolygons(&status); meshContainer->numVertices = mesh.numVertices(&status); meshContainer->numNormals = mesh.numNormals(&status); } else { meshContainer->numPolygons = 0; meshContainer->numVertices = 0; meshContainer->numNormals = 0; } MIntArray vertexCount; MIntArray vertexList; MIntArray normalCount; MIntArray normalList; MIntArray uvCounts; MIntArray uvIds; mesh.getAssignedUVs(uvCounts, uvIds); MIntArray triangleCount; MIntArray triangleList; MIntArray triangleNList; MIntArray triangleUVList; mesh.getVertices(vertexCount, vertexList); mesh.getNormalIds(normalCount, normalList); mesh.getTriangles(triangleCount, triangleList); triangleNList.setLength(triangleList.length()); triangleUVList.setLength(triangleList.length()); meshContainer->numTriangles = triangleList.length() / 3; int * vcarray = new int[vertexCount.length()]; int * vlarray = new int[vertexList.length()]; int * ncarray = new int[normalCount.length()]; int * nlarray = new int[normalList.length()]; // Triangulation int poly_idx_offset = 0; int tri_idx_offset = 0; for (int i = 0; i < mesh.numPolygons(); ++i) { for (int j = 0; j < triangleCount[i]; ++j) { for(unsigned int k=0; k < 3; ++k) { int v_idx = triangleList[tri_idx_offset+j*3 + k]; int match = -1; int l = 0; while (match < 0 && l < vertexCount[i]) { if (vertexList[poly_idx_offset+l] == v_idx) match = l; ++l; } triangleNList[tri_idx_offset+j*3 + k] = normalList[poly_idx_offset+match]; int id = 0; if (uvIds.length() != 0) mesh.getPolygonUVid(i, match, id); triangleUVList[tri_idx_offset+j*3 + k] = id; } } poly_idx_offset += vertexCount[i]; tri_idx_offset += 3 * triangleCount[i]; } he.tlist.resize(triangleList.length(), -1); //he.itlist.resize(triangleList.length()); he.itlist.resize(triangleList.length()); //std::map<std::pair<int, int>, int> h; std::map<triplet, int> h; int idx = 0; for (int i = 0, n = triangleList.length(); i != n; ++i) { //std::pair<int, int> p = std::make_pair(triangleList[i], triangleNList[i]); triplet p(triangleList[i], triangleNList[i], triangleUVList[i]); //std::map<std::pair<int, int>, int>::const_iterator match = h.find(p); std::map<triplet, int>::const_iterator match = h.find(p); if (match != h.end()) { he.tlist[i] = match->second; he.itlist[i] = match->first; } else { h[p] = idx; he.tlist[i] = idx; he.itlist[i] = p; ++idx; } } meshContainer->numHwVertices = he.idmax = idx; if (mode == MESH_EXPORT_FULL_TOPOLOGY) { vertexCount.get(vcarray); vertexList.get(vlarray); normalCount.get(ncarray); normalList.get(nlarray); drnStatus = drn_writer_add_chunk(cache, vcarray, sizeof(int) * vertexCount.length()); meshContainer->vertexCountPerFace = drn_writer_get_last_chunk_id(cache); drnStatus = drn_writer_add_chunk(cache, vlarray, sizeof(int) * vertexList.length()); meshContainer->vertexListPerFace = drn_writer_get_last_chunk_id(cache); drnStatus = drn_writer_add_chunk(cache, ncarray, sizeof(int) * normalCount.length()); meshContainer->normalCountPerFace = drn_writer_get_last_chunk_id(cache); drnStatus = drn_writer_add_chunk(cache, nlarray, sizeof(int) * normalList.length()); meshContainer->normalListPerFace = drn_writer_get_last_chunk_id(cache); drnStatus = drn_writer_add_chunk(cache, & (he.tlist[0]), sizeof(int) * he.tlist.size()); meshContainer->triangleList = drn_writer_get_last_chunk_id(cache); delete[] vcarray; delete[] vlarray; delete[] ncarray; delete[] nlarray; } else { meshContainer->numUVSets = 0; drnStatus = drn_writer_add_chunk(cache, & (he.tlist[0]), sizeof(int) * he.tlist.size()); meshContainer->triangleList = drn_writer_get_last_chunk_id(cache); meshContainer->defaultUVSet = 0; } DRNT_DBG_LVL2(std::cout << "trianglelist" << triangleList << std::endl;);
int32_t drn_close_writer(drn_writer_t *cache) { drn_header_container_t header; drn_map_container_t * maps = (drn_map_container_t *) ALLOCATE(sbcount(cache->maps) * sizeof(drn_map_container_t)); uint64_t m_idx; uint64_t i; size_t bytes; for (m_idx=0; m_idx < sbcount(cache->maps); ++m_idx) { drn_writer_map_t * map = cache->maps + m_idx; drn_hash_cell_t * hash_map = (drn_hash_cell_t *) ALLOCATE(DRN_HASH_MAP_SIZE * sizeof (drn_hash_cell_t)); uint64_t hc_idx; uint64_t chunk_count = 0; uint64_t values_size = 0; drn_writer_key_t * key_array = map->keys; uint64_t k_idx; drn_hash_desc_t * descriptors; char * values_string_array; uint32_t desc_offset_cntr; uint32_t value_strings_offset_cntr; for (hc_idx = 0; hc_idx < DRN_HASH_MAP_SIZE; ++hc_idx) { hash_map[hc_idx].offset = 0; hash_map[hc_idx].count = 0; } /* count Es + sum VV lengths */ for (k_idx = 0; k_idx < sbcount(map->keys); ++k_idx) { drn_writer_key_t * value = map->keys + k_idx; chunk_count += sbcount(value->descriptors); values_size += strlen(value->value)+1; } /* Allocate Es */ descriptors = (drn_hash_desc_t*) ALLOCATE((size_t) chunk_count * sizeof(drn_hash_desc_t)); /* Allocate Vv */ values_string_array = (char *) ALLOCATE((size_t) values_size * sizeof(char)); /* Sort Vs */ qsort(key_array, sbcount(map->keys), sizeof(drn_writer_key_t), drn_val_hash_cmp); /* For each V */ desc_offset_cntr = 0; value_strings_offset_cntr = 0; for (k_idx = 0; k_idx < sbcount(map->keys); ++k_idx) { uint32_t hash = drn_oat_hash(key_array[k_idx].value, (uint32_t) strlen(key_array[k_idx].value))%DRN_HASH_MAP_SIZE; uint64_t * chunk_ids = key_array[k_idx].descriptors; uint64_t d_idx; /* Fill H */ hash_map[hash].offset = desc_offset_cntr; hash_map[hash].count = sbcount(key_array[k_idx].descriptors); /* Fill Vv */ memcpy(values_string_array + value_strings_offset_cntr, key_array[k_idx].value, strlen(key_array[k_idx].value)+1); /* fill E */ qsort(chunk_ids, sbcount(key_array[k_idx].descriptors), sizeof(uint64_t), drn_uint64_cmp); for (d_idx = 0; d_idx < sbcount(key_array[k_idx].descriptors); ++d_idx) { descriptors[desc_offset_cntr].chunk_id = chunk_ids[d_idx]; descriptors[desc_offset_cntr].key_value_offset = value_strings_offset_cntr; ++desc_offset_cntr; } /* Increment offsets */ value_strings_offset_cntr += (uint32_t) strlen(key_array[k_idx].value)+1; } /* Write hash array as desc */ drn_writer_add_chunk(cache, hash_map, sizeof(drn_hash_cell_t) * DRN_HASH_MAP_SIZE); maps[m_idx].hash_chunk_id = drn_writer_get_last_chunk_id(cache); /* Write hash name as desc */ drn_writer_add_chunk(cache, map->name, strlen(map->name) + 1); maps[m_idx].name_chunk_id = drn_writer_get_last_chunk_id(cache); /* Write value string array as desc */ drn_writer_add_chunk(cache, descriptors, sizeof(drn_hash_desc_t) * chunk_count); maps[m_idx].descriptors_chunk_id = drn_writer_get_last_chunk_id(cache); /* Write desc array as desc */ drn_writer_add_chunk(cache, values_string_array, values_size); maps[m_idx].value_strings_chunk_id = drn_writer_get_last_chunk_id(cache); FREE(hash_map); FREE(descriptors); FREE(values_string_array); } drn_writer_add_chunk(cache, maps, sizeof(drn_map_container_t) * sbcount(cache->maps)); FREE(maps); header.version = cache->version; memcpy(header.description, cache->description, 256); header.index_offset = cache->desc_start_offset + cache->desc_end_offset; header.chunk_count = cache->chunk_count; header.maps_chunk_id = drn_writer_get_last_chunk_id(cache); LSEEK(cache->fd, 0L, SEEK_SET); bytes = WRITE(cache->fd, &header, sizeof(drn_header_container_t)); if (bytes != sizeof(drn_header_container_t)) return -1; LSEEK(cache->fd, cache->desc_start_offset + cache->desc_end_offset, SEEK_SET); bytes = WRITE(cache->fd, cache->descriptors, WRITE_COUNT_CAST (sizeof(drn_desc_t) * cache->chunk_count)); if (bytes != sizeof(drn_desc_t) * cache->chunk_count) return -1; if (CLOSE(cache->fd) == -1) return -1; for (i = 0; i < sbcount(cache->maps); ++i) { drn_writer_map_t * map = cache->maps + i; uint64_t j; for (j = 0; j < sbcount(map->keys); ++j) { drn_writer_key_t * value = map->keys + j; sbfree(value->descriptors); FREE(value->value); } sbfree(map->keys); FREE(map->name); } sbfree(cache->maps); sbfree(cache->descriptors); return 0; }