Esempio n. 1
0
/**
 * @brief Check rain particle visibility
 * @details Check the snowflake is visible and still going, wrapping if necessary.
 */
static qboolean CG_SnowParticleCheckVisible(cg_atmosphericParticle_t *particle)
{
    float  moved;
    vec2_t distance;

    if (!particle || particle->active == ACT_NOT)
    {
        return qfalse;
    }

    // units moved since last frame
    moved = (cg.time - cg_atmFx.lastRainTime) * 0.001;
    VectorMA(particle->pos, moved, particle->delta, particle->pos);

    if (particle->pos[2] < BG_GetSkyGroundHeightAtPoint(particle->pos))
    {
        return CG_SetParticleActive(particle, ACT_NOT);
    }

    distance[0] = particle->pos[0] - cg.refdef_current->vieworg[0];
    distance[1] = particle->pos[1] - cg.refdef_current->vieworg[1];

    if ((distance[0] * distance[0] + distance[1] * distance[1]) > Square(MAX_ATMOSPHERIC_DISTANCE))
    {
        // just nuke this particle, let it respawn
        return CG_SetParticleActive(particle, ACT_NOT);
    }

    return qtrue;
}
static qboolean CG_SnowParticleCheckVisible(cg_atmosphericParticle_t *particle)
{
	// Check the snowflake is visible and still going, wrapping if necessary.

	float  moved;
	vec2_t distance;
	//int msec = trap_Milliseconds();

	//n_checkvisibletime++;

	if (!particle || particle->active == ACT_NOT)
	{
//      checkvisibletime += trap_Milliseconds() - msec;
		return(qfalse);
	}

	moved = (cg.time - cg_atmFx.lastRainTime) * 0.001;    // Units moved since last frame
	VectorMA(particle->pos, moved, particle->delta, particle->pos);
	if (particle->pos[2] < BG_GetSkyGroundHeightAtPoint(particle->pos))
	{
		//checkvisibletime += trap_Milliseconds() - msec;
		return CG_SetParticleActive(particle, ACT_NOT);
	}

	distance[0] = particle->pos[0] - cg.refdef_current->vieworg[0];
	distance[1] = particle->pos[1] - cg.refdef_current->vieworg[1];
	if ((distance[0] * distance[0] + distance[1] * distance[1]) > Square(MAX_ATMOSPHERIC_DISTANCE))
	{
		// just nuke this particle, let it respawn
		return CG_SetParticleActive(particle, ACT_NOT);
	}

	//checkvisibletime += trap_Milliseconds() - msec;
	return(qtrue);
}
static qboolean CG_SnowParticleCheckVisible( cg_atmosphericParticle_t *particle )
{
	// Check the snowflake is visible and still going, wrapping if necessary.

	float moved;
	vec2_t distance;
//	int msec = trap_Milliseconds();

//	n_checkvisibletime++;

	if( !particle || particle->active == ACT_NOT ) {
//		checkvisibletime += trap_Milliseconds() - msec;
		return( qfalse );
	}

	moved = (cg.time - cg_atmFx.lastRainTime) * 0.001;	// Units moved since last frame
	VectorMA( particle->pos, moved, particle->delta, particle->pos );
	if( particle->pos[2] < BG_GetSkyGroundHeightAtPoint( particle->pos ) ) {
//		checkvisibletime += trap_Milliseconds() - msec;
		return CG_SetParticleActive( particle, ACT_NOT );
	}

	distance[0] = particle->pos[0] - cg.refdef_current->vieworg[0];
	distance[1] = particle->pos[1] - cg.refdef_current->vieworg[1];
 	if( (distance[0] * distance[0] + distance[1] * distance[1]) > Square( MAX_ATMOSPHERIC_DISTANCE ) )
 	{
		// ydnar: just nuke this particle, let it respawn
		return CG_SetParticleActive( particle, ACT_NOT );
		
		/*
		// Attempt to respot the particle at our other side
		particle->pos[0] -= 1.85f * distance[0];
		particle->pos[1] -= 1.85f * distance[1];

		// ydnar: place particle in random position between ground and sky
		groundHeight = BG_GetSkyGroundHeightAtPoint( particle->pos );
		skyHeight = BG_GetSkyHeightAtPoint( particle->pos );
		if( skyHeight == MAX_ATMOSPHERIC_HEIGHT )
			return CG_SetParticleActive( particle, ACT_NOT );
		particle->pos[ 2 ] = groundHeight + random() * (skyHeight - groundHeight);
		
		// ydnar: valid spot?
		if( particle->pos[ 2 ] <= groundHeight || particle->pos[ 2 ] >= skyHeight )
			return CG_SetParticleActive( particle, ACT_NOT );
		*/
	}

//	checkvisibletime += trap_Milliseconds() - msec;
	return( qtrue );
}
static qboolean CG_RainParticleCheckVisible( cg_atmosphericParticle_t *particle )
{
	// Check the raindrop is visible and still going, wrapping if necessary.

	float moved;
	vec2_t distance;
//	int msec = trap_Milliseconds();

	if( !particle || particle->active == ACT_NOT ) {
//		checkvisibletime += trap_Milliseconds() - msec;
		return( qfalse );
	}

	moved = (cg.time - cg_atmFx.lastRainTime) * 0.001;	// Units moved since last frame
	VectorMA( particle->pos, moved, particle->delta, particle->pos );
 	if( particle->pos[2] + particle->height < BG_GetSkyGroundHeightAtPoint( particle->pos ) ) {
//		checkvisibletime += trap_Milliseconds() - msec;
		return CG_SetParticleActive( particle, ACT_NOT );
	}

	distance[0] = particle->pos[0] - cg.refdef_current->vieworg[0];
	distance[1] = particle->pos[1] - cg.refdef_current->vieworg[1];
 	if( (distance[0] * distance[0] + distance[1] * distance[1]) > Square( MAX_ATMOSPHERIC_DISTANCE ) )
 	{
		// ydnar: just nuke this particle, let it respawn
		return CG_SetParticleActive( particle, ACT_NOT );
		
		/*
		// Attempt to respot the particle at our other side
		particle->pos[0] -= 1.85f * distance[0];
		particle->pos[1] -= 1.85f * distance[1];

		// Valid spot?
		pointHeight = BG_GetSkyHeightAtPoint( particle->pos );
		if( pointHeight == MAX_ATMOSPHERIC_HEIGHT ) {
//			checkvisibletime += trap_Milliseconds() - msec;
			return CG_SetParticleActive( particle, ACT_NOT );
		}

		pointHeight = BG_GetSkyGroundHeightAtPoint( particle->pos );
		if( pointHeight == MAX_ATMOSPHERIC_HEIGHT || pointHeight >= particle->pos[2] ) {
//			checkvisibletime += trap_Milliseconds() - msec;
			return CG_SetParticleActive( particle, ACT_NOT );
		}
		*/
	}

//	checkvisibletime += trap_Milliseconds() - msec;
	return( qtrue );
}
Esempio n. 5
0
/**
 * @brief Generate rain particle
 * @details Attempt to 'spot' a raindrop somewhere below a sky texture.
 */
static qboolean CG_RainParticleGenerate(cg_atmosphericParticle_t *particle, vec3_t currvec, float currweight)
{
    float angle = random() * 2 * M_PI, distance = 20 + MAX_ATMOSPHERIC_DISTANCE * random();
    float groundHeight, skyHeight;

    particle->pos[0] = cg.refdef_current->vieworg[0] + sin(angle) * distance;
    particle->pos[1] = cg.refdef_current->vieworg[1] + cos(angle) * distance;

    // choose a spawn point randomly between sky and ground
    skyHeight = BG_GetSkyHeightAtPoint(particle->pos);
    if (skyHeight >= MAX_ATMOSPHERIC_HEIGHT)
    {
        return qfalse;
    }
    groundHeight = BG_GetSkyGroundHeightAtPoint(particle->pos);
    if (groundHeight + particle->height + ATMOSPHERIC_PARTICLE_OFFSET >= skyHeight)
    {
        return qfalse;
    }
    particle->pos[2] = groundHeight + random() * (skyHeight - groundHeight);

    // make sure it doesn't fall from too far cause it then will go over our heads ('lower the ceiling')
    if (cg_atmFx.baseHeightOffset > 0)
    {
        if (particle->pos[2] - cg.refdef_current->vieworg[2] > cg_atmFx.baseHeightOffset)
        {
            particle->pos[2] = cg.refdef_current->vieworg[2] + cg_atmFx.baseHeightOffset;

            if (particle->pos[2] < groundHeight)
            {
                return qfalse;
            }
        }
    }

    // rain goes in bursts - allow max raindrops every 10 seconds
    if (cg_atmFx.oldDropsActive > (0.50 * cg_atmFx.numDrops + 0.001 * cg_atmFx.numDrops * (10000 - (cg.time % 10000))))
    {
        return qfalse;
    }

    CG_SetParticleActive(particle, ACT_FALLING);
    particle->colour[0] = 0.6 + 0.2 * random() * 0xFF;
    particle->colour[1] = 0.6 + 0.2 * random() * 0xFF;
    particle->colour[2] = 0.6 + 0.2 * random() * 0xFF;
    VectorCopy(currvec, particle->delta);
    particle->delta[2] += crandom() * 100;
    VectorCopy(particle->delta, particle->deltaNormalized);
    VectorNormalizeFast(particle->deltaNormalized);
    particle->height       = ATMOSPHERIC_RAIN_HEIGHT + crandom() * 100;
    particle->weight       = currweight;
    particle->effectshader = &cg_atmFx.effectshaders[0];
    //particle->effectshader = &cg_atmFx.effectshaders[ (int) (random() * ( cg_atmFx.numEffectShaders - 1 )) ];

    return qtrue;
}
Esempio n. 6
0
static qboolean CG_SnowParticleGenerate( cg_atmosphericParticle_t *particle, vec3_t currvec, float currweight ) {
	// Attempt to 'spot' a snowflake somewhere below a sky texture.

	float angle, distance;
	float groundHeight, skyHeight;
//	int msec = trap_Milliseconds();

//	n_generatetime++;

	angle = random() * 2 * M_PI;
	distance = 20 + MAX_ATMOSPHERIC_DISTANCE * random();

	particle->pos[0] = cg.refdef.vieworg[0] + sin( angle ) * distance;
	particle->pos[1] = cg.refdef.vieworg[1] + cos( angle ) * distance;

	// ydnar: choose a spawn point randomly between sky and ground
	skyHeight = BG_GetSkyHeightAtPoint( particle->pos );
	if ( skyHeight == MAX_ATMOSPHERIC_HEIGHT ) {
		return qfalse;
	}
	groundHeight = BG_GetSkyGroundHeightAtPoint( particle->pos );
	if ( groundHeight >= skyHeight ) {
		return qfalse;
	}
	particle->pos[2] = groundHeight + random() * ( skyHeight - groundHeight );

	// make sure it doesn't fall from too far cause it then will go over our heads ('lower the ceiling')
	if ( cg_atmFx.baseHeightOffset > 0 ) {
		if ( particle->pos[2] - cg.refdef.vieworg[2] > cg_atmFx.baseHeightOffset ) {
			particle->pos[2] = cg.refdef.vieworg[2] + cg_atmFx.baseHeightOffset;
			if ( particle->pos[2] < groundHeight ) {
				return qfalse;
			}
		}
	}

	CG_SetParticleActive( particle, ACT_FALLING );
	VectorCopy( currvec, particle->delta );
	particle->delta[2] += crandom() * 25;
	VectorCopy( particle->delta, particle->deltaNormalized );
	VectorNormalizeFast( particle->deltaNormalized );
	particle->height = ATMOSPHERIC_SNOW_HEIGHT + random() * 2;
	particle->weight = particle->height * 0.5f;

	if (cg_atmFx.numEffectShaders > 1) {
		particle->effectshader = &cg_atmFx.effectshaders[ rand()%cg_atmFx.numEffectShaders ];
	} else {
		particle->effectshader = &cg_atmFx.effectshaders[0];
	}

//	generatetime += trap_Milliseconds() - msec;
	return( qtrue );
}
Esempio n. 7
0
/**
 * @brief Generate a snowflake
 * @details Attempt to 'spot' a snowflake somewhere below a sky texture.
 */
static qboolean CG_SnowParticleGenerate(cg_atmosphericParticle_t *particle, vec3_t currvec, float currweight)
{
    float angle = random() * 2 * M_PI, distance = 20 + MAX_ATMOSPHERIC_DISTANCE * random();
    float groundHeight, skyHeight;

    particle->pos[0] = cg.refdef_current->vieworg[0] + sin(angle) * distance;
    particle->pos[1] = cg.refdef_current->vieworg[1] + cos(angle) * distance;

    // choose a spawn point randomly between sky and ground
    skyHeight = BG_GetSkyHeightAtPoint(particle->pos);

    if (skyHeight >= MAX_ATMOSPHERIC_HEIGHT)
    {
        return qfalse;
    }

    groundHeight = BG_GetSkyGroundHeightAtPoint(particle->pos);

    if (groundHeight + particle->height + ATMOSPHERIC_PARTICLE_OFFSET >= skyHeight)
    {
        return qfalse;
    }

    particle->pos[2] = groundHeight + random() * (skyHeight - groundHeight);

    // make sure it doesn't fall from too far cause it then will go over our heads ('lower the ceiling')
    if (cg_atmFx.baseHeightOffset > 0)
    {
        if (particle->pos[2] - cg.refdef_current->vieworg[2] > cg_atmFx.baseHeightOffset)
        {
            particle->pos[2] = cg.refdef_current->vieworg[2] + cg_atmFx.baseHeightOffset;
            if (particle->pos[2] < groundHeight)
            {
                return qfalse;
            }
        }
    }

    CG_SetParticleActive(particle, ACT_FALLING);

    VectorCopy(currvec, particle->delta);
    particle->delta[2] += crandom() * 25;

    VectorCopy(particle->delta, particle->deltaNormalized);
    VectorNormalizeFast(particle->deltaNormalized);
    particle->height       = ATMOSPHERIC_SNOW_HEIGHT + random() * 2;
    particle->weight       = particle->height * 0.5f;
    particle->effectshader = &cg_atmFx.effectshaders[0];
    //particle->effectshader = &cg_atmFx.effectshaders[ (int) (random() * ( cg_atmFx.numEffectShaders - 1 )) ];

    return qtrue;
}
static qboolean CG_RainParticleGenerate( cg_atmosphericParticle_t *particle, vec3_t currvec, float currweight )
{
	// Attempt to 'spot' a raindrop somewhere below a sky texture.

	float angle, distance;
	float groundHeight, skyHeight;
//	int msec = trap_Milliseconds();

//	n_generatetime++;
	
	angle = random() * 2*M_PI;
	distance = 20 + MAX_ATMOSPHERIC_DISTANCE * random();

	particle->pos[0] = cg.refdef_current->vieworg[0] + sin(angle) * distance;
	particle->pos[1] = cg.refdef_current->vieworg[1] + cos(angle) * distance;
	
	// ydnar: choose a spawn point randomly between sky and ground
	skyHeight = BG_GetSkyHeightAtPoint( particle->pos );
	if( skyHeight == MAX_ATMOSPHERIC_HEIGHT )
		return qfalse;
	groundHeight = BG_GetSkyGroundHeightAtPoint( particle->pos );
	if( groundHeight >= skyHeight )
		return qfalse;
	particle->pos[2] = groundHeight + random() * (skyHeight - groundHeight);

	// make sure it doesn't fall from too far cause it then will go over our heads ('lower the ceiling')
	if( cg_atmFx.baseHeightOffset > 0 ) {
		if( particle->pos[2] - cg.refdef_current->vieworg[2] > cg_atmFx.baseHeightOffset ) {
			particle->pos[2] = cg.refdef_current->vieworg[2] + cg_atmFx.baseHeightOffset;

			if( particle->pos[2] < groundHeight ) {
				return qfalse;
			}
		}
	}
	
	// ydnar: rain goes in bursts
	{
		float		maxActiveDrops;
		
		// every 10 seconds allow max raindrops
		maxActiveDrops = 0.50 * cg_atmFx.numDrops + 0.001 * cg_atmFx.numDrops * (10000 - (cg.time % 10000));
		if( cg_atmFx.oldDropsActive > maxActiveDrops )
			return qfalse;
	}
	
	CG_SetParticleActive( particle, ACT_FALLING );
	particle->colour[0] = 0.6 + 0.2 * random() * 0xFF;
	particle->colour[1] = 0.6 + 0.2 * random() * 0xFF;
	particle->colour[2] = 0.6 + 0.2 * random() * 0xFF;
	VectorCopy( currvec, particle->delta );
	particle->delta[2] += crandom() * 100;
	VectorCopy( particle->delta, particle->deltaNormalized );
	VectorNormalizeFast( particle->deltaNormalized );
	particle->height = ATMOSPHERIC_RAIN_HEIGHT + crandom() * 100;
	particle->weight = currweight;
	particle->effectshader = &cg_atmFx.effectshaders[0];
//	particle->effectshader = &cg_atmFx.effectshaders[ (int) (random() * ( cg_atmFx.numEffectShaders - 1 )) ];

//	generatetime += trap_Milliseconds() - msec;
	return( qtrue );
}