tr_model_md3: parallel MD3 model loading

Author: illwieckz

src/engine/renderer/tr_model_md3.cpp

@@ -22,6 +22,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 // tr_models.c -- model loading and caching
 #include "tr_local.h"
+#include "framework/Omp.h"
 
 #define LL(x) x = LittleLong(x)
 #define LF(x) x = LittleFloat(x)
@@ -33,8 +34,6 @@ R_LoadMD3
 */
 bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 {
-	int            i, j, k; //, l;
-
 	md3Header_t    *md3Model;
 	md3Frame_t     *md3Frame;
 	md3Surface_t   *md3Surf;
@@ -47,7 +46,6 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 	mdvModel_t     *mdvModel;
 	mdvFrame_t     *frame;
 	mdvSurface_t   *surf; //, *surface;
-	srfTriangle_t  *tri;
 	mdvXyz_t       *v;
 	mdvNormal_t    *n;
 	mdvSt_t        *st;
@@ -94,11 +92,11 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 	md3Frame = ( md3Frame_t * )( ( byte * ) md3Model + md3Model->ofsFrames );
 
-	for ( i = 0; i < md3Model->numFrames; i++, frame++, md3Frame++ )
+	for ( size_t i = 0; i < md3Model->numFrames; i++, frame++, md3Frame++ )
 	{
 		frame->radius = LittleFloat( md3Frame->radius );
 
-		for ( j = 0; j < 3; j++ )
+		for ( size_t j = 0; j < 3; j++ )
 		{
 			frame->bounds[ 0 ][ j ] = LittleFloat( md3Frame->bounds[ 0 ][ j ] );
 			frame->bounds[ 1 ][ j ] = LittleFloat( md3Frame->bounds[ 1 ][ j ] );
@@ -112,9 +110,9 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 	md3Tag = ( md3Tag_t * )( ( byte * ) md3Model + md3Model->ofsTags );
 
-	for ( i = 0; i < md3Model->numTags * md3Model->numFrames; i++, tag++, md3Tag++ )
+	for ( size_t i = 0; i < md3Model->numTags * md3Model->numFrames; i++, tag++, md3Tag++ )
 	{
-		for ( j = 0; j < 3; j++ )
+		for ( size_t j = 0; j < 3; j++ )
 		{
 			tag->origin[ j ] = LittleFloat( md3Tag->origin[ j ] );
 			tag->axis[ 0 ][ j ] = LittleFloat( md3Tag->axis[ 0 ][ j ] );
@@ -127,7 +125,7 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 	md3Tag = ( md3Tag_t * )( ( byte * ) md3Model + md3Model->ofsTags );
 
-	for ( i = 0; i < md3Model->numTags; i++, tagName++, md3Tag++ )
+	for ( size_t i = 0; i < md3Model->numTags; i++, tagName++, md3Tag++ )
 	{
 		Q_strncpyz( tagName->name, md3Tag->name, sizeof( tagName->name ) );
 	}
@@ -138,7 +136,7 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 	md3Surf = ( md3Surface_t * )( ( byte * ) md3Model + md3Model->ofsSurfaces );
 
-	for ( i = 0; i < md3Model->numSurfaces; i++ )
+	for ( size_t i = 0; i < md3Model->numSurfaces; i++ )
 	{
 		LL( md3Surf->ident );
 		LL( md3Surf->flags );
@@ -178,7 +176,7 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 		// strip off a trailing _1 or _2
 		// this is a crutch for q3data being a mess
-		j = strlen( surf->name );
+		size_t j = strlen( surf->name );
 
 		if ( j > 2 && surf->name[ j - 2 ] == '_' )
 		{
@@ -191,6 +189,8 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 		// swap all the triangles
 		surf->numTriangles = md3Surf->numTriangles;
+
+		srfTriangle_t *tri;
 		surf->triangles = tri = (srfTriangle_t*) ri.Hunk_Alloc( sizeof( *tri ) * md3Surf->numTriangles, ha_pref::h_low );
 
 		md3Tri = ( md3Triangle_t * )( ( byte * ) md3Surf + md3Surf->ofsTriangles );
@@ -246,12 +246,11 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 		srfVBOMDVMesh_t *vboSurf;
 		glIndex_t       *indexes;
 
-		int             f;
-
 		std::vector<srfVBOMDVMesh_t *> vboSurfaces;
 		vboSurfaces.reserve( 10 );
 
-		for ( i = 0, surf = mdvModel->surfaces; i < mdvModel->numSurfaces; i++, surf++ )
+		surf = mdvModel->surfaces;
+		for ( size_t i = 0; i < mdvModel->numSurfaces; i++, surf++ )
 		{
 			//allocate temp memory for vertex data
 			vec3_t *scaledPosition = (vec3_t *)ri.Hunk_AllocateTempMemory( sizeof( vec3_t ) * mdvModel->numFrames * surf->numVerts );
@@ -264,35 +263,33 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 
 			// calc and feed tangent spaces
 			{
-				const float *v0, *v1, *v2;
-				const float *t0, *t1, *t2;
-				vec3_t      tangent, *tangents;
-				vec3_t      binormal, *binormals;
+				vec3_t *tangents = (vec3_t *)ri.Hunk_AllocateTempMemory( surf->numVerts * sizeof( vec3_t ) );
+				vec3_t *binormals = (vec3_t *)ri.Hunk_AllocateTempMemory( surf->numVerts * sizeof( vec3_t ) );
 
-				tangents = (vec3_t *)ri.Hunk_AllocateTempMemory( surf->numVerts * sizeof( vec3_t ) );
-				binormals = (vec3_t *)ri.Hunk_AllocateTempMemory( surf->numVerts * sizeof( vec3_t ) );
-
-				for ( f = 0; f < mdvModel->numFrames; f++ )
+				for ( size_t f = 0; f < mdvModel->numFrames; f++ )
 				{
-					for ( j = 0; j < ( surf->numVerts ); j++ )
+					for ( size_t j = 0; j < ( surf->numVerts ); j++ )
 					{
 						VectorClear( tangents[ j ] );
 						VectorClear( binormals[ j ] );
 					}
 
-					for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
+					auto task0 = [&]( const size_t& j ) -> void
 					{
-						v0 = surf->verts[ surf->numVerts * f + tri->indexes[ 0 ] ].xyz;
-						v1 = surf->verts[ surf->numVerts * f + tri->indexes[ 1 ] ].xyz;
-						v2 = surf->verts[ surf->numVerts * f + tri->indexes[ 2 ] ].xyz;
+						srfTriangle_t *tri = surf->triangles + j;
+
+						const float *v0 = surf->verts[ surf->numVerts * f + tri->indexes[ 0 ] ].xyz;
+						const float *v1 = surf->verts[ surf->numVerts * f + tri->indexes[ 1 ] ].xyz;
+						const float *v2 = surf->verts[ surf->numVerts * f + tri->indexes[ 2 ] ].xyz;
 
-						t0 = surf->st[ tri->indexes[ 0 ] ].st;
-						t1 = surf->st[ tri->indexes[ 1 ] ].st;
-						t2 = surf->st[ tri->indexes[ 2 ] ].st;
+						const float *t0 = surf->st[ tri->indexes[ 0 ] ].st;
+						const float *t1 = surf->st[ tri->indexes[ 1 ] ].st;
+						const float *t2 = surf->st[ tri->indexes[ 2 ] ].st;
 
+						vec3_t tangent, binormal;
 						R_CalcTangents( tangent, binormal, v0, v1, v2, t0, t1, t2 );
 
-						for ( k = 0; k < 3; k++ )
+						for ( size_t k = 0; k < 3; k++ )
 						{
 							float *w;
 
@@ -302,17 +299,21 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 							w = binormals[ tri->indexes[ k ] ];
 							VectorAdd( w, binormal, w );
 						}
-					}
+					};
 
-					for ( j = 0; j < surf->numVerts; j++ )
+					Omp::Tasker( task0, surf->numTriangles );
+
+					auto task1 = [&]( const size_t& j ) -> void
 					{
 						VectorNormalize( tangents[ j ] );
 						VectorNormalize( binormals[ j ] );
 						R_TBNtoQtangents(
 							tangents[ j ], binormals[ j ],
 							surf->normals[ f * surf->numVerts + j ].normal,
 							qtangents[ f * surf->numVerts + j ] );
-					}
+					};
+
+					Omp::Tasker( task1, surf->numVerts );
 				}
 
 				ri.Hunk_FreeTempMemory( binormals );
@@ -354,8 +355,11 @@ bool R_LoadMD3( model_t *mod, int lod, const void *buffer, const char *modName )
 			ri.Hunk_FreeTempMemory( scaledPosition );
 
 			indexes = (glIndex_t *)ri.Hunk_AllocateTempMemory( 3 * surf->numTriangles * sizeof( glIndex_t ) );
-			for ( f = j = 0; j < surf->numTriangles; j++ ) {
-				for( k = 0; k < 3; k++ ) {
+
+			size_t f = 0;
+
+			for ( size_t j = 0; j < surf->numTriangles; j++ ) {
+				for( size_t k = 0; k < 3; k++ ) {
 					indexes[ f++ ] = surf->triangles[ j ].indexes[ k ];
 				}
 			}