Merge branch 'master' into for-0.56.0/sync

Author: illwieckz

src/common/Defs.h

@@ -37,7 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** No case, No spaces */
 #define PRODUCT_NAME_LOWER  "unvanquished"
 
-#define PRODUCT_VERSION     "0.55.2"
+#define PRODUCT_VERSION     "0.55.3"
 
 /** Default base package */
 #define DEFAULT_BASE_PAK    PRODUCT_NAME_LOWER

src/engine/renderer/GeometryOptimiser.cpp

@@ -308,20 +308,25 @@ void MergeDuplicateVertices( bspSurface_t** rendererSurfaces, int numSurfaces, s
 	for ( int i = 0; i < numSurfaces; i++ ) {
 		bspSurface_t* surface = rendererSurfaces[i];
 
-		srfGeneric_t* face = ( srfGeneric_t* ) surface->data;
-		face->firstIndex = idx;
-		for ( srfTriangle_t* triangle = face->triangles; triangle < face->triangles + face->numTriangles; triangle++ ) {
+		srfGeneric_t* srf = ( srfGeneric_t* ) surface->data;
+		srf->firstIndex = idx;
+		for ( srfTriangle_t* triangle = srf->triangles; triangle < srf->triangles + srf->numTriangles; triangle++ ) {
 			for ( int j = 0; j < 3; j++ ) {
-				srfVert_t& vert = face->verts[triangle->indexes[j]];
+				srfVert_t& vert = srf->verts[triangle->indexes[j]];
 				uint32_t index = verts[vert];
 
-				ASSERT_LT( idx, numIndicesIn );
+				/* There were some crashes due to bad lightmap values in .bsp vertices,
+				do the check again here just in case some calculation earlier, like patch mesh triangulation,
+				fucks things up again */
+				ValidateVertex( &vert, -1, surface->shader );
+
+				ASSERT_LT( idx, ( uint32_t ) numIndicesIn );
 				if ( !index ) {
 					verts[vert] = vertIdx + 1;
 					vertices[vertIdx] = vert;
 					indices[idx] = vertIdx;
 
-					ASSERT_LT( vertIdx, numVerticesIn );
+					ASSERT_LT( vertIdx, ( uint32_t ) numVerticesIn );
 
 					vertIdx++;
 				} else {
@@ -356,7 +361,7 @@ void MergeDuplicateVertices( bspSurface_t** rendererSurfaces, int numSurfaces, s
 	}
 } */
 
-std::vector<MaterialSurface> OptimiseMapGeometryMaterial( world_t* world, int numSurfaces ) {
+std::vector<MaterialSurface> OptimiseMapGeometryMaterial(bspSurface_t** rendererSurfaces, int numSurfaces ) {
 	std::vector<MaterialSurface> materialSurfaces;
 	materialSurfaces.reserve( numSurfaces );
 
@@ -365,24 +370,46 @@ std::vector<MaterialSurface> OptimiseMapGeometryMaterial( world_t* world, int nu
 
 	// std::unordered_map<TriEdge, TriIndex> triEdges;
 
-	int surfaceIndex = 0;
-	for ( int k = 0; k < world->numSurfaces; k++ ) {
-		bspSurface_t* surface = &world->surfaces[k];
+	vec3_t worldBounds[2] = {};
+	for ( int i = 0; i < numSurfaces; i++ ) {
+		bspSurface_t* surface = rendererSurfaces[i];
+
+		if ( surface->BSPModel ) {
+			// Not implemented yet
+			continue;
+		}
 
 		MaterialSurface srf {};
 
 		srf.shader = surface->shader;
+
 		srf.bspSurface = true;
+		srf.skyBrush = surface->skyBrush;
+
+		srf.lightMapNum = surface->lightmapNum;
 		srf.fog = surface->fogIndex;
+		srf.portalNum = surface->portalNum;
 
 		srf.firstIndex = ( ( srfGeneric_t* ) surface->data )->firstIndex;
-		srf.count = ( ( srfGeneric_t* ) surface->data )->numTriangles;
+		srf.count = ( ( srfGeneric_t* ) surface->data )->numTriangles * 3;
 		srf.verts = ( ( srfGeneric_t* ) surface->data )->verts;
 		srf.tris = ( ( srfGeneric_t* ) surface->data )->triangles;
 
+		VectorCopy( ( ( srfGeneric_t* ) surface->data )->origin, srf.origin );
+		srf.radius = ( ( srfGeneric_t* ) surface->data )->radius;
+
+		BoundsAdd( worldBounds[0], worldBounds[1],
+			( ( srfGeneric_t* ) surface->data )->bounds[0], ( ( srfGeneric_t* ) surface->data )->bounds[1] );
+
+		materialSystem.GenerateMaterial( &srf );
+
 		materialSurfaces.emplace_back( srf );
-		surfaceIndex++;
 	}
 
+	materialSystem.GenerateWorldMaterialsBuffer();
+	materialSystem.GeneratePortalBoundingSpheres();
+	materialSystem.SetWorldBounds( worldBounds );
+	materialSystem.GenerateWorldCommandBuffer( materialSurfaces );
+
 	return materialSurfaces;
 }

src/engine/renderer/GeometryOptimiser.h

@@ -68,18 +68,12 @@ struct TriIndex {
 
 struct MapVertHasher {
 	size_t operator()( const srfVert_t& vert ) const {
-		size_t hash = ~( *( ( size_t* ) &vert.xyz[0] ) << 15 );
-		hash ^= ( *( ( size_t* ) &vert.xyz[0] ) >> 10 );
-		hash += ( *( ( size_t* ) &vert.xyz[1] ) << 3 );
-		hash ^= ( *( ( size_t* ) &vert.xyz[1] ) >> 6 );
-		hash += ~( *( ( size_t* ) &vert.xyz[2] ) << 11 );
-		hash ^= ( *( ( size_t* ) &vert.xyz[2] ) >> 16 );
-
-		hash ^= ( *( ( size_t* ) &vert.st[0] ) << 7 );
-		hash += ( *( ( size_t* ) &vert.st[0] ) >> 12 );
-
-		hash ^= ( *( ( size_t* ) &vert.st[1] ) << 13 );
-		hash += ( *( ( size_t* ) &vert.st[1] ) >> 8 );
+		uint32_t hash = ~( Util::bit_cast<uint32_t, float>( vert.xyz[0] ) << 15 );
+		hash ^= ( Util::bit_cast<uint32_t, float>( vert.xyz[0] ) >> 10 );
+		hash += ( Util::bit_cast<uint32_t, float>( vert.xyz[1] ) << 3 );
+		hash ^= ( Util::bit_cast<uint32_t, float>( vert.xyz[1] ) >> 6 );
+		hash += ( Util::bit_cast<uint32_t, float>( vert.xyz[2] ) << 11 );
+		hash ^= ( Util::bit_cast<uint32_t, float>( vert.xyz[2] ) >> 16 );
 
 		return hash;
 	}
@@ -98,14 +92,15 @@ struct MapVertEqual {
 			&& VectorCompareEpsilon( lhs.normal, rhs.normal, 0.0001f )
 			&& CompareEpsilon( lhs.qtangent[0], rhs.qtangent[0] ) && CompareEpsilon( lhs.qtangent[1], rhs.qtangent[1] )
 			&& CompareEpsilon( lhs.qtangent[2], rhs.qtangent[2] ) && CompareEpsilon( lhs.qtangent[3], rhs.qtangent[3] )
-			&& lhs.lightColor.ArrayBytes() == rhs.lightColor.ArrayBytes();
+			&& lhs.lightColor.Red() == rhs.lightColor.Red() && lhs.lightColor.Green() == rhs.lightColor.Green()
+			&& lhs.lightColor.Blue() == rhs.lightColor.Blue() && lhs.lightColor.Alpha() == rhs.lightColor.Alpha();
 	}
 };
 
 void OptimiseMapGeometryCore( world_t* world, bspSurface_t** rendererSurfaces, int numSurfaces );
 void MergeLeafSurfacesCore( world_t* world, bspSurface_t** rendererSurfaces, int numSurfaces );
 void MergeDuplicateVertices( bspSurface_t** rendererSurfaces, int numSurfaces, srfVert_t* vertices, int numVerticesIn,
 	glIndex_t* indices, int numIndicesIn, int& numVerticesOut, int& numIndicesOut );
-std::vector<MaterialSurface> OptimiseMapGeometryMaterial( world_t* world, int numSurfaces );
+std::vector<MaterialSurface> OptimiseMapGeometryMaterial( bspSurface_t** rendererSurfaces, int numSurfaces );
 
 #endif // GEOMETRY_OPTIMISER_H