void init(IStorm3D* s3d, IStorm3D_Scene* scene) {
				
		GenParticleSystem::init(s3d, scene);
		
		std::string fileName;
		m_pb->getValue(PB_POINT_ARRAY_MODEL_FILE, fileName);
		if(fileName.empty())
			return;
		
		IStorm3D_Model* model = s3d->CreateNewModel();
		if(model->LoadS3D(fileName.c_str())) 
		{
			Iterator<IStorm3D_Model_Object*>* obj = model->ITObject->Begin();
			IStorm3D_Mesh* mesh = obj->GetCurrent()->GetMesh();
			if(mesh) {
				boost::shared_ptr<ParticleMesh> pm(new ParticleMesh());
				pm->verts.resize(mesh->GetVertexCount());
				pm->normals.resize(mesh->GetVertexCount());
				Storm3D_Vertex* v = mesh->GetVertexBuffer();
				for(int i = 0; i < mesh->GetVertexCount(); i++) {
					pm->verts[i] = v[i].position;
					pm->normals[i] = v[i].normal;
				}
				m_mesh.swap(pm);
			}
			delete obj;
		}
		delete model;

	}
Ejemplo n.º 2
0
void CollisionModel::create()
{
	data->model = boost::shared_ptr<IStorm3D_Model> (data->storm.storm->CreateNewModel());
	data->model->CastShadows(false);
	
	IStorm3D_Material *material = data->storm.storm->CreateNewMaterial("ah");
	IStorm3D_Model_Object *object = data->model->Object_New("uh");
	IStorm3D_Mesh *mesh = data->storm.storm->CreateNewMesh();

	material->SetSpecial(true, true);
	material->SetColor(data->color);
	material->SetSelfIllumination(COL(1.f,1.f,1.f));

	mesh->UseMaterial(material);
	data->createMesh(*mesh);
	object->SetMesh(mesh);

	QUAT rotation = getRotation(data->rotation);
	//rotation.MakeFromAngles(0, data->yAngle, 0);

	data->model->SetPosition(data->position);
	data->model->SetRotation(rotation);

	data->addScene();
}
Ejemplo n.º 3
0
		SharedModel(shared_ptr<IStorm3D_Model> model_, shared_ptr<IStorm3D_Model> fadeModel_, const std::string &bones_, const std::string &idleAnimation_)
		:	model(model_),
			fadeModel(fadeModel_),
			bones(bones_),
			idleAnimation(idleAnimation_),
			radius(0),
			radius2d(0)
		{
			boost::scoped_ptr<Iterator<IStorm3D_Model_Object *> > objectIterator(model->ITObject->Begin());
			for(; !objectIterator->IsEnd(); objectIterator->Next())
			{
				IStorm3D_Model_Object *object = objectIterator->GetCurrent();
				if(!object)
					continue;

				IStorm3D_Mesh *mesh = object->GetMesh();
				if(!mesh)
					continue;

				VC3 objectPosition = object->GetPosition();
				float objectDistance = objectPosition.GetLength();
				float distance = objectDistance + mesh->GetRadius();
				if(distance > radius)
					radius = distance;

				float meshRadius = mesh->GetRadius();
				if(meshRadius + objectDistance > radius2d)
					radius2d = meshRadius + objectDistance;
			}

			if(!bones.empty())
				model->LoadBones(bones.c_str());
		}
void PointArrayParticleSystem::init(IStorm3D* s3d, IStorm3D_Scene* scene)
{
    defaultInit(s3d, scene, *m_eds);

    std::string fileName = m_eds->modelFile;
    if(fileName.empty())
        return;

    Matrix sm;
    Matrix rm;
    QUAT q;
    q.MakeFromAngles(m_eds->rotation.x, m_eds->rotation.y, m_eds->rotation.z);
    rm.CreateRotationMatrix(q);
    sm.CreateScaleMatrix(m_eds->scale);
    sm.Multiply(rm);
    IStorm3D_Model* model = s3d->CreateNewModel();
    assert(model != NULL);

    if(model->LoadS3D(fileName.c_str()))
    {
        Iterator<IStorm3D_Model_Object*>* obj = model->ITObject->Begin();
        assert(obj != NULL);

        boost::shared_ptr<PointArray> pm(new PointArray());
        for(; !obj->IsEnd(); obj->Next())
        {
            IStorm3D_Mesh* mesh = obj->GetCurrent()->GetMesh();
            VC3 opos = obj->GetCurrent()->GetPosition();

            if(mesh)
            {
                int base = pm->verts.size();
                pm->verts.resize(base + mesh->GetVertexCount());
                pm->normals.resize(base + mesh->GetVertexCount());

                Storm3D_Vertex *v = mesh->GetVertexBuffer();
                for(int i = 0; i < mesh->GetVertexCount(); i++)
                {
                    Vector pos = v[i].position + opos;
                    Vector nor = v[i].normal;
                    sm.TransformVector(pos);
                    rm.RotateVector(nor);

                    pm->verts[base + i] = pos;
                    pm->normals[base + i] = nor;
                }
            }
        }

        m_parray.swap(pm);
        if(m_eds->firstVertex < 0)
            m_eds->firstVertex = 0;
        if(m_eds->lastVertex >= (int)m_parray->verts.size())
            m_eds->lastVertex = m_parray->verts.size()-1;

        delete obj;
    }
    delete model;
}
boost::shared_ptr<PhysicsMesh> ParticlePhysics::createConvexMesh(const char *filename, IStorm3D_Model_Object *object)
{
	boost::shared_ptr<PhysicsMesh> mesh(new PhysicsMesh());
	IStorm3D_Mesh *stormMesh = object->GetMesh();

	int vertexAmount = stormMesh->GetVertexCount();
	const Storm3D_Vertex *buffer = stormMesh->GetVertexBufferReadOnly();

	VC3 minValues(10000.f, 10000.f, 10000.f);
	VC3 maxValues(-10000.f, -10000.f, -10000.f);
	for(int i = 0; i < vertexAmount; ++i)
	{
		VC3 pos = buffer[i].position;

		minValues.x = std::min(minValues.x, pos.x);
		minValues.y = std::min(minValues.y, pos.y);
		minValues.z = std::min(minValues.z, pos.z);

		maxValues.x = std::max(maxValues.x, pos.x);
		maxValues.y = std::max(maxValues.y, pos.y);
		maxValues.z = std::max(maxValues.z, pos.z);
	}

	VC3 size = maxValues - minValues;
	if(size.x < MIN_BOX_SIZE)
	{
		float diff = (MIN_BOX_SIZE - size.x) * 0.5f;
		maxValues.x += diff;
		minValues.x -= diff;
	}
	if(size.y < MIN_BOX_SIZE)
	{
		float diff = (MIN_BOX_SIZE - size.y) * 0.5f;
		maxValues.y += diff;
		minValues.y -= diff;
	}
	if(size.z < MIN_BOX_SIZE)
	{
		float diff = (MIN_BOX_SIZE - size.z) * 0.5f;
		maxValues.z += diff;
		minValues.z -= diff;
	}

	mesh->size = (maxValues - minValues) * 0.5f;
	mesh->localPosition = minValues + mesh->size;
	mesh->localPosition.y -= mesh->size.y;
	mesh->volume = mesh->size.x * mesh->size.y * mesh->size.z * 2.f;

	return mesh;
}
Ejemplo n.º 6
0
	void createMesh(IStorm3D_Mesh &mesh)
	{
		Vector v[8];
		v[0] = Vector(data.radiusX, 0, data.radiusZ);
		v[1] = Vector(data.radiusX, 0, -data.radiusZ);
		v[2] = Vector(-data.radiusX, 0, data.radiusZ);
		v[3] = Vector(-data.radiusX, 0, -data.radiusZ);

		v[4] = v[0] + Vector(0, data.height, 0);
		v[5] = v[1] + Vector(0, data.height, 0);
		v[6] = v[2] + Vector(0, data.height, 0);
		v[7] = v[3] + Vector(0, data.height, 0);

		mesh.ChangeVertexCount(8);
		mesh.ChangeFaceCount(24);

		Storm3D_Vertex *vertexBuffer = mesh.GetVertexBuffer();
		Storm3D_Face *faceBuffer = mesh.GetFaceBuffer();

		for(int i = 0; i < 8; ++i)
			vertexBuffer[i].position = v[i];

		faceBuffer[0].vertex_index[0] = 0;
		faceBuffer[0].vertex_index[1] = 1;
		faceBuffer[0].vertex_index[2] = 2;
		faceBuffer[1].vertex_index[0] = 1;
		faceBuffer[1].vertex_index[1] = 2;
		faceBuffer[1].vertex_index[2] = 3;
		faceBuffer[2].vertex_index[0] = 4;
		faceBuffer[2].vertex_index[1] = 5;
		faceBuffer[2].vertex_index[2] = 6;
		faceBuffer[3].vertex_index[0] = 5;
		faceBuffer[3].vertex_index[1] = 6;
		faceBuffer[3].vertex_index[2] = 7;
		faceBuffer[4].vertex_index[0] = 0;
		faceBuffer[4].vertex_index[1] = 1;
		faceBuffer[4].vertex_index[2] = 4;
		faceBuffer[5].vertex_index[0] = 4;
		faceBuffer[5].vertex_index[1] = 5;
		faceBuffer[5].vertex_index[2] = 1;
		faceBuffer[6].vertex_index[0] = 2;
		faceBuffer[6].vertex_index[1] = 3;
		faceBuffer[6].vertex_index[2] = 6;			
		faceBuffer[7].vertex_index[0] = 6;
		faceBuffer[7].vertex_index[1] = 7;
		faceBuffer[7].vertex_index[2] = 3;
		faceBuffer[8].vertex_index[0] = 0;
		faceBuffer[8].vertex_index[1] = 2;
		faceBuffer[8].vertex_index[2] = 6;
		faceBuffer[9].vertex_index[0] = 6;
		faceBuffer[9].vertex_index[1] = 4;
		faceBuffer[9].vertex_index[2] = 0;
		faceBuffer[10].vertex_index[0] = 1;
		faceBuffer[10].vertex_index[1] = 3;
		faceBuffer[10].vertex_index[2] = 7;
		faceBuffer[11].vertex_index[0] = 7;
		faceBuffer[11].vertex_index[1] = 5;
		faceBuffer[11].vertex_index[2] = 1;

		faceBuffer[0+12].vertex_index[0] = 0;
		faceBuffer[0+12].vertex_index[1] = 2;
		faceBuffer[0+12].vertex_index[2] = 1;
		faceBuffer[1+12].vertex_index[0] = 1;
		faceBuffer[1+12].vertex_index[1] = 3;
		faceBuffer[1+12].vertex_index[2] = 2;
		faceBuffer[2+12].vertex_index[0] = 4;
		faceBuffer[2+12].vertex_index[1] = 6;
		faceBuffer[2+12].vertex_index[2] = 5;
		faceBuffer[3+12].vertex_index[0] = 5;
		faceBuffer[3+12].vertex_index[1] = 7;
		faceBuffer[3+12].vertex_index[2] = 6;
		faceBuffer[4+12].vertex_index[0] = 0;
		faceBuffer[4+12].vertex_index[1] = 4;
		faceBuffer[4+12].vertex_index[2] = 1;
		faceBuffer[5+12].vertex_index[0] = 4;
		faceBuffer[5+12].vertex_index[1] = 1;
		faceBuffer[5+12].vertex_index[2] = 5;
		faceBuffer[6+12].vertex_index[0] = 2;
		faceBuffer[6+12].vertex_index[1] = 6;
		faceBuffer[6+12].vertex_index[2] = 3;			
		faceBuffer[7+12].vertex_index[0] = 6;
		faceBuffer[7+12].vertex_index[1] = 3;
		faceBuffer[7+12].vertex_index[2] = 7;
		faceBuffer[8+12].vertex_index[0] = 0;
		faceBuffer[8+12].vertex_index[1] = 6;
		faceBuffer[8+12].vertex_index[2] = 2;
		faceBuffer[9+12].vertex_index[0] = 6;
		faceBuffer[9+12].vertex_index[1] = 0;
		faceBuffer[9+12].vertex_index[2] = 4;
		faceBuffer[10+12].vertex_index[0] = 1;
		faceBuffer[10+12].vertex_index[1] = 7;
		faceBuffer[10+12].vertex_index[2] = 3;
		faceBuffer[11+12].vertex_index[0] = 7;
		faceBuffer[11+12].vertex_index[1] = 1;
		faceBuffer[11+12].vertex_index[2] = 5;
	}