コード例 #1
0
/*
================
DialogAFConstraintHinge::SaveConstraint
================
*/
void DialogAFConstraintHinge::SaveConstraint( void ) {
	int s1, s2;
	CString str;

	if ( !file || !constraint ) {
		return;
	}
	UpdateData( TRUE );

	// save anchor to the current idDeclAF_Constraint
	GetSafeComboBoxSelection( &m_comboAnchorJoint, str, -1 );
	constraint->anchor.joint1 = str;
	constraint->anchor.ToVec3().x = m_anchor_x;
	constraint->anchor.ToVec3().y = m_anchor_y;
	constraint->anchor.ToVec3().z = m_anchor_z;

	// hinge axis
	if ( constraint->axis.type == idAFVector::VEC_BONEDIR ) {
		s1 = GetSafeComboBoxSelection( &m_comboAxisJoint1, str, -1 );
		constraint->axis.joint1 = str;
		s2 = GetSafeComboBoxSelection( &m_comboAxisJoint2, str, s1 );
		constraint->axis.joint2 = str;
	}
	else {
		constraint->axis.ToVec3() = idAngles( m_axisPitch, m_axisYaw, 0.0f ).ToForward();
	}

	// hinge limit
	constraint->limitAngles[0] = m_limitAngle1;
	constraint->limitAngles[1] = m_limitAngle2;
	constraint->limitAngles[2] = m_limitAngle3;

	AFDialogSetFileModified();
}
コード例 #2
0
/*
============
idAASBuild::AddBrushesForMapEntity
============
*/
idBrushList idAASBuild::AddBrushesForMapEntity( const idMapEntity *mapEnt, int entityNum, idBrushList brushList ) {
	int i;
	idVec3 origin;
	idMat3 axis;
	if( mapEnt->GetNumPrimitives() < 1 ) {
		return brushList;
	}
	mapEnt->epairs.GetVector( "origin", "0 0 0", origin );
	if( !mapEnt->epairs.GetMatrix( "rotation", "1 0 0 0 1 0 0 0 1", axis ) ) {
		float angle = mapEnt->epairs.GetFloat( "angle" );
		if( angle != 0.0f ) {
			axis = idAngles( 0.0f, angle, 0.0f ).ToMat3();
		} else {
			axis.Identity();
		}
	}
	for( i = 0; i < mapEnt->GetNumPrimitives(); i++ ) {
		idMapPrimitive	*mapPrim;
		mapPrim = mapEnt->GetPrimitive( i );
		if( mapPrim->GetType() == idMapPrimitive::TYPE_BRUSH ) {
			brushList = AddBrushesForMapBrush( static_cast<idMapBrush *>( mapPrim ), origin, axis, entityNum, i, brushList );
			continue;
		}
		if( mapPrim->GetType() == idMapPrimitive::TYPE_PATCH ) {
			if( aasSettings->usePatches ) {
				brushList = AddBrushesForMapPatch( static_cast<idMapPatch *>( mapPrim ), origin, axis, entityNum, i, brushList );
			}
			continue;
		}
	}
	return brushList;
}
コード例 #3
0
ファイル: Vector.cpp プロジェクト: blaquee/QLBot
/*
=============
idVec3::ToAngles
=============
*/
idAngles idVec3::ToAngles( void ) const {
	float forward;
	float yaw;
	float pitch;
	
	if ( ( x == 0.0f ) && ( y == 0.0f ) ) {
		yaw = 0.0f;
		if ( z > 0.0f ) {
			pitch = 90.0f;
		} else {
			pitch = 270.0f;
		}
	} else {
		yaw = RAD2DEG( idMath::ATan( y, x ) );
		if ( yaw < 0.0f ) {
			yaw += 360.0f;
		}

		forward = ( float )idMath::Sqrt( x * x + y * y );
		pitch = RAD2DEG( idMath::ATan( z, forward ) );
		if ( pitch < 0.0f ) {
			pitch += 360.0f;
		}
	}

	return idAngles( -pitch, yaw, 0.0f );
}
コード例 #4
0
ファイル: EndLevel.cpp プロジェクト: Justasic/DOOM-3
/*
================
idTarget_EndLevel::Draw
================
*/
void idTarget_EndLevel::Draw() {

	if (noGui) {
		return;
	}

	renderView_t			renderView;

	memset( &renderView, 0, sizeof( renderView ) );

	renderView.width = SCREEN_WIDTH;
	renderView.height = SCREEN_HEIGHT;
	renderView.x = 0;
	renderView.y = 0;

	renderView.fov_x = 90;
	renderView.fov_y = gameLocal.CalcFovY( renderView.fov_x );
	renderView.time = gameLocal.time;

#if 0
	renderView.vieworg = initialViewOrg;
	renderView.viewaxis = idAngles(initialViewAngles).toMat3();
#else
	renderView.vieworg = renderEntity.origin;
	renderView.viewaxis = renderEntity.axis;
#endif

	gameRenderWorld->RenderScene( &renderView );

	// draw the gui on top of the 3D view
	gui->Redraw(gameLocal.time);
}
コード例 #5
0
ファイル: DialogSound.cpp プロジェクト: janisl/doom3.gpl
void CDialogSound::OnBtnDrop()
{
	idStr		classname;
	idStr		key;
	idStr		value;
	idVec3		org;
	idDict		args;
	idAngles	viewAngles;


	gameEdit->PlayerGetViewAngles( viewAngles );
	gameEdit->PlayerGetEyePosition( org );
	org += idAngles( 0, viewAngles.yaw, 0 ).ToForward() * 80 + idVec3( 0, 0, 1 );
	args.Set("origin", org.ToString());
	args.Set("classname", "speaker");
	args.Set("angle", va( "%f", viewAngles.yaw + 180 ));
	args.Set("s_shader", strShader);
	args.Set("s_looping", "1" );
	args.Set("s_shakes", "0" );


	idStr name = gameEdit->GetUniqueEntityName( "speaker" );
	bool nameValid = false;
	while (!nameValid) {
		DialogName dlg("Name Speaker", this);
		dlg.m_strName = name;
		if (dlg.DoModal() == IDOK) {
			idEntity *gameEnt = gameEdit->FindEntity(dlg.m_strName);
			if (gameEnt) {
				if (MessageBox("Please choose another name", "Duplicate Entity Name!", MB_OKCANCEL) == IDCANCEL) {
					return;
				}
			} else {
				nameValid = true;
				name = dlg.m_strName;
			}
		}
	}

	args.Set("name", name.c_str());

	idEntity *ent = NULL;
	gameEdit->SpawnEntityDef( args, &ent );
	if (ent) {
		gameEdit->EntityUpdateChangeableSpawnArgs( ent, NULL );
		gameEdit->ClearEntitySelection();
		gameEdit->AddSelectedEntity( ent );
	}

	gameEdit->MapAddEntity( &args );
	const idDict *dict = gameEdit->MapGetEntityDict( args.GetString( "name" ) );
	Set( dict );
	AddGroups();
	AddSpeakers();
}
コード例 #6
0
ファイル: Aimbot.cpp プロジェクト: blaquee/QLBot
idAngles Aimbot::Main( float fov, float ping, bool humanize, float smoothMultiplier, float smoothTransposition )
{
#define FRAME_TIME_SECONDS 0.008f
		Ping = ping;
	FOV = fov;
	_Muzzle = ImportExport::User->EyePosition() + ImportExport::User->ViewAngles().ToMat3()[0]*14.0f + EvaluatePath(idVec3(0,0,0), 
		ImportExport::User->Velocity(), FRAME_TIME_SECONDS);
	if ( ScanForTarget() )
	{
		idAngles angles = AimAt( TargetOrigin() );
		return humanize ? Humanize( smoothMultiplier, smoothTransposition, angles ) : angles;
	}
	return idAngles(0, 0, 0);
}
コード例 #7
0
/*
================
DialogAFConstraintBallAndSocket::SaveConstraint
================
*/
void DialogAFConstraintBallAndSocket::SaveConstraint( void ) {
	int s1, s2;
	CString str;
	idAngles angles;

	if ( !file || !constraint ) {
		return;
	}
	UpdateData( TRUE );

	// anchor
	GetSafeComboBoxSelection( &m_comboAnchorJoint, str, -1 );
	constraint->anchor.joint1 = str;
	constraint->anchor.ToVec3().x = m_anchor_x;
	constraint->anchor.ToVec3().y = m_anchor_y;
	constraint->anchor.ToVec3().z = m_anchor_z;

	// limit
	if ( constraint->limit == idDeclAF_Constraint::LIMIT_CONE ) {
		constraint->limitAngles[0] = m_coneAngle;
	}
	else {
		constraint->limitAngles[0] = m_pyramidAngle1;
	}
	constraint->limitAngles[1] = m_pyramidAngle2;
	constraint->limitAngles[2] = m_limitRoll;
	angles.pitch = m_limitPitch;
	angles.yaw = m_limitYaw;
	angles.roll = 0.0f;
	constraint->limitAxis.ToVec3() = angles.ToForward();
	s1 = GetSafeComboBoxSelection( &m_comboLimitJoint1, str, -1 );
	constraint->limitAxis.joint1 = str;
	s2 = GetSafeComboBoxSelection( &m_comboLimitJoint2, str, s1 );
	constraint->limitAxis.joint2 = str;

	// limit axis
	if ( constraint->shaft[0].type == idAFVector::VEC_BONEDIR ) {
		s1 = GetSafeComboBoxSelection( &m_comboLimitAxisJoint1, str, -1 );
		constraint->shaft[0].joint1 = str;
		s2 = GetSafeComboBoxSelection( &m_comboLimitAxisJoint2, str, s1 );
		constraint->shaft[0].joint2 = str;
	}
	else {
		constraint->shaft[0].ToVec3() = idAngles( m_limitAxisPitch, m_limitAxisYaw, 0.0f ).ToForward();
	}

	AFDialogSetFileModified();
}
コード例 #8
0
void idRenderWindow::Render( int time ) {
	rLight.origin = lightOrigin.ToVec3();
	rLight.shaderParms[SHADERPARM_RED] = lightColor.x();
	rLight.shaderParms[SHADERPARM_GREEN] = lightColor.y();
	rLight.shaderParms[SHADERPARM_BLUE] = lightColor.z();
	world->UpdateLightDef(lightDef, &rLight);
	if ( worldEntity.hModel ) {
		if (updateAnimation) {
			BuildAnimation(time);
		}
		if (modelAnim) {
			if (time > animEndTime) {
				animEndTime = time + animLength;
			}
			gameEdit->ANIM_CreateAnimFrame(worldEntity.hModel, modelAnim, worldEntity.numJoints, worldEntity.joints, animLength - (animEndTime - time), vec3_origin, false );
		}
		worldEntity.axis = idAngles(modelRotate.x(), modelRotate.y(), modelRotate.z()).ToMat3();
		world->UpdateEntityDef(modelDef, &worldEntity);
	}
}
コード例 #9
0
ファイル: Leaf.cpp プロジェクト: revelator/Revelation-Engine
END_CLASS

void idEntity_Leaf::Spawn() {
	liveTime		= spawnArgs.GetFloat( "leaf_liveTime" );	// in seconds. Keep this low to prevent too many leaves in the map at a time. each leaf is an entity! Try to make each leaf live at least until it touches the ground. Some leaves will slide along the ground if they live long enough. default: 8
	moveSpeed		= spawnArgs.GetFloat( "leaf_moveSpeed" );	// from 1-10. How fast the leaves move regardless of wind. Keep this high. default: 10
	spread			= spawnArgs.GetFloat( "leaf_spread" );	// from 1-10. Affects how far apart leafs speread apart when falling. default: 10
	windPower		= spawnArgs.GetFloat( "leaf_windPower" );	// from 1-10. How strong the wind is on the leaves. default: 1
	windDir			= spawnArgs.GetVector( "leaf_windDir" );	// Wind direction. default: '0 1 0'
	gravity			= spawnArgs.GetVector( "leaf_gravity" );	// Gravity of the leaf. Keep this pretty low, or accept the default. default: '0 0 -20'
	origin			= spawnArgs.GetVector( "leaf_origin" );
	ang				= GetAngles();
	dieTime			= gameLocal.time + liveTime * 1000;
	if( moveSpeed == 0 ) {
		moveSpeed = 1;
	}
	if( origin != idVec3( 0, 0, 0 ) ) {
		SetOrigin( origin );
	}
	spread = spread / 20; //max spread is 0.5
	dir = gameLocal.random.RandomInt( 3 );
	if( dir < 1 ) {
		spreadX = spread;
	} else if( dir < 2 && dir > 1 ) {
		spreadX = 0;
	} else {
		spreadX = -spread;
	}
	dir = gameLocal.random.RandomInt( 3 );
	if( dir < 1 ) {
		spreadY = spread;
	} else if( dir < 2 && dir > 1 ) {
		spreadY = 0;
	} else {
		spreadY = -spread;
	}
	SetAngles( idAngles( gameLocal.random.CRandomFloat() * 360, gameLocal.random.CRandomFloat() * 360, gameLocal.random.CRandomFloat() * 360 ) );
	GetPhysics()->SetLinearVelocity( idVec3( 0, 0, 0 ) );
	GetPhysics()->SetGravity( idVec3( 0, 0, 0 ) ); //gravity - if we set zero gravity, the leaves stop when they hit the ground. dont know why, but it's cool!
	curVel = GetPhysics()->GetLinearVelocity();
	nextAngles = 0;
}
コード例 #10
0
/*
============
idAASLocal::ShowFloorTrace
============
*/
void idAASLocal::ShowFloorTrace( const idVec3 &origin ) const {
	idPlayer *player;

	player = gameLocal.GetLocalPlayer();
	if ( !player ) {
		return;
	}
	idMat3 playerAxis = idAngles( 0.0f, player->GetViewAngles().yaw, 0.0f ).ToMat3();

	idVec3 org = origin;
	int areaNum = PointReachableAreaNum( org, DefaultSearchBounds(), AAS_AREA_REACHABLE_WALK, TravelFlagInvalidForTeam() );
	PushPointIntoArea( areaNum, org );

	aasTraceFloor_t trace;
	TraceFloor( trace, org, areaNum, origin + playerAxis[0] * 1024, TFL_WALK|TFL_AIR );

	gameRenderWorld->DebugArrow( colorCyan, org, trace.endpos, 1, 0 );
	idVec3 up = trace.endpos + playerAxis[2] * 64;
	const idVec4 &color = ( trace.fraction >= 1.0f ) ? colorGreen : colorRed;
	gameRenderWorld->DebugArrow( color, trace.endpos, up + playerAxis[1] * 32, 1, 0, true );
	gameRenderWorld->DebugArrow( color, trace.endpos, up - playerAxis[1] * 32, 1, 0, true );
}
コード例 #11
0
/*
================
DialogAFConstraintSlider::SaveConstraint
================
*/
void DialogAFConstraintSlider::SaveConstraint( void ) {
	int s1, s2;
	CString str;

	if ( !file || !constraint ) {
		return;
	}
	UpdateData( TRUE );

	// slider axis
	if ( constraint->axis.type == idAFVector::VEC_BONEDIR ) {
		s1 = GetSafeComboBoxSelection( &m_comboAxisJoint1, str, -1 );
		constraint->axis.joint1 = str;
		s2 = GetSafeComboBoxSelection( &m_comboAxisJoint2, str, s1 );
		constraint->axis.joint2 = str;
	}
	else {
		constraint->axis.ToVec3() = idAngles( m_axisPitch, m_axisYaw, 0.0f ).ToForward();
	}

	AFDialogSetFileModified();
}
コード例 #12
0
ファイル: GLWidget.cpp プロジェクト: Salamek/Shadow-of-Dust
void idGLDrawableModel::draw(int x, int y, int w, int h) {
    if ( !worldModel ) {
        return;
    }
    if ( worldModel->IsDynamicModel() != DM_STATIC ) {
        //return;
    }

    rect.Set( x, y, w, h );

    qglViewport(x, y, w, h);
    qglScissor(x, y, w, h);
    qglMatrixMode(GL_PROJECTION);
    qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
    qglClear(GL_COLOR_BUFFER_BIT);

    if (worldDirty) {
        //InitWorld();
        world->InitFromMap( NULL );
        renderLight_t	parms;
        idDict spawnArgs;
        spawnArgs.Set("classname", "light");
        spawnArgs.Set("name", "light_1");
        spawnArgs.Set("origin", "-128 0 0");
        idStr str;
        sprintf(str, "%f %f %f", light, light, light);
        spawnArgs.Set("_color", str);
        gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &parms );
        lightDef = world->AddLightDef( &parms );

        renderEntity_t worldEntity;
        memset( &worldEntity, 0, sizeof( worldEntity ) );
        spawnArgs.Clear();
        spawnArgs.Set("classname", "func_static");
        spawnArgs.Set("name", spawnArgs.GetString("model"));
        spawnArgs.Set("origin", "0 0 0");
        if ( skinStr.Length() ) {
            spawnArgs.Set( "skin", skinStr );
        }
        gameEdit->ParseSpawnArgsToRenderEntity(&spawnArgs, &worldEntity);
        worldEntity.hModel = worldModel;

        worldEntity.axis = rotation.ToMat3();

        worldEntity.shaderParms[0] = 1;
        worldEntity.shaderParms[1] = 1;
        worldEntity.shaderParms[2] = 1;
        worldEntity.shaderParms[3] = 1;
        modelDef = world->AddEntityDef( &worldEntity );

        worldDirty = false;
    }

    renderView_t	refdef;
    // render it
    renderSystem->BeginFrame(w, h);
    memset( &refdef, 0, sizeof( refdef ) );
    refdef.vieworg.Set(zOffset, xOffset, -yOffset);

    refdef.viewaxis = idAngles(0,0,0).ToMat3();
    refdef.shaderParms[0] = 1;
    refdef.shaderParms[1] = 1;
    refdef.shaderParms[2] = 1;
    refdef.shaderParms[3] = 1;

    refdef.width = SCREEN_WIDTH;
    refdef.height = SCREEN_HEIGHT;
    refdef.fov_x = 90;
    refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;

    refdef.time = eventLoop->Milliseconds();

    world->RenderScene( &refdef );
    int frontEnd, backEnd;
    renderSystem->EndFrame( &frontEnd, &backEnd );

    qglMatrixMode( GL_MODELVIEW );
    qglLoadIdentity();
}
コード例 #13
0
ファイル: GLWidget.cpp プロジェクト: Salamek/Shadow-of-Dust
void idGLDrawableMaterial::draw(int x, int y, int w, int h) {
    const idMaterial *mat = material;
    if (mat) {
        qglViewport(x, y, w, h);
        qglScissor(x, y, w, h);
        qglMatrixMode(GL_PROJECTION);
        qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
        qglClear(GL_COLOR_BUFFER_BIT);

        if (worldDirty) {
            InitWorld();
            renderLight_t	parms;
            idDict spawnArgs;
            spawnArgs.Set("classname", "light");
            spawnArgs.Set("name", "light_1");
            spawnArgs.Set("origin", "0 0 0");
            idStr str;
            sprintf(str, "%f %f %f", light, light, light);
            spawnArgs.Set("_color", str);
            gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &parms );
            lightDef = world->AddLightDef( &parms );

            idImage *img = (mat->GetNumStages() > 0) ? mat->GetStage(0)->texture.image : mat->GetEditorImage();

            if (img == NULL) {
                common->Warning("Unable to load image for preview for %s", mat->GetName());
                return;
            }

            int width = img->uploadWidth;
            int height = img->uploadHeight;

            width *= scale;
            height *= scale;

            srfTriangles_t *tris = worldModel->AllocSurfaceTriangles( 4, 6 );
            tris->numVerts = 4;
            tris->numIndexes = 6;

            tris->indexes[0] = 0;
            tris->indexes[1] = 1;
            tris->indexes[2] = 2;
            tris->indexes[3] = 3;
            tris->indexes[4] = 1;
            tris->indexes[5] = 0;

            tris->verts[0].xyz.x = 64;
            tris->verts[0].xyz.y = -xOffset + 0 - width / 2;
            tris->verts[0].xyz.z = yOffset + 0 - height / 2;
            tris->verts[0].st.x = 1;
            tris->verts[0].st.y = 1;

            tris->verts[1].xyz.x = 64;
            tris->verts[1].xyz.y = -xOffset + width / 2;
            tris->verts[1].xyz.z = yOffset + height / 2;
            tris->verts[1].st.x = 0;
            tris->verts[1].st.y = 0;

            tris->verts[2].xyz.x = 64;
            tris->verts[2].xyz.y = -xOffset + 0 - width / 2;
            tris->verts[2].xyz.z = yOffset + height / 2;
            tris->verts[2].st.x = 1;
            tris->verts[2].st.y = 0;

            tris->verts[3].xyz.x = 64;
            tris->verts[3].xyz.y = -xOffset + width / 2;
            tris->verts[3].xyz.z = yOffset + 0 - height / 2;
            tris->verts[3].st.x = 0;
            tris->verts[3].st.y = 1;

            tris->verts[0].normal = tris->verts[1].xyz.Cross(tris->verts[3].xyz);
            tris->verts[1].normal = tris->verts[2].normal = tris->verts[3].normal = tris->verts[0].normal;
            AddTris(tris, mat);

            worldModel->FinishSurfaces();

            renderEntity_t worldEntity;

            memset( &worldEntity, 0, sizeof( worldEntity ) );
            if ( mat->HasGui() ) {
                worldEntity.gui[ 0 ] = mat->GlobalGui();
            }
            worldEntity.hModel = worldModel;
            worldEntity.axis = mat3_default;
            worldEntity.shaderParms[0] = 1;
            worldEntity.shaderParms[1] = 1;
            worldEntity.shaderParms[2] = 1;
            worldEntity.shaderParms[3] = 1;
            modelDef = world->AddEntityDef( &worldEntity );

            worldDirty = false;
        }

        renderView_t	refdef;
        // render it
        renderSystem->BeginFrame(w, h);
        memset( &refdef, 0, sizeof( refdef ) );
        refdef.vieworg.Set(viewAngle, 0, 0);

        refdef.viewaxis = idAngles(0,0,0).ToMat3();
        refdef.shaderParms[0] = 1;
        refdef.shaderParms[1] = 1;
        refdef.shaderParms[2] = 1;
        refdef.shaderParms[3] = 1;

        refdef.width = SCREEN_WIDTH;
        refdef.height = SCREEN_HEIGHT;
        refdef.fov_x = 90;
        refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;

        refdef.time = eventLoop->Milliseconds();

        world->RenderScene( &refdef );
        int frontEnd, backEnd;
        renderSystem->EndFrame( &frontEnd, &backEnd );

        qglMatrixMode( GL_MODELVIEW );
        qglLoadIdentity();
    }

}
コード例 #14
0
/*
==================
FixGlobalTjunctions
==================
*/
void	FixGlobalTjunctions( uEntity_t *e ) {
	mapTri_t	*a;
	int			vert;
	int			i;
	optimizeGroup_t	*group;
	int			areaNum;

	common->Printf( "----- FixGlobalTjunctions -----\n" );

	// clear the hash tables
	memset( hashVerts, 0, sizeof( hashVerts ) );

	numHashVerts = 0;
	numTotalVerts = 0;

	// bound all the triangles to determine the bucket size
	hashBounds.Clear();
	for ( areaNum = 0 ; areaNum < e->numAreas ; areaNum++ ) {
		for ( group = e->areas[areaNum].groups ; group ; group = group->nextGroup ) {
			for ( a = group->triList ; a ; a = a->next ) {
				hashBounds.AddPoint( a->v[0].xyz );
				hashBounds.AddPoint( a->v[1].xyz );
				hashBounds.AddPoint( a->v[2].xyz );
			}
		}
	}

	// spread the bounds so it will never have a zero size
	for ( i = 0 ; i < 3 ; i++ ) {
		hashBounds[0][i] = floor( hashBounds[0][i] - 1 );
		hashBounds[1][i] = ceil( hashBounds[1][i] + 1 );
		hashIntMins[i] = hashBounds[0][i] * SNAP_FRACTIONS;

		hashScale[i] = ( hashBounds[1][i] - hashBounds[0][i] ) / HASH_BINS;
		hashIntScale[i] = hashScale[i] * SNAP_FRACTIONS;
		if ( hashIntScale[i] < 1 ) {
			hashIntScale[i] = 1;
		}
	}

	// add all the points to the hash buckets
	for ( areaNum = 0 ; areaNum < e->numAreas ; areaNum++ ) {
		for ( group = e->areas[areaNum].groups ; group ; group = group->nextGroup ) {
			// don't touch discrete surfaces
			if ( group->material != NULL && group->material->IsDiscrete() ) {
				continue;
			}

			for ( a = group->triList ; a ; a = a->next ) {
				for ( vert = 0 ; vert < 3 ; vert++ ) {
					a->hashVert[vert] = GetHashVert( a->v[vert].xyz );
				}
			}
		}
	}

	// add all the func_static model vertexes to the hash buckets
	// optionally inline some of the func_static models
	if ( dmapGlobals.entityNum == 0 ) {
		for ( int eNum = 1 ; eNum < dmapGlobals.num_entities ; eNum++ ) {
			uEntity_t *entity = &dmapGlobals.uEntities[eNum];
			const char *className = entity->mapEntity->epairs.GetString( "classname" );
			if ( idStr::Icmp( className, "func_static" ) ) {
				continue;
			}
			const char *modelName = entity->mapEntity->epairs.GetString( "model" );
			if ( !modelName ) {
				continue;
			}
			if ( !strstr( modelName, ".lwo" ) && !strstr( modelName, ".ase" ) && !strstr( modelName, ".ma" ) ) {
				continue;
			}

			idRenderModel	*model = renderModelManager->FindModel( modelName );

//			common->Printf( "adding T junction verts for %s.\n", entity->mapEntity->epairs.GetString( "name" ) );

			idMat3	axis;
			// get the rotation matrix in either full form, or single angle form
			if ( !entity->mapEntity->epairs.GetMatrix( "rotation", "1 0 0 0 1 0 0 0 1", axis ) ) {
				float angle = entity->mapEntity->epairs.GetFloat( "angle" );
				if ( angle != 0.0f ) {
					axis = idAngles( 0.0f, angle, 0.0f ).ToMat3();
				} else {
					axis.Identity();
				}
			}

			idVec3	origin = entity->mapEntity->epairs.GetVector( "origin" );

			for ( i = 0 ; i < model->NumSurfaces() ; i++ ) {
				const modelSurface_t *surface = model->Surface( i );
				const srfTriangles_t *tri = surface->geometry;

				mapTri_t	mapTri;
				memset( &mapTri, 0, sizeof( mapTri ) );
				mapTri.material = surface->shader;
				// don't let discretes (autosprites, etc) merge together
				if ( mapTri.material->IsDiscrete() ) {
					mapTri.mergeGroup = (void *)surface;
				}
				for ( int j = 0 ; j < tri->numVerts ; j += 3 ) {
					idVec3 v = tri->verts[j].xyz * axis + origin;
					GetHashVert( v );
				}
			}
		}
	}



	// now fix each area
	for ( areaNum = 0 ; areaNum < e->numAreas ; areaNum++ ) {
		for ( group = e->areas[areaNum].groups ; group ; group = group->nextGroup ) {
			// don't touch discrete surfaces
			if ( group->material != NULL && group->material->IsDiscrete() ) {
				continue;
			}

			mapTri_t *newList = NULL;
			for ( mapTri_t *tri = group->triList ; tri ; tri = tri->next ) {
				mapTri_t *fixed = FixTriangleAgainstHash( tri );
				newList = MergeTriLists( newList, fixed );
			}
			FreeTriList( group->triList );
			group->triList = newList;
		}
	}


	// done
	FreeTJunctionHash();
}
コード例 #15
0
stateResult_t rvMonsterStroggHover::State_DeathSpiral ( const stateParms_t& parms ) {
	enum { 
		STAGE_INIT,
		STAGE_SPIRAL
	};
	switch ( parms.stage ) {
		case STAGE_INIT:
			{
				disablePain = true;

				// Make sure all animation and attack states stop
				StopAnimState ( ANIMCHANNEL_TORSO );
				StopAnimState ( ANIMCHANNEL_LEGS );

				// Start the crash & burn effects
				for ( int i = 0; i < numHoverJoints; i++ ) {
					if ( jointHover[i] != INVALID_JOINT ) {
						PlayEffect ( "fx_hurt", jointHover[i], false );
						effectHover[i] = PlayEffect ( "fx_crash", jointHover[i], true );
					}
				}
				deathPitch = viewAxis.ToAngles()[0];
				deathRoll = viewAxis.ToAngles()[2];

				deathPitchRate = gameLocal.random.RandomFloat()*0.3f + 0.1f;
				deathYawRate = gameLocal.random.RandomFloat()*2.0f + 1.5f;
				deathRollRate = gameLocal.random.RandomFloat()*3.0f + 1.0f;
				deathSpeed = gameLocal.random.RandomFloat()*300.0f + 500.0f;
				deathGrav = gameLocal.random.RandomFloat()*6.0f + 6.0f;

				strafeRight = (gameLocal.random.RandomFloat()>0.5f);
				StopSound( SND_CHANNEL_HEART, false ); 
				StartSound ( "snd_crash", SND_CHANNEL_HEART, 0, false, NULL );
			}
			return SRESULT_STAGE ( STAGE_SPIRAL );
		case STAGE_SPIRAL:
			{
				move.current_yaw += (strafeRight?-deathYawRate:deathYawRate);
				deathPitch = idMath::ClampFloat( -90.0f, 90.0f, deathPitch+deathPitchRate );
				deathRoll += (strafeRight?deathRollRate:-deathRollRate);
				viewAxis = idAngles( deathPitch, move.current_yaw, deathRoll ).ToMat3();

				idVec3 vel = GetPhysics()->GetLinearVelocity();
				idVec3 strafeVel = viewAxis[0] * deathSpeed;
				strafeVel.z = 0;
				vel += strafeVel;
				vel.Normalize();
				vel *= deathSpeed;
				vel += GetPhysics()->GetGravity()/deathGrav;

				physicsObj.UseVelocityMove( true );

				physicsObj.SetLinearVelocity( vel );

				idSoundEmitter *emitter = soundSystem->EmitterForIndex( SOUNDWORLD_GAME, refSound.referenceSoundHandle );
				if( emitter ) {
					refSound.parms.frequencyShift += 0.025f;
					emitter->ModifySound ( SND_CHANNEL_HEART, &refSound.parms );
				}
			}
			return SRESULT_WAIT;
	}

	return SRESULT_ERROR;
}
コード例 #16
0
/*
================
idTestModel::Think
================
*/
void idTestModel::Think()
{
	idVec3 pos;
	idMat3 axis;
	idAngles ang;
	int	i;
	
	if( thinkFlags & TH_THINK )
	{
		if( anim && ( gameLocal.testmodel == this ) && ( mode != g_testModelAnimate.GetInteger() ) )
		{
			StopSound( SND_CHANNEL_ANY, false );
			if( head.GetEntity() )
			{
				head.GetEntity()->StopSound( SND_CHANNEL_ANY, false );
			}
			switch( g_testModelAnimate.GetInteger() )
			{
				default:
				case 0:
					// cycle anim with origin reset
					if( animator.NumFrames( anim ) <= 1 )
					{
						// single frame animations end immediately, so just cycle it since it's the same result
						animator.CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
						if( headAnim )
						{
							headAnimator->CycleAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
						}
					}
					else
					{
						animator.PlayAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
						if( headAnim )
						{
							headAnimator->PlayAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
							if( headAnimator->AnimLength( headAnim ) > animator.AnimLength( anim ) )
							{
								// loop the body anim when the head anim is longer
								animator.CurrentAnim( ANIMCHANNEL_ALL )->SetCycleCount( -1 );
							}
						}
					}
					animator.RemoveOriginOffset( false );
					break;
					
				case 1:
					// cycle anim with fixed origin
					animator.CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					animator.RemoveOriginOffset( true );
					if( headAnim )
					{
						headAnimator->CycleAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					}
					break;
					
				case 2:
					// cycle anim with continuous origin
					animator.CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					animator.RemoveOriginOffset( false );
					if( headAnim )
					{
						headAnimator->CycleAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					}
					break;
					
				case 3:
					// frame by frame with continuous origin
					animator.SetFrame( ANIMCHANNEL_ALL, anim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					animator.RemoveOriginOffset( false );
					if( headAnim )
					{
						headAnimator->SetFrame( ANIMCHANNEL_ALL, headAnim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					}
					break;
					
				case 4:
					// play anim once
					animator.PlayAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					animator.RemoveOriginOffset( false );
					if( headAnim )
					{
						headAnimator->PlayAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					}
					break;
					
				case 5:
					// frame by frame with fixed origin
					animator.SetFrame( ANIMCHANNEL_ALL, anim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					animator.RemoveOriginOffset( true );
					if( headAnim )
					{
						headAnimator->SetFrame( ANIMCHANNEL_ALL, headAnim, frame, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
					}
					break;
			}
			
			mode = g_testModelAnimate.GetInteger();
		}
		
		if( ( mode == 0 ) && ( gameLocal.time >= starttime + animtime ) )
		{
			starttime = gameLocal.time;
			StopSound( SND_CHANNEL_ANY, false );
			animator.PlayAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
			if( headAnim )
			{
				headAnimator->PlayAnim( ANIMCHANNEL_ALL, headAnim, gameLocal.time, FRAME2MS( g_testModelBlend.GetInteger() ) );
				if( headAnimator->AnimLength( headAnim ) > animator.AnimLength( anim ) )
				{
					// loop the body anim when the head anim is longer
					animator.CurrentAnim( ANIMCHANNEL_ALL )->SetCycleCount( -1 );
				}
			}
		}
		
		if( headAnimator )
		{
			// copy the animation from the body to the head
			for( i = 0; i < copyJoints.Num(); i++ )
			{
				if( copyJoints[ i ].mod == JOINTMOD_WORLD_OVERRIDE )
				{
					idMat3 mat = head.GetEntity()->GetPhysics()->GetAxis().Transpose();
					GetJointWorldTransform( copyJoints[ i ].from, gameLocal.time, pos, axis );
					pos -= head.GetEntity()->GetPhysics()->GetOrigin();
					headAnimator->SetJointPos( copyJoints[ i ].to, copyJoints[ i ].mod, pos * mat );
					headAnimator->SetJointAxis( copyJoints[ i ].to, copyJoints[ i ].mod, axis * mat );
				}
				else
				{
					animator.GetJointLocalTransform( copyJoints[ i ].from, gameLocal.time, pos, axis );
					headAnimator->SetJointPos( copyJoints[ i ].to, copyJoints[ i ].mod, pos );
					headAnimator->SetJointAxis( copyJoints[ i ].to, copyJoints[ i ].mod, axis );
				}
			}
		}
		
		// update rotation
		RunPhysics();
		
		physicsObj.GetAngles( ang );
		physicsObj.SetAngularExtrapolation( extrapolation_t( EXTRAPOLATION_LINEAR | EXTRAPOLATION_NOSTOP ), gameLocal.time, 0, ang, idAngles( 0, g_testModelRotate.GetFloat() * 360.0f / 60.0f, 0 ), ang_zero );
		
		idClipModel* clip = physicsObj.GetClipModel();
		if( clip != NULL && animator.ModelDef() )
		{
			idVec3 neworigin;
			idMat3 axis;
			jointHandle_t joint;
			
			joint = animator.GetJointHandle( "origin" );
			animator.GetJointTransform( joint, gameLocal.time, neworigin, axis );
			neworigin = ( ( neworigin - animator.ModelDef()->GetVisualOffset() ) * physicsObj.GetAxis() ) + GetPhysics()->GetOrigin();
			clip->Link( gameLocal.clip, this, 0, neworigin, clip->GetAxis() );
		}
	}
	
	UpdateAnimation();
	Present();
	
	if( ( gameLocal.testmodel == this ) && g_showTestModelFrame.GetInteger() && anim )
	{
		gameLocal.Printf( "^5 Anim: ^7%s  ^5Frame: ^7%d/%d  Time: %.3f\n", animator.AnimFullName( anim ), animator.CurrentAnim( ANIMCHANNEL_ALL )->GetFrameNumber( gameLocal.time ),
						  animator.CurrentAnim( ANIMCHANNEL_ALL )->NumFrames(), MS2SEC( gameLocal.time - animator.CurrentAnim( ANIMCHANNEL_ALL )->GetStartTime() ) );
		if( headAnim )
		{
			gameLocal.Printf( "^5 Head: ^7%s  ^5Frame: ^7%d/%d  Time: %.3f\n\n", headAnimator->AnimFullName( headAnim ), headAnimator->CurrentAnim( ANIMCHANNEL_ALL )->GetFrameNumber( gameLocal.time ),
							  headAnimator->CurrentAnim( ANIMCHANNEL_ALL )->NumFrames(), MS2SEC( gameLocal.time - headAnimator->CurrentAnim( ANIMCHANNEL_ALL )->GetStartTime() ) );
		}
		else
		{
			gameLocal.Printf( "\n\n" );
		}
	}
}
コード例 #17
0
ファイル: DeclAF.cpp プロジェクト: anonreclaimer/morpheus
/*
================
idDeclAF::ParseBody
================
*/
bool idDeclAF::ParseBody( idLexer &src ) {
	bool hasJoint = false;
	idToken token;
	idAFVector angles;
	idDeclAF_Body *body = new idDeclAF_Body;

	bodies.Alloc() = body;

	body->SetDefault( this );

	if ( !src.ExpectTokenType( TT_STRING, 0, &token ) ||
			!src.ExpectTokenString( "{" ) ) {
		return false;
	}

	body->name = token;
	if ( !body->name.Icmp( "origin" ) || !body->name.Icmp( "world" ) ) {
		src.Error( "a body may not be named \"origin\" or \"world\"" );
		return false;
	}

	while( src.ReadToken( &token ) ) {

		if ( !token.Icmp( "model" ) ) {
			if ( !src.ExpectTokenType( TT_NAME, 0, &token ) ) {
				return false;
			}
			if ( !token.Icmp( "box" ) ) {
				body->modelType = TRM_BOX;
				if ( !src.ExpectTokenString( "(" ) ||
					!body->v1.Parse( src ) ||
					!src.ExpectTokenString( "," ) ||
					!body->v2.Parse( src ) ||
					!src.ExpectTokenString( ")" ) ) {
					return false;
				}
			} else if ( !token.Icmp( "octahedron" ) ) {
				body->modelType = TRM_OCTAHEDRON;
				if ( !src.ExpectTokenString( "(" ) ||
					!body->v1.Parse( src ) ||
					!src.ExpectTokenString( "," ) ||
					!body->v2.Parse( src ) ||
					!src.ExpectTokenString( ")" ) ) {
					return false;
				}
			} else if ( !token.Icmp( "dodecahedron" ) ) {
				body->modelType = TRM_DODECAHEDRON;
				if ( !src.ExpectTokenString( "(" ) ||
					!body->v1.Parse( src ) ||
					!src.ExpectTokenString( "," ) ||
					!body->v2.Parse( src ) ||
					!src.ExpectTokenString( ")" ) ) {
					return false;
				}
			} else if ( !token.Icmp( "cylinder" ) ) {
				body->modelType = TRM_CYLINDER;
				if ( !src.ExpectTokenString( "(" ) ||
					!body->v1.Parse( src ) ||
					!src.ExpectTokenString( "," ) ||
					!body->v2.Parse( src ) ||
					!src.ExpectTokenString( "," ) ) {
					return false;
				}
				body->numSides = src.ParseInt();
				if ( !src.ExpectTokenString( ")" ) ) {
					return false;
				}
			} else if ( !token.Icmp( "cone" ) ) {
				body->modelType = TRM_CONE;
				if ( !src.ExpectTokenString( "(" ) ||
					!body->v1.Parse( src ) ||
					!src.ExpectTokenString( "," ) ||
					!body->v2.Parse( src ) ||
					!src.ExpectTokenString( "," ) ) {
					return false;
				}
				body->numSides = src.ParseInt();
				if ( !src.ExpectTokenString( ")" ) ) {
					return false;
				}
			} else if ( !token.Icmp( "bone" ) ) {
				body->modelType = TRM_BONE;
				if ( !src.ExpectTokenString( "(" ) ||
					!body->v1.Parse( src ) ||
					!src.ExpectTokenString( "," ) ||
					!body->v2.Parse( src ) ||
					!src.ExpectTokenString( "," ) ) {
					return false;
				}
				body->width = src.ParseFloat();
				if ( !src.ExpectTokenString( ")" ) ) {
					return false;
				}
			} else if ( !token.Icmp( "custom" ) ) {
				src.Error( "custom models not yet implemented" );
				return false;
			} else {
				src.Error( "unkown model type %s", token.c_str() );
				return false;
			}
		} else if ( !token.Icmp( "origin" ) ) {
			if ( !body->origin.Parse( src ) ) {
				return false;
			}
		} else if ( !token.Icmp( "angles" ) ) {
			if ( !angles.Parse( src ) ) {
				return false;
			}
			body->angles = idAngles( angles.ToVec3().x, angles.ToVec3().y, angles.ToVec3().z );
		} else if ( !token.Icmp( "joint" ) ) {
			if ( !src.ExpectTokenType( TT_STRING, 0, &token ) ) {
				return false;
			}
			body->jointName = token;
			hasJoint = true;
		} else if ( !token.Icmp( "mod" ) ) {
			if ( !src.ExpectAnyToken( &token ) ) {
				return false;
			}
			body->jointMod = JointModFromString( token.c_str() );
		} else if ( !token.Icmp( "density" ) ) {
			body->density = src.ParseFloat();
		} else if ( !token.Icmp( "inertiaScale" ) ) {
			src.Parse1DMatrix( 9, body->inertiaScale[0].ToFloatPtr() );
		} else if ( !token.Icmp( "friction" ) ) {
			body->linearFriction = src.ParseFloat();
			src.ExpectTokenString( "," );
			body->angularFriction = src.ParseFloat();
			src.ExpectTokenString( "," );
			body->contactFriction = src.ParseFloat();
		} else if ( !token.Icmp( "contents" ) ) {
			ParseContents( src, body->contents );
		} else if ( !token.Icmp( "clipMask" ) ) {
			ParseContents( src, body->clipMask );
		} else if ( !token.Icmp( "selfCollision" ) ) {
			body->selfCollision = src.ParseBool();
		} else if ( !token.Icmp( "containedjoints" ) ) {
			if ( !src.ExpectTokenType( TT_STRING, 0, &token ) ) {
				return false;
			}
			body->containedJoints = token;
		} else if ( !token.Icmp( "frictionDirection" ) ) {
			if ( !body->frictionDirection.Parse( src ) ) {
				return false;
			}
		} else if ( !token.Icmp( "contactMotorDirection" ) ) {
			if ( !body->contactMotorDirection.Parse( src ) ) {
				return false;
			}
		} else if ( token == "}" ) {
			break;
		} else {
			src.Error( "unknown token %s in body", token.c_str() );
			return false;
		}
	}

	if ( body->modelType == TRM_INVALID ) {
		src.Error( "no model set for body" );
		return false;
	}

	if ( !hasJoint ) {
		src.Error( "no joint set for body" );
		return false;
	}

	body->clipMask |= CONTENTS_MOVEABLECLIP;

	return true;
}
コード例 #18
0
ファイル: worldmanager.cpp プロジェクト: tankorsmash/quadcow
void idWorldManager::UpdatePlay( int idx )
{
	int currentIndex = records[idx].index;

	if (currentIndex > records[idx].events.Num() - 1)
	{
		return;
	}

	if (records[idx].events[currentIndex].timestamp < gameLocal.time - recordStarttime)
	{
		if (!records[idx].events[currentIndex].frobcommand.IsEmpty() && !records[idx].events[currentIndex].done)
		{
			//FROB EVENT.
			idEntity *frobEnt;
			frobEnt = gameLocal.FindEntity( records[idx].events[currentIndex].frobcommand );
			if (frobEnt)
			{

				if (frobEnt->IsType(idTrigger_Multi::Type))
				{
					static_cast<idTrigger_Multi *>( frobEnt )->TriggerAction(NULL);
				}
				else
				{
					gameLocal.GetLocalPlayer()->DoFrob(frobEnt);
					//common->Printf("frobbing! %d\n", gameLocal.time);
				}
			}
			else
			{
				gameLocal.Warning("WorldManager couldn't find frob ent: %s\n", gameLocal.FindEntity( records[idx].events[currentIndex].frobcommand.c_str()));
			}

			records[idx].events[currentIndex].done = true;
		}
		else if (records[idx].events[currentIndex].recordtype == RECORD_LAUNCHAIM && !records[idx].events[currentIndex].done)
		{
			//event: change launcher aim.
			
			//find the launcher with this id.
			int i;
			int targetEnt = -1;

			for ( i = 0; i < gameLocal.num_entities; i++ )
			{
				if ( !gameLocal.entities[ i ] )
					continue;

				int kk = records[idx].events[currentIndex].entID;

				if (gameLocal.entities[i]->spawnArgs.GetInt("id") != records[idx].events[currentIndex].entID)
				{
					continue;
				}

				targetEnt = i;
				break;
			}

			if (developer.GetBool())
			{
				common->Printf("worldmanager: aiming launcher entity ID %d  \n", records[idx].events[currentIndex].entID);
			}

			if (targetEnt >= 0)
			{
				//legacy.
				gameLocal.entities[targetEnt]->spawnArgs.SetVector("new_launchdir", records[idx].events[currentIndex].position);
				gameLocal.entities[targetEnt]->spawnArgs.SetInt("new_force", records[idx].events[currentIndex].yaw);
				gameLocal.entities[targetEnt]->spawnArgs.SetInt("new_update", 1);

				static_cast<idLauncher *>( gameLocal.entities[i] )->SetLaunchDir(records[idx].events[currentIndex].position, records[idx].events[currentIndex].yaw);
			}

			records[idx].events[currentIndex].done = true;
		}
		else if (!records[idx].events[currentIndex].deckcommand.IsEmpty() && !records[idx].events[currentIndex].done)
		{
			//DECK EVENT.
			gameLocal.RunDeckCommand(records[idx].events[currentIndex].deckcommand.c_str());

			records[idx].events[currentIndex].done = true;
		}
		else if (records[idx].events[currentIndex].recordtype == RECORD_UNSPAWN && !records[idx].events[currentIndex].done)
		{
			//UNSPAWN EVENT.
			//find the ent with this id.
			int i;
			int targetEnt = -1;

			for ( i = 0; i < gameLocal.num_entities; i++ )
			{
				if ( !gameLocal.entities[ i ] )
					continue;

				int kk = records[idx].events[currentIndex].entID;

				if (gameLocal.entities[i]->spawnArgs.GetInt("id") != records[idx].events[currentIndex].entID)
				{
					continue;
				}

				targetEnt = i;
				break;
			}

			if (targetEnt >= 0)
			{
				gameLocal.entities[targetEnt]->PostEventMS( &EV_Remove, 0 );
				//gameLocal.entities[targetEnt]->Event_CallFunction("onPick");
			}

			records[idx].events[currentIndex].done = true;
		}
		else if (records[idx].events[currentIndex].recordtype == RECORD_SPAWN && !records[idx].events[currentIndex].done)
		{
			
			//SPAWN EVENT.

			idEntity	*ent;
			idDict		args;
			idAngles	ang;

			int id = gameLocal.time - recordStarttime;

			if (developer.GetBool())
			{
				common->Printf("worldmanager: spawning entity ID %d  classname %s \n", records[idx].events[currentIndex].entID,
					records[idx].events[currentIndex].spawncommand.c_str());
			}

			args.Set( "classname", records[idx].events[currentIndex].spawncommand );
			args.SetVector( "origin", records[idx].events[currentIndex].position );
			args.SetInt( "id", records[idx].events[currentIndex].entID);
			bool bSpawn = gameLocal.SpawnEntityDef( args, &ent );

			if (ent)
			{
				ent->spawnArgs.SetInt("id", records[idx].events[currentIndex].entID);  //BC 7-21-2016 was crashing here.
			
				ang.pitch = 0;
				ang.yaw = records[idx].events[currentIndex].yaw;
				ang.roll = 0;
				ent->SetAngles( ang );
			}

			if (developer.GetBool())
			{
				common->Printf("worldmanager: spawning success:%d\n",  bSpawn);
				
			}

			records[idx].events[currentIndex].done = true;
		}
		else
		{
			//MOVE EVENT.
			float moveTime = (float)RECORDRATE / 1000;
		
			records[idx].ghost->Event_SetMoveTime(moveTime);
			records[idx].ghost->Event_MoveToPos(records[idx].events[currentIndex].position);
			
			idAngles newAng = idAngles(0, records[idx].events[currentIndex].yaw, 0);
			records[idx].ghost->SetAxis(newAng.ToMat3());

			if (index == -1)
			{
				int lastLineIndex = recordlines[idx].lines.Num() - 1;
				recordline_t newLine;
				newLine.position1 = recordlines[idx].lines[lastLineIndex].position2;
				newLine.position2 = records[idx].events[currentIndex].position;

				recordlines[idx].lines.Append(newLine);
			}

			records[idx].events[currentIndex].done = true;
		}

		
		records[idx].index++;
	}
}
コード例 #19
0
ファイル: Force_Field.cpp プロジェクト: tankorsmash/quadcow
/*
================
idForce_Field::Evaluate
================
*/
void idForce_Field::Evaluate( int time ) {
	int numClipModels, i;
	idBounds bounds;
	idVec3 force, torque, angularVelocity;
	idClipModel *cm, *clipModelList[ MAX_GENTITIES ];

	assert( clipModel );

	bounds.FromTransformedBounds( clipModel->GetBounds(), clipModel->GetOrigin(), clipModel->GetAxis() );
	numClipModels = gameLocal.clip.ClipModelsTouchingBounds( bounds, -1, clipModelList, MAX_GENTITIES );

	for ( i = 0; i < numClipModels; i++ ) {
		cm = clipModelList[ i ];

		if ( !cm->IsTraceModel() ) {
			continue;
		}

		idEntity *entity = cm->GetEntity();

		if ( !entity ) {
			continue;
		}
		
		//bc ignore things.
		if (entity->IsType( idMoveableItem::Type ))
		{
			//int ignoreNum = static_cast<idMoveableItem *>( entity)->forcefieldIgnore.GetEntityNum();
			//int myOwnerNum = this->owner.GetEntityNum();

			if (static_cast<idMoveableItem *>( entity)->forcefieldIgnore.GetEntityNum() == this->owner.GetEntityNum())
			{
				continue;
			}
		}
		


		idPhysics *physics = entity->GetPhysics();

		//bc
		/*
		if (this->owner.IsValid())
		{
			if (gameLocal.GetLocalPlayer()->pickerState >= 2)
			{
				if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.IsValid())
				{
					if( gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.GetEntity()->IsGrabbed() && physics->IsType( idPhysics_Player::Type ))
					{
						continue;
					}
				}
			}			
		}
		*/


		if ( playerOnly ) {
			if ( !physics->IsType( idPhysics_Player::Type ) ) {
				continue;
			}
		} else if ( monsterOnly ) {
			if ( !physics->IsType( idPhysics_Monster::Type ) ) {
				continue;
			}
		}

		if ( !gameLocal.clip.ContentsModel( cm->GetOrigin(), cm, cm->GetAxis(), -1,
									clipModel->Handle(), clipModel->GetOrigin(), clipModel->GetAxis() ) ) {
			continue;
		}

		switch( type ) {
			case FORCEFIELD_UNIFORM: {
				force = dir;
				break;
			}
			case FORCEFIELD_EXPLOSION: {
				force = cm->GetOrigin() - clipModel->GetOrigin();
				force.Normalize();
				break;
			}
			case FORCEFIELD_IMPLOSION: {
				force = clipModel->GetOrigin() - cm->GetOrigin();
				force.Normalize();
				break;
			}
			default: {
				gameLocal.Error( "idForce_Field: invalid type" );
				break;
			}
		}
		
		if ( randomTorque != 0.0f ) {
			torque[0] = gameLocal.random.CRandomFloat();
			torque[1] = gameLocal.random.CRandomFloat();
			torque[2] = gameLocal.random.CRandomFloat();
			if ( torque.Normalize() == 0.0f ) {
				torque[2] = 1.0f;
			}
		}

		switch( applyType ) {
			case FORCEFIELD_APPLY_FORCE: {
				if ( randomTorque != 0.0f ) {
					entity->AddForce( gameLocal.world, cm->GetId(), cm->GetOrigin() + torque.Cross( dir ) * randomTorque, dir * magnitude );
				}
				else {
					entity->AddForce( gameLocal.world, cm->GetId(), cm->GetOrigin(), force * magnitude );
				}
				break;
			}
			case FORCEFIELD_APPLY_VELOCITY:
			{
				//triggered by jumppad. LAUNCHER.


				//ignore objects that are being held by the player.

				if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.IsValid())
				{
					//player is holding onto an object.
					if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.GetEntity() == entity)
					{
						//the thrown object equals the carried object. abort.
						continue;
					}
				}

				if ( entity->IsType( idDoor::Type ) )
					continue;

				if ( entity->IsType( idAFEntity_Generic::Type ))
				{

					physics->SetLinearVelocity( force * magnitude, cm->GetId() );

					continue;
				}

				//BC hack. only launch players when they're reeeaally close, to lessen accidental launches when
				//launch is plopped down near player's feet.
				if ( entity->IsType( idPlayer::Type ) )
				{
					idVec3 playerPos = entity->GetPhysics()->GetOrigin();
					playerPos.z = clipModel->GetOrigin().z;
					idVec3 rawDist = playerPos - clipModel->GetOrigin();
					float finalDist = rawDist.LengthFast();
					

					if (finalDist > 24)
						continue;

					//force *= 0.98f; //BC hack. reduce player boost.

					static_cast<idPlayer *>( entity )->physicsObj.inJump = true;
					


				}				
				else
				{
					
					force *= g_launchermultiplier.GetFloat(); //BC hack. give non-players an extra boost.

					//TODO: figure out why/how physics treats players and objects differently.
					//force *= 1.1f; //was 1.43
					//force *= 1.9f; //was 1.43
					//force *= forceMultiplier;
				}



				//common->Printf("thrown mass is %f\n", 					entity->GetPhysics()->GetMass());

				


				//bc hack: snap the object to the center of the jumppad so jump arc is more consistent.
				if (jumppadTimer < time)
				{
					jumppadTimer = time + 400;

					idVec3 jumppadOrigin = clipModel->GetOrigin();
					//jumppadOrigin.z = physics->GetOrigin().z;  //retain objects' original vertical (z) axis, so that things don't get stuck in the ground.

					//jumppadOrigin.z
					//gameRenderWorld->DebugCircle( colorWhite, jumppadOrigin, idVec3(0,0,1), 32, 12, 5000 );

					//physics->GetAbsBounds()					

					jumppadOrigin.z += 5;
					physics->SetOrigin( jumppadOrigin );



					//BC 10-13-2015 reset object angle to 0,0,0.
					idAngles snapAngle = idAngles(0,0,0);
					physics->SetAxis(snapAngle.ToMat3());



					//common->Printf("tele hack\n");

					//gameRenderWorld->DebugBounds( colorMagenta, physics->GetBounds(), physics->GetOrigin(), 5000 );
					//gameRenderWorld->DebugCircle( colorOrange, physics->GetOrigin(), idVec3(0,0,1), 16, 12, 5000 );
					//gameRenderWorld->DebugCircle( colorWhite, clipModel->GetOrigin(), idVec3(0,0,1), 32, 12, 5000 );

					physics->SetLinearVelocity( force * magnitude, cm->GetId() );
				}				
				
				
				/*
				if ( randomTorque != 0.0f )
				{
					angularVelocity = physics->GetAngularVelocity( cm->GetId() );
					physics->SetAngularVelocity( 0.5f * (angularVelocity + torque * randomTorque), cm->GetId() );
				}
				*/

				//Raven
				if ( !physics->IsType( idPhysics_AF::Type ))					
					lastApplyTime = time;

				break;
			}
			case FORCEFIELD_APPLY_IMPULSE: {
				if ( randomTorque != 0.0f ) {
					entity->ApplyImpulse( gameLocal.world, cm->GetId(), cm->GetOrigin() + torque.Cross( dir ) * randomTorque, dir * magnitude );
				}
				else {
					entity->ApplyImpulse( gameLocal.world, cm->GetId(), cm->GetOrigin(), force * magnitude );
				}
				break;
			}
			default: {
				gameLocal.Error( "idForce_Field: invalid apply type" );
				break;
			}
		}
	}
}
コード例 #20
0
ファイル: Simd.cpp プロジェクト: MWisBest/idTech4Prime
/*
============
TestMath
============
*/
void TestMath() {
	int i;
	TIME_TYPE start, end, bestClocks;

	idLib::common->Printf("====================================\n" );

	float tst = -1.0f;
	float tst2 = 1.0f;
	float testvar = 1.0f;
	idRandom rnd;

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = fabs( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "            fabs( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		int tmp = * ( int * ) &tst;
		tmp &= 0x7FFFFFFF;
		tst = * ( float * ) &tmp;
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::Fabs( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = 10.0f + 100.0f * rnd.RandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = sqrt( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * 0.01f;
		tst = 10.0f + 100.0f * rnd.RandomFloat();
	}
	PrintClocks( "            sqrt( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.RandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Sqrt( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.RandomFloat();
	}
	PrintClocks( "    idMath::Sqrt( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.RandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Sqrt16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.RandomFloat();
	}
	PrintClocks( "  idMath::Sqrt16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Sin( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "     idMath::Sin( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Sin16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "   idMath::Sin16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Cos( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "     idMath::Cos( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Cos16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "   idMath::Cos16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		idMath::SinCos( tst, tst, tst2 );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::SinCos( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		idMath::SinCos16( tst, tst, tst2 );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "idMath::SinCos16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Tan( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "     idMath::Tan( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Tan16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "   idMath::Tan16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::ASin( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * ( 1.0f / idMath::PI );
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::ASin( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::ASin16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * ( 1.0f / idMath::PI );
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::ASin16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::ACos( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * ( 1.0f / idMath::PI );
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::ACos( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::ACos16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * ( 1.0f / idMath::PI );
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::ACos16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::ATan( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::ATan( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::ATan16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::ATan16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Pow( 2.7f, tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * 0.1f;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::Pow( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Pow16( 2.7f, tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * 0.1f;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::Pow16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Exp( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * 0.1f;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::Exp( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		tst = idMath::Exp16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst * 0.1f;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::Exp16( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		tst = fabs( tst ) + 1.0f;
		StartRecordTime( start );
		tst = idMath::Log( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "    idMath::Log( tst )", 1, bestClocks );

	bestClocks = 0;
	tst = rnd.CRandomFloat();
	for ( i = 0; i < NUMTESTS; i++ ) {
		tst = fabs( tst ) + 1.0f;
		StartRecordTime( start );
		tst = idMath::Log16( tst );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
		testvar = ( testvar + tst ) * tst;
		tst = rnd.CRandomFloat();
	}
	PrintClocks( "  idMath::Log16( tst )", 1, bestClocks );

	idLib::common->Printf( "testvar = %f\n", testvar );

	idMat3 resultMat3;
	idQuat fromQuat, toQuat, resultQuat;
	idCQuat cq;
	idAngles ang;

	fromQuat = idAngles( 30, 45, 0 ).ToQuat();
	toQuat = idAngles( 45, 0, 0 ).ToQuat();
	cq = idAngles( 30, 45, 0 ).ToQuat().ToCQuat();
	ang = idAngles( 30, 40, 50 );

	bestClocks = 0;
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		resultMat3 = fromQuat.ToMat3();
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
	}
	PrintClocks( "       idQuat::ToMat3()", 1, bestClocks );

	bestClocks = 0;
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		resultQuat.Slerp( fromQuat, toQuat, 0.3f );
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
	}
	PrintClocks( "        idQuat::Slerp()", 1, bestClocks );

	bestClocks = 0;
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		resultQuat = cq.ToQuat();
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
	}
	PrintClocks( "      idCQuat::ToQuat()", 1, bestClocks );

	bestClocks = 0;
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		resultQuat = ang.ToQuat();
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
	}
	PrintClocks( "     idAngles::ToQuat()", 1, bestClocks );

	bestClocks = 0;
	for ( i = 0; i < NUMTESTS; i++ ) {
		StartRecordTime( start );
		resultMat3 = ang.ToMat3();
		StopRecordTime( end );
		GetBest( start, end, bestClocks );
	}
	PrintClocks( "     idAngles::ToMat3()", 1, bestClocks );
}
コード例 #21
0
/*
============
hhDebrisSpawner::SpawnDebris
============
*/
void hhDebrisSpawner::SpawnDebris() {
	const idKeyValue *	kv = NULL;
	idEntity *			debris;
	idDict				args;
	idStr				debrisEntity;
	idList<idStr>		debrisEntities;
	int					numDebris;
	// For entity sources
	idBounds 			sourceBounds;	
	idVec3				sourceBoundCenter;
	idVec3				debrisOrigin;
	idBounds			searchBounds;
	idVec3				debrisVelocity;
	bool				fit;
	idBounds			afBounds; //rww
	bool				gotAFBounds = false; //rww
	idVec3				defOrigin = vec3_zero;
	idAngles			defAngles = ang_zero;

	// Optimization: if player is far away, don't spawn the chunks
	if (!gameLocal.isMultiplayer) {
		float maxDistance = spawnArgs.GetFloat("max_debris_distance");
		if (maxDistance > 0.0f) {
			float distSquared = (gameLocal.GetLocalPlayer()->GetOrigin() - origin).LengthSqr();
			if (distSquared > maxDistance*maxDistance) {
				return;
			}
		}
	}
	args.SetInt( "nodrop", 1 );
	args.SetVector( "origin", origin );
	args.SetFloat( "duration", duration );

	// Pass along variabes requested
	hhUtils::PassArgs( spawnArgs, args, "pass_" );

	if (useAFBounds && sourceEntity && sourceEntity->IsType(idActor::Type)) { //rww - try for AF bounds
		idActor *actor = static_cast<idActor *>(sourceEntity);
		if (actor->IsActiveAF()) { //they are ragdolling, so we have a chance.
			idPhysics_AF *afPhys = actor->GetAFPhysics();

			if (afPhys) { //got the af physics object, now loop through the bodies and collect an appropriate bounds.
				afBounds.Zero();

				for (int bodyCount = 0; bodyCount < afPhys->GetNumBodies(); bodyCount++) {
					idAFBody *b = afPhys->GetBody(bodyCount);
					if (b) {
						idClipModel *bodyClip = b->GetClipModel();
						if (bodyClip) { //now add the bounds of the clipModel into afBounds
							idBounds bodyBounds = bodyClip->GetBounds();
							idVec3 point = (b->GetWorldOrigin()-origin);

							bodyBounds.AddPoint(point);
							afBounds.AddBounds(bodyBounds);
							gotAFBounds = true;
						}
					}
				}
			}
		}
	}

	// Find all Debris
	while ( GetNextDebrisData( debrisEntities, numDebris, kv, defOrigin, defAngles ) ) {
		int numEntities = debrisEntities.Num();
		for ( int count = 0; count < numDebris; ++count ) {
			// Select a debris to use from the list
			debrisEntity = debrisEntities[ gameLocal.random.RandomInt( numEntities ) ];

			// If we have a bounding box to fill, use that
			if ( fillBounds && ( sourceEntity || hasBounds ) ) {
				if (gotAFBounds) { //rww
					sourceBounds = afBounds;
					//gameRenderWorld->DebugBounds(colorGreen, afBounds, origin, 1000);
				}
				else if ( sourceEntity ) {
					sourceBounds = sourceEntity->GetPhysics()->GetBounds();
				}
				else {
					sourceBounds = bounds;
				}

				fit = false;
				for ( int i = 0; i < 4; i++ ) {
					if ( i == 0 && defOrigin != vec3_zero ) {
						//first try bone origin without random offset
						debrisOrigin = defOrigin;
					} else {
						debrisOrigin = origin + hhUtils::RandomPointInBounds( sourceBounds );
					}
		
					if ( !testBounds || hhUtils::EntityDefWillFit( debrisEntity, debrisOrigin, defAngles.ToMat3(), CONTENTS_SOLID, NULL ) ) {
						fit = true;
						break; // Found a spot for the gib
					}
				}
			
				if ( !fit ) { // Gib didn't fit after 4 attempts, so don't spawn the gib
					//common->Warning( "SpawnDebris: gib didn't fit when spawned (%s)\n", debrisEntity.c_str() );
					defAngles = ang_zero;
					continue;
				}

				args.SetVector( "origin", debrisOrigin );
				if ( sourceEntity ) {
					idMat3 sourceAxis = idAngles( 0, sourceEntity->GetAxis().ToAngles().yaw, 0 ).ToMat3();
					args.SetMatrix( "rotation", defAngles.ToMat3() * sourceAxis );
				} else {
					args.SetMatrix( "rotation", defAngles.ToMat3() );
				}
			}


			if ( duration ) {
				args.SetFloat( "removeTime", duration + duration * gameLocal.random.CRandomFloat() );
			}

			// Spawn the object
			debris = gameLocal.SpawnObject( debrisEntity, &args );
			HH_ASSERT(debris != NULL); // JRM - Nick, I added this because of a crash I got. Hopefully this will catch it sooner

			// mdl:  Added this check to make sure no AFs go through the debris spawner
			if ( debris->IsType( idAFEntity_Base::Type ) ) {
				gameLocal.Warning( "hhDebrisSpawner spawned an articulated entity:  '%s'.", debrisEntity.c_str() );
			}

			if ( nonSolid ) {

				idVec3 origin;
				if ( debris->GetFloorPos( 64.0f, origin ) ) {
					debris->SetOrigin( origin ); // Start on floor, since we're not going to be moving at all
					debris->RunPhysics(); // Make sure any associated effects get updated before we turn collision off
				}

				// Turn off collision
				debris->GetPhysics()->SetContents( 0 );
				debris->GetPhysics()->SetClipMask( 0 );
				debris->GetPhysics()->UnlinkClip();
				debris->GetPhysics()->PutToRest();

			} else {
				// Add in random velocity
				idVec3 randVel( gameLocal.random.RandomInt( power.x ) - power.x / 2,
								gameLocal.random.RandomInt( power.y ) - power.y / 2,
								gameLocal.random.RandomInt( power.z ) - power.z / 2 );

				// Set linear velocity
				debrisVelocity.x = velocity.x * power.x * 0.25;
				debrisVelocity.y = velocity.y * power.y * 0.25;
				debrisVelocity.z = 0.0f;
				debris->GetPhysics()->SetLinearVelocity( debrisVelocity + randVel );

				// Add random angular velocity
				idVec3 aVel;
				aVel.x = spawnArgs.GetFloat( "ang_vel", "90.0" ) * gameLocal.random.CRandomFloat();
				aVel.y = spawnArgs.GetFloat( "ang_vel", "90.0" ) * gameLocal.random.CRandomFloat();
				aVel.z = spawnArgs.GetFloat( "ang_vel", "90.0" ) * gameLocal.random.CRandomFloat();
			
				if ( defAngles == ang_zero ) {
					debris->GetPhysics()->SetAxis( idVec3( 1, 0, 0 ).ToMat3() );
				}
				debris->GetPhysics()->SetAngularVelocity( aVel );
			}
		}
		defAngles = ang_zero;

		// Zero out the list
		debrisEntities.Clear();
	}

	return;
}
コード例 #22
0
/*
=====================
PutPrimitivesInAreas

=====================
*/
void PutPrimitivesInAreas( uEntity_t *e ) {
	uBrush_t		*b;
	int				i;
	side_t			*side;
	primitive_t		*prim;
	mapTri_t		*tri;

	common->Printf( "----- PutPrimitivesInAreas -----\n");

	// allocate space for surface chains for each area
	e->areas = (uArea_t *)Mem_Alloc( e->numAreas * sizeof( e->areas[0] ) );
	memset( e->areas, 0, e->numAreas * sizeof( e->areas[0] ) );

	// for each primitive, clip it to the non-solid leafs
	// and divide it into different areas
	for ( prim = e->primitives ; prim ; prim = prim->next ) {
		b = prim->brush;

		if ( !b ) {
			// add curve triangles
			for ( tri = prim->tris ; tri ; tri = tri->next ) {
				AddMapTriToAreas( tri, e );
			}
			continue;
		}

		// clip in brush sides
		for ( i = 0 ; i < b->numsides ; i++ ) {
			side = &b->sides[i];
			if ( !side->visibleHull ) {
				continue;
			}
			PutWindingIntoAreas_r( e, side->visibleHull, side, e->tree->headnode );
		}
	}


	// optionally inline some of the func_static models
	if ( dmapGlobals.entityNum == 0 ) {
		bool inlineAll = dmapGlobals.uEntities[0].mapEntity->epairs.GetBool( "inlineAllStatics" );

		for ( int eNum = 1 ; eNum < dmapGlobals.num_entities ; eNum++ ) {
			uEntity_t *entity = &dmapGlobals.uEntities[eNum];
			const char *className = entity->mapEntity->epairs.GetString( "classname" );
			if ( idStr::Icmp( className, "func_static" ) ) {
				continue;
			}
			if ( !entity->mapEntity->epairs.GetBool( "inline" ) && !inlineAll ) {
				continue;
			}
			const char *modelName = entity->mapEntity->epairs.GetString( "model" );
			if ( !modelName ) {
				continue;
			}
			idRenderModel	*model = renderModelManager->FindModel( modelName );

			common->Printf( "inlining %s.\n", entity->mapEntity->epairs.GetString( "name" ) );

			idMat3	axis;
			// get the rotation matrix in either full form, or single angle form
			if ( !entity->mapEntity->epairs.GetMatrix( "rotation", "1 0 0 0 1 0 0 0 1", axis ) ) {
				float angle = entity->mapEntity->epairs.GetFloat( "angle" );
				if ( angle != 0.0f ) {
					axis = idAngles( 0.0f, angle, 0.0f ).ToMat3();
				} else {
					axis.Identity();
				}
			}

			idVec3	origin = entity->mapEntity->epairs.GetVector( "origin" );

			for ( i = 0 ; i < model->NumSurfaces() ; i++ ) {
				const modelSurface_t *surface = model->Surface( i );
				const srfTriangles_t *tri = surface->geometry;

				mapTri_t	mapTri;
				memset( &mapTri, 0, sizeof( mapTri ) );
				mapTri.material = surface->shader;
				// don't let discretes (autosprites, etc) merge together
				if ( mapTri.material->IsDiscrete() ) {
					mapTri.mergeGroup = (void *)surface;
				}
				for ( int j = 0 ; j < tri->numIndexes ; j += 3 ) {
					for ( int k = 0 ; k < 3 ; k++ ) {
						idVec3 v = tri->verts[tri->indexes[j+k]].xyz;

						mapTri.v[k].xyz = v * axis + origin;

						mapTri.v[k].normal = tri->verts[tri->indexes[j+k]].normal * axis;
						mapTri.v[k].st = tri->verts[tri->indexes[j+k]].st;
					}
					AddMapTriToAreas( &mapTri, e );
				}
			}
		}
	}
}
コード例 #23
0
/*
============
idAASLocal::ShowWallEdges
============
*/
void idAASLocal::ShowWallEdges( const idVec3 &origin, int mode, bool showNumbers ) const {
	const int MAX_WALL_EDGES = 1024;
	int edges[MAX_WALL_EDGES];
	float textSize;

	idPlayer *player = gameLocal.GetLocalPlayer();
	if ( player == NULL ) {
		return;
	}

	idMat3 viewAxis = player->GetViewAxis();
	idVec3 viewOrigin = player->GetViewPos();
	idMat3 playerAxis = idAngles( 0.0f, -player->GetViewAngles().yaw, 0.0f ).ToMat3();

	if ( mode == 3 ) {
		textSize = 0.2f;
	} else {
		textSize = 0.1f;
	}

	float radius = file->GetSettings().obstaclePVSRadius;

	int areaNum = PointReachableAreaNum( origin, DefaultSearchBounds(), AAS_AREA_REACHABLE_WALK, TravelFlagInvalidForTeam() );
	//int numEdges = GetWallEdges( areaNum, idBounds( origin ).Expand( radius ), TFL_WALK, 64.0f, edges, MAX_WALL_EDGES );
	int numEdges = GetObstaclePVSWallEdges( areaNum, edges, MAX_WALL_EDGES );

	// move the wall edges to the start of the list
	int numWallEdges = 0;
	for ( int i = 0; i < numEdges; i++ ) {
		if ( ( file->GetEdge( abs( edges[i] ) ).flags & AAS_EDGE_WALL ) != 0 ) {
			idSwap( edges[numWallEdges++], edges[i] );
		}
	}

	for ( int i = 0; i < numEdges; i++ ) {
		idVec3 start, end;

		GetEdge( edges[i], start, end );

		if ( mode == 2 ) {

			start.z = end.z = origin.z;

		} else if ( mode == 3 ) {

			ProjectTopDown( start, viewOrigin, viewAxis, playerAxis, radius * 2.0f );
			ProjectTopDown( end, viewOrigin, viewAxis, playerAxis, radius * 2.0f );
		}

		if ( ( file->GetEdge( abs( edges[i] ) ).flags & AAS_EDGE_WALL ) != 0 ) {
			gameRenderWorld->DebugLine( colorRed, start, end, 0 );
		} else {
			gameRenderWorld->DebugLine( colorGreen, start, end, 0 );
		}
		if ( showNumbers ) {
			gameRenderWorld->DrawText( va( "%d", edges[i] ), ( start + end ) * 0.5f, textSize, colorWhite, viewAxis, 1, 0 );
		}
	}

	if ( mode == 3 ) {
		idVec3 box[7] = { origin, origin, origin, origin, origin, origin, origin };

		box[0][0] += radius;
		box[0][1] += radius;

		box[1][0] += radius;
		box[1][1] -= radius;

		box[2][0] -= radius;
		box[2][1] -= radius;

		box[3][0] -= radius;
		box[3][1] += radius;

		box[4][1] += radius;

		box[5][0] += radius * 0.1f;
		box[5][1] += radius - radius * 0.1f;

		box[6][0] -= radius * 0.1f;
		box[6][1] += radius - radius * 0.1f;

		for ( int i = 0; i < 7; i++ ) {
			ProjectTopDown( box[i], viewOrigin, viewAxis, playerAxis, radius * 2.0f );
		}
		for ( int i = 0; i < 4; i++ ) {
			gameRenderWorld->DebugLine( colorCyan, box[i], box[(i+1)&3], 0 );
		}
		gameRenderWorld->DebugLine( colorCyan, box[4], box[5], 0 );
		gameRenderWorld->DebugLine( colorCyan, box[4], box[6], 0 );
	}
}