///
//Frees resuorces allocated by an Asset Buffer
//Deletes data being held in buffer!!
//
//PArameters:
// buffer: pointer to The buffer to free
static void AssetManager_FreeBuffer(AssetBuffer* buffer)
{
for (unsigned int i = 0; i < buffer->meshMap->data->capacity; i++)
{
struct HashMap_KeyValuePair* pair = *(struct HashMap_KeyValuePair**)DynamicArray_Index(buffer->meshMap->data, i);
if(pair != NULL)
{
Mesh* m = (Mesh*)pair->data;
Mesh_Free(m);
//Following line will be done by HashMap_Free
//HashMap_KeyValuePair_Free(pair);
}
}
printf("Meshes freed\n");
HashMap_Free(buffer->meshMap);
printf("MeshMap freed\n");
for (unsigned int i = 0; i < buffer->textureMap->data->capacity; i++)
{
struct HashMap_KeyValuePair* pair = *(struct HashMap_KeyValuePair**)DynamicArray_Index(buffer->textureMap->data, i);
if(pair != NULL)
{
Texture* t = (Texture*)pair->data;
Texture_Free(t);
}
}
printf("Textures freed.\n");
HashMap_Free(buffer->textureMap);
printf("Texture Map Freed.\n");
}
///
//Frees resuorces allocated by an Asset Buffer
//Deletes data being held in buffer!!
//
//PArameters:
// buffer: pointer to The buffer to free
static void AssetManager_FreeBuffer(AssetBuffer* buffer)
{
for (int i = 0; i < buffer->meshMap->data->capacity; i++)
{
//Mesh_Free((Mesh*)buffer->meshMap->data[i]->data);
Mesh* m = *(Mesh**)DynamicArray_Index(buffer->meshMap->data, i);
if(m != NULL)
{
Mesh_Free(m);
}
}
HashMap_Free(buffer->meshMap);
//for (int i = 0; i < buffer->textureMap->size; i++)
for (int i = 0; i < buffer->textureMap->data->capacity; i++)
{
//Texture_Free((Texture*)buffer->meshMap->data[i]->data);
Texture* t = *(Texture**)DynamicArray_Index(buffer->textureMap->data, i);
if(t != NULL)
{
Texture_Free(t);
}
}
HashMap_Free(buffer->textureMap);
}
/*
==============================
Layer_FreeTexCoords
==============================
*/
void Layer_FreeTexCoords( layer_t *layer )
{
if ( layer->tc )
{
Mesh_Free( layer->tc );
layer->tc = NULL;
}
}
/*
==============================
Tess_CreateMesh_glmesh
==============================
*/
void Tess_CreateMesh_glmesh( shape_t *shp )
{
mesh_t *mesh;
int ofs_vertex;
int num_vertex;
int ofs_vref;
int num_vref;
int ofs_cmd;
int num_cmd;
vec3d_t *m_vertices;
int tmp_int;
int i;
if ( shp->tess_name != ShapeTesselation_glmesh )
__error( "tess_name is not ShapeTesselation_meshtile\n" );
if ( !(shp->flags & SHAPE_FLAGS_HAVE_GLMESH) )
__error( "missing flag SHAPE_FLAGS_HAVE_GLMESH\n" );
__chkptr( shp->glmesh_obj );
__chkptr( shp->glmesh_base );
EasyFindInt( &ofs_vertex, shp->glmesh_obj, "ofs_vertex" );
EasyFindInt( &num_vertex, shp->glmesh_obj, "num_vertex" );
EasyFindInt( &ofs_vref, shp->glmesh_obj, "ofs_vref" );
EasyFindInt( &num_vref, shp->glmesh_obj, "num_vref" );
EasyFindInt( &ofs_cmd, shp->glmesh_obj, "ofs_cmd" );
EasyFindInt( &num_cmd, shp->glmesh_obj, "num_cmd" );
Mesh_BeginInstance();
Mesh_AddExternVec3dArray( num_vertex, &shp->glmesh_base[ofs_vertex] );
Mesh_AddExternIntArray( num_vref, &shp->glmesh_base[ofs_vref] );
Mesh_AddExternIntArray( num_cmd, &shp->glmesh_base[ofs_cmd] );
mesh = Mesh_EndInstance();
Mesh_GetVec3dBase( mesh, 0, &tmp_int, &m_vertices );
U_VACalcBB( m_vertices, tmp_int, shp->min, shp->max );
for ( i = 0; i < 3; i++ )
{
shp->min[i] -= SHAPE_BOUNDBOX_SIDE_SPACE;
shp->max[i] += SHAPE_BOUNDBOX_SIDE_SPACE;
}
if ( shp->mesh )
Mesh_Free( shp->mesh );
shp->mesh = mesh;
}
/*
==============================
Tess_CreateMesh_curved_face
==============================
*/
void Tess_CreateMesh_curved_face( shape_t *shp )
{
int i;
mesh_t *mesh;
u_list_iter_t iter;
shape_ctrl_point_t *cp;
int pnum;
vec3d_t pts[CURVED_FACE_MAX_POINTS];
int fs[CURVED_FACE_MAX_POINTS];
if ( shp->tess_name != ShapeTesselation_curved_face )
__error( "tess_name invalid\n" );
if ( shp->norm[0] == 0 &&
shp->norm[1] == 0 &&
shp->norm[2] == 0 )
__error( "missing plane hint\n" );
if ( shp->vnum != 1 )
__error( "invalid v order\n" );
if ( shp->unum <= 0 )
__error( "invalid u order\n" );
if ( shp->unum != U_ListLength( shp->cp_list ) )
__error( "control point inconsitancy\n" );
// fixme: lod init
if ( shp->u_lod == 0 )
{
shp->u_lod = 3;
}
pnum = shp->unum;
for ( i = 0; i < pnum; i++ )
fs[i] = CURVED_FACE_FLAGS_NONE;
// setup and check control points
U_ListIterInit( &iter, shp->cp_list );
for ( ; ( cp = (shape_ctrl_point_t *)U_ListIterNext( &iter ) ) ; )
{
if ( cp->u < 0 || cp->u > pnum-1 || cp->v != 0 )
__error( "invalid control point\n" );
if ( fs[cp->u] != CURVED_FACE_FLAGS_NONE )
__error( "dublicated control points\n" );
fs[cp->u] |= CURVED_FACE_FLAGS_USED;
Vec3dCopy( pts[cp->u], cp->p );
}
Trify_BeginGenericPolygon();
Trify_SetPlane( shp->norm, shp->dist );
Tess_CurvedFace_GenCurvedEdge( shp->u_lod, pnum, pts );
mesh = Trify_End();
if ( shp->mesh )
Mesh_Free( shp->mesh );
shp->mesh = mesh;
Tess_CurvedFace_CalcBoundBox( shp );
}
/*
==============================
Tess_CreateMesh_curved_surface
==============================
*/
void Tess_CreateMesh_curved_surface( shape_t *shp )
{
int u, v;
int u_order, v_order;
u_list_iter_t iter;
shape_ctrl_point_t *cp;
int cpnum;
mesh_t *mesh;
vec3d_t pts[CURVED_SURFACE_MAX_U_ORDER][CURVED_SURFACE_MAX_V_ORDER];
int fs[CURVED_SURFACE_MAX_U_ORDER][CURVED_SURFACE_MAX_V_ORDER];
if ( shp->tess_name != ShapeTesselation_curved_surface )
__error( "tess_name invalid\n" );
u_order = shp->unum;
v_order = shp->vnum;
if ( u_order <= 1 || u_order >= CURVED_SURFACE_MAX_U_ORDER )
__error( "invalid u order\n" );
if ( v_order <= 1 || v_order >= CURVED_SURFACE_MAX_V_ORDER )
__error( "invalid v order\n" );
for ( u = 0; u < u_order; u++ )
{
for ( v = 0; v < v_order; v++ )
{
fs[u][v] = CURVED_SURFACE_FLAGS_NONE;
}
}
// setup and check control points
U_ListIterInit( &iter, shp->cp_list );
for ( cpnum = 0; ( cp = (shape_ctrl_point_t *)U_ListIterNext( &iter ) ); cpnum++ )
{
u = cp->u;
v = cp->v;
if ( u < 0 || u >= u_order )
__error( "invalid control point\n" );
if ( v < 0 || v >= v_order )
__error( "invalid control point\n" );
if ( fs[u][v] != CURVED_SURFACE_FLAGS_NONE )
__error( "dublicated control points\n" );
fs[u][v] |= CURVED_SURFACE_FLAGS_USED;
Vec3dCopy( pts[u][v], cp->p );
}
if ( cpnum != u_order*v_order )
__error( "not enough control points\n" );
// fixme: lod init
if ( shp->u_lod == 0 && shp->v_lod == 0 )
{
Tess_CurvedSurface_ClassifyLOD( &shp->u_lod, &shp->v_lod, u_order, v_order, pts );
}
mesh = Tess_CurvedSurface_GenMesh( shp->u_lod, shp->v_lod, u_order, v_order, pts );
if ( shp->mesh )
Mesh_Free( shp->mesh );
shp->mesh = mesh;
Tess_CurvedSurface_CalcBoundBox( shp );
}
/*
==============================
Layer_CreateTexCoords_uv
==============================
*/
void Layer_CreateTexCoords_uv( layer_t *layer, mesh_t *mesh )
{
int i;
surface_ctrl_t *sc;
vec2d_t v;
vec2d_t *m_uvs;
int *m_vrefs;
int m_vertexnum;
int m_vrefnum;
mesh_t *tc_mesh;
vec2d_t *m_tc;
int tmp_int;
sc = NewBezierSurface( 2, 2 );
U_BeginMemUnpack( layer->packed_info );
// fixme: move insane cotrol point order to the caller
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 0, 0, v[0], v[1], 0 );
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 0, 1, v[0], v[1], 0 );
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 1, 0, v[0], v[1], 0 );
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 1, 1, v[0], v[1], 0 );
U_EndMemUnpack();
Mesh_GetIntBase( mesh, 1, &m_vrefnum, &m_vrefs );
Mesh_GetVec2dBase( mesh, 3, &m_vertexnum, &m_uvs );
Mesh_BeginInstance();
Mesh_AddVec2dArray( m_vrefnum );
tc_mesh = Mesh_EndInstance();
Mesh_GetVec2dBase( tc_mesh, 0, &tmp_int, &m_tc );
for ( i = 0; i < m_vrefnum; i++ )
{
vec3d_t v3;
EvalSurfacePoint( sc, m_uvs[m_vrefs[i]][0], m_uvs[m_vrefs[i]][1], v3 );
v[0] = v3[0];
v[1] = v3[1];
if ( layer->flags & LAYER_FLAGS_MODE_TEXEL0N )
UniTex_RealTexCoord_0N( layer->real_source, m_tc[i], v );
else if ( layer->flags & LAYER_FLAGS_MODE_TEXEL01 )
UniTex_RealTexCoord_01( layer->real_source, m_tc[i], v );
else
__error( "unknown texcoord access type\n" );
}
if ( layer->tc )
Mesh_Free( layer->tc );
layer->tc = tc_mesh;
}
/*
==============================
Layer_CreateTexCoords_projection_with_stack
==============================
*/
void Layer_CreateTexCoords_projection_with_stack( layer_t *layer, mesh_t *mesh )
{
int i;
vec3d_t *m_vertices;
int *m_vrefs;
int m_vertexnum;
int m_vrefnum;
mesh_t *tc_mesh;
vec2d_t *m_tc;
int tmp_int;
Mesh_GetVec3dBase( mesh, 0, &m_vertexnum, &m_vertices );
Mesh_GetIntBase( mesh, 1, &m_vrefnum, &m_vrefs );
Mesh_BeginInstance();
Mesh_AddVec2dArray( m_vrefnum );
tc_mesh = Mesh_EndInstance();
Mesh_GetVec2dBase( tc_mesh, 0, &tmp_int, &m_tc );
// init tc_mesh with projected vertices
for ( i = 0; i < m_vrefnum; i++ )
{
vec3d_t v3;
vec2d_t v2;
Vec3dCopy( v3, m_vertices[m_vrefs[i]] );
if ( layer->flags & LAYER_FLAGS_PROJECTION_X )
{
v2[0] = v3[2];
v2[1] = v3[1];
}
else if ( layer->flags & LAYER_FLAGS_PROJECTION_Y )
{
v2[0] = v3[0];
v2[1] = v3[2];
}
else if ( layer->flags & LAYER_FLAGS_PROJECTION_Z )
{
v2[0] = v3[0];
v2[1] = v3[1];
}
else
{
__error( "invalid projection plane\n" );
}
Vec2dCopy( m_tc[i], v2 );
}
for ( i = 0; i < m_vrefnum; i++ )
{
TF2D_StackCalc( layer->tf2d_stack, m_tc[i], m_tc[i] );
}
for ( i = 0; i < m_vrefnum; i++ )
{
vec2d_t tmp;
Vec2dCopy( tmp, m_tc[i] );
if ( layer->flags & LAYER_FLAGS_MODE_TEXEL0N )
UniTex_RealTexCoord_0N( layer->real_source, m_tc[i], tmp );
else if ( layer->flags & LAYER_FLAGS_MODE_TEXEL01 )
UniTex_RealTexCoord_01( layer->real_source, m_tc[i], tmp );
else
__error( "unknown texcoord access type\n" );
}
if ( layer->tc )
Mesh_Free( layer->tc );
layer->tc = tc_mesh;
}
/*
==============================
Layer_CreateTexCoords_projection
==============================
*/
void Layer_CreateTexCoords_projection( layer_t *layer, mesh_t *mesh )
{
int i, j;
vec3d_t *m_vertices;
int *m_vrefs;
int m_vertexnum;
int m_vrefnum;
mesh_t *tc_mesh;
vec2d_t *m_tc;
int tmp_int;
int trans_num;
Mesh_GetVec3dBase( mesh, 0, &m_vertexnum, &m_vertices );
Mesh_GetIntBase( mesh, 1, &m_vrefnum, &m_vrefs );
Mesh_BeginInstance();
Mesh_AddVec2dArray( m_vrefnum );
tc_mesh = Mesh_EndInstance();
Mesh_GetVec2dBase( tc_mesh, 0, &tmp_int, &m_tc );
// init tc_mesh with projected vertices
for ( i = 0; i < m_vrefnum; i++ )
{
vec3d_t v3;
vec2d_t v2;
Vec3dCopy( v3, m_vertices[m_vrefs[i]] );
if ( layer->flags & LAYER_FLAGS_PROJECTION_X )
{
v2[0] = v3[2];
v2[1] = v3[1];
}
else if ( layer->flags & LAYER_FLAGS_PROJECTION_Y )
{
v2[0] = v3[0];
v2[1] = v3[2];
}
else if ( layer->flags & LAYER_FLAGS_PROJECTION_Z )
{
v2[0] = v3[0];
v2[1] = v3[1];
}
else
{
__error( "invalid projection plane\n" );
}
Vec2dCopy( m_tc[i], v2 );
}
// unpack layer_info
U_BeginMemUnpack( layer->packed_info ); // fixme: missing U_EndMemUnpack() ...
U_MemUnpacki32( &trans_num );
for ( j = 0; j < trans_num; j++ )
{
int trans_type;
U_MemUnpacki32( &trans_type );
if ( trans_type & LAYER_FLAGS_TRANSFORMATION_AXIS )
{
vec2d_t x, y;
U_MemUnpackf32v2( x );
U_MemUnpackf32v2( y );
for ( i = 0; i < m_vrefnum; i++ )
{
vec2d_t tmp;
Vec2dCopy( tmp, m_tc[i] );
m_tc[i][0] = tmp[0]*x[0] + tmp[1]*x[1];
m_tc[i][1] = tmp[0]*y[0] + tmp[1]*y[1];
}
}
else if ( trans_type & LAYER_FLAGS_TRANSFORMATION_SCALE )
{
vec2d_t scale;
U_MemUnpackf32v2( scale );
for ( i = 0; i < m_vrefnum; i++ )
{
m_tc[i][0] *= scale[0];
m_tc[i][1] *= scale[1];
}
}
else if ( trans_type & LAYER_FLAGS_TRANSFORMATION_SHIFT )
{
vec2d_t shift;
U_MemUnpackf32v2( shift );
for ( i = 0; i < m_vrefnum; i++ )
{
m_tc[i][0] += shift[0];
m_tc[i][1] += shift[1];
}
}
else
{
__error( "invalid projectiv transformation\n" );
}
}
for ( i = 0; i < m_vrefnum; i++ )
{
vec2d_t tmp;
Vec2dCopy( tmp, m_tc[i] );
if ( layer->flags & LAYER_FLAGS_MODE_TEXEL0N )
UniTex_RealTexCoord_0N( layer->real_source, m_tc[i], tmp );
else if ( layer->flags & LAYER_FLAGS_MODE_TEXEL01 )
UniTex_RealTexCoord_01( layer->real_source, m_tc[i], tmp );
else
__error( "unknown texcoord access type\n" );
}
if ( layer->tc )
Mesh_Free( layer->tc );
layer->tc = tc_mesh;
}
