Exemple #1
0
	void		walk		(ISpatial_NODE* N, Fvector& n_C, float n_R, u32 fmask)
	{
		// box
		float	n_vR	=		2*n_R;
		Fbox	BB;		BB.set	(n_C.x-n_vR, n_C.y-n_vR, n_C.z-n_vR, n_C.x+n_vR, n_C.y+n_vR, n_C.z+n_vR);
		if		(fcvNone==F->testAABB(BB.data(),fmask))	return;

		// test items
		xr_vector<ISpatial*>::iterator _it	=	N->items.begin	();
		xr_vector<ISpatial*>::iterator _end	=	N->items.end	();
		for (; _it!=_end; _it++)
		{
			ISpatial*		S	= *_it;
			if (0==(S->spatial.type&mask))	continue;

			Fvector&		sC		= S->spatial.sphere.P;
			float			sR		= S->spatial.sphere.R;
			u32				tmask	= fmask;
			if (fcvNone==F->testSphere(sC,sR,tmask))	continue;

			space->q_result->push_back	(S);
		}

		// recurse
		float	c_R		= n_R/2;
		for (u32 octant=0; octant<8; octant++)
		{
			if (0==N->children[octant])	continue;
			Fvector		c_C;			c_C.mad	(n_C,c_spatial_offset[octant],c_R);
			walk						(N->children[octant],c_C,c_R,fmask);
		}
	}
Exemple #2
0
float CBaseMonster::get_screen_space_coverage_diagonal()
{
	Fbox		b		= Visual()->getVisData().box;

	Fmatrix				xform;
	xform.mul			(Device.mFullTransform,XFORM());
	Fvector2	mn		={flt_max,flt_max},mx={flt_min,flt_min};

	for (u32 k=0; k<8; ++k)
	{
		Fvector p;
		b.getpoint		(k,p);
		xform.transform	(p);
		mn.x			= _min(mn.x,p.x);
		mn.y			= _min(mn.y,p.y);
		mx.x			= _max(mx.x,p.x);
		mx.y			= _max(mx.y,p.y);
	}

	float const width	=	mx.x - mn.x;
	float const height	=	mx.y - mn.y;

	float const	average_diagonal	=	_sqrt(width * height);
	return				average_diagonal;
}
Exemple #3
0
void ESceneAIMapTool::CalculateNodesBBox(Fbox& bb)
{
    bb.invalidate();
	for (AINodeIt b_it=m_Nodes.begin(); b_it!=m_Nodes.end(); ++b_it)
    {
    	VERIFY(_valid((*b_it)->Pos));
    	bb.modify((*b_it)->Pos);
    }
}
IC void get_cam_oob( Fvector	&bc, Fvector &bd, Fmatrix33	&mat, const Fmatrix &xform, const SRotation &r_torso, float alpha, float radius, float c )
{
	get_box_mat ( mat, alpha, r_torso );
	Fbox				xf;
	get_q_box( xf, c, alpha, radius );
	xf.xform			( Fbox().set(xf), xform )	;
	// query
	xf.get_CD			(bc,bd)		;
}
Exemple #5
0
void CalculateRelSet(Fvector &pos, vecW &rel_set)
{
	// calculate volume in local level space
	Fbox	Volume;
	Volume.set(pos,pos);
	float	Vsize = (g_params.m_relevance+g_params.m_sample_step)/2.f; 
	Volume.min.sub(Vsize);
	Volume.max.add(Vsize);
	Volume.min.sub(g_TREE_ROOT->bbox.min);
	Volume.max.sub(g_TREE_ROOT->bbox.min);

	// scale it to sample grid space
	Volume.min.div(g_params.m_sample_step);
	Volume.max.div(g_params.m_sample_step);

	// calc volume in grid-space
	int minX,minY,minZ;
	int maxX,maxY,maxZ;

	minX = iROUND(floorf(Volume.min.x));	clamp(minX, 0, int(g_pvs_X)-1);
	minY = iROUND(floorf(Volume.min.y));	clamp(minY, 0, int(g_pvs_Y)-1);
	minZ = iROUND(floorf(Volume.min.z));	clamp(minZ, 0, int(g_pvs_Z)-1);

	maxX = iROUND(ceilf(Volume.max.x));		clamp(maxX, 0, int(g_pvs_X)-1);
	maxY = iROUND(ceilf(Volume.max.y));		clamp(maxY, 0, int(g_pvs_Y)-1);
	maxZ = iROUND(ceilf(Volume.max.z));		clamp(maxZ, 0, int(g_pvs_Z)-1);

	/*
	clMsg("- Selected BB: [%d,%d,%d]-[%d,%d,%d]",
		minX,minY,minZ,
		maxX,maxY,maxZ
		);
	*/

	// merge data
	for (int z=minZ; z<=maxZ; z++) {
		for (int x=minX; x<=maxX; x++) {
			for (int y=minY; y<=maxY; y++)
			{
				u32	cell	= z*g_pvs_X*g_pvs_Y + x*g_pvs_Y + y;
//				clMsg("* Sample #%d",cell);
				int		ptr		= g_pvs_map_vm[cell];
				if (ptr>=0)
				{
					rel_set.insert(rel_set.end(),g_pvs[ptr].begin(),g_pvs[ptr].end());
				}
			}
		}
	}
	if (rel_set.size()>1)
	{
		std::sort(rel_set.begin(),rel_set.end());
		vecW_IT I = std::unique(rel_set.begin(),rel_set.end());
		rel_set.erase(I,rel_set.end());
	}
}
void CPHMovementControl::Load					(LPCSTR section){

	//capture
	
	//strcpy(m_capture_bone,pSettings->r_string(section,"capture_bone"));
	
	Fbox	bb;

	// m_PhysicMovementControl: BOX
	Fvector	vBOX1_center= pSettings->r_fvector3	(section,"ph_box1_center"	);
	Fvector	vBOX1_size	= pSettings->r_fvector3	(section,"ph_box1_size"		);
	bb.set	(vBOX1_center,vBOX1_center); bb.grow(vBOX1_size);
	SetBox		(1,bb);

	// m_PhysicMovementControl: BOX
	Fvector	vBOX0_center= pSettings->r_fvector3	(section,"ph_box0_center"	);
	Fvector	vBOX0_size	= pSettings->r_fvector3	(section,"ph_box0_size"		);
	bb.set	(vBOX0_center,vBOX0_center); bb.grow(vBOX0_size);
	SetBox		(0,bb);

	//// m_PhysicMovementControl: Foots
	//Fvector	vFOOT_center= pSettings->r_fvector3	(section,"ph_foot_center"	);
	//Fvector	vFOOT_size	= pSettings->r_fvector3	(section,"ph_foot_size"		);
	//bb.set	(vFOOT_center,vFOOT_center); bb.grow(vFOOT_size);
	//SetFoots	(vFOOT_center,vFOOT_size);

	// m_PhysicMovementControl: Crash speed and mass
	float	cs_min		= pSettings->r_float	(section,"ph_crash_speed_min"	);
	float	cs_max		= pSettings->r_float	(section,"ph_crash_speed_max"	);
	float	mass		= pSettings->r_float	(section,"ph_mass"				);
	xr_token retrictor_types[]={
		{ "actor",			CPHCharacter::rtActor},
		{ "medium_monster",	CPHCharacter::rtMonsterMedium},
		{ "stalker",		CPHCharacter::rtStalker	},
		{ "none",			CPHCharacter::rtNone	},
		{ 0,							0}
	};

	if(pSettings->line_exist(section,"actor_restrictor"))
		SetRestrictionType(CPHCharacter::ERestrictionType(pSettings->r_token(section,"actor_restrictor",retrictor_types)));
	fCollisionDamageFactor=READ_IF_EXISTS(pSettings,r_float,section,"ph_collision_damage_factor",fCollisionDamageFactor);
	R_ASSERT3(fCollisionDamageFactor<=1.f,"ph_collision_damage_factor >1.",section);
	SetCrashSpeeds	(cs_min,cs_max);
	SetMass		(mass);


	// m_PhysicMovementControl: Frictions
	//float af, gf, wf;
	//af					= pSettings->r_float	(section,"ph_friction_air"	);
	//gf					= pSettings->r_float	(section,"ph_friction_ground");
	//wf					= pSettings->r_float	(section,"ph_friction_wall"	);
	//SetFriction	(af,wf,gf);

	// BOX activate
//	ActivateBox	(0);
}
Exemple #7
0
bool ESceneObjectTools::GetBox		(Fbox& bb)
{
	bb.invalidate					();
    Fbox bbo;
    for (ObjectIt a_it=m_Objects.begin(); a_it!=m_Objects.end(); a_it++){
    	(*a_it)->GetBox				(bbo);
        bb.merge					(bbo);
    }
    return bb.is_valid();
}
Exemple #8
0
void modify							(const int &vertex_id, Fbox &bounding_box)
{
	const CGameGraph		&graph = ai().game_graph();
	bounding_box.modify		(graph.vertex(vertex_id)->game_point());

	CGameGraph::const_iterator	I,E;
	graph.begin				(vertex_id,I,E);
	for ( ; I != E; ++I)
		bounding_box.modify	(graph.vertex(graph.value(vertex_id,I))->game_point());
}
IC void get_q_box( Fbox &xf,  float c, float alpha, float radius )
{
	Fvector src_pt,		tgt_pt;
	calc_point			(tgt_pt,radius,0,alpha);
	src_pt.set			(0,tgt_pt.y,0);
	xf.invalidate		();
	xf.modify			(src_pt);
	xf.modify			(tgt_pt);
	xf.grow				(c);

}
Exemple #10
0
int EScene::BoxQuery(SPickQuery& PQ, const Fbox& bb, u32 flags, CDB::MODEL* model)
{
    PQ.prepare_bq	(bb,flags);
	ETOOLS::box_options	(flags);
    Fvector c,d;
    bb.getcenter	(c);
    bb.getradius	(d);
    ETOOLS::box_query	(model,c,d);
    for (int r=0; r<ETOOLS::r_count(); r++)
        PQ.append	(ETOOLS::r_begin()+r,0,0);
	return PQ.r_count();
}
void EDetailManager::UpdateSlotBBox(int sx, int sz, DetailSlot& slot)
{
	Fbox bbox;
    Frect rect;
    GetSlotRect			(rect,sx,sz);
    bbox.min.set		(rect.x1, m_BBox.min.y, rect.y1);
    bbox.max.set		(rect.x2, m_BBox.max.y, rect.y2);

    SBoxPickInfoVec pinf;
    ETOOLS::box_options(0);
    if (Scene->BoxPickObjects(bbox,pinf,&m_SnapObjects)){
		bbox.grow		(EPS_L_VAR);
    	Fplane			frustum_planes[4];
		frustum_planes[0].build(bbox.min,left_vec);
		frustum_planes[1].build(bbox.min,back_vec);
		frustum_planes[2].build(bbox.max,right_vec);
		frustum_planes[3].build(bbox.max,fwd_vec);

        CFrustum frustum;
        frustum.CreateFromPlanes(frustum_planes,4);

        float y_min		= flt_max;
        float y_max		= flt_min;
		for (SBoxPickInfoIt it=pinf.begin(); it!=pinf.end(); it++){
        	for (int k=0; k<(int)it->inf.size(); k++){
                float range;
                Fvector verts[3];
                it->e_obj->GetFaceWorld(it->s_obj->_Transform(),it->e_mesh,it->inf[k].id,verts);
                sPoly sSrc	(verts,3);
                sPoly sDest;
                sPoly* sRes = frustum.ClipPoly(sSrc, sDest);
                if (sRes){
                    for (u32 k=0; k<sRes->size(); k++){
                        float H = (*sRes)[k].y;
                        if (H>y_max) y_max = H+0.03f;
                        if (H<y_min) y_min = H-0.03f;
                    }
                    slot.w_y	(y_min,y_max-y_min);
                    slot.w_id(0,DetailSlot::ID_Empty);
                    slot.w_id(1,DetailSlot::ID_Empty);
                    slot.w_id(2,DetailSlot::ID_Empty);
                    slot.w_id(3,DetailSlot::ID_Empty);
                }
            }
	    }
    }else{
    	ZeroMemory(&slot,sizeof(DetailSlot));
    	slot.w_id(0,DetailSlot::ID_Empty);
    	slot.w_id(1,DetailSlot::ID_Empty);
    	slot.w_id(2,DetailSlot::ID_Empty);
    	slot.w_id(3,DetailSlot::ID_Empty);
    }
}
Exemple #12
0
float	CalculateHeight(Fbox& BB)
{
	// All nodes
	BB.invalidate();

	for (u32 i=0; i<g_nodes.size(); i++)
	{
		vertex&	N	= g_nodes[i];
		BB.modify	(N.Pos);
	}
	return BB.max.y-BB.min.y+EPS_L;
}
Exemple #13
0
void ESceneLightTools::SelectLightsForObject(CCustomObject* obj)
{
    for (u32 i=0; i<frame_light.size(); i++){
        CLight* l = frame_light[i];
//        if (obj->IsDynamic()&&!l->m_Flags.is(CLight::flAffectDynamic)) continue;
//        if (!obj->IsDynamic()&&!l->m_Flags.is(CLight::flAffectStatic)) continue;
        Fbox bb; 	obj->GetBox(bb);
        Fvector C; 	float R; bb.getsphere(C,R);
        float d 	= C.distance_to(l->PPosition) - l->m_Range - R;
        Device.LightEnable(i,(d<0));
    }
}
Exemple #14
0
bool CGroupObject::FrustumPick(const CFrustum& frustum)
{
    if (m_Objects.empty()){
        Fbox 		bb;
        GetBox		(bb);
        u32 mask	= u32(-1); 
        return (frustum.testAABB(bb.data(),mask));
    }else{
        for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++)
            if ((*it)->FrustumPick(frustum)) return true;
    }
    return false;
}
Exemple #15
0
void CEditableObject::UpdateBox(){
	VERIFY(!m_Meshes.empty());
    EditMeshIt m = m_Meshes.begin();
    m_Box.invalidate();
    for(;m!=m_Meshes.end();m++){
        Fbox meshbox;
        (*m)->GetBox(meshbox);
        for(int i=0; i<8; i++){
            Fvector pt;
            meshbox.getpoint(i, pt);
            m_Box.modify(pt);
        }
    }
}
Exemple #16
0
void CDrawUtilities::OnDeviceCreate()
{
	Device.seqRender.Add			(this,REG_PRIORITY_LOW-1000);

	m_SolidBox.CreateFromData		(D3DPT_TRIANGLELIST,DU_BOX_NUMFACES,		D3DFVF_XYZ|D3DFVF_DIFFUSE,du_box_vertices,			DU_BOX_NUMVERTEX,			du_box_faces,			DU_BOX_NUMFACES*3);
	m_SolidCone.CreateFromData		(D3DPT_TRIANGLELIST,DU_CONE_NUMFACES,		D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cone_vertices,		DU_CONE_NUMVERTEX,			du_cone_faces,			DU_CONE_NUMFACES*3);
	m_SolidSphere.CreateFromData	(D3DPT_TRIANGLELIST,DU_SPHERE_NUMFACES,		D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_vertices,		DU_SPHERE_NUMVERTEX,		du_sphere_faces,		DU_SPHERE_NUMFACES*3);
	m_SolidSpherePart.CreateFromData(D3DPT_TRIANGLELIST,DU_SPHERE_PART_NUMFACES,D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_part_vertices,	DU_SPHERE_PART_NUMVERTEX,	du_sphere_part_faces,	DU_SPHERE_PART_NUMFACES*3);
    m_SolidCylinder.CreateFromData	(D3DPT_TRIANGLELIST,DU_CYLINDER_NUMFACES,	D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cylinder_vertices,	DU_CYLINDER_NUMVERTEX,		du_cylinder_faces,		DU_CYLINDER_NUMFACES*3);
    m_WireBox.CreateFromData		(D3DPT_LINELIST,	DU_BOX_NUMLINES,		D3DFVF_XYZ|D3DFVF_DIFFUSE,du_box_vertices,			DU_BOX_NUMVERTEX,			du_box_lines,			DU_BOX_NUMLINES*2);
	m_WireCone.CreateFromData		(D3DPT_LINELIST,	DU_CONE_NUMLINES,		D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cone_vertices,		DU_CONE_NUMVERTEX,			du_cone_lines,			DU_CONE_NUMLINES*2);
	m_WireSphere.CreateFromData		(D3DPT_LINELIST,	DU_SPHERE_NUMLINES,		D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_verticesl,		DU_SPHERE_NUMVERTEXL,		du_sphere_lines,		DU_SPHERE_NUMLINES*2);
	m_WireSpherePart.CreateFromData	(D3DPT_LINELIST,	DU_SPHERE_PART_NUMLINES,D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_part_vertices,	DU_SPHERE_PART_NUMVERTEX,	du_sphere_part_lines,	DU_SPHERE_PART_NUMLINES*2);
    m_WireCylinder.CreateFromData	(D3DPT_LINELIST,	DU_CYLINDER_NUMLINES,	D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cylinder_vertices,	DU_CYLINDER_NUMVERTEX,		du_cylinder_lines,		DU_CYLINDER_NUMLINES*2);

	for(int i=0;i<LINE_DIVISION;i++){                                
		float angle = M_PI * 2.f * (i / (float)LINE_DIVISION);
        float _sa=_sin(angle), _ca=_cos(angle);
		circledef1[i].x = _ca;
		circledef1[i].y = _sa;
		circledef1[i].z = 0;
		circledef2[i].x = 0;
		circledef2[i].y = _ca;
		circledef2[i].z = _sa;
		circledef3[i].x = _sa;
		circledef3[i].y = 0;
		circledef3[i].z = _ca;
	}
    // initialize identity box
	Fbox bb;
	bb.set(-0.505f,-0.505f,-0.505f, 0.505f,0.505f,0.505f);
	for (i=0; i<8; i++){
    	Fvector S;
    	Fvector p;
        bb.getpoint(i,p);
        S.set((float)SIGN(p.x),(float)SIGN(p.y),(float)SIGN(p.z));
    	boxvert[i*6+0].set(p);
    	boxvert[i*6+1].set(p.x-S.x*0.25f,p.y,p.z);
    	boxvert[i*6+2].set(p);
    	boxvert[i*6+3].set(p.x,p.y-S.y*0.25f,p.z);
    	boxvert[i*6+4].set(p);
    	boxvert[i*6+5].set(p.x,p.y,p.z-S.z*0.25f);
    }
    // create render stream
	vs_L.create		(FVF::F_L,RCache.Vertex.Buffer(),RCache.Index.Buffer());
    vs_TL.create	(FVF::F_TL,RCache.Vertex.Buffer(),RCache.Index.Buffer());
    vs_LIT.create	(FVF::F_LIT,RCache.Vertex.Buffer(),RCache.Index.Buffer());

	m_Font						= new CGameFont("stat_font");
}
Exemple #17
0
IC BOOL	ValidateMerge	(Fbox& bb_base, Fbox& bb, float& volume, float SLimit)
{
	// Size
	Fbox	merge;	merge.merge		(bb_base,bb);
	Fvector sz;		merge.getsize	(sz);	sz.add	(EPS_L);
	if (sz.x>SLimit)		return FALSE;	// Don't exceed limits (4/3 GEOM)
	if (sz.y>SLimit)		return FALSE;
	if (sz.z>SLimit)		return FALSE;

	// Volume
	volume		= merge.getvolume	();

	// OK
	return TRUE;
}
Exemple #18
0
bool ESoundSource::GetBox( Fbox& box )
{
	box.set( m_Params.position, m_Params.position );
	box.min.sub(m_Params.max_distance);
	box.max.add(m_Params.max_distance);
	return true;
}
Exemple #19
0
bool CGlow::GetBox( Fbox& box )
{
	box.set( PPosition, PPosition );
	box.min.sub(m_fRadius);
	box.max.add(m_fRadius);
	return true;
}
Exemple #20
0
void ESceneAIMapTool::GetBBox(Fbox& bb, bool bSelOnly)
{
    switch (LTools->GetSubTarget()){
    case estAIMapNode:{
    	if (bSelOnly){
            for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++)
                if ((*it)->flags.is(SAINode::flSelected)){
                	bb.modify(Fvector().add((*it)->Pos,-m_Params.fPatchSize*0.5f));
                	bb.modify(Fvector().add((*it)->Pos,m_Params.fPatchSize*0.5f));
                }
        }else{
        	bb.merge		(m_AIBBox);
        }
    }break;
    }
}
Exemple #21
0
bool CLight::GetBox( Fbox& box )
{
	box.set		(PPosition, PPosition);
	box.min.sub	(m_Range);
	box.max.add	(m_Range);
	return true;
}
Exemple #22
0
void ComputeSphere(Fsphere &B, FvectorVec& V)
{
    if (V.size()<3) 	{ B.P.set(0,0,0); B.R=0.f; return; }

	// 1: calc first variation
	Fsphere	S1;
    Fsphere_compute		(S1,V.begin(),V.size());
	BOOL B1				= SphereValid(V,S1);
    
	// 2: calc ordinary algorithm (2nd)
	Fsphere	S2;
	Fbox bbox;
    bbox.invalidate		();
	for (FvectorIt I=V.begin(); I!=V.end(); I++)	bbox.modify(*I);
	bbox.grow			(EPS_L);
	bbox.getsphere		(S2.P,S2.R);
	S2.R = -1;
	for (I=V.begin(); I!=V.end(); I++)	{
		float d = S2.P.distance_to_sqr(*I);
		if (d>S2.R) S2.R=d;
	}
	S2.R = _sqrt (_abs(S2.R));
	BOOL B2				= SphereValid(V,S2);

	// 3: calc magic-fm
	Mgc::Sphere _S3 = Mgc::MinSphere(V.size(), (const Mgc::Vector3*) V.begin());
	Fsphere	S3;
	S3.P.set			(_S3.Center().x,_S3.Center().y,_S3.Center().z);
	S3.R				= _S3.Radius();
	BOOL B3				= SphereValid(V,S3);

	// select best one
	if (B1 && (S1.R<S2.R)){		// miniball or FM
		if (B3 && (S3.R<S1.R)){ // FM wins
        	B.set	(S3);
		}else{					// MiniBall wins
        	B.set	(S1);
		}
	}else{						// base or FM
		if (B3 && (S3.R<S2.R)){	// FM wins
        	B.set	(S3);
		}else{					// Base wins :)
        	R_ASSERT(B2);
        	B.set	(S2);
		}
	}
}
Exemple #23
0
bool CEditShape::GetBox(Fbox& box)
{
	if (m_Box.is_valid()){
    	box.xform(m_Box,FTransform);
    	return true;
    }
	return false;
}
Exemple #24
0
bool CEditShape::RayPick(float& distance, const Fvector& start, const Fvector& direction, SRayPickInfo* pinf)
{
    float dist					= distance;

	for (ShapeIt it=shapes.begin(); it!=shapes.end(); it++){
		switch (it->type){
		case cfSphere:{
            Fvector S,D;
            Fmatrix M;
            M.invert			(FTransformR);
            M.transform_dir		(D,direction);
            FITransform.transform_tiny(S,start);
            Fsphere&	T		= it->data.sphere;
            float bk_r = T.R;
//            T.R					= FScale.x;
            T.intersect			(S,D,dist);
            if (dist<=0.f)		dist = distance;

            T.R					= bk_r;
		}break;
		case cfBox:{
        	Fbox box;
            box.identity		();
            Fmatrix BI;
            BI.invert			(it->data.box);
		    Fvector S,D,S1,D1,P;
		    FITransform.transform_tiny	(S,start);
		    FITransform.transform_dir	(D,direction);
		    BI.transform_tiny			(S1,S);
		    BI.transform_dir			(D1,D);
            Fbox::ERP_Result	rp_res 	= box.Pick2(S1,D1,P);
            if (rp_res==Fbox::rpOriginOutside){
            	it->data.box.transform_tiny	(P);
                FTransform.transform_tiny	(P);
                P.sub			(start);
                dist			= P.magnitude();
            }
		}break;
		}
    }
    if (dist<distance){
        distance	= dist;
        return 		true;
    }
	return false;
}
Exemple #25
0
IC void BoxQuery(Fbox& BB, bool exact)
{
	if (exact) 		XRC.box_options	(CDB::OPT_FULL_TEST);
	else			XRC.box_options	(0);
	Fvector			C,D;
	BB.get_CD		(C,D);
	XRC.box_query	(&Level,C,D);
}
Exemple #26
0
void	setup_bbs	(Fbox& b1, Fbox& b2, Fbox& bb,int edge)	{
	Fvector	size;
	b1.set	(bb);	b2.set(bb);
	size.sub(bb.max,bb.min);
	switch	(edge)	{
		case 0:
			b1.max.x -= size.x/2;
			b2.min.x += size.x/2;
			break;
		case 1:
			b1.max.y -= size.y/2;
			b2.min.y += size.y/2;
			break;
		case 2:
			b1.max.z -= size.z/2;
			b2.min.z += size.z/2;
			break;
	}
};
bool CLevelTool::GetSelectionPosition(Fmatrix& result)
{
	if(pCurTool)
    {
    	Fvector 			center;
    	Fbox 				BB;
        BB.invalidate		();
//    	pCurTool->GetBBox	(BB, true);

        const CCustomObject* object = pCurTool->LastSelected();
        if(!object)
        	return false;
            
        object->GetBox		(BB);
        
        BB.getcenter		(center);
        center.y			= BB.max.y;

		Fvector2			pt_ss;
        pt_ss.set			(10000,-10000);
        Fvector				pt_ss_3d;
        BB.setb				(center, Fvector().set(1.0f,1.0f,1.0f));
        for(int k=0;k<8;++k)
        {
        	Fvector pt;
        	BB.getpoint(k,pt);
			EDevice.mFullTransform.transform(pt_ss_3d, pt);
            
            pt_ss.x = _min(pt_ss.x, pt_ss_3d.y);
            pt_ss.y = _max(pt_ss.y, pt_ss_3d.y);
        }

        float r_bb_ss	 = pt_ss.y - pt_ss.x;
        clamp(r_bb_ss, 0.0f,0.10f);
        float des_radius = 0.2f; 
        float csale 	 = des_radius/r_bb_ss;
        
        result.scale	(csale,csale,csale);
        result.c 		= center;
        return 			true;
    }else
		return 			false;
}
bool CCharacterPhysicsSupport::CollisionCorrectObjPos(const Fvector& start_from,bool	character_create/*=false*/)
{
	//Fvector shift;shift.sub( start_from, m_EntityAlife.Position() );
	Fvector shift;shift.set(0,0,0);
	Fbox box;
	if(character_create)
		box.set( movement()->Box() );
	else
	{
		if(m_pPhysicsShell)
		{
			VERIFY(m_pPhysicsShell->isFullActive());
			Fvector sz,c;
			get_box( m_pPhysicsShell, mXFORM, sz, c );
			box.setb( Fvector().sub( c, m_EntityAlife.Position() ), Fvector(sz).mul(0.5f) );
			m_pPhysicsShell->DisableCollision();
		}else
			box.set( m_EntityAlife.BoundingBox() );
	}

	Fvector vbox;Fvector activation_pos;
	box.get_CD(activation_pos,vbox);
	shift.add(activation_pos);
	vbox.mul(2.f);
	activation_pos.add(shift,m_EntityAlife.Position());

	CPHActivationShape activation_shape;
	activation_shape.Create(activation_pos,vbox,&m_EntityAlife);
	if( !DoCharacterShellCollide() && !character_create )
	{
		CPHCollideValidator::SetCharacterClassNotCollide(activation_shape);
	}
	if( !character_create )
			activation_shape.set_rotation( mXFORM );
	bool ret = activation_shape.Activate(vbox,1,1.f,M_PI/8.f);
	m_EntityAlife.Position().sub(activation_shape.Position(),shift);

	activation_shape.Destroy();
	if(m_pPhysicsShell)
		m_pPhysicsShell->EnableCollision();
	return ret;
}
void CCharacterPhysicsSupport::CollisionCorrectObjPos(const Fvector& start_from,bool	character_create/*=false*/)
{
	Fvector shift;shift.sub(start_from,m_EntityAlife.Position());

	Fbox box;
	if(character_create)box.set(movement()->Box());
	else	box.set(m_EntityAlife.BoundingBox());
	Fvector vbox;Fvector activation_pos;
	box.get_CD(activation_pos,vbox);shift.add(activation_pos);vbox.mul(2.f);
	activation_pos.add(shift,m_EntityAlife.Position());
	CPHActivationShape activation_shape;
	activation_shape.Create(activation_pos,vbox,&m_EntityAlife);
	if(!DoCharacterShellCollide()&&!character_create)
	{
		CPHCollideValidator::SetCharacterClassNotCollide(activation_shape);
	}
	activation_shape.Activate(vbox,1,1.f,M_PI/8.f);
	m_EntityAlife.Position().sub(activation_shape.Position(),shift);
	activation_shape.Destroy();
}
Exemple #30
0
bool EParticlesObject::GetBox( Fbox& box )
{
	box.set( PPosition, PPosition );
	box.min.x -= PSOBJECT_SIZE;
	box.min.y -= PSOBJECT_SIZE;
	box.min.z -= PSOBJECT_SIZE;
	box.max.x += PSOBJECT_SIZE;
	box.max.y += PSOBJECT_SIZE;
	box.max.z += PSOBJECT_SIZE;
    return true;
}