A better Blender::blend_vec()

inline void Blender::blend_vec( int x, int y, int squaresPerTargetEdge_log2, const U16 *lmap, U16 **destmips )
{
	PROFILE_START(ALTIVEC_BLEND);
	const U32 squaresPerTargetEdge(1 << squaresPerTargetEdge_log2); // 32 (low detail) to 4 (high detail).
	const U32 texelsPerSquareEdge_log2(TEXELS_PER_TARGET_EDGE_LOG2 - squaresPerTargetEdge_log2);  // 5 (high detail) to 2 (low detail)
	const U32 texelsPerSquareEdge(1 << texelsPerSquareEdge_log2); // == TEXELS_PER_TARGET_EDGE / squaresPerTargetEdge); 4 (low) to 32 (high) detail.
	const U32 texelsPerSquare_log2(texelsPerSquareEdge_log2 << 1);  // 10 (high detail) to 4 (low detail)
	const U32 sourceMipMapIndex(MAX_TEXELS_PER_SQUARE_EDGE_LOG2 - texelsPerSquareEdge_log2);
	const U32 targetTexelsPerLumel_log2(texelsPerSquareEdge_log2 - LUMELS_PER_SQUARE_EDGE_LOG2);
	const U32 targetTexelsPerLumel(1 << targetTexelsPerLumel_log2);
	
	const U32 yStrideThroughTarget(TEXELS_PER_TARGET_EDGE);
	const U32 yStrideThroughSquare(texelsPerSquareEdge);
	const U32 xStrideAcrossLumels(targetTexelsPerLumel);
	const U32 yStrideThroughTargetAcrossLumels(yStrideThroughTarget << targetTexelsPerLumel_log2);
	const U32 yStrideThroughSquareAcrossLumels(yStrideThroughSquare << targetTexelsPerLumel_log2);
		
	const U32 *const*const allSourceBitMaps = &bmpdata[sourceMipMapIndex * num_src_bmps];
	
	const AlphaCalc	alphaCalc;
	
	// sy & sx index through the SQUAREs of the DESTINATION MIP-MAP
	// All Source MIP-MAPs are 2D arrays of squares:
	//      SQUARE source_mip_map_2D[SQUARES_PER_MIPMAP_EDGE][SQUARES_PER_MIPMAP_EDGE];
	// But they are stored as 1D arrays:
	//      SQUARE source_mip_map_1D[SQUARES_PER_MIPMAP_EDGE*SQUARES_PER_MIPMAP_EDGE];
	// therefore the following are equivalent:
	//               source_mip_map_2D[Y][X]
	//                  source_mip_map_1D[(Y * SQUARES_PER_MIPMAP_EDGE) + X]
	//                  source_mip_map_1D[(Y << SQUARES_PER_MIPMAP_EDGE_LOG2) + X]
	//                  source_mip_map_1D[(Y << SQUARES_PER_MIPMAP_EDGE_LOG2) | X]
	// This loop is from [0] through [squaresPerTargetEdge - 1] of the destination
	// and from [y] through [y + squaresPerTargetEdge - 1] of the source.
	// A single terrain TILE is equivalently:
	//      SQUARE terrain_tile_2D[SQUARES_PER_TILE_EDGE][SQUARES_PER_TILE_EDGE];
	// or
	//      SQUARE terrain_tile_1D[SQUARES_PER_TILE_EDGE*SQUARES_PER_TILE_EDGE];
	// therefore the following are equivalent:
	//               terrain_tile_2D[Y][X]
	//                  terrain_tile_1D[(Y << SQUARES_PER_MIPMAP_EDGE_LOG2) | X]
	// Neither source_mip_map_1D nor terrain_tile_1D appear explicitly.
	
	for ( int yInTarget = 0; yInTarget < squaresPerTargetEdge; ++yInTarget )
	{
		// This whole section is called "doing 2-dimensional array indexing the hard way"
		// yInTile & after_yInTile are the bottom and top of the source square we are actually processing,
		// masked to tile size which is what causes the "repeating" effect
		const int yInTile((y + yInTarget) & SQUARES_PER_TILE_EDGE_MASK);
		const int after_yInTile((yInTile + 1) & SQUARES_PER_TILE_EDGE_MASK);
		
		// yInTile_offset and after_yInTile_offset are the offsets into the terrain_tile_1D format arrays
		const int yInTile_offset(yInTile << SQUARES_PER_TILE_EDGE_LOG2);
		const int after_yInTile_offset(after_yInTile << SQUARES_PER_TILE_EDGE_LOG2);
		
		// py is the row index in squares into the source_mip_map_2D
		const int yInSource(yInTile & SQUARES_PER_MIPMAP_EDGE_MASK);
		// yInSource_offset is the offset in squares into the source_mip_map_1D, times the size
		// of the squares.
		const int yInSource_offset(yInSource << (texelsPerSquare_log2 + SQUARES_PER_MIPMAP_EDGE_LOG2));
		
		// This loop is from [yInTarget][0] through [yInTarget][squaresPerTargetEdge - 1] of the destination
		// and from [yInTile][x] through [yInTile][x + squaresPerTargetEdge - 1] of the source.
		
		for ( int xInTarget = 0; xInTarget < squaresPerTargetEdge; xInTarget++ )
		{
			// xInTile & after_xInTile are the left and right side of the source square we are actually processing,
			// masked to tile size which is what causes the "repeating" effect
			const int xInTile((x + xInTarget) & SQUARES_PER_TILE_EDGE_MASK);
			const int after_xInTile((xInTile + 1) & SQUARES_PER_TILE_EDGE_MASK);
			// xInSource is the column index in squares into the source_mip_map_2D
			const int xInSource(xInTile & SQUARES_PER_MIPMAP_EDGE_MASK);
			// As you can see the GRID is accessed in TILE co-ordinates
			const U32 gridflags(GRIDFLAGS( xInTile, yInTile ));
			
			
			// Cache the source textures at our mip-map level as specified by the GRID-FLAGS
			const U32 *sourceSquareBitMaps[MAXIMUM_TEXTURES];
			// Cache the Alpha-Maps as specified by the GRID-FLAGS
			const U8 *alphaMaps[MAXIMUM_TEXTURES];
			
			// Pre-calculate (U8*) &source_mip_map_2D[yInSource][xInSource] --
			// ( (yInSource * SQUARES_PER_MIPMAP_EDGE) + xInSource ) * sizeof(SQUARE)
			const int bitmapOffset(yInSource_offset | (xInSource << texelsPerSquare_log2));
			
			int numTexturesToBlend = 0;

			for ( int i = 0; i < num_src_bmps; ++i )
			{
				if ( gridflags & (MATERIALSTART << i) ) // Gridflags tell us which materials are used for this square
				{// Cache Alpha maps and bitmaps.
					alphaMaps[ numTexturesToBlend ] = alpha_data[ i ];
					sourceSquareBitMaps[ numTexturesToBlend++ ] = &allSourceBitMaps[ i ][bitmapOffset];
					
					if ( numTexturesToBlend == MAXIMUM_TEXTURES )
						break; // Why? What happens if more than (4) textures should be blended?
				}
			}
					
			const U32 *bufferToLightFrom = blendbuffer;
			
			if ( numTexturesToBlend < 2 )
			{
				// don't copy the square over...just leave it and tell
				//  lighting code to use src bmp as the source instead of
				//  the blend_buffer;
				bufferToLightFrom = sourceSquareBitMaps[ 0 ];
			}
			else
			{
				int alphaOffsets[4];
				
				alphaOffsets[0] = yInTile_offset | xInTile;            // precalculate offsets for tile-coords[yInTile][xInTile]
				alphaOffsets[1] = yInTile_offset | after_xInTile;      // and so on for the square bounded by
				alphaOffsets[2] = after_yInTile_offset | xInTile;      //   [yInTile][xInTile]         [yInTile][after_xInTile]
				alphaOffsets[3] = after_yInTile_offset | after_xInTile;//   [after_yInTile][xInTile]   [after_yInTile][after_xInTile]
				
				switch( numTexturesToBlend ) // Blend 1 square of the numTexturesToBlend bit-maps into the blend buffer
				{
						case 2:
							doSquare2( blendbuffer, texelsPerSquareEdge_log2, alphaOffsets, sourceSquareBitMaps, alphaMaps  );
							break;
						case 3:
							doSquare3( blendbuffer, texelsPerSquareEdge_log2, alphaOffsets, sourceSquareBitMaps, alphaMaps  );
							break;
						default: // more subtle paranoia
							doSquare4( blendbuffer, texelsPerSquareEdge_log2, alphaOffsets, sourceSquareBitMaps, alphaMaps  );
							break;
				}
			}
				
				// [these comments are making me paranoid -- Ed.]

// copy in the lighting info
				
				// Once again we make with the linear 2D array
				const U32 xTexelInTarget(xInTarget << texelsPerSquareEdge_log2);
				const U32 yTexelInTarget(yInTarget << texelsPerSquareEdge_log2);
				const U32 yTexelInTarget_offset((yTexelInTarget << TEXELS_PER_TARGET_EDGE_LOG2));
				U16 *const bits0 = &destmips[0][ yTexelInTarget_offset + xTexelInTarget ];
				U16 *const bits1 = &destmips[1][ (yTexelInTarget_offset >> 2) + (xTexelInTarget >> 1) ];
				U16 *const bits2 = &destmips[2][ (yTexelInTarget_offset >> 4) + (xTexelInTarget >> 2) ];
				
				const U32 base_xInLightmap(xInTile << LUMELS_PER_SQUARE_EDGE_LOG2);
				const U32 base_yInLightmap(yInTile << LUMELS_PER_SQUARE_EDGE_LOG2);
				
				U32 yInLightmap_offset(base_yInLightmap << LUMELS_PER_TILE_EDGE_LOG2);
				U32 next_yInLightmap(base_yInLightmap);
				U32 yTexelInTargetSquare_offset(0);
				U32 yTexelInSquare_offset(0);
				
				for(U32 yLumelInSquare(0); yLumelInSquare < LUMELS_PER_SQUARE_EDGE; ++yLumelInSquare)
				{
					next_yInLightmap = (next_yInLightmap + 1) & LUMELS_PER_TILE_EDGE_MASK;
					const U32 next_yInLightmap_offset(next_yInLightmap << LUMELS_PER_TILE_EDGE_LOG2);
					
					U32 xInLightmap(base_xInLightmap);
					U32 xTexelInSquare_offset = 0;
					
					for(U32 xLumelInSquare(0); xLumelInSquare < LUMELS_PER_SQUARE_EDGE; ++xLumelInSquare)
					{
						const U32 next_xInLightmap((xInLightmap + 1) & LUMELS_PER_TILE_EDGE_MASK);
						U32 texelInTargetSquare_offset = yTexelInTargetSquare_offset + xTexelInSquare_offset;
						U32 texelInSquare_offset = yTexelInSquare_offset + xTexelInSquare_offset;
						
						unsigned int *loader = (unsigned int *) &vlumels;
						//lumels = (vector unsigned int) (lmap[xInLightmap | yInLightmap_offset], lmap[next_xInLightmap | yInLightmap_offset],
						//							  lmap[xInLightmap | next_yInLightmap_offset], lmap[next_xInLightmap | next_yInLightmap_offset]);
						loader[0] = lmap[xInLightmap | yInLightmap_offset];
						loader[1] = lmap[next_xInLightmap | yInLightmap_offset];
						loader[2] = lmap[xInLightmap | next_yInLightmap_offset];
						loader[3] = lmap[next_xInLightmap | next_yInLightmap_offset];
						
						// Split the LUMELs into colors
						vector unsigned int col[4];
						vector unsigned int col_const = (vector unsigned int) (0x1f << 11);
						
						col[2] = vec_and(vlumels, col_const);
						col[1] = vec_and(vec_sl(vlumels, (vector unsigned int) (5)), col_const);
						col[0] = vec_and(vec_sl(vlumels, (vector unsigned int) (10)), col_const);

						vector unsigned int vec_targetTexelsPerLumel_log2 = vec_loadAndSplatU32( &targetTexelsPerLumel_log2 );

						transpose(4, col);	// transpose the matrix since we were using rows and now we need columns
						
						// One for each color component
						vector unsigned int left_component_delta = vec_sr(vec_sub(col[2], col[0]), vec_targetTexelsPerLumel_log2);
						vector unsigned int right_component_delta = vec_sr(vec_sub(col[3], col[1]), vec_targetTexelsPerLumel_log2);
						
						vector unsigned int vscan_left_component = col[0];
						vector unsigned int vscan_right_component = col[1];
						
						// Now we interpolate the color shifts across the square
						for(U32 yTexelInLumel = 0; yTexelInLumel < targetTexelsPerLumel; ++yTexelInLumel)
						{
							vector unsigned int across_component_delta = vec_sr(vec_sub(vscan_right_component, vscan_left_component), vec_targetTexelsPerLumel_log2);
							vector unsigned int hscan_component = vscan_left_component;
							
							vscan_left_component = vec_add(vscan_left_component, left_component_delta);
							vscan_right_component = vec_add(vscan_right_component, right_component_delta);
							
							U16 *dstbits = &bits0[ texelInTargetSquare_offset ];
							const U8 *srcbits = (U8 *)&bufferToLightFrom[ texelInSquare_offset ];
							
							for(U32 xTexelInLumel = 0; xTexelInLumel < targetTexelsPerLumel; ++xTexelInLumel)
							{
								vector unsigned int cur_srcbits;
								loader = (unsigned int *) &cur_srcbits;
								loader[0] = srcbits[0];
								loader[1] = srcbits[1];
								loader[2] = srcbits[2];

								*dstbits++ = alphaCalc.Calc( hscan_component, cur_srcbits );

								srcbits += 4;
							}
							
							texelInTargetSquare_offset += yStrideThroughTarget;
							texelInSquare_offset += yStrideThroughSquare;
						}

						xTexelInSquare_offset += xStrideAcrossLumels;
						xInLightmap = next_xInLightmap;
					}
					yInLightmap_offset = next_yInLightmap_offset;
					yTexelInTargetSquare_offset += yStrideThroughTargetAcrossLumels;
					yTexelInSquare_offset += yStrideThroughSquareAcrossLumels;
				}
				// end of lighting.
		}
	}
	
	extrude( destmips, TEXELS_PER_TARGET_EDGE_LOG2 );
	PROFILE_END();
}