void command_prompt(void *pvParameters)
{
char buf[128];
char *argv[20];
char hint[] = USER_NAME "@" USER_NAME "-STM32:~$ ";
fio_printf(1, "\rWelcome to FreeRTOS Shell\r\n");
while(1){
fio_printf(1, "%s", hint);
fio_read(0, buf, 127);
int n=parse_command(buf, argv);
/* will return pointer to the command function */
//if (*argv[0]=='\0')
cmdfunc *fptr=do_command(argv[0]);
if(fptr!=NULL)
fptr(n, argv);
else if (*argv[0]!='\0')
fio_printf(2, "\r\n\"%s\" command not found.\r\n", argv[0]);
else
fio_printf(1, "\r\n");
}
}
int main(int argc, char *argv[])
{
char buf[1024] = {0};
int fd = open("./fio_read.c", O_RDONLY);
int ret = fio_read(fd, buf, 1024);
printf("ret = %d\n", ret);
return 0;
}
int model_loadmesh(struct gfx_model_mesh* mesh, file_t f, struct allocator* alloc)
{
struct h3d_mesh h3dmesh;
fio_read(f, &h3dmesh, sizeof(h3dmesh), 1);
mesh->geo_id = h3dmesh.geo_idx;
mesh->submesh_cnt = h3dmesh.submesh_cnt;
if (h3dmesh.submesh_cnt > 0) {
mesh->submeshes = (struct gfx_model_submesh*)A_ALLOC(alloc,
sizeof(struct gfx_model_submesh)*h3dmesh.submesh_cnt, MID_GFX);
if (mesh->submeshes == NULL)
return FALSE;
for (uint i = 0; i < h3dmesh.submesh_cnt; i++) {
struct h3d_submesh h3dsubmesh;
fio_read(f, &h3dsubmesh, sizeof(h3dsubmesh), 1);
mesh->submeshes[i].mtl_id = h3dsubmesh.mtl_idx;
mesh->submeshes[i].subset_id = h3dsubmesh.subset_idx;
}
}
return TRUE;
}
int model_loadocc(struct gfx_model_occ* occ, file_t f, struct allocator* alloc)
{
struct h3d_occ h3docc;
fio_read(f, &h3docc, sizeof(struct h3d_occ), 1);
strcpy(occ->name, h3docc.name);
occ->tri_cnt = h3docc.tri_cnt;
occ->vert_cnt = h3docc.vert_cnt;
occ->indexes = (uint16*)A_ALLOC(alloc, sizeof(uint16)*h3docc.tri_cnt*3, MID_GFX);
occ->poss = (struct vec3f*)A_ALIGNED_ALLOC(alloc, sizeof(struct vec3f)*h3docc.vert_cnt, MID_GFX);
if (occ->indexes == NULL || occ->poss == NULL) {
err_printn(__FILE__, __LINE__, RET_OUTOFMEMORY);
return FALSE;
}
fio_read(f, occ->indexes, sizeof(uint16), h3docc.tri_cnt*3);
fio_read(f, occ->poss, sizeof(struct vec3f), h3docc.vert_cnt);
return TRUE;
}
int model_loadnode(struct gfx_model_node* node, file_t f, struct allocator* alloc)
{
struct h3d_node h3dnode;
fio_read(f, &h3dnode, sizeof(h3dnode), 1);
strcpy(node->name, h3dnode.name);
node->name_hash = hash_str(h3dnode.name);
node->mesh_id = h3dnode.mesh_idx;
node->child_cnt = h3dnode.child_cnt;
node->parent_id = h3dnode.parent_idx;
model_loadmat(&node->local_mat, h3dnode.local_xform);
aabb_setf(&node->bb, h3dnode.bb_min[0], h3dnode.bb_min[1], h3dnode.bb_min[2],
h3dnode.bb_max[0], h3dnode.bb_max[1], h3dnode.bb_max[2]);
if (h3dnode.child_cnt > 0) {
node->child_ids = (uint*)A_ALLOC(alloc, sizeof(uint)*h3dnode.child_cnt, MID_GFX);
if (node->child_ids == NULL)
return FALSE;
fio_read(f, node->child_ids, sizeof(uint), h3dnode.child_cnt);
}
return TRUE;
}
void read_romfs_task(void *pvParameters)
{
char buf[128];
size_t count;
int fd = fs_open("/romfs/test.txt", 0, O_RDONLY);
do {
//Read from /romfs/test.txt to buffer
count = fio_read(fd, buf, sizeof(buf));
//Write buffer to fd 1 (stdout, through uart)
fio_write(1, buf, count);
} while (count);
while (1);
}
int model_loadmtl(struct gfx_model_mtl* mtl, file_t f, struct allocator* alloc)
{
struct h3d_mtl h3dmtl;
fio_read(f, &h3dmtl, sizeof(h3dmtl), 1);
color_setf(&mtl->ambient, h3dmtl.ambient[0], h3dmtl.ambient[1], h3dmtl.ambient[2], 1.0f);
color_setf(&mtl->diffuse, h3dmtl.diffuse[0], h3dmtl.diffuse[1], h3dmtl.diffuse[2], 1.0f);
color_setf(&mtl->specular, h3dmtl.specular[0], h3dmtl.specular[1], h3dmtl.specular[2], 1.0f);
color_setf(&mtl->emissive, h3dmtl.emissive[0], h3dmtl.emissive[1], h3dmtl.emissive[2], 1.0f);
mtl->spec_exp = h3dmtl.spec_exp;
mtl->spec_intensity = h3dmtl.spec_intensity;
mtl->opacity = h3dmtl.opacity;
mtl->map_cnt = h3dmtl.texture_cnt;
if (h3dmtl.texture_cnt > 0) {
mtl->maps = (struct gfx_model_map*)A_ALLOC(alloc,
sizeof(struct gfx_model_map)*h3dmtl.texture_cnt, MID_GFX);
if (mtl->maps == NULL)
return FALSE;
for (uint i = 0; i < h3dmtl.texture_cnt; i++) {
struct h3d_texture h3dtex;
fio_read(f, &h3dtex, sizeof(h3dtex), 1);
/* h3d_texture_type = gfx_model_maptype */
mtl->maps[i].type = (enum gfx_model_maptype)h3dtex.type;
strcpy(mtl->maps[i].filepath, h3dtex.filepath);
/* TODO: this is a workaround for diffuse mapped materials that
* imports false color values from assimp */
if (mtl->maps[i].type == GFX_MODEL_DIFFUSEMAP)
color_setc(&mtl->diffuse, &g_color_white);
}
}
if (mtl->opacity < (1.0f - EPSILON))
BIT_ADD(mtl->flags, GFX_MODEL_MTLFLAG_TRANSPARENT);
return TRUE;
}
int filedump(const char *filename){
char buf[128];
int fd=fs_open(filename, 0, O_RDONLY);
if(fd==OPENFAIL)
return 0;
fio_printf(1, "\r\n");
int count;
while((count=fio_read(fd, buf, sizeof(buf)))>0){
fio_write(1, buf, count);
}
fio_close(fd);
return 1;
}
gfx_buffer model_loadvbuffer(file_t f, uint vert_cnt, uint elem_sz, struct allocator* tmp_alloc,
uint thread_id)
{
uint size = vert_cnt * elem_sz;
A_SAVE(tmp_alloc);
void* buf = A_ALLOC(tmp_alloc, size, MID_GFX);
if (buf == NULL) {
A_LOAD(tmp_alloc);
return NULL;
}
fio_read(f, buf, elem_sz, vert_cnt);
gfx_buffer gbuf = gfx_create_buffer(GFX_BUFFER_VERTEX, GFX_MEMHINT_STATIC, size, buf, thread_id);
A_FREE(tmp_alloc, buf);
A_LOAD(tmp_alloc);
return gbuf;
}
void command_prompt(void *pvParameters)
{
char buf[128];
char *argv[20];
fio_printf(1, "\rWelcome to FreeRTOS Shell\r\n");
while(1){
fio_printf(1, "\r>>");
fio_read(0, buf, 127);
int n=parse_command(buf, argv);
/* will return pointer to the command function */
cmdfunc *fptr=do_command(argv[0]);
if(fptr!=NULL)
fptr(n, argv);
else
fio_printf(2, "\r\n\"%s\" command not found.\r\n", argv[0]);
}
}
/* Display the content of the file specified. */
void cmd_cat( const char *filename )
{
char buffer[129];
int fd = fs_open( filename, 0, O_RDONLY ), count;
if ( fd < 0 )
{
sPuts( "The file dose not exist!" );
return;
}
while( ( count = fio_read( fd, buffer, sizeof(buffer) - 1 ) ) > 0 )
{
buffer[ count ] = '\0';
print_to_console( buffer );
}
sPuts( "" );
fio_close( fd );
return;
}
static void fill_parameters(struct header_s *h)
{
rrand_seed(time(NULL), time(NULL) + 2);
h->index_id = rrand();
h->iblock = iblock;
h->segment_size = segment_size;
char *basename = pparm_common_name(dex_names[FW]);
char *name;
int fd;
asprintf(&name, "%s.%u.nfo", basename, iblock);
if ((fd = open(name, O_RDONLY, 0)) == -1)
dub_sysdie("Couldn't open file %s", name);
fio_read(fd, h->fw_layers, sizeof(h->fw_layers));
close(fd);
free(name);
free(basename);
}
int main()
{
int whichdrawbuf = 0;
int s;
char *buffer;
int i;
int size;
int rc;
int fd;
// Initialise RPC system.
sif_rpc_init(0);
// Setup the Video.
DmaReset();
initGraph(3);
SetVideoMode();
//install_VRstart_handler();
// Setup the double buffers.
// SetDrawFrameBuffer(1);
// SetDrawFrameBuffer(0);
// SetCrtFrameBuffer(1);
// Load the modules!
loadModules();
// Loaded the modules.. now try ps2ip now..
if(ps2ip_init()<0)
{
printf("ERROR: ps2ip_init failed2");
k_SleepThread();
}
//put here your file path
fd=fio_open("ps2vfs:\\primer\\segun\\mio.txt",O_RDONLY);
if (fd>0)
{
printf("file id kernel is %d \n");
size=fio_lseek(fd,0,SEEK_END);
i=fio_lseek(fd,0,SEEK_SET);
buffer=(char *)malloc(sizeof(char)*size);
i=fio_read(fd,buffer,size);
printf("receive size: %d \n",i);
printf("receive: buffer= %s \n",buffer);
fio_close(fd);
}
while ( 1 )
{
//WaitForNextVRstart(1);
//ClearVRcount();
//SetCrtFrameBuffer(whichdrawbuf);
//whichdrawbuf ^= 1;
//SetDrawFrameBuffer(whichdrawbuf);
// scr_printf( "t" );
}
// We shouldn't get here.. but just in case.
k_SleepThread();
}
struct gfx_model* gfx_model_load(struct allocator* alloc, const char* h3dm_filepath,
uint thread_id)
{
struct allocator* tmp_alloc = tsk_get_tmpalloc(thread_id);
A_SAVE(tmp_alloc);
struct h3d_header header;
struct h3d_model h3dmodel;
struct gfx_model* model = NULL;
uint renderable_idx = 0;
struct stack_alloc stack_mem;
struct allocator stack_alloc;
result_t r;
memset(&stack_mem, 0x00, sizeof(stack_mem));
file_t f = fio_openmem(tmp_alloc, h3dm_filepath, FALSE, MID_GFX);
if (f == NULL) {
err_printf(__FILE__, __LINE__, "load model '%s' failed: could not open file", h3dm_filepath);
goto err_cleanup;
}
/* header */
fio_read(f, &header, sizeof(header), 1);
if (header.sign != H3D_SIGN || header.type != H3D_MESH) {
err_printf(__FILE__, __LINE__, "load model '%s' failed: invalid file format", h3dm_filepath);
goto err_cleanup;
}
if (header.version != H3D_VERSION && header.version != H3D_VERSION_13) {
err_printf(__FILE__, __LINE__, "load model '%s' failed: file version not implemented/obsolete",
h3dm_filepath);
goto err_cleanup;
}
/* model */
fio_read(f, &h3dmodel, sizeof(h3dmodel), 1);
/* calculate size and create stack allocator for proceeding allocations */
size_t total_sz =
sizeof(struct gfx_model) +
h3dmodel.node_cnt*sizeof(struct gfx_model_node) + 16 +
h3dmodel.node_cnt*sizeof(uint) +
h3dmodel.geo_cnt*sizeof(struct gfx_model_geo) +
h3dmodel.mesh_cnt*sizeof(struct gfx_model_mesh) +
h3dmodel.mtl_cnt*sizeof(struct gfx_model_mtl) +
h3dmodel.has_occ*sizeof(struct gfx_model_occ) +
h3dmodel.total_childidxs*sizeof(uint) +
h3dmodel.total_geo_subsets*sizeof(struct gfx_model_geosubset) +
h3dmodel.total_joints*sizeof(struct gfx_model_joint) +
h3dmodel.total_joints*sizeof(struct mat3f) +
h3dmodel.total_submeshes*sizeof(struct gfx_model_submesh) +
h3dmodel.total_skeletons*sizeof(struct gfx_model_skeleton) +
h3dmodel.total_skeletons*32 + /* 2 aligned allocs per skeleton */
h3dmodel.total_maps*sizeof(struct gfx_model_map) +
h3dmodel.occ_idx_cnt*sizeof(uint16) +
h3dmodel.occ_vert_cnt*sizeof(struct vec3f) +
h3dmodel.has_occ*16; /* 1 aligned alloc for occ */
r = mem_stack_create(alloc, &stack_mem, total_sz, MID_GFX);
if (IS_FAIL(r)) {
err_printn(__FILE__, __LINE__, RET_OUTOFMEMORY);
goto err_cleanup;
}
mem_stack_bindalloc(&stack_mem, &stack_alloc);
/* */
model = (struct gfx_model*)A_ALLOC(&stack_alloc, sizeof(struct gfx_model), MID_GFX);
if (model == NULL) {
err_printn(__FILE__, __LINE__, RET_OUTOFMEMORY);
goto err_cleanup;
}
memset(model, 0x00, sizeof(struct gfx_model));
model->alloc = alloc;
/* nodes */
if (h3dmodel.node_cnt > 0) {
model->nodes = (struct gfx_model_node*)A_ALIGNED_ALLOC(&stack_alloc,
sizeof(struct gfx_model_node)*h3dmodel.node_cnt, MID_GFX);
ASSERT(model->nodes);
memset(model->nodes, 0x00, sizeof(struct gfx_model_node)*h3dmodel.node_cnt);
for (uint i = 0; i < h3dmodel.node_cnt; i++) {
struct gfx_model_node* node = &model->nodes[i];
if (!model_loadnode(node, f, &stack_alloc))
goto err_cleanup;
/* NOTE: we set root matrix to identity and keep the old one as "root_mat" */
if (i == 0) {
mat3_setm(&model->root_mat, &node->local_mat);
mat3_set_ident(&node->local_mat);
}
model->node_cnt ++;
}
}
/* meshes */
if (h3dmodel.mesh_cnt > 0) {
model->meshes = (struct gfx_model_mesh*)A_ALLOC(&stack_alloc,
sizeof(struct gfx_model_mesh)*h3dmodel.mesh_cnt, MID_GFX);
ASSERT(model->meshes);
memset(model->meshes, 0x00, sizeof(struct gfx_model_mesh)*h3dmodel.mesh_cnt);
uint idx = 0;
for (uint i = 0; i < h3dmodel.mesh_cnt; i++) {
struct gfx_model_mesh* mesh = &model->meshes[i];
if (!model_loadmesh(mesh, f, &stack_alloc))
goto err_cleanup;
/* assign global indexes */
for (uint k = 0; k < mesh->submesh_cnt; k++)
mesh->submeshes[k].offset_idx = idx++;
model->mesh_cnt ++;
}
}
/* geos */
if (h3dmodel.geo_cnt > 0) {
model->geos = (struct gfx_model_geo*)A_ALLOC(&stack_alloc,
sizeof(struct gfx_model_geo)*h3dmodel.geo_cnt, MID_GFX);
ASSERT(model->geos);
memset(model->geos, 0x00, sizeof(struct gfx_model_geo)*h3dmodel.geo_cnt);
for (uint i = 0; i < h3dmodel.geo_cnt; i++) {
struct gfx_model_geo* geo = &model->geos[i];
if (!model_loadgeo(geo, f, &stack_alloc, tmp_alloc, thread_id))
goto err_cleanup;
model->geo_cnt ++;
}
}
/* materials */
if (h3dmodel.mtl_cnt > 0) {
model->mtls = (struct gfx_model_mtl*)A_ALLOC(&stack_alloc,
sizeof(struct gfx_model_mtl)*h3dmodel.mtl_cnt, MID_GFX);
ASSERT(model->mtls);
memset(model->mtls, 0x00, sizeof(struct gfx_model_mtl)*h3dmodel.mtl_cnt);
for (uint i = 0; i < h3dmodel.mtl_cnt; i++) {
struct gfx_model_mtl* mtl = &model->mtls[i];
if (!model_loadmtl(mtl, f, &stack_alloc))
goto err_cleanup;
model->mtl_cnt ++;
}
}
if (header.version >= H3D_VERSION_11 && h3dmodel.has_occ) {
model->occ = (struct gfx_model_occ*)A_ALLOC(&stack_alloc, sizeof(struct gfx_model_occ),
MID_GFX);
ASSERT(model->occ);
memset(model->occ, 0x00, sizeof(struct gfx_model_occ));
if (!model_loadocc(model->occ, f, &stack_alloc))
goto err_cleanup;
}
/* populate renderable nodes */
model->renderable_idxs = (uint*)A_ALLOC(&stack_alloc, sizeof(uint)*h3dmodel.node_cnt,
MID_GFX);
ASSERT(model->renderable_idxs);
for (uint i = 0; i < h3dmodel.node_cnt; i++) {
struct gfx_model_node* node = &model->nodes[i];
if (node->mesh_id != INVALID_INDEX)
model->renderable_idxs[renderable_idx++] = i;
}
model->renderable_cnt = renderable_idx;
/* calculate sum of aabb(s) from renderable nodes */
aabb_setzero(&model->bb);
struct mat3f node_mat; /* transform matrix, relative to model */
for (uint i = 0; i < renderable_idx; i++) {
struct gfx_model_node* node = &model->nodes[model->renderable_idxs[i]];
mat3_setm(&node_mat, &node->local_mat);
struct gfx_model_node* pnode = node;
while (pnode->parent_id != INVALID_INDEX) {
pnode = &model->nodes[pnode->parent_id];
mat3_mul(&node_mat, &node_mat, &pnode->local_mat);
}
if (node->parent_id != INVALID_INDEX)
mat3_mul(&node_mat, &node_mat, &model->root_mat);
/* transform local box to model-relative bounding box and merge with final */
struct aabb bb;
aabb_xform(&bb, &model->nodes[model->renderable_idxs[i]].bb, &node_mat);
aabb_merge(&model->bb, &model->bb, &bb);
}
/* for empty models, we set a minimal bounding-box */
if (aabb_iszero(&model->bb)) {
aabb_pushptf(&model->bb, 0.1f, 0.1f, 0.1f);
aabb_pushptf(&model->bb, -0.1f, -0.1f, -0.1f);
}
fio_close(f);
A_LOAD(tmp_alloc);
if (thread_id != 0) {
gfx_delayed_waitforobjects(thread_id);
gfx_delayed_fillobjects(thread_id);
}
return model;
err_cleanup:
if (f != NULL)
fio_close(f);
if (model != NULL)
gfx_model_unload(model);
mem_stack_destroy(&stack_mem);
A_LOAD(tmp_alloc);
return NULL;
}
int model_loadgeo(struct gfx_model_geo* geo, file_t f, struct allocator* alloc,
struct allocator* tmp_alloc, uint thread_id)
{
struct h3d_geo h3dgeo;
uint v_cnt = 0;
fio_read(f, &h3dgeo, sizeof(h3dgeo), 1);
geo->vert_cnt = h3dgeo.vert_cnt;
geo->vert_id_cnt = h3dgeo.vert_id_cnt;
geo->tri_cnt = h3dgeo.tri_cnt;
geo->subset_cnt = h3dgeo.subset_cnt;
geo->ib_type = h3dgeo.ib_isui32 ? GFX_INDEX_UINT32 : GFX_INDEX_UINT16;
memcpy(geo->vert_ids, h3dgeo.vert_ids, sizeof(h3dgeo.vert_ids));
/* subsets */
ASSERT(h3dgeo.subset_cnt > 0);
geo->subsets = (struct gfx_model_geosubset*)A_ALLOC(alloc,
sizeof(struct gfx_model_geosubset)*h3dgeo.subset_cnt, MID_GFX);
ASSERT(geo->subsets != NULL);
for (uint i = 0; i < h3dgeo.subset_cnt; i++) {
struct h3d_geo_subset h3dsubset;
fio_read(f, &h3dsubset, sizeof(h3dsubset), 1);
geo->subsets[i].ib_idx = h3dsubset.ib_idx;
geo->subsets[i].idx_cnt = h3dsubset.idx_cnt;
}
/* indexes */
ASSERT(h3dgeo.tri_cnt > 0);
uint ibuffer_sz = (geo->ib_type == GFX_INDEX_UINT16) ? sizeof(uint16)*h3dgeo.tri_cnt*3 :
sizeof(uint)*h3dgeo.tri_cnt*3;
void* indexes = A_ALLOC(tmp_alloc, ibuffer_sz, MID_GFX);
if (indexes == NULL)
goto err_cleanup;
fio_read(f, indexes, ibuffer_sz, 1);
geo->ibuffer = gfx_create_buffer(GFX_BUFFER_INDEX, GFX_MEMHINT_STATIC, ibuffer_sz, indexes,
thread_id);
A_FREE(tmp_alloc, indexes);
if (geo->ibuffer == NULL)
goto err_cleanup;
/* vertices */
/* base data */
int has_pos = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_POSITION);
int has_norm = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_NORMAL);
int has_coord = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_TEXCOORD0);
if (has_pos | has_norm | has_coord) {
geo->vbuffers[GFX_MODEL_BUFFER_BASE] =
model_loadvbuffer(f, h3dgeo.vert_cnt, sizeof(struct h3d_vertex_base), tmp_alloc,
thread_id);
if (geo->vbuffers[GFX_MODEL_BUFFER_BASE] == NULL)
goto err_cleanup;
}
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_POSITION;
if (has_norm)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_NORMAL;
if (has_coord)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_TEXCOORD0;
/* skin data */
int has_bindex = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_BLENDINDEX);
int has_bweight = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_BLENDWEIGHT);
if (has_bindex | has_bweight) {
geo->vbuffers[GFX_MODEL_BUFFER_SKIN] = model_loadvbuffer(f, h3dgeo.vert_cnt,
sizeof(struct h3d_vertex_skin), tmp_alloc, thread_id);
if (geo->vbuffers[GFX_MODEL_BUFFER_BASE] == NULL)
goto err_cleanup;
}
if (has_bindex)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_BLENDINDEX;
if (has_bweight)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_BLENDWEIGHT;
/* normal-map coord data */
int has_tangent = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_TANGENT);
int has_binorm = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_BINORMAL);
if (has_tangent | has_binorm) {
geo->vbuffers[GFX_MODEL_BUFFER_NMAP] = model_loadvbuffer(f, h3dgeo.vert_cnt,
sizeof(struct h3d_vertex_nmap), tmp_alloc, thread_id);
if (geo->vbuffers[GFX_MODEL_BUFFER_NMAP] == NULL)
goto err_cleanup;
}
if (has_tangent)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_TANGENT;
if (has_binorm)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_BINORMAL;
/* Extra data */
int has_coord1 = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_TEXCOORD1);
int has_color = model_checkvertid(h3dgeo.vert_ids, h3dgeo.vert_id_cnt,
GFX_INPUTELEMENT_ID_COLOR);
if (has_coord1 | has_color) {
geo->vbuffers[GFX_MODEL_BUFFER_EXTRA] = model_loadvbuffer(f, h3dgeo.vert_cnt,
sizeof(struct h3d_vertex_extra), tmp_alloc, thread_id);
if (geo->vbuffers[GFX_MODEL_BUFFER_EXTRA] == NULL)
goto err_cleanup;
}
if (has_coord1)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_TEXCOORD1;
if (has_color)
geo->vert_ids[v_cnt++] = GFX_INPUTELEMENT_ID_COLOR;
/* skeleton */
if (h3dgeo.joint_cnt > 0) {
geo->skeleton = (struct gfx_model_skeleton*)A_ALLOC(alloc,
sizeof(struct gfx_model_skeleton), MID_GFX);
if (geo->skeleton == NULL)
return FALSE;
memset(geo->skeleton, 0x00, sizeof(struct gfx_model_skeleton));
geo->skeleton->joint_cnt = h3dgeo.joint_cnt;
geo->skeleton->bones_pervertex_max = h3dgeo.bones_pervertex_max;
model_loadmat(&geo->skeleton->joints_rootmat, h3dgeo.joints_rootmat);
geo->skeleton->init_pose = (struct mat3f*)A_ALIGNED_ALLOC(alloc,
sizeof(struct mat3f)*h3dgeo.joint_cnt, MID_GFX);
geo->skeleton->joints = (struct gfx_model_joint*)A_ALIGNED_ALLOC(alloc,
sizeof(struct gfx_model_joint)*h3dgeo.joint_cnt, MID_GFX);
ASSERT(geo->skeleton->init_pose != NULL);
ASSERT(geo->skeleton->joints != NULL);
for (uint i = 0; i < h3dgeo.joint_cnt; i++) {
struct h3d_joint h3djoint;
struct gfx_model_joint* joint = &geo->skeleton->joints[i];
fio_read(f, &h3djoint, sizeof(h3djoint), 1);
strcpy(joint->name, h3djoint.name);
joint->name_hash = hash_str(h3djoint.name);
model_loadmat(&joint->offset_mat, h3djoint.offset_mat);
joint->parent_id = h3djoint.parent_idx;
}
fio_read(f, geo->skeleton->init_pose, sizeof(struct mat3f), h3dgeo.joint_cnt);
}
ASSERT(v_cnt > 0);
/* input layout */
uint buff_cnt = 0;
uint input_cnt = geo->vert_id_cnt;
struct gfx_input_vbuff_desc vbuffs[GFX_MODEL_BUFFER_CNT];
struct gfx_input_element_binding inputs[GFX_INPUTELEMENT_ID_CNT];
for (uint i = 0; i < input_cnt; i++) {
inputs[i].id = (enum gfx_input_element_id)geo->vert_ids[i];
inputs[i].vb_idx = gfx_model_choose_elem_buffidx(inputs[i].id, &inputs[i].elem_offset);
}
for (uint i = 0; i < GFX_MODEL_BUFFER_CNT; i++) {
if (geo->vbuffers[i] != NULL) {
vbuffs[buff_cnt].stride = gfx_model_choose_vbuff_size(i);
vbuffs[buff_cnt].vbuff = geo->vbuffers[i];
buff_cnt ++;
}
}
geo->inputlayout = gfx_create_inputlayout(vbuffs, buff_cnt, inputs, input_cnt,
geo->ibuffer, geo->ib_type, thread_id);
if (geo->inputlayout == NULL)
goto err_cleanup;
return TRUE;
err_cleanup:
if (geo != NULL)
model_unloadgeo(geo);
return FALSE;
}
