示例#1
0
void
CalcPixels2(double Edges[3][2], int **Pixels, int *counter)
{
    int i;
    double minX=10000000,maxX=-10000000,minY=100000000,maxY=-100000000;
    for (i=0;i<3;i++){
        Edges[i][0] = round(Edges[i][0]);
        Edges[i][1] = round(Edges[i][1]);
    }
    for (i=0;i<3;i++){
        if (Edges[i][0]<minX){
            minX = Edges[i][0];
        }
        if (Edges[i][0]>maxX){
            maxX = Edges[i][0];
        }
        if (Edges[i][1]<minY){
            minY = Edges[i][1];
        }
        if (Edges[i][1]>maxY){
            maxY = Edges[i][1];
        }
    }
    *counter = 0;
    int A01 = Edges[0][1] - Edges[1][1], B01 = Edges[1][0] - Edges[0][0];
    int A12 = Edges[1][1] - Edges[2][1], B12 = Edges[2][0] - Edges[1][0];
    int A20 = Edges[2][1] - Edges[0][1], B20 = Edges[0][0] - Edges[2][0];
    struct Point2D p = { minX, minY };
    struct Point2D v0 = { Edges[0][0], Edges[0][1]};
    struct Point2D v1 = { Edges[1][0], Edges[1][1]};
    struct Point2D v2 = { Edges[2][0], Edges[2][1]};
    int w0_row = orient2d(v1, v2, p);
    int w1_row = orient2d(v2, v0, p);
    int w2_row = orient2d(v0, v1, p);
    for (p.y = minY; p.y <= maxY; p.y++) {
        int w0 = w0_row;
        int w1 = w1_row;
        int w2 = w2_row;
        for (p.x = minX; p.x <= maxX; p.x++) {
            if (w0 >= 0 && w1 >= 0 && w2 >= 0){
                Pixels[*counter][0] = p.x;
                Pixels[*counter][1] = p.y;
                *counter+=1;
            }
            else if(len2d(v1,v2,p)<0.99){
                Pixels[*counter][0] = p.x;
                Pixels[*counter][1] = p.y;
                *counter+=1;
            }
            else if(len2d(v2,v0,p)<0.99){
                Pixels[*counter][0] = p.x;
                Pixels[*counter][1] = p.y;
                *counter+=1;
            }
            else if(len2d(v0,v1,p)<0.99){
                Pixels[*counter][0] = p.x;
                Pixels[*counter][1] = p.y;
                *counter+=1;
            }
            w0 += A12;
            w1 += A20;
            w2 += A01;
        }
        w0_row += B12;
        w1_row += B20;
        w2_row += B01;
    }
}
//! Affects an array of particles.
void CParticlePushAffector::affect(u32 now, SParticle* particlearray, u32 count)
{
	// if this is the first time the affector has been executed
	if( LastTime == 0 )
	{
		// just record the time and return as we cannot calculate a delta
		LastTime = now;
		return;
	}

	// calculate the time delta based on the amount of time that has passed between frames
	f32 timeDelta = ( now - LastTime ) / 1000.0f;

	// record the time so we can calculate the next delta
	LastTime = now;

	// if this affector is disabled we have nothing to do
	if (!Enabled)
		return;

	// itterate all of the particles
	for(u32 i=0; i<count; ++i)
	{
		/* calculate the direction of effect ( even if this is a distant effect we
		still need this to calculate the strength of the effect */
		core::vector3df direction = particlearray[i].pos - CenterOfEffect;
		f32 distance = direction.getLength() - NearestDistanceOfEffect;

		// if we are within the field of effect
		if (( distance >= 0.0f ) && ( distance < FurthestDistanceOfEffect ))
		{
			f32 strength;
			core::vector3df AppliedStrengthOfEffect = StrengthOfEffect;

			/* if this is a torus effect then its X, Z effect is modulated
			between the distant and near */
			// if there is no near distance
			if ( NearestDistanceOfEffect == 0.0f )
			{
				/* calculate the strength based on the distance from the center of the
				effect and the amount of time that has passed */
				strength = timeDelta * (1.0f - ( distance / FurthestDistanceOfEffect ));
			}
			else
			{
				/* calculate the strength based on the halfway distance between
				the near and far distance from the center of the effect and the
				amount of time that has passed */
				strength = timeDelta * (1.0f - ( fabs(distance * 2.0f - FurthestDistanceOfEffect ) / FurthestDistanceOfEffect ));
			}

			// if there is a column distance
			if ( ColumnDistanceOfEffect != 0.0f )
			{
				core::vector2df len2d( fabs( direction.X ), fabs( direction.Z ));
				strength *= ( ColumnDistanceOfEffect - len2d.getLength()) / ColumnDistanceOfEffect;
			}

			// if this is a distant effect
			if ( !DistantEffect )
			{
				// all particles are affected in the same way
				particlearray[i].pos += AppliedStrengthOfEffect * strength;
			}
			else
			{
				// particles are affected individually dependant on their relation to the center of effect
				particlearray[i].pos += direction.normalize() * AppliedStrengthOfEffect * strength;
			}
		}
	}
}