Exemple #1
0
// 下滤算法
void filter(int *data, unsigned int i, unsigned int n)
{
	int currentNodeValue = data[i];
	unsigned int child = leftChildIndex(i);
	
	while (child < n)
	{
		if (hasSibling(child, n) && data[child + 1] < data[child])
		{
			child++;	// 取左右子节点中，更小的值
		}
		
		if (data[child] < currentNodeValue)
		{
			data[i] = data[child];
			i = child;
			child = leftChildIndex(i);
		}
		else
		{
			break;
		}
	}
	
	data[i] = currentNodeValue;
}
Exemple #2
0
void ElysiumEngine::RigidBody::lateInitialize()
{
    if(hasSibling("Transform"))
    {
        transform = getSibling<Transform>("Transform");
    }
    else
    {
        assert(0 && "Rigid Body relies on Transform");
    }
    
    if(m_Gravity)
    {
        accumulator.AddForce(new Gravity(Vec4(0.0f,m_GravMag,0.0f),m_Mass));
    }
    
    switch(m_Type)
	{
        case E_SPHERE:
		{
			if(!hasSibling("SphereCollider"))
				return;
			SphereCollider *Collider = getSibling<SphereCollider>("SphereCollider");
			m_IntertiaTensor[0][0] = m_IntertiaTensor[1][1] = m_IntertiaTensor[2][2] = Collider->getRadius() * Collider->getRadius();
			m_IntertiaTensor *= (2.0f / 5.0f)  * m_Mass;
			m_IntertiaTensor[3][3] = 1.0f;
		}
            break;
        case E_BOX:
		{
			if(!hasSibling("OBBCollider"))
				return;
			Vec4 Scale = transform->GetScale();
			m_IntertiaTensor[0][0] = Scale.y * Scale.y + Scale.z * Scale.z;
			m_IntertiaTensor[1][1] = Scale.x * Scale.x + Scale.z * Scale.z;
			m_IntertiaTensor[2][2] = Scale.x * Scale.x + Scale.y * Scale.y;
			m_IntertiaTensor *= 1.0f / 12.0f * m_Mass;
			m_IntertiaTensor[3][3] = 1.0f;
			break;
		}
        case E_MESH:
            break;
	}
	m_InverseTensor = m_IntertiaTensor.Inverse();
    
    if(hasSibling("MeshRenderable"))
    {
        MeshRenderable *renderable = getSibling<MeshRenderable>("MeshRenderable");
        Mesh *mesh = renderable->getMesh();
        Matrix tensor;
        tensor.Identity();
        this->m_IntertiaTensor.Identity();
        
        Vec4 *verts = new Vec4[mesh->vertexCount];
        int *indices = new int[mesh->indexCount * 3];
        
        for(int i = 0; i < mesh->vertexCount; ++i)
        {
            verts[i] = mesh->vertices[i].position;
        }
        
        for(int i = 0; i < mesh->indexCount * 3; ++i)
        {
            indices[i] = mesh->indices[i];
        }
        
        compute(verts, mesh->indexCount , indices, m_Mass, com, this->m_IntertiaTensor);
        
        m_Mass *= density;
        m_InverseMass = 1.0f / m_Mass;

        m_IntertiaTensor *= density;
        
        m_InverseTensor = m_IntertiaTensor.Inverse();
        
        std::cout << "\nMass: " << m_Mass << std::endl;
        delete []verts;
        delete []indices;
    }
}