Refactor parser with cleaned code
Finally made separation btw obj_parts and face_groups
This commit is contained in:
parent
1deb5eae2c
commit
9e551619a1
GPG Key ID:
832E52F4E23F8F24
@ -104,7 +104,7 @@ static unsigned int mainProcess(int args_cnt, char* args_value[], T_PROG_OPTIONS
|
||||
}
|
||||
|
||||
// If Texture module loaded, process HMT file for mtl naming (doesn't extract texture!)
|
||||
if (p_opts->texture_module) {
|
||||
if (p_opts->texture_module && p_opts->export_mtl) {
|
||||
if (strlen(args_value[file_index]) >= MAX_STR_VAR) return RSPLIB_ERROR_GENERIC;
|
||||
|
||||
strncpy(hmt_filename, args_value[file_index], strlen(args_value[file_index]) - 3);
|
||||
|
||||
@ -82,6 +82,7 @@ typedef struct hob_face {
|
||||
} T_RSPMODEL_FACE;
|
||||
|
||||
typedef struct rspmodel_obj_parts {
|
||||
unsigned int meshdef0_offset;
|
||||
unsigned int meshdef1_offset;
|
||||
|
||||
unsigned int face_block_end_offset;
|
||||
|
||||
@ -21,8 +21,15 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static unsigned short ExtractObjects(T_RSPMODEL_HOB*, const MEMFILE, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ExtractObjParts(T_RSPMODEL_OBJECT*, const MEMFILE, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ExtractObjParts_faces(T_RSPMODEL_OBJ_PARTS*, const MEMFILE, const RSPMODEL_PARAMETERS*);
|
||||
|
||||
static unsigned short ParseObjectHeader(T_RSPMODEL_OBJECT*, const MEMFILE, const unsigned char, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ParseObjectPartsHeaders(T_RSPMODEL_OBJECT*, const MEMFILE, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ParseObjectPartHeader(T_RSPMODEL_OBJ_PARTS*, const MEMFILE, const int, const unsigned char, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ParseObjectMeshDef(T_RSPMODEL_OBJ_PARTS*, const MEMFILE, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ParseObjectFaceblockHeader(T_RSPMODEL_OBJ_PARTS*, const MEMFILE, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ParseObjectFace(T_RSPMODEL_FACE*, const MEMFILE, unsigned int* const, const unsigned int, const RSPMODEL_PARAMETERS*);
|
||||
static unsigned short ParseObjectFaceVertices(T_RSPMODEL_VERTEX*, const MEMFILE, const unsigned int, const unsigned int, const RSPMODEL_PARAMETERS*);
|
||||
|
||||
static unsigned short ExtractObjpart_Face_Colors(T_RSPMODEL_FACE*, const char*);
|
||||
static unsigned short ExtractObjpart_Face_UVMaps(T_RSPMODEL_FACE*, const char*);
|
||||
|
||||
@ -102,7 +109,8 @@ unsigned short RSP_ModelLib_FreeHOBFile(const MEMFILE* memFile) {
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ExtractObjects(T_RSPMODEL_HOB* pHobStruct, const MEMFILE pMemfile, const RSPMODEL_PARAMETERS* pParams) {
|
||||
unsigned int i;
|
||||
unsigned int i, j, k;
|
||||
unsigned int faceExtraOffset = 0;
|
||||
|
||||
if (pHobStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
@ -119,318 +127,436 @@ static unsigned short ExtractObjects(T_RSPMODEL_HOB* pHobStruct, const MEMFILE p
|
||||
if (pHobStruct->objects == NULL) return RSPLIB_ERROR_MEMORY;
|
||||
|
||||
for ( i = 0; i < pHobStruct->obj_count; i++ ) {
|
||||
if (pParams->debug_mode) printf("\n-=====================-Begin of Object part-======================-\n");
|
||||
if (pParams->debug_mode) printf("\n-=======================- Begin of Object -=======================-\n");
|
||||
|
||||
// Get object name
|
||||
memcpy(pHobStruct->objects[i].name, ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->object_name, 16);
|
||||
// Parse object headers
|
||||
ParseObjectHeader(&pHobStruct->objects[i], pMemfile, i, pParams);
|
||||
|
||||
if (pParams->verbose_mode) printf("\n[INFO] - Process %s object...\n", pHobStruct->objects[i].name);
|
||||
// Extract object parts
|
||||
ParseObjectPartsHeaders(&pHobStruct->objects[i], pMemfile, pParams);
|
||||
|
||||
pHobStruct->objects[i].object_parts = calloc(pHobStruct->objects[i].object_part_count, sizeof(T_RSPMODEL_OBJ_PARTS));
|
||||
if (pHobStruct->objects[i].object_parts == NULL) return RSPLIB_ERROR_MEMORY;
|
||||
|
||||
for ( j = 0; j < pHobStruct->objects[i].object_part_count; j++ ) {
|
||||
if (pParams->debug_mode) printf("\n-~~~~~~~~~~~~~~~~~~~~~- Begin of obj. part -~~~~~~~~~~~~~~~~~~~~~~-\n");
|
||||
|
||||
// Parse object parts headers
|
||||
ParseObjectPartHeader(&pHobStruct->objects[i].object_parts[j], pMemfile, pHobStruct->objects[i].object_parts_header_offset, j, pParams);
|
||||
|
||||
// Parse object meshdef
|
||||
ParseObjectMeshDef(&pHobStruct->objects[i].object_parts[j], pMemfile, pParams);
|
||||
|
||||
if (pHobStruct->objects[i].object_parts[j].meshdef1_offset) {
|
||||
if (pParams->debug_mode) printf("\n------------------------- Begin of Mesh -------------------------\n");
|
||||
|
||||
// Extract object faces header datas
|
||||
ParseObjectFaceblockHeader(&pHobStruct->objects[i].object_parts[j], pMemfile, pParams);
|
||||
|
||||
pHobStruct->objects[i].object_parts[j].faces = calloc(pHobStruct->objects[i].object_parts[j].face_count, sizeof(T_RSPMODEL_FACE));
|
||||
if (pHobStruct->objects[i].object_parts[j].faces == NULL) return RSPLIB_ERROR_MEMORY;
|
||||
|
||||
faceExtraOffset = pHobStruct->objects[i].object_parts[j].face_block_offset + sizeof(T_HOBFILE_FACEBLOCK);
|
||||
for ( k = 0; k < pHobStruct->objects[i].object_parts[j].face_count; k++ ) {
|
||||
if (pParams->debug_mode) printf("\n-......................- Begin of Face -.....................-\n");
|
||||
|
||||
ParseObjectFace(&pHobStruct->objects[i].object_parts[j].faces[k], pMemfile, &faceExtraOffset, k, pParams);
|
||||
|
||||
if (pParams->debug_mode) printf("\n-.......................- End of Face -......................-\n");
|
||||
}
|
||||
|
||||
// Get vertex datas
|
||||
pHobStruct->objects[i].object_parts[j].vertices = calloc(pHobStruct->objects[i].object_parts[j].vertex_count, sizeof(T_RSPMODEL_VERTEX));
|
||||
if (pHobStruct->objects[i].object_parts[j].vertices == NULL) return RSPLIB_ERROR_MEMORY;
|
||||
|
||||
for ( k = 0; k < pHobStruct->objects[i].object_parts[j].vertex_count; k++ ) {
|
||||
ParseObjectFaceVertices(&pHobStruct->objects[i].object_parts[j].vertices[k], pMemfile,
|
||||
pHobStruct->objects[i].object_parts[j].vertex_block_offset + sizeof(T_RSPMODEL_VERTEX) * k, k, pParams);
|
||||
}
|
||||
|
||||
if (pParams->debug_mode) printf("\n------------------------- End of Mesh ---------------------------\n");
|
||||
}
|
||||
|
||||
if (pParams->debug_mode) printf("\n-~~~~~~~~~~~~~~~~~~~~~~- End of obj. part -~~~~~~~~~~~~~~~~~~~~~~~-\n");
|
||||
}
|
||||
|
||||
if (pParams->debug_mode) printf("\n-=======================- End of Object -=========================-\n");
|
||||
}
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Parse datas from object's header
|
||||
*
|
||||
* @param[in|out] pObjStruct Take object structure and fill it with header datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] objIndex Object index for correct offset align.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ParseObjectHeader(T_RSPMODEL_OBJECT* pObjStruct, const MEMFILE pMemfile, const unsigned char objIndex, const RSPMODEL_PARAMETERS* pParams) {
|
||||
if (pObjStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_OBJ_HEADER* const hobObjHeader =
|
||||
((T_HOBFILE_OBJ_HEADER*)(pMemfile + sizeof(T_HOBFILE_HEADER) + sizeof(T_HOBFILE_OBJ_HEADER) * objIndex));
|
||||
|
||||
// Get object name
|
||||
memcpy(pObjStruct->name, hobObjHeader->object_name, 16);
|
||||
if (pParams->verbose_mode) printf("\n[INFO] - Process %s object...\n", pObjStruct->name);
|
||||
|
||||
// Get offsets
|
||||
pObjStruct->face_group_offset = hobObjHeader->facegroup_start_offset;
|
||||
pObjStruct->object_parts_header_offset = hobObjHeader->object_parts_offset;
|
||||
pObjStruct->object_parts_header_offset2 = hobObjHeader->object_parts_offset2;
|
||||
pObjStruct->object_parts_header2_offset = hobObjHeader->object_parts2_offset;
|
||||
pObjStruct->object_parts_header2_offset2 = hobObjHeader->object_parts2_offset2;
|
||||
pObjStruct->object_subparts_names_offset = hobObjHeader->subparts_namelist_offset;
|
||||
pObjStruct->effects_offset = hobObjHeader->effects_offset;
|
||||
pObjStruct->properties_offset2 = hobObjHeader->properties_offset;
|
||||
if (pParams->verbose_mode) {
|
||||
printf("[DBG] > Face group start offset: 0x%X\n", pObjStruct->face_group_offset);
|
||||
printf("[DBG] > Object parts 1st header offset (main): 0x%X\n", pObjStruct->object_parts_header_offset);
|
||||
printf("[DBG] > Object parts 1st header offset (aux): 0x%X\n", pObjStruct->object_parts_header_offset2);
|
||||
printf("[DBG] > Object parts 2nd header offset (main): 0x%X\n", pObjStruct->object_parts_header2_offset);
|
||||
printf("[DBG] > Object parts 2nd header offset (aux): 0x%X\n", pObjStruct->object_parts_header2_offset2);
|
||||
printf("[DBG] > Object subparts names offset: 0x%X\n", pObjStruct->object_subparts_names_offset);
|
||||
printf("[DBG] > Object effects offset: 0x%X\n", pObjStruct->effects_offset);
|
||||
printf("[DBG] > Object properties offset: 0x%X\n", pObjStruct->properties_offset2);
|
||||
}
|
||||
|
||||
// Get bounding box
|
||||
pObjStruct->bounding_box.start.x = hobObjHeader->bbox_start_x;
|
||||
pObjStruct->bounding_box.start.y = hobObjHeader->bbox_start_y;
|
||||
pObjStruct->bounding_box.start.z = hobObjHeader->bbox_start_z;
|
||||
pObjStruct->bounding_box.end.x = hobObjHeader->bbox_end_x;
|
||||
pObjStruct->bounding_box.end.y = hobObjHeader->bbox_end_y;
|
||||
pObjStruct->bounding_box.end.z = hobObjHeader->bbox_end_z;
|
||||
if (pParams->verbose_mode) {
|
||||
printf("[DBG] > Bounding box start: (%.8f, %.8f, %.8f)\n",
|
||||
pObjStruct->bounding_box.start.x,
|
||||
pObjStruct->bounding_box.start.y,
|
||||
pObjStruct->bounding_box.start.z
|
||||
);
|
||||
printf("[DBG] > Bounding box end: (%.8f, %.8f, %.8f)\n",
|
||||
pObjStruct->bounding_box.end.x,
|
||||
pObjStruct->bounding_box.end.y,
|
||||
pObjStruct->bounding_box.end.z
|
||||
);
|
||||
}
|
||||
|
||||
if (pParams->god_mode) {
|
||||
printf("[DBG] > Object header unknown4: %.8f\n", hobObjHeader->unknown4);
|
||||
}
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Parse datas from object parts's headers
|
||||
*
|
||||
* "objects" are individual, independent from each others, element of the game world.
|
||||
* "object parts" are a group of mesh isolated by their animation attribute (and probably others physics attributes...)
|
||||
* "facegroup" are like object parts but isolated by their rendering properties like associated texture, lighting properties, etc.
|
||||
*
|
||||
* @param[in|out] pObjStruct Take object structure and fill it with header datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ParseObjectPartsHeaders(T_RSPMODEL_OBJECT* pObjStruct, const MEMFILE pMemfile, const RSPMODEL_PARAMETERS* pParams) {
|
||||
unsigned int i;
|
||||
char tmpStr[9] = {0};
|
||||
if (pObjStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
|
||||
// Get offsets
|
||||
pHobStruct->objects[i].face_group_offset = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->facegroup_start_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Face group start offset: 0x%X\n", pHobStruct->objects[i].face_group_offset);
|
||||
pHobStruct->objects[i].object_parts_header_offset = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->object_parts_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object parts 1st header offset (main): 0x%X\n", pHobStruct->objects[i].object_parts_header_offset);
|
||||
pHobStruct->objects[i].object_parts_header_offset2 = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->object_parts_offset2;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object parts 1st header offset (aux): 0x%X\n", pHobStruct->objects[i].object_parts_header_offset2);
|
||||
pHobStruct->objects[i].object_parts_header2_offset = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->object_parts2_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object parts 2nd header offset (main): 0x%X\n", pHobStruct->objects[i].object_parts_header2_offset);
|
||||
pHobStruct->objects[i].object_parts_header2_offset2 = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->object_parts2_offset2;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object parts 2nd header offset (aux): 0x%X\n", pHobStruct->objects[i].object_parts_header2_offset2);
|
||||
pHobStruct->objects[i].object_subparts_names_offset = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->subparts_namelist_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object subparts names offset: 0x%X\n", pHobStruct->objects[i].object_subparts_names_offset);
|
||||
pHobStruct->objects[i].effects_offset = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->effects_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object effects offset: 0x%X\n", pHobStruct->objects[i].effects_offset);
|
||||
pHobStruct->objects[i].properties_offset2 = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->properties_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object properties offset: 0x%X\n", pHobStruct->objects[i].properties_offset2);
|
||||
|
||||
pHobStruct->objects[i].bounding_box.start.x = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->bbox_start_x;
|
||||
pHobStruct->objects[i].bounding_box.start.y = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->bbox_start_y;
|
||||
pHobStruct->objects[i].bounding_box.start.z = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->bbox_start_z;
|
||||
pHobStruct->objects[i].bounding_box.end.x = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->bbox_end_x;
|
||||
pHobStruct->objects[i].bounding_box.end.y = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->bbox_end_y;
|
||||
pHobStruct->objects[i].bounding_box.end.z = ((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER)
|
||||
+ sizeof(T_HOBFILE_OBJ_HEADER) * i))->bbox_end_z;
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_OBJPARTS_HEADER* const hobObjPartsHeader1 = ((T_HOBFILE_OBJPARTS_HEADER*)(pMemfile + pObjStruct->object_parts_header_offset));
|
||||
const T_HOBFILE_OBJPARTS_NAMEID* const hobObjPartsNames = ((T_HOBFILE_OBJPARTS_NAMEID*)(pMemfile + pObjStruct->object_subparts_names_offset));
|
||||
|
||||
// Get count and offsets from the facegroup header
|
||||
pObjStruct->object_part_count = hobObjPartsHeader1->object_part_count;
|
||||
pObjStruct->face_group_count = hobObjPartsHeader1->facegroup_count;
|
||||
if (pParams->verbose_mode) {
|
||||
printf("\n");
|
||||
printf("[DBG] > Object parts count: %d\n", pObjStruct->object_part_count);
|
||||
printf("[DBG] > Face groups count: %d\n", pObjStruct->face_group_count);
|
||||
}
|
||||
|
||||
//TODO: others T_HOBFILE_FACEGROUP_XXXXXXX parsing
|
||||
|
||||
// Get names from object parts and ID association
|
||||
printf("\n");
|
||||
for (i = 0; i < (pObjStruct->object_part_count - 1); i++) { // object_part_count minus 1 because the first one (id=0) is always the root part
|
||||
memcpy(tmpStr, hobObjPartsNames[i].name, 8);
|
||||
if (pParams->verbose_mode)
|
||||
printf("[DBG] > Object parts ID/name found: %d/%s\n", hobObjPartsNames[i].id, tmpStr);
|
||||
|
||||
if (pParams->god_mode && hobObjPartsNames[i].unknown0)
|
||||
printf("[DBG] > Object parts ID unknown0 unexpected: 0x%X\n", hobObjPartsNames[i].unknown0);
|
||||
}
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Parse datas from the specific object header.
|
||||
*
|
||||
* @param[in|out] pObjPartStruct Take object part structure and fill it with header datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] objPartIndex Object part index for correct offset align.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ParseObjectPartHeader(T_RSPMODEL_OBJ_PARTS* pObjPartStruct, const MEMFILE pMemfile,
|
||||
const int objPartHdrOffset, const unsigned char objPartIndex, const RSPMODEL_PARAMETERS* pParams) {
|
||||
|
||||
if (pObjPartStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_OBJPART_HEADER* const hobObjPartHeader = ((T_HOBFILE_OBJPART_HEADER *)(pMemfile + objPartHdrOffset
|
||||
+ sizeof(T_HOBFILE_OBJPARTS_HEADER) + sizeof(T_HOBFILE_OBJPART_HEADER) * objPartIndex));
|
||||
|
||||
// Get object part datas offset
|
||||
pObjPartStruct->meshdef0_offset = hobObjPartHeader->facegroup_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Obj. part %d facegroup (meshdef0) array offset: 0x%X\n", objPartIndex, pObjPartStruct->meshdef0_offset);
|
||||
if (pParams->god_mode) printf("[DBG] > Obj. part unknown0: 0x%X\n", hobObjPartHeader->unknown0);
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Parse datas from object mesh definition.
|
||||
*
|
||||
* MeshDef (or Facegroup) is a compact structure containing the global geometry informations of a specific mesh.
|
||||
* It's split in 2 parts: meshdef0 and meshdef1, meshdef1 offset is indicated in meshdef0 struct.
|
||||
*
|
||||
* @param[in|out] pObjPartStruct Take object part structure and fill it with header datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ParseObjectMeshDef(T_RSPMODEL_OBJ_PARTS* pObjPartStruct, const MEMFILE pMemfile, const RSPMODEL_PARAMETERS* pParams) {
|
||||
if (pObjPartStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_MESHDEF0* const hobObjMeshDef0 = ((T_HOBFILE_MESHDEF0*)(pMemfile + pObjPartStruct->meshdef0_offset));
|
||||
|
||||
// Get meshdef0 datas
|
||||
//pObjPartStruct->id = hobObjMeshDef0->object_id; // Get object part ID, used by animation? bones?
|
||||
pObjPartStruct->transform.x = hobObjMeshDef0->transform_x; // Get the transform matrix, used by complex objects like at-st and at-at (at this time)
|
||||
pObjPartStruct->transform.y = hobObjMeshDef0->transform_y;
|
||||
pObjPartStruct->transform.z = hobObjMeshDef0->transform_z;
|
||||
if (pParams->verbose_mode) {
|
||||
printf("[DBG] > Facegroup/object transform matrix: [%.8f %.8f %.8f]\n",
|
||||
pObjPartStruct->transform.x,
|
||||
pObjPartStruct->transform.y,
|
||||
pObjPartStruct->transform.z
|
||||
);
|
||||
printf("[DBG] > Prev meshdef0 offset: 0x%X\n", hobObjMeshDef0->prev_meshdef0_offset);
|
||||
printf("[DBG] > Next meshdef0 offset: 0x%X\n", hobObjMeshDef0->next_meshdef0_offset);
|
||||
}
|
||||
if (pParams->god_mode) {
|
||||
printf("[DBG] > meshdef0 offset1: 0x%X\n", hobObjMeshDef0->offset1);
|
||||
printf("[DBG] > meshdef0 offset2: 0x%X\n", hobObjMeshDef0->offset2);
|
||||
|
||||
printf("[DBG] > meshdef0 unknown3: %.8f\n", hobObjMeshDef0->unknown3);
|
||||
printf("[DBG] > meshdef0 unknown4: %.8f\n", hobObjMeshDef0->unknown4);
|
||||
printf("[DBG] > meshdef0 unknown5: %.8f\n", hobObjMeshDef0->unknown5);
|
||||
|
||||
printf("[DBG] > meshdef0 unknown6: 0x%X\n", hobObjMeshDef0->unknown6);
|
||||
|
||||
printf("[DBG] > meshdef0 unknown7: %.8f\n", hobObjMeshDef0->unknown7);
|
||||
printf("[DBG] > meshdef0 unknown8: %.8f\n", hobObjMeshDef0->unknown8);
|
||||
printf("[DBG] > meshdef0 unknown9: %.8f\n", hobObjMeshDef0->unknown9);
|
||||
|
||||
printf("[DBG] > meshdef0 unknown10: %.8f\n", hobObjMeshDef0->unknown10);
|
||||
printf("[DBG] > meshdef0 unknown11: %.8f\n", hobObjMeshDef0->unknown11);
|
||||
printf("[DBG] > meshdef0 unknown12: %.8f\n", hobObjMeshDef0->unknown12);
|
||||
|
||||
printf("[DBG] > meshdef0 unknown13: %.8f\n", hobObjMeshDef0->unknown13);
|
||||
printf("[DBG] > meshdef0 unknown14: %.8f\n", hobObjMeshDef0->unknown14);
|
||||
printf("[DBG] > meshdef0 unknown15: %.8f\n", hobObjMeshDef0->unknown15);
|
||||
|
||||
printf("[DBG] > meshdef0 unknown16: %.8f\n", hobObjMeshDef0->unknown16);
|
||||
}
|
||||
|
||||
// Get meshdef1 (mesh descriptor) offset
|
||||
pObjPartStruct->meshdef1_offset = hobObjMeshDef0->meshdef1_offset_plus_4;
|
||||
if (pObjPartStruct->meshdef1_offset > 0) {
|
||||
const T_HOBFILE_MESHDEF1* const hobObjMeshDef1 = ((T_HOBFILE_MESHDEF1*)(pMemfile + pObjPartStruct->meshdef1_offset - 4));
|
||||
|
||||
// Read meshdef1 datas
|
||||
pObjPartStruct->face_block_end_offset = hobObjMeshDef1->facedef_end_offset;
|
||||
pObjPartStruct->vertex_count = hobObjMeshDef1->vertex_count;
|
||||
pObjPartStruct->face_block_offset = hobObjMeshDef1->faceblock_offset;
|
||||
pObjPartStruct->vertex_block_offset = hobObjMeshDef1->vertexblocks_offset;
|
||||
if (pParams->verbose_mode) {
|
||||
printf("[DBG] > Bounding box start: (%.8f, %.8f, %.8f)\n",
|
||||
pHobStruct->objects[i].bounding_box.start.x,
|
||||
pHobStruct->objects[i].bounding_box.start.y,
|
||||
pHobStruct->objects[i].bounding_box.start.z
|
||||
);
|
||||
printf("[DBG] > Bounding box end: (%.8f, %.8f, %.8f)\n",
|
||||
pHobStruct->objects[i].bounding_box.end.x,
|
||||
pHobStruct->objects[i].bounding_box.end.y,
|
||||
pHobStruct->objects[i].bounding_box.end.z
|
||||
);
|
||||
printf("\n[DBG] > Facegroup vertices descriptor (meshdef1) offset: 0x%X\n", pObjPartStruct->meshdef1_offset);
|
||||
printf("[DBG] > Vertex count: %d\n", pObjPartStruct->vertex_count);
|
||||
printf("[DBG] > Faces offset: 0x%X\n", pObjPartStruct->face_block_offset);
|
||||
printf("[DBG] > Vertex offset: 0x%X\n", pObjPartStruct->vertex_block_offset);
|
||||
}
|
||||
|
||||
if (pParams->god_mode) {
|
||||
printf("[DBG] > Object header unknown4: %.8f\n",((T_HOBFILE_OBJ_HEADER *)(pMemfile + sizeof(T_HOBFILE_HEADER) + sizeof(T_HOBFILE_OBJ_HEADER) * i))->unknown4);
|
||||
}
|
||||
|
||||
// Get count and offsets from the facegroup header
|
||||
pHobStruct->objects[i].object_part_count = ((T_HOBFILE_FACEGROUP_HEADER_1 *)(pMemfile
|
||||
+ pHobStruct->objects[i].object_parts_header_offset))->object_part_count;
|
||||
if (pParams->verbose_mode) printf("\n[DBG] > Object parts count: %d\n", pHobStruct->objects[i].object_part_count);
|
||||
pHobStruct->objects[i].face_group_count = ((T_HOBFILE_FACEGROUP_HEADER_1 *)(pMemfile
|
||||
+ pHobStruct->objects[i].object_parts_header_offset))->facegroup_count;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Face groups count: %d\n", pHobStruct->objects[i].face_group_count);
|
||||
//TODO: Caution with obj/facegrp count difference. What is REALLY facegroup count???
|
||||
/*
|
||||
* Seem "object" are independant structure like xwing, turret, etc.
|
||||
* Facegroup is more like part of previous object, like wing-left, turret-barrel, etc.
|
||||
*/
|
||||
if (pHobStruct->objects[i].object_part_count != pHobStruct->objects[i].face_group_count)
|
||||
if (pParams->verbose_mode) printf("[DBG] > Object parts / facegroup count are different!\n");
|
||||
|
||||
// Get facegroup datas
|
||||
ExtractObjParts(&pHobStruct->objects[i], pMemfile, pParams);
|
||||
} else {
|
||||
if (pParams->verbose_mode) printf("\n[DBG] > No vertices datas (meshdef1 = 0x0).\n");
|
||||
}
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Count object's sub-part and extract datas from them.
|
||||
* @brief Parse datas from object faceblock header.
|
||||
*
|
||||
* @param[in|out] pObject Take object structure to get the T_RSPMODEL_OBJ_PARTS buffer and object datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
* Faceblock is group of faces elements with header.
|
||||
* Meshdef have one associated faceblock.
|
||||
*
|
||||
* @param[in|out] pObjPartStruct Take object part structure and fill it with header datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ExtractObjParts(T_RSPMODEL_OBJECT* pObject, const MEMFILE pMemfile, const RSPMODEL_PARAMETERS* pParams) {
|
||||
unsigned int i, subpart_offset = 0;
|
||||
static unsigned short ParseObjectFaceblockHeader(T_RSPMODEL_OBJ_PARTS* pObjPartStruct, const MEMFILE pMemfile, const RSPMODEL_PARAMETERS* pParams) {
|
||||
if (pObjPartStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
if (pObject == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_FACEBLOCK* const hobObjFaceblock = ((T_HOBFILE_FACEBLOCK*)(pMemfile + pObjPartStruct->face_block_offset));
|
||||
|
||||
pObject->object_parts = calloc(pObject->object_part_count, sizeof(T_RSPMODEL_OBJ_PARTS));
|
||||
if (pObject->object_parts == NULL) return RSPLIB_ERROR_MEMORY;
|
||||
// Get faces count
|
||||
pObjPartStruct->face_count = hobObjFaceblock->faceCounts;
|
||||
if (pParams->debug_mode) printf("[DBG] > Faces count: %d\n", pObjPartStruct->face_count);
|
||||
|
||||
for ( i = 0; i < pObject->object_part_count; i++ ) {
|
||||
if (pParams->debug_mode) printf("\n-----------------------Begin of Mesh part-------------------------\n");
|
||||
subpart_offset = ((T_HOBFILE_FACEGROUP_OFFSET_1 *)(pMemfile + pObject->object_parts_header_offset
|
||||
+ sizeof(T_HOBFILE_FACEGROUP_HEADER_1) + sizeof(T_HOBFILE_FACEGROUP_OFFSET_1) * i))->facegroup_offset;
|
||||
if (pParams->verbose_mode) printf("\n[DBG] > Face group meshdef0 offset: 0x%X\n", subpart_offset);
|
||||
|
||||
// Get meshdef0 datas
|
||||
if (pParams->god_mode) printf("[DBG] > meshdef0 offset1: 0x%X\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->offset1);
|
||||
if (pParams->god_mode) printf("[DBG] > meshdef0 offset2: 0x%X\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->offset2);
|
||||
if (pParams->verbose_mode) printf("[DBG] > Prev meshdef0 offset: 0x%X\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->prev_meshdef0_offset);
|
||||
if (pParams->verbose_mode) printf("[DBG] > Next meshdef0 offset: 0x%X\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->next_meshdef0_offset);
|
||||
|
||||
if (pParams->god_mode) printf("[DBG] > meshdef0 unknown3: %.8f\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->unknown3);
|
||||
if (pParams->god_mode) printf("[DBG] > meshdef0 unknown4: %.8f\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->unknown4);
|
||||
if (pParams->god_mode) printf("[DBG] > meshdef0 unknown5: %.8f\n",((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->unknown5);
|
||||
|
||||
// Get meshdef1 (mesh descriptor) offset
|
||||
pObject->object_parts[i].meshdef1_offset = ((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->meshdef1_offset_plus_4;
|
||||
if (pParams->verbose_mode) printf("\n[DBG] > Face group vertices descriptor (meshdef1) offset: 0x%X\n", pObject->object_parts[i].meshdef1_offset);
|
||||
|
||||
if( ((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->reserved1 != 0 ||
|
||||
((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->reserved2 != 0 ) {
|
||||
if (pParams->god_mode) printf("[DBG] > Face group meshdef0: no 0!\n");
|
||||
if (pParams->god_mode) {
|
||||
if( hobObjFaceblock->reserved1 != 0 || hobObjFaceblock->reserved2 != 0 ) {
|
||||
printf("[DBG] > Faceblock: uncommon zero header! (0x%X) (0x%X)\n", hobObjFaceblock->reserved1, hobObjFaceblock->reserved2);
|
||||
}
|
||||
|
||||
if (pObject->object_parts[i].meshdef1_offset > 0) {
|
||||
// Read meshdef1 datas
|
||||
pObject->object_parts[i].face_block_end_offset = ((T_HOBFILE_MESHDEF1 *)(pMemfile
|
||||
+ pObject->object_parts[i].meshdef1_offset - 4))->facedef_end_offset;
|
||||
pObject->object_parts[i].vertex_count = ((T_HOBFILE_MESHDEF1 *)(pMemfile
|
||||
+ pObject->object_parts[i].meshdef1_offset - 4))->vertex_count;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Vertex count: %d\n", pObject->object_parts[i].vertex_count);
|
||||
pObject->object_parts[i].face_block_offset = ((T_HOBFILE_MESHDEF1 *)(pMemfile
|
||||
+ pObject->object_parts[i].meshdef1_offset - 4))->faceblock_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Faces offset: 0x%X\n", pObject->object_parts[i].face_block_offset);
|
||||
pObject->object_parts[i].vertex_block_offset = ((T_HOBFILE_MESHDEF1 *)(pMemfile
|
||||
+ pObject->object_parts[i].meshdef1_offset - 4))->vertexblocks_offset;
|
||||
if (pParams->verbose_mode) printf("[DBG] > Vertex offset: 0x%X\n\n", pObject->object_parts[i].vertex_block_offset);
|
||||
|
||||
// Get faces datas
|
||||
ExtractObjParts_faces(&pObject->object_parts[i], pMemfile, pParams);
|
||||
} else {
|
||||
if (pParams->verbose_mode) printf("\n[DBG] > No vertices datas (meshdef1 = 0x0).\n");
|
||||
if ( hobObjFaceblock->facesOffset != pObjPartStruct->face_block_offset + sizeof(T_HOBFILE_FACEBLOCK) ) {
|
||||
printf("[DBG] > Faceblock: uncommon face data offset position!\n");
|
||||
}
|
||||
|
||||
// Get object part ID, used by animation? bones?
|
||||
pObject->object_parts[i].id = ((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->object_id;
|
||||
if (pParams->verbose_mode) printf("\n[DBG] > Facegroup/object ID: %d\n", pObject->object_parts[i].id);
|
||||
|
||||
// Get the transform matrix, used by at-st and at-at (at this time)
|
||||
pObject->object_parts[i].transform.x = ((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->transform_x;
|
||||
pObject->object_parts[i].transform.y = ((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->transform_y;
|
||||
pObject->object_parts[i].transform.z = ((T_HOBFILE_MESHDEF0 *)(pMemfile + subpart_offset))->transform_z;
|
||||
if (pParams->god_mode) printf("\n[DBG] > Facegroup/object transform matrix: [%.8f %.8f %.8f]\n",
|
||||
pObject->object_parts[i].transform.x,
|
||||
pObject->object_parts[i].transform.y,
|
||||
pObject->object_parts[i].transform.z
|
||||
);
|
||||
|
||||
if (pParams->debug_mode) printf("\n-----------------------End of Mesh part---------------------------\n");
|
||||
}
|
||||
|
||||
if (pParams->debug_mode) printf("\n-=====================-End of Object part-========================-\n");
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Extract datas from faces from object sub-part.
|
||||
* @brief Parse datas from object face.
|
||||
*
|
||||
* @param[in|out] pObjPart Take object sub-part structure to get the T_RSPMODEL_FACE buffer and object sub-part datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
* @param[in|out] pFaceStruct Take face structure and fill it with face datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in|out] facesExtraOffset Face correction offset to correctly align with datas
|
||||
* @param[in] faceNbr Face number (for debug print only)
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ExtractObjParts_faces(T_RSPMODEL_OBJ_PARTS* pObjPart, const MEMFILE pMemfile, const RSPMODEL_PARAMETERS* pParams) {
|
||||
unsigned int i, facesExtraOffset = 0, localOffset = 0;
|
||||
unsigned short headerSeparator;
|
||||
static unsigned short ParseObjectFace(T_RSPMODEL_FACE* pFaceStruct, const MEMFILE pMemfile,
|
||||
unsigned int* const facesExtraOffset, const unsigned int faceNbr, const RSPMODEL_PARAMETERS* pParams) {
|
||||
unsigned int localOffset;
|
||||
|
||||
if (pObjPart == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
if (pFaceStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
if( ((T_HOBFILE_FACEBLOCK *)(pMemfile + pObjPart->face_block_offset))->reserved1 != 0 ||
|
||||
((T_HOBFILE_FACEBLOCK *)(pMemfile + pObjPart->face_block_offset))->reserved2 != 0 ) {
|
||||
if (pParams->god_mode) printf("[DBG] > Face block: uncommon zero header!\n");
|
||||
}
|
||||
if ( ((T_HOBFILE_FACEBLOCK *)(pMemfile + pObjPart->face_block_offset))->facesOffset !=
|
||||
pObjPart->face_block_offset + sizeof(T_HOBFILE_FACEBLOCK)) {
|
||||
if (pParams->god_mode) printf("[DBG] > Face block: uncommon face data offset position!\n");
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_FACES_HEADER* const hobObjFace = ((T_HOBFILE_FACES_HEADER*)(pMemfile + *facesExtraOffset));
|
||||
|
||||
// Get flags
|
||||
pFaceStruct->flags = hobObjFace->flags;
|
||||
|
||||
// Get unknown bytes
|
||||
pFaceStruct->b1 = hobObjFace->b1;
|
||||
pFaceStruct->b2 = hobObjFace->b2;
|
||||
pFaceStruct->b3 = hobObjFace->b3;
|
||||
pFaceStruct->bsize = hobObjFace->faceBlockIntSize * 4; // Multiply by 4 to get the bytes exact number
|
||||
|
||||
if (hobObjFace->headerSeparator != 0) {
|
||||
if (pParams->god_mode) printf("[DBG] > Face header: uncommon separator! (0x%X)\n", hobObjFace->headerSeparator);
|
||||
}
|
||||
|
||||
pObjPart->face_count = ((T_HOBFILE_FACEBLOCK *)(pMemfile + pObjPart->face_block_offset))->faceCounts;
|
||||
if (pParams->debug_mode) printf("[DBG] > Faces count: %d\n", pObjPart->face_count);
|
||||
pObjPart->faces = calloc(pObjPart->face_count, sizeof(T_RSPMODEL_FACE));
|
||||
for ( i = 0; i < pObjPart->face_count; i++ ) {
|
||||
if (pParams->debug_mode) printf("\n----------------------Begin of Face part----------------------\n");
|
||||
// Get materials index
|
||||
pFaceStruct->mt_index = hobObjFace->materialIndex;
|
||||
|
||||
// Get flags
|
||||
pObjPart->faces[i].flags = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->flags;
|
||||
// Get vertex indices
|
||||
memcpy(pFaceStruct->indices, hobObjFace->vertexIndices, sizeof(unsigned short) * 4);
|
||||
|
||||
// Get unknown bytes
|
||||
pObjPart->faces[i].b1 = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->b1;
|
||||
pObjPart->faces[i].b2 = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->b2;
|
||||
pObjPart->faces[i].b3 = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->b3;
|
||||
// Recalculate the dynamic extra bytes offset size - if present
|
||||
//if (pObjPart->faces[i].flags_bits.fHasExtraBytesBeforeColor) facesExtraOffset += 8;
|
||||
localOffset = pFaceStruct->flags_bits.fHasExtraBytesBeforeColor ? 8 : 0;
|
||||
|
||||
pObjPart->faces[i].bsize = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->faceBlockIntSize * 4; // Multiply by 4 to get the bytes exact number
|
||||
|
||||
headerSeparator = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->headerSeparator;
|
||||
if (headerSeparator != 0) {
|
||||
if (pParams->god_mode) printf("[DBG] > Face header: uncommon separator! (0x%X)\n", headerSeparator);
|
||||
}
|
||||
|
||||
// Get materials index
|
||||
pObjPart->faces[i].mt_index = ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->materialIndex;
|
||||
|
||||
// Get vertex indices
|
||||
memcpy(pObjPart->faces[i].indices, ((T_HOBFILE_FACES_HEADER *)(pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + facesExtraOffset))->vertexIndices,
|
||||
sizeof(unsigned short) * 4);
|
||||
|
||||
// Recalculate the dynamic extra bytes offset size - if present
|
||||
//if (pObjPart->faces[i].flags_bits.fHasExtraBytesBeforeColor) facesExtraOffset += 8;
|
||||
localOffset = pObjPart->faces[i].flags_bits.fHasExtraBytesBeforeColor ? 8 : 0;
|
||||
|
||||
// Get vertex color - if present
|
||||
if (pObjPart->faces[i].flags_bits.fHasColor) {
|
||||
localOffset += ExtractObjpart_Face_Colors(&pObjPart->faces[i], pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + sizeof(T_HOBFILE_FACES_HEADER) * (i + 1)
|
||||
+ facesExtraOffset + localOffset);
|
||||
}
|
||||
|
||||
// Get UV map - if present
|
||||
if (pObjPart->faces[i].flags_bits.fHasTexture) {
|
||||
localOffset += ExtractObjpart_Face_UVMaps(&pObjPart->faces[i], pMemfile + pObjPart->face_block_offset
|
||||
+ sizeof(T_HOBFILE_FACEBLOCK) + sizeof(T_HOBFILE_FACES_HEADER) * (i + 1)
|
||||
+ facesExtraOffset + localOffset);
|
||||
}
|
||||
|
||||
facesExtraOffset += pObjPart->faces[i].bsize;
|
||||
|
||||
if (pParams->debug_mode) {
|
||||
printf("[DBG] > Face %d details: flags:0x%X b1:0x%X b2:0x%X b3:0x%X bsize:%d\n", i, pObjPart->faces[i].flags,
|
||||
pObjPart->faces[i].b1, pObjPart->faces[i].b2, pObjPart->faces[i].b3, pObjPart->faces[i].bsize);
|
||||
printf("[DBG] - Type is Quad: %d\n", pObjPart->faces[i].flags_bits.fIsQuad);
|
||||
printf("[DBG] - Have color: %d\n", pObjPart->faces[i].flags_bits.fHasColor);
|
||||
printf("[DBG] - Have texture: %d\n", pObjPart->faces[i].flags_bits.fHasTexture);
|
||||
printf("[DBG] - Material/texture index: %d\n", pObjPart->faces[i].mt_index);
|
||||
printf("[DBG] - Vertex indices: %d, %d, %d, %d\n", pObjPart->faces[i].indices[0], pObjPart->faces[i].indices[1],
|
||||
pObjPart->faces[i].indices[2], pObjPart->faces[i].indices[3]);
|
||||
printf("[DBG] - Vertex colors: 0x%X, 0x%X, 0x%X, 0x%X\n", pObjPart->faces[i].vertex_colors[0],
|
||||
pObjPart->faces[i].vertex_colors[1], pObjPart->faces[i].vertex_colors[2], pObjPart->faces[i].vertex_colors[3]);
|
||||
printf("[DBG] - Vertex UV coord (divided by 4096):\n");
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[0].u,
|
||||
pObjPart->faces[i].tex_coords[0].u,
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[0].v,
|
||||
pObjPart->faces[i].tex_coords[0].v
|
||||
);
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[1].u,
|
||||
pObjPart->faces[i].tex_coords[1].u,
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[1].v,
|
||||
pObjPart->faces[i].tex_coords[1].v
|
||||
);
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[2].u,
|
||||
pObjPart->faces[i].tex_coords[2].u,
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[2].v,
|
||||
pObjPart->faces[i].tex_coords[2].v
|
||||
);
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[3].u,
|
||||
pObjPart->faces[i].tex_coords[3].u,
|
||||
((double) 1/4096) * pObjPart->faces[i].tex_coords[3].v,
|
||||
pObjPart->faces[i].tex_coords[3].v
|
||||
);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
if (pParams->debug_mode) printf("\n-----------------------End of Face part-----------------------\n");
|
||||
// Get vertex color - if present
|
||||
if (pFaceStruct->flags_bits.fHasColor) {
|
||||
localOffset += ExtractObjpart_Face_Colors(pFaceStruct, pMemfile + *facesExtraOffset + sizeof(T_HOBFILE_FACES_HEADER) + localOffset);
|
||||
}
|
||||
|
||||
// Get vertex datas
|
||||
pObjPart->vertices = calloc(pObjPart->vertex_count, sizeof(T_RSPMODEL_VERTEX));
|
||||
if (pObjPart->vertices == NULL) return RSPLIB_ERROR_MEMORY;
|
||||
// Get UV map - if present
|
||||
if (pFaceStruct->flags_bits.fHasTexture) {
|
||||
localOffset += ExtractObjpart_Face_UVMaps(pFaceStruct, pMemfile + *facesExtraOffset + sizeof(T_HOBFILE_FACES_HEADER) + localOffset);
|
||||
}
|
||||
|
||||
for ( i = 0; i < pObjPart->vertex_count; i++ ) {
|
||||
pObjPart->vertices[i].x =
|
||||
((T_HOBFILE_VERTEX *)(pMemfile + pObjPart->vertex_block_offset + sizeof(T_RSPMODEL_VERTEX) * i))->x;
|
||||
// Recalculate the extra bytes offset (it's assume the faces are parsed in order)
|
||||
*facesExtraOffset += pFaceStruct->bsize;
|
||||
|
||||
pObjPart->vertices[i].y =
|
||||
((T_HOBFILE_VERTEX *)(pMemfile + pObjPart->vertex_block_offset + sizeof(T_RSPMODEL_VERTEX) * i))->y;
|
||||
if (pParams->debug_mode) {
|
||||
printf("[DBG] > Face %d details: flags:0x%X b1:0x%X b2:0x%X b3:0x%X bsize:%d\n", faceNbr,
|
||||
pFaceStruct->flags, pFaceStruct->b1, pFaceStruct->b2, pFaceStruct->b3, pFaceStruct->bsize);
|
||||
printf("[DBG] - Type is Quad: %d\n", pFaceStruct->flags_bits.fIsQuad);
|
||||
printf("[DBG] - Have color: %d\n", pFaceStruct->flags_bits.fHasColor);
|
||||
printf("[DBG] - Have texture: %d\n", pFaceStruct->flags_bits.fHasTexture);
|
||||
printf("[DBG] - Material/texture index: %d\n", pFaceStruct->mt_index);
|
||||
printf("[DBG] - Vertex indices: %d, %d, %d, %d\n", pFaceStruct->indices[0], pFaceStruct->indices[1], pFaceStruct->indices[2], pFaceStruct->indices[3]);
|
||||
printf("[DBG] - Vertex colors: 0x%X, 0x%X, 0x%X, 0x%X\n", pFaceStruct->vertex_colors[0], pFaceStruct->vertex_colors[1], pFaceStruct->vertex_colors[2], pFaceStruct->vertex_colors[3]);
|
||||
printf("[DBG] - Vertex UV coord (divided by 4096):\n");
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[0].u, pFaceStruct->tex_coords[0].u,
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[0].v, pFaceStruct->tex_coords[0].v
|
||||
);
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[1].u, pFaceStruct->tex_coords[1].u,
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[1].v, pFaceStruct->tex_coords[1].v
|
||||
);
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[2].u, pFaceStruct->tex_coords[2].u,
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[2].v, pFaceStruct->tex_coords[2].v
|
||||
);
|
||||
printf("[DBG] > %.8f(%d), %.8f(%d)\n",
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[3].u, pFaceStruct->tex_coords[3].u,
|
||||
((double) 1/4096) * pFaceStruct->tex_coords[3].v, pFaceStruct->tex_coords[3].v
|
||||
);
|
||||
}
|
||||
|
||||
pObjPart->vertices[i].z =
|
||||
((T_HOBFILE_VERTEX *)(pMemfile + pObjPart->vertex_block_offset + sizeof(T_RSPMODEL_VERTEX) * i))->z;
|
||||
return RSPLIB_SUCCESS;
|
||||
}
|
||||
|
||||
pObjPart->vertices[i].w =
|
||||
((T_HOBFILE_VERTEX *)(pMemfile + pObjPart->vertex_block_offset + sizeof(T_RSPMODEL_VERTEX) * i))->w; // Always 0???
|
||||
/**
|
||||
* @brief Parse datas from object face.
|
||||
*
|
||||
* @param[in|out] pVertexStruct Take vertex structure and fill it with vertices datas.
|
||||
* @param[in] pMemfile Pointer to an in-memory file location.
|
||||
* @param[in] verticesOffset Vertices area offset to correctly align with datas
|
||||
* @param[in] vertexNbr Vertex number (for debug print only)
|
||||
* @param[in] pParams Program option, used to tune parser features.
|
||||
*
|
||||
* @return Error code, RSPLIB_SUCCESS when no error.
|
||||
*/
|
||||
static unsigned short ParseObjectFaceVertices(T_RSPMODEL_VERTEX* pVertexStruct, const MEMFILE pMemfile,
|
||||
const unsigned int verticesOffset, const unsigned int vertexNbr, const RSPMODEL_PARAMETERS* pParams) {
|
||||
|
||||
if (pParams->debug_mode) printf("[DBG] > Found vertex %d: (%d, %d, %d)\n", i,
|
||||
pObjPart->vertices[i].x, pObjPart->vertices[i].y, pObjPart->vertices[i].z
|
||||
);
|
||||
if (pVertexStruct == NULL || pMemfile == NULL) return RSPLIB_ERROR_ARGS_NULL;
|
||||
|
||||
// Create struct casting for clean code reading
|
||||
const T_HOBFILE_VERTEX* const hobObjVertex = ((T_HOBFILE_VERTEX*)(pMemfile + verticesOffset));
|
||||
|
||||
pVertexStruct->x = hobObjVertex->x;
|
||||
pVertexStruct->y = hobObjVertex->y;
|
||||
pVertexStruct->z = hobObjVertex->z;
|
||||
pVertexStruct->w = hobObjVertex->w; // Always 0???
|
||||
|
||||
if (pParams->debug_mode) {
|
||||
printf("[DBG] > Found vertex %d: (%d, %d, %d)\n", vertexNbr, pVertexStruct->x, pVertexStruct->y, pVertexStruct->z);
|
||||
}
|
||||
|
||||
return RSPLIB_SUCCESS;
|
||||
|
||||
@ -93,29 +93,53 @@ typedef struct PACK hobfile_obj_header {
|
||||
float bbox_end_z;
|
||||
} T_HOBFILE_OBJ_HEADER;
|
||||
|
||||
typedef struct PACK hobfile_facegroup_header_1 {
|
||||
|
||||
/*
|
||||
* T_HOBFILE_OBJPARTS_HEADER
|
||||
* |
|
||||
* \
|
||||
* |T_HOBFILE_OBJPART_HEADER
|
||||
* \
|
||||
* T_HOBFILE_OBJPART_HEADER
|
||||
* |
|
||||
* \
|
||||
* |T_HOBFILE_FACEGROUP_HEADER
|
||||
* \
|
||||
* T_HOBFILE_FACEGROUP_HEADER
|
||||
*/
|
||||
typedef struct PACK hobfile_objparts_header {
|
||||
unsigned short object_part_count;
|
||||
unsigned short facegroup_count;
|
||||
} T_HOBFILE_FACEGROUP_HEADER_1;
|
||||
unsigned short facegroup_count; //aka. meshdef count
|
||||
} T_HOBFILE_OBJPARTS_HEADER;
|
||||
|
||||
typedef struct PACK hobfile_facegroup_offset_1 {
|
||||
unsigned int unknown0; // Flags?
|
||||
typedef struct PACK hobfile_objpart_header {
|
||||
unsigned int unknown0; // It is flags?
|
||||
unsigned int facegroup_offset;
|
||||
} T_HOBFILE_FACEGROUP_OFFSET_1;
|
||||
} T_HOBFILE_OBJPART_HEADER;
|
||||
|
||||
typedef struct PACK hobfile_facegroup_header_2 {
|
||||
/* TODO: Not sure these exist
|
||||
typedef struct PACK hobfile_facegroup_header_2 { //TODO: This is part of a bigger one
|
||||
unsigned short object_part_count;
|
||||
unsigned short facegroup_count;
|
||||
} T_HOBFILE_FACEGROUP_HEADER_2;
|
||||
|
||||
typedef struct PACK hobfile_facegroup_offset_2 {
|
||||
typedef struct PACK hobfile_facegroup_offset_2 { //TODO: This is part of a bigger one
|
||||
unsigned int unknownOffset0;
|
||||
} T_HOBFILE_FACEGROUP_OFFSET_2;
|
||||
*/
|
||||
|
||||
typedef struct PACK hobfile_facegroup_nameid {
|
||||
typedef struct PACK hobfile_objparts_nameid {
|
||||
unsigned char name[8];
|
||||
unsigned short id;
|
||||
} T_HOBFILE_FACEGROUP_NAMEID;
|
||||
unsigned char unknown0; // Always zeros ?
|
||||
unsigned char id;
|
||||
} T_HOBFILE_OBJPARTS_NAMEID;
|
||||
|
||||
/* TODO:
|
||||
typedef struct PACK hobfile_effects {
|
||||
unsigned char something0;
|
||||
unsigned short something1;
|
||||
} T_HOBFILE_EFFECTS;
|
||||
*/
|
||||
|
||||
typedef struct PACK hobfile_meshdef0 {
|
||||
unsigned int offset1;
|
||||
@ -145,20 +169,21 @@ typedef struct PACK hobfile_meshdef0 {
|
||||
unsigned int reserved10;
|
||||
unsigned int reserved11;
|
||||
|
||||
unsigned int object_id;
|
||||
unsigned int unknown6; // Not fg_object_ID
|
||||
|
||||
float unknown12; // Can be a vector???
|
||||
float unknown13;
|
||||
float unknown7; // Can be a vector???
|
||||
float unknown8;
|
||||
float unknown9;
|
||||
|
||||
float unknown10; // Can be a vector???
|
||||
float unknown11;
|
||||
float unknown12;
|
||||
|
||||
float unknown13; // Can be a matrix???
|
||||
float unknown14;
|
||||
float unknown15;
|
||||
|
||||
float unknown15; // Can be a vector???
|
||||
float unknown16;
|
||||
float unknown17;
|
||||
|
||||
float unknown18; // Can be a matrix???
|
||||
float unknown19;
|
||||
float unknown20;
|
||||
float unknown21;
|
||||
|
||||
float transform_x;
|
||||
float transform_y;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user