/**
Draws a VerticalGradient onto a CFbsBitmap from top/color aLo to bottom/aHi
*/
void CTe_graphicsperformanceSuiteStepBase::VerticalGradientAlphaL(CFbsBitmap* aBitmap, TRgb aLo, TRgb aHi)
	{
	const TSize size = aBitmap->SizeInPixels();
	const TDisplayMode mode = aBitmap->DisplayMode();
	const TInt scanLineLength = CFbsBitmap::ScanLineLength(size.iWidth, mode);
	HBufC8* buffer = HBufC8::NewL(scanLineLength);
	CleanupStack::PushL(buffer);
	TPtr8 des = buffer->Des();
	des.SetLength(scanLineLength);
	for(TInt i=0; i<size.iHeight; i++)
		{
		TRgb color = InterpolateColour(aLo, aHi, i, size.iHeight);
		switch(mode)
			{
			case EGray256:
				{
				TUint8  g = color.Gray256();
				TUint8* p = (TUint8*)des.Ptr();
				for(TInt j=0; j<size.iWidth; j++)
					{						
					p[j] = g;
					}
				}
				break;
			case EColor64K:
				{
				TUint16  g = color._Color64K();
				TUint16* p = (TUint16*)des.Ptr();
				for(TInt j=0; j<size.iWidth/2; j++)
					{						
					p[j] = g;
					}
				}
				break;
			case EColor16MU:
				{
				TUint32 rgba = color._Color16MU();
				TUint32* p = (TUint32*)des.Ptr();
				for(TInt j=0; j<(size.iWidth/4); j++)
					{						
					p[j] = rgba;
					}
				}
				break;
			case EColor16MA:
				{
				TUint32 rgba = color._Color16MA();
				TUint32* p = (TUint32*)des.Ptr();
				for(TInt j=0; j<(size.iWidth/4); j++)
					{						
					p[j] = rgba;
					}
				}
				break;
			case EColor16MAP:
				{
				TUint32 rgba = color._Color16MAP();
				TUint32* p = (TUint32*)des.Ptr();
				for(TInt j=0; j<(size.iWidth/4); j++)
					{						
					p[j] = rgba;
					}
				}
				break;
			default:
				ASSERT(EFalse);
				break;
			}
		aBitmap->SetScanLine(des, i);
		}
	CleanupStack::PopAndDestroy(buffer);
	}
Esempio n. 2
0
//-----------------------------------------------------------------------
void MapSplatter::BuildPoint(ColourValue& out, int x, int z, Real& alpha1, 
                           Real& alpha2, Real& alpha3, Real& alpha4)
{
    // Init the colour
    
    alpha1 = 0.0f;
    alpha2 = 0.0f;
    alpha3 = 0.0f;
    alpha4 = 0.0f;


#define SNOW  0
#define SAND  1
#define GRASS 2
#define ROCK  3
    // Ask for the current height value and the 8 surrounding values
    Real height[9];
    if ( x == 0 )
    {
        x = 1;
    }
    else if (x == int (mWidth))
    {
        x = mWidth - 1;
    }
    if ( z == 0 )
    {
        z = 1;
    }
    else if (z == int (mHeight))
    {
        z = mHeight - 1;
    }
//    /*
//            h1
//      h0*---*---*h2
//        |0 /|2 /|
//        | / | / |
//        |/ 1|/ 3|
//      h3*---h4--*h5
//        |7 /|4 /|
//        | / | / |
//        |/ 6|/ 5|
//      h6*---*--*h8
//            h7
//            */  
    height[0] = MapUtil::getSingleton().getHeight( x - 1, z - 1 );		// Top-Left
    height[1] = MapUtil::getSingleton().getHeight( x, z - 1 );			// Top-Center
    height[2] = MapUtil::getSingleton().getHeight( x + 1, z - 1 );		// Top-Right
    height[3] = MapUtil::getSingleton().getHeight( x - 1, z );			// Left
    height[4] = MapUtil::getSingleton().getHeight( x, z );				// Current Point
    height[5] = MapUtil::getSingleton().getHeight( x + 1, z );			// Right
    height[6] = MapUtil::getSingleton().getHeight( x - 1, z + 1 );		// Bottom-Left
    height[7] = MapUtil::getSingleton().getHeight( x, z + 1 );			// Bottom-Center
    height[8] = MapUtil::getSingleton().getHeight( x + 1, z + 1 );		// Bottom-Right
   
    // Weight( pt1 , pt2 ) = 1 - DistanceSquared(pt1,pt2) / (1.75)^2
    
    //The sloppy test
    
	Real sloppy[8];
    const Real dx = MapUtil::getSingleton().scale.x;
	const Real dz = MapUtil::getSingleton().scale.z;
    const Real inv_dxdz = 1.0 / (dx+dz);
    const Real inv_dx = 1.0 / dx;
    const Real inv_dz = 1.0 / dz;

	sloppy[0] = Math::Abs ( height[0] - height[4] ) * inv_dxdz;
	sloppy[1] = Math::Abs ( height[1] - height[4] ) * inv_dz;
	sloppy[2] = Math::Abs ( height[2] - height[4] ) * inv_dxdz;
	sloppy[3] = Math::Abs ( height[3] - height[4] ) * inv_dx;
	sloppy[4] = Math::Abs ( height[5] - height[4] ) * inv_dx;
	sloppy[5] = Math::Abs ( height[6] - height[4] ) * inv_dxdz;
	sloppy[6] = Math::Abs ( height[7] - height[4] ) * inv_dz;
	sloppy[7] = Math::Abs ( height[8] - height[4] ) * inv_dxdz;
    
    out = ColourValue(0.0f, 0.0f, 0.0f, 0.0f);
    for ( uint i = 0; i < 7; i++ )
    {    
        if ( height[i] < matHeight[0] )
         {
            if ( sloppy[i] < 0.2f )
            {
                // grass-grass
                InterpolateColour( out, 1.0f, GRASS, GRASS );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 1.0f, GRASS, GRASS );
            }
            if ( sloppy[i] >= 0.15f && sloppy[i] < 0.4f )
            {
                // sand-grass
                InterpolateColour( out, 0.25f, SAND, GRASS );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.25f, SAND, GRASS );
            }
            if ( sloppy[i] >= 0.3f && sloppy[i] < 0.65f )
            {
                // sand-sand
                InterpolateColour( out, 1.0f, SAND, SAND );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 1.0f, SAND, SAND );
            }
            if ( sloppy[i] >= 0.55f && sloppy[i] < 0.75f )
            {
                // sand-rock
                InterpolateColour( out, 0.75f, SAND, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.75f, SAND, ROCK );
            }
            if ( sloppy[i] >= 0.70 )
            {
                // rock-rock
                InterpolateColour( out, 1.0, ROCK, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 1.0f, ROCK, ROCK );
            }
        }
        else if ( height[i] < matHeight[1] )
        {
            if ( sloppy[i] < 0.15 )
            {
                // grass-snow
                InterpolateColour( out, 0.25f, GRASS, SNOW );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.25f, GRASS, SNOW );
            }
            if ( sloppy[i] >= 0.10 && sloppy[i] < 0.45 )
            {
                // snow-sand
                InterpolateColour( out, 0.65f, SNOW, SAND );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.65f, SNOW, SAND );
            }
            if ( sloppy[i] >= 0.25f && sloppy[i] < 0.65f )
            {
                // snow-rock
                InterpolateColour( out, 0.5, SNOW, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.5f, SNOW, ROCK );
            }
            if ( sloppy[i] >= 0.50f && sloppy[i] < 0.75f )
            {
                // snow-rock
                InterpolateColour( out, 0.75f, SNOW, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.75f, SNOW, ROCK );
            }
            if ( sloppy[i] >= 0.70 )
             {
                // rock-rock
                InterpolateColour( out, 1.0f, ROCK, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 1.0f, ROCK, ROCK );
            }
        }
        else
        {
            if ( sloppy[i] < 0.15f )
            {
                // snow-snow
                InterpolateColour( out, 1.0f, SNOW, SNOW );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 1.0f, 0, 0 );
            }
            if ( sloppy[i] >= 0.1f && sloppy[i] < 0.45f )
            {
                // snow-sand
                InterpolateColour( out, 0.35f, SNOW, SAND );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.35f, 0, 1 );
            }
            if ( sloppy[i] >= 0.25f && sloppy[i] < 0.65f )
            {
                // snow-rock
                InterpolateColour( out, 0.5f, SNOW, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.5f, 0, 3 );
            }
            if ( sloppy[i] >= 0.5f && sloppy[i] < 0.75f )
            {
                // snow-rock
                InterpolateColour( out, 0.75f, SNOW, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 0.75f, 0, 3 );
            }
            if ( sloppy[i] >= 0.7f )
            {
                // rock-rock
                InterpolateColour( out, 1.0f, ROCK, ROCK );
                InterpolateAlpha( alpha1, alpha2, alpha3, alpha4, 1.0f, 3, 3 );
            }
        }
     }
 }