PyObject* MeshPy::writeInventor(PyObject *args)
{
float creaseangle=0.0f;
if (!PyArg_ParseTuple(args, "|f",&creaseangle))
return NULL;
MeshObject* mesh = getMeshObjectPtr();
const MeshCore::MeshFacetArray& faces = mesh->getKernel().GetFacets();
std::vector<int> indices;
std::vector<Base::Vector3f> coords;
coords.reserve(mesh->countPoints());
for (MeshObject::const_point_iterator it = mesh->points_begin(); it != mesh->points_end(); ++it)
coords.push_back(Base::Vector3f((float)it->x,(float)it->y,(float)it->z));
indices.reserve(4*faces.size());
for (MeshCore::MeshFacetArray::_TConstIterator it = faces.begin(); it != faces.end(); ++it) {
indices.push_back(it->_aulPoints[0]);
indices.push_back(it->_aulPoints[1]);
indices.push_back(it->_aulPoints[2]);
indices.push_back(-1);
}
std::stringstream result;
Base::InventorBuilder builder(result);
builder.addIndexedFaceSet(coords, indices, creaseangle);
builder.close();
return Py::new_reference_to(Py::String(result.str()));
}
void saveMeshObject(const std::string& filename, MeshObject& mo)
{
std::vector<tinyobj::shape_t> out_shape(1);
tinyobj::mesh_t& mesh = out_shape[0].mesh;
VerticesArray& vts = mo.getVertices();
NormalsArray& nls = mo.getNormals();
FacesArray& fs = mo.getFaces();
for (size_t v = 0; v < vts.size(); ++ v)
{
mesh.positions.push_back(vts[v].x());
mesh.positions.push_back(vts[v].y());
mesh.positions.push_back(vts[v].z());
}
for (size_t n = 0; n < nls.size(); ++ n)
{
mesh.normals.push_back(nls[n].x());
mesh.normals.push_back(nls[n].y());
mesh.normals.push_back(nls[n].z());
}
for (size_t f = 0; f < fs.size(); ++ f)
{
mesh.indices.push_back(fs[f][0]);
mesh.indices.push_back(fs[f][1]);
mesh.indices.push_back(fs[f][2]);
}
bool ret = WriteObj(filename, out_shape, false);
assert(ret);
}
MainApplication::ComponentCollection MainApplication::addDrawDebug(MeshCollider * collider, int level)
{
BVHNode * root = collider->m_bvh->root();
Material * wireframe = new Material(Shader::find("shader"));
wireframe->setAmbientColor(glm::vec4(1.0f));
wireframe->setWireframe(true);
std::vector<BVHNode *> nodes;
collectBvhs(nodes, root, level, level);
int leaves = 0;
ComponentCollection components;
for (unsigned i = 0; i < nodes.size(); i++) {
BoundingSphere * bs = nodes[i]->m_bv;
if (nodes[i]->m_isLeaf)
leaves++;
MeshObject * sphere = new MeshObject(MeshFactory::Sphere(glm::vec4(1.0f), 10), wireframe);
sphere->transform().translate(bs->c);
sphere->transform().translate(collider->transform().position());
sphere->transform().scale(glm::vec3(1.0f) * bs->r);
components.push_back(sphere);
}
Trace::info("Nodes at level %d: %d (%d leaves)\n", level, nodes.size(), leaves);
return components;
}
void Actor::setHighlighted(bool highlight)
{
if (highlight != mHighlighted)
{
//getControlledObject()->setHighlighted(highlight);
mHighlighted = highlight;
}
if (mHighlighted && mDescription == NULL)
{
if (mSceneNode != NULL)
{
mDescription = new MovableText(mName + "_desc", mName);
mDescription->showOnTop(true);
mDescription->setAlignment(MovableText::ALIGN_CENTER);
if (mActorControlledObject && mActorControlledObject->isMeshObject())
{
MeshObject* mo = static_cast<MeshObject*>(mActorControlledObject);
AxisAlignedBox aabb = mo->getDefaultSize();
mDescription->setPositionOffset(Vector3(0, aabb.getMaximum().y * 1.1, 0));
}
mSceneNode->attachObject(mDescription);
}
}
else if (mDescription)
{
mDescription->setVisible(highlight);
}
}
void PSCM_Accessor::Set(PB2Value &v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t)
{
switch(id)
{
// case anima_specular_body:
case anima_rgb_value:
// case anima_specular_head:
if (obj!=NULL)
obj->UpdateMaterialValues();
break;
case anima_max_model_value:
if (obj!=NULL)
obj->UpdateMaxModel();
UpdateLabelInfo();
break;
case anima_filepath:
MeshObject::meshObject->Clear();
UpdateLabelInfo();
//MeshObject::meshObject->Load(v.s,FindNodeRef(MeshObject::meshObject));
//MeshObject::meshObject->Load();
// map->SetCubeMapFile(v.s);
break;
}
}
void loadMeshObject(const std::string& filename, MeshObject& mo)
{
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string err = tinyobj::LoadObj(shapes, materials, filename.c_str());
if (!err.empty()) {
std::cerr << err << std::endl;
exit(1);
}
assert(shapes.size() == 1 ? true : ("obj should be only one shape" && false));
tinyobj::mesh_t& mesh = shapes[0].mesh;
assert((mesh.positions.size() % 3) == 0);
assert((mesh.normals.size() % 3) == 0);
assert((mesh.indices.size() % 3) == 0);
VerticesArray& vts = mo.getVertices();
NormalsArray& nls = mo.getNormals();
FacesArray& fs = mo.getFaces();
for (size_t v = 0; v < mesh.positions.size() / 3; v++)
vts.push_back(VertexType(mesh.positions[3*v+0], mesh.positions[3*v+1], mesh.positions[3*v+2]));
for (size_t n = 0; n < mesh.normals.size() / 3; n++)
nls.push_back(NormalType(mesh.normals[3*n+0], mesh.normals[3*n+1], mesh.normals[3*n+2]));
for (size_t f = 0; f < mesh.indices.size() / 3; f++)
fs.push_back(Face(mesh.indices[3*f+0], mesh.indices[3*f+1], mesh.indices[3*f+2]));
}
RefTargetHandle MeshObject::Clone(RemapDir& remap)
{
MeshObject* newob = new MeshObject(NULL,false);
newob->ReplaceReference(0,remap.CloneRef(pblock));
newob->ivalid.SetEmpty();
BaseClone(this, newob, remap);
return(newob);
}
Py::List MeshPy::getFacets(void) const
{
Py::List FacetList;
MeshObject* mesh = getMeshObjectPtr();
for (MeshObject::const_facet_iterator it = mesh->facets_begin(); it != mesh->facets_end(); ++it) {
FacetList.append(Py::Object(new FacetPy(new Facet(*it)), true));
}
return FacetList;
}
PyObject* MeshFeaturePy::removeNonManifolds(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
Mesh::Feature* obj = getFeaturePtr();
MeshObject* kernel = obj->Mesh.startEditing();
kernel->removeNonManifolds();
obj->Mesh.finishEditing();
Py_Return
}
Py::List MeshPy::getPoints(void) const
{
Py::List PointList;
unsigned int Index=0;
MeshObject* mesh = getMeshObjectPtr();
for (MeshObject::const_point_iterator it = mesh->points_begin(); it != mesh->points_end(); ++it) {
PointList.append(Py::Object(new MeshPointPy(new MeshPoint(*it,getMeshObjectPtr(),Index++)), true));
}
return PointList;
}
PyObject* MeshFeaturePy::removeDuplicatedPoints(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
PY_TRY {
Mesh::Feature* obj = getFeaturePtr();
MeshObject* kernel = obj->Mesh.startEditing();
kernel->removeDuplicatedPoints();
obj->Mesh.finishEditing();
} PY_CATCH;
Py_Return;
}
PyObject* MeshFeaturePy::fixIndices(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
PY_TRY {
Mesh::Feature* obj = getFeaturePtr();
MeshObject* kernel = obj->Mesh.startEditing();
kernel->validateIndices();
obj->Mesh.finishEditing();
} PY_CATCH;
Py_Return;
}
bool MaterialSlot::setItem(Item* item)
{
if (!Slot::setItem(item))
{
return false;
}
if (item)
{
try
{
CeGuiString mat = item->getProperty("material").toString();
CeGuiString mesh = item->getSubmeshName();
///@todo: what to do if actor is null?, think about changing the inventory of an gameobject not in scene
if (mOwner->getActor())
{
MeshObject* mo = dynamic_cast<MeshObject*>(
mOwner->getActor()->getControlledObject());
MergeableMeshObject* mmo = dynamic_cast<MergeableMeshObject*>(
mo);
if (mmo && !mesh.empty())
{
mmo->replaceSubmesh(mSubmesh, mesh.c_str());
}
if (mo)
{
mo->setMaterial(mat.c_str(), mSubmesh);
}
}
}
catch (const IllegalArgumentException&)
{
LOG_ERROR(Logger::RULES, "Item " + item->getName() + " has no property material.");
}
catch (const WrongFormatException&)
{
LOG_ERROR(Logger::RULES, "Item " + item->getName() + " has a property material, but it is no string property.");
}
}
else
{
///@todo reset material?
}
return true;
}
void compute_smooth_vertex_normals_base_pose(MeshObject& object)
{
assert(object.get_vertex_normal_count() == 0);
const size_t vertex_count = object.get_vertex_count();
const size_t triangle_count = object.get_triangle_count();
vector<GVector3> normals(vertex_count, GVector3(0.0));
for (size_t i = 0; i < triangle_count; ++i)
{
Triangle& triangle = object.get_triangle(i);
triangle.m_n0 = triangle.m_v0;
triangle.m_n1 = triangle.m_v1;
triangle.m_n2 = triangle.m_v2;
const GVector3& v0 = object.get_vertex(triangle.m_v0);
const GVector3& v1 = object.get_vertex(triangle.m_v1);
const GVector3& v2 = object.get_vertex(triangle.m_v2);
const GVector3 normal = normalize(cross(v1 - v0, v2 - v0));
normals[triangle.m_v0] += normal;
normals[triangle.m_v1] += normal;
normals[triangle.m_v2] += normal;
}
object.reserve_vertex_normals(vertex_count);
for (size_t i = 0; i < vertex_count; ++i)
object.push_vertex_normal(safe_normalize(normals[i]));
}
PyObject* MeshFeaturePy::smooth(PyObject *args)
{
int iter=1;
float d_max=FLOAT_MAX;
if (!PyArg_ParseTuple(args, "|if", &iter,&d_max))
return NULL;
PY_TRY {
Mesh::Feature* obj = getFeaturePtr();
MeshObject* kernel = obj->Mesh.startEditing();
kernel->smooth(iter, d_max);
obj->Mesh.finishEditing();
} PY_CATCH;
Py_Return;
}
PyObject* MeshFeaturePy::removeFoldsOnSurface(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
try {
Mesh::Feature* obj = getFeaturePtr();
MeshObject* kernel = obj->Mesh.startEditing();
kernel->removeFoldsOnSurface();
obj->Mesh.finishEditing();
}
catch (const Base::Exception& e) {
PyErr_SetString(Base::BaseExceptionFreeCADError, e.what());
return NULL;
}
Py_Return;
}
void compute_smooth_vertex_tangents(MeshObject& object)
{
compute_smooth_vertex_tangents_base_pose(object);
for (size_t i = 0; i < object.get_motion_segment_count(); ++i)
compute_smooth_vertex_tangents_pose(object, i);
}
void ObjectCollectionItem::insert_objects(const string& path) const
{
const string base_object_name =
bf::path(path).replace_extension().filename().string();
ParamArray params;
params.insert("filename", path);
SearchPaths search_paths;
MeshObjectArray mesh_objects;
if (!MeshObjectReader().read(
search_paths,
base_object_name.c_str(),
params,
mesh_objects))
return;
for (size_t i = 0; i < mesh_objects.size(); ++i)
{
MeshObject* object = mesh_objects[i];
m_parent_item->add_item(object);
m_parent.objects().insert(auto_release_ptr<Object>(object));
const string object_instance_name = string(object->get_name()) + "_inst";
auto_release_ptr<ObjectInstance> object_instance(
ObjectInstanceFactory::create(
object_instance_name.c_str(),
ParamArray(),
object->get_name(),
Transformd::identity(),
StringDictionary()));
m_parent_item->add_item(object_instance.get());
m_parent.object_instances().insert(object_instance);
}
if (!mesh_objects.empty())
{
m_parent.bump_version_id();
m_editor_context.m_project_builder.slot_notify_project_modification();
}
}
static PyObject * importer(PyObject *self, PyObject *args)
{
char* Name;
char* DocName=0;
if (!PyArg_ParseTuple(args, "et|s","utf-8",&Name,&DocName))
return NULL;
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
PY_TRY {
App::Document *pcDoc = 0;
if (DocName)
pcDoc = App::GetApplication().getDocument(DocName);
else
pcDoc = App::GetApplication().getActiveDocument();
if (!pcDoc) {
pcDoc = App::GetApplication().newDocument(DocName);
}
MeshObject mesh;
if (mesh.load(EncodedName.c_str())) {
Base::FileInfo file(EncodedName.c_str());
unsigned long segmct = mesh.countSegments();
if (segmct > 1) {
for (unsigned long i=0; i<segmct; i++) {
std::auto_ptr<MeshObject> segm(mesh.meshFromSegment(mesh.getSegment(i).getIndices()));
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(pcDoc->addObject("Mesh::Feature", file.fileNamePure().c_str()));
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(*segm);
pcFeature->purgeTouched();
}
}
else {
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(pcDoc->addObject("Mesh::Feature", file.fileNamePure().c_str()));
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
pcFeature->purgeTouched();
}
}
} PY_CATCH;
Py_Return;
}
void compute_smooth_vertex_tangents_pose(MeshObject& object, const size_t motion_segment_index)
{
assert(object.get_tex_coords_count() > 0);
const size_t vertex_count = object.get_vertex_count();
const size_t triangle_count = object.get_triangle_count();
vector<GVector3> tangents(vertex_count, GVector3(0.0));
for (size_t i = 0; i < triangle_count; ++i)
{
const Triangle& triangle = object.get_triangle(i);
if (!triangle.has_vertex_attributes())
continue;
const GVector2 v0_uv = object.get_tex_coords(triangle.m_a0);
const GVector2 v1_uv = object.get_tex_coords(triangle.m_a1);
const GVector2 v2_uv = object.get_tex_coords(triangle.m_a2);
//
// Reference:
//
// Physically Based Rendering, first edition, pp. 128-129
//
const GScalar du0 = v0_uv[0] - v2_uv[0];
const GScalar dv0 = v0_uv[1] - v2_uv[1];
const GScalar du1 = v1_uv[0] - v2_uv[0];
const GScalar dv1 = v1_uv[1] - v2_uv[1];
const GScalar det = du0 * dv1 - dv0 * du1;
if (det == GScalar(0.0))
continue;
const GVector3& v2 = object.get_vertex_pose(triangle.m_v2, motion_segment_index);
const GVector3 dp0 = object.get_vertex_pose(triangle.m_v0, motion_segment_index) - v2;
const GVector3 dp1 = object.get_vertex_pose(triangle.m_v1, motion_segment_index) - v2;
const GVector3 tangent = normalize(dv1 * dp0 - dv0 * dp1);
tangents[triangle.m_v0] += tangent;
tangents[triangle.m_v1] += tangent;
tangents[triangle.m_v2] += tangent;
}
for (size_t i = 0; i < vertex_count; ++i)
object.set_vertex_tangent_pose(i, motion_segment_index, safe_normalize(tangents[i]));
}
// 添加一个盒子
void GameGrid::AddBox(const Point3& pos)
{
// 格子被占据，不添加
if (!m_World[pos.x][pos.y][pos.z].obj)
{
Vector3f p((float)pos.x - 0.5f - WORLD_SIZE / 2 + 1, (float)pos.y + 0.5f, (float)pos.z - 0.5f - WORLD_SIZE / 2 + 1);
WorldGrid* grid = &m_World[pos.x][pos.y][pos.z];
//grid->pos = pos;
MeshObject* obj = FACTORY_CREATE(m_Scene, MeshObject);
obj->SetMesh(m_MeshBox);
obj->SetPosition(p);
obj->SetMaterial(m_BoxMaterial, 0);
//obj->CreateLightableObject();
grid->obj = obj;
}
}
PhysicsRagDoll::PhysicsRagDoll(const Ogre::String& ragdollResource, Actor* actor) :
mRootBone(NULL),
mNode(NULL),
mWorld(NULL),
mMesh(NULL),
mSkeleton(NULL)
{
mRootBone = NULL;
mNode = actor->_getSceneNode();
mWorld = PhysicsManager::getSingleton()._getNewtonWorld();
if (!actor->getControlledObject()->isMeshObject())
Throw(IllegalArgumentException, "PhysicsRagDoll::PhysicsRagDoll needs a Mesh-Actor as argument!");
MeshObject* meshObj = static_cast<MeshObject*>(actor->getControlledObject());
// stop all animations
meshObj->stopAllAnimations();
// get the skeleton.
mSkeleton = meshObj->getEntity()->getSkeleton();
// get the mesh.
mMesh = meshObj->getEntity()->getMesh();
LOG_MESSAGE(Logger::CORE, "Loading ragdoll '" + ragdollResource + "'");
TiXmlDocument* doc = loadDocument(ragdollResource);
if (!doc)
{
LOG_ERROR(Logger::CORE, "Ragdoll resource '" + ragdollResource + "' not found");
}
else
{
TiXmlElement* dataDocumentContent = doc->RootElement();
mRootBone =_addAllBones(NULL, getChildNamed(dataDocumentContent, "Bone"), actor);
}
}
void Actor::setScale( Ogre::Real sx, Ogre::Real sy, Ogre::Real sz )
{
Node* node = getControlledObject()->getMovableObject()->getParentNode();
if( node )
{
Vector3 vec = Vector3(sx,sy,sz);
node->setScale( vec );
// Falls es sich um ein Mesh handelt ...
if( getControlledObject()->isMeshObject() )
{
MeshObject* meshObj = dynamic_cast<MeshObject*>( getControlledObject() );
// ... und größer/kleiner als normal skaliert wird ...
if( vec != Vector3(1,1,1) )
// ... müssen die Normalen neu berechnet werden.
meshObj->getEntity()->setNormaliseNormals( true );
else
meshObj->getEntity()->setNormaliseNormals( false );
}
}
}
void compute_smooth_vertex_normals_pose(MeshObject& object, const size_t motion_segment_index)
{
const size_t vertex_count = object.get_vertex_count();
const size_t triangle_count = object.get_triangle_count();
vector<GVector3> normals(vertex_count, GVector3(0.0));
for (size_t i = 0; i < triangle_count; ++i)
{
const Triangle& triangle = object.get_triangle(i);
const GVector3& v0 = object.get_vertex_pose(triangle.m_v0, motion_segment_index);
const GVector3& v1 = object.get_vertex_pose(triangle.m_v1, motion_segment_index);
const GVector3& v2 = object.get_vertex_pose(triangle.m_v2, motion_segment_index);
const GVector3 normal = normalize(cross(v1 - v0, v2 - v0));
normals[triangle.m_v0] += normal;
normals[triangle.m_v1] += normal;
normals[triangle.m_v2] += normal;
}
for (size_t i = 0; i < vertex_count; ++i)
object.set_vertex_normal_pose(i, motion_segment_index, safe_normalize(normals[i]));
}
int main(int argc, const char * argv[]) {
// Initialize glfw
if (!glfwInit()){
std::cerr << "Failed to initialize glfw" << std::endl;
exit(EXIT_FAILURE);
}
// Set the error callback for glfw
glfwSetErrorCallback(error_callback);
// Set window settings
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow *window = glfwCreateWindow(800,600, "OpenGL Renderer", NULL, NULL);
if (!window) {
std::cerr << "Could not create glfw window!" << std::endl;
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetKeyCallback(window, key_callback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
float ratio = width / (float) height;
Camera cam(glm::vec3(0,0,-2));
cam.setProjMatrix(ratio);
DefaultMaterial m(glm::vec3(.2f,.2f,.9f));
MeshObject cube;
cube.setMaterial(&m);
SceneNode cubeNode(&cube);
cubeNode.setTransform(glm::scale(glm::mat4(), glm::vec3(2)));
double lastFrameTime = glfwGetTime();
double xpos, ypos;
while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
double currentFrameTime = glfwGetTime();
double delta = currentFrameTime - lastFrameTime;
lastFrameTime = currentFrameTime;
cam.translate(glm::vec3(delta * camXSpeed, delta * camYSpeed, delta * camZSpeed));
glfwGetCursorPos(window, &xpos, &ypos);
// Cursor rotation is currently broken.
//cam.rotateFromCursor(2*xpos/width - 1, 2*ypos/height - 1);
cubeNode.render(window, cam.getViewMatrix(), cam.getProjMatrix());
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void MainApplication::initScene()
{
m_components.clear();
m_debugComponents.clear();
g_world = SoftBodyWorld();
g_body = 0;
// Create wood material
Material * woodMaterial = new Material(Shader::find("shader"));
woodMaterial->setTexture(new Texture("resources/wood.bmp"));
// Load bowl model
MeshObject * bowl = new MeshObject(MeshFactory::FromFile("resources/bowl.ply"), woodMaterial);
bowl->transform().translate(glm::vec3(0.0f, 2.0f, 0.0f));
bowl->transform().update();
// Load low-poly model of bowl for collision detection
Mesh * lowpoly = MeshFactory::FromFile("resources/bowl-low.ply");
MeshCollider * bowlCollider = new MeshCollider(bowl);
bowlCollider->m_mesh = lowpoly;
bowlCollider->m_bvh = BVH::constructFromMesh(lowpoly);
CollisionDetector::instance()->addCollider(bowlCollider);
m_components.push_back(bowl);
// Create cloth material
Material * clothMaterial = new Material(Shader::find("shader"));
clothMaterial->setTexture(new Texture("resources/cloth.bmp"));
clothMaterial->setDiffuseColor(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f));
clothMaterial->setAmbientColor(glm::vec4(0.3f, 0.3f, 0.3f, 1.0f));
clothMaterial->setSpecularColor(glm::vec4(0.5f, 0.5f, 0.5f, 1.0f));
// Create cloth mesh with attached soft body information
MeshObject * cloth = SoftBody::createCloth(clothMaterial, &g_world, &g_body);
cloth->transform().translate(glm::vec3(-2.5f, 5.0f, -2.5f));
cloth->transform().update();
m_components.push_back(cloth);
// Create material for apple
Material * appleMaterial = new Material(Shader::find("shader"));
appleMaterial->setDiffuseColor(glm::vec4(0.9f));
appleMaterial->setTexture(new Texture("resources/apple.bmp"));
// Load apple model from file
MeshObject * apple = new MeshObject(MeshFactory::FromFile("resources/apple.ply"), appleMaterial);
apple->transform().translate(glm::vec3(0.0f, 3.0f, 10.0f));
apple->transform().scale(glm::vec3(0.5f));
// Create a mathematical sphere collider for the apple
SphereCollider * sphereCollider = new SphereCollider(apple);
CollisionDetector::instance()->addCollider(sphereCollider);
m_components.push_back(apple);
// Create animator that animates the apple
KeyframeAnimator<glm::vec3> * anim = new KeyframeAnimator<glm::vec3>(apple, new LinearInterpolator<glm::vec3>, apple->transform().position());
anim->addKeyframe(0.0f, glm::vec3(0.0f, 3.0f, 10.0f));
anim->addKeyframe(20000.0f, glm::vec3(0.0f, 3.0f, -10.0f));
anim->addKeyframe(40000.0f, glm::vec3(0.0f, 3.0f, 10.0f));
m_ballAnimator = anim;
// Create some debug spheres for the BVH
int level = 0;
while (true) {
ComponentCollection components = addDrawDebug(bowlCollider, level);
if (components.empty())
break;
m_debugComponents[level] = components;
level++;
}
}
void MainApplication::initScene()
{
m_components.clear();
Material * grassMaterial = new Material(Shader::find("shader"));
grassMaterial->setTexture(new Texture("resources/ground.bmp"));
grassMaterial->setDiffuseColor(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
grassMaterial->setAmbientColor(glm::vec4(0.5f, 0.5f, 0.5f, 1.0f));
Mesh * terrain = MeshFactory::Terrain();
MeshObject * grass = new MeshObject(terrain, grassMaterial);
grass->transform().scale(glm::vec3(10.0f));
grass->transform().translate(glm::vec3(-5.0f, 0.0f, -5.0f));
m_components.push_back(grass);
{ // palm tree
PlantDefinition * def = new PlantDefinition();
def->iterations = 2;
def->angle = 22.5f;
def->diameter = 0.10f;
def->length = 0.20f;
def->thinning = 1.9f;
def->axiom = "F";
def->addTerminals("+-!?&/[]Q");
def->addProduction('F', "F[-F]F[+F]F[&F]F[/F]F[QQQQQ]F");
def->barkTexture = "resources/bark_palm.bmp";
def->leafTexture = "resources/palm_leaf.bmp";
def->size = 0.5f;
LSystem * system = new LSystem(def);
glm::vec3 position = terrain->vertexAt(random.randXX(0, terrain->vertices().size()-1)).position;
position = glm::vec3(grass->transform().world() * glm::vec4(position, 1.0f));
system->transform().translate(position);
m_components.push_back(system);
}
{ // tropical tree
PlantDefinition * def = new PlantDefinition();
def->addTerminals("+-!?&/[]<Q`");
def->iterations = 7;
def->angle = 22.5f;
def->diameter = 0.15f;
def->length = 0.15f;
def->thinning = 1.5f;
def->axiom = "A";
def->addProduction('A', "[+FLA]?????[+FLA]???????`[+FLA]");
def->addProduction('F', "S?????F");
def->addProduction('S', "F");
def->addProduction('L', "[Q--Q][Q&&Q]");
def->barkTexture = "resources/bark.bmp";
def->leafTexture = "resources/leaf.bmp";
LSystem * system = new LSystem(def);
glm::vec3 position = terrain->vertexAt(random.randXX(0, terrain->vertices().size()-1)).position;
position = glm::vec3(grass->transform().world() * glm::vec4(position, 1.0f));
system->transform().translate(position);
m_components.push_back(system);
}
{ // small tree
PlantDefinition * def = new PlantDefinition();
def->addTerminals("+-!?&/[]<FQ");
def->iterations = 13;
def->angle = 15.0f;
def->diameter = 0.02f;
def->length = 0.15f;
def->thinning = 1.3f;
def->axiom = "FA";
def->addProduction('A', "/FB???B?????BQ");
def->addProduction('B', "[//F??????A]");
def->barkTexture = "resources/bark2.bmp";
def->leafTexture = "resources/papaya_leaf.bmp";
LSystem * system = new LSystem(def, 2000.0f);
glm::vec3 position = terrain->vertexAt(random.randXX(0, terrain->vertices().size()-1)).position;
position = glm::vec3(grass->transform().world() * glm::vec4(position, 1.0f));
system->transform().translate(position);
m_components.push_back(system);
}
{ // "maple" tree
PlantDefinition * def = new PlantDefinition();
def->addTerminals("+-!?&/[]<FQ");
def->iterations = 6;
def->angle = 19.0f;
def->diameter = 0.075f;
def->length = 0.20f;
def->thinning = 2.0f;
def->axiom = "F&A";
def->addProduction('A', "F[-F/AQ]?[+FAQ]&[!FAQ]");
def->barkTexture = "resources/bark_maple.bmp";
def->leafTexture = "resources/maple_leaf.bmp";
LSystem * system = new LSystem(def, 6000.0f);
glm::vec3 position = terrain->vertexAt(random.randXX(0, terrain->vertices().size()-1)).position;
position = glm::vec3(grass->transform().world() * glm::vec4(position, 1.0f));
system->transform().translate(position);
m_components.push_back(system);
}
{ // deathly tree
PlantDefinition * def = new PlantDefinition();
def->addTerminals("+-!?&/[]Q");
def->iterations = 3;
def->angle = 22.5f;
def->diameter = 0.02f;
def->length = 0.20f;
def->thinning = 1.1f;
def->axiom = "F";
def->addProduction('F', "FF-[-F&F!F]QQ![&F??FQ-FQ]");
def->barkTexture = "resources/bark_black.bmp";
def->leafTexture = "resources/white_leaf.bmp";
LSystem * system = new LSystem(def, 3500.0f);
glm::vec3 position = terrain->vertexAt(random.randXX(0, terrain->vertices().size()-1)).position;
position = glm::vec3(grass->transform().world() * glm::vec4(position, 1.0f));
system->transform().translate(position);
m_components.push_back(system);
}
//Trace::info("Generated: %s\n", plant->generate().c_str());
}
bool VART::Human::LoadFromFile(const string& fileName)
{
XmlScene scene;
bool result = scene.LoadFromFile(fileName);
if (result) // if no read errors
{
// Detach human's root joint from local scene and add it to self
hipJointPtr = dynamic_cast<Joint*>(scene.GetObjects().front());
orientation.AddChild(*hipJointPtr);
scene.Unreference(hipJointPtr);
// Find smaller vertex on front right foot
MeshObject* rightFootFingersMeshPtr =
dynamic_cast<MeshObject*>(hipJointPtr->FindChildByName("R_footfingersMesh"));
assert(rightFootFingersMeshPtr != NULL);
hipJointPtr->FindPathTo(rightFootFingersMeshPtr, &pathToRFoot);
Point4D::xWeight = 0.1;
Point4D::yWeight = 3;
Point4D::zWeight = 2;
Point4D::operatorLess = &Point4D::WeightedLess;
rightFootFingersMeshPtr->SmallerVertex(&rfFront); // Compute right foot front
ResetPosition();
// Find smaller vertex on front left foot
MeshObject* leftFootFingersMeshPtr =
dynamic_cast<MeshObject*>(hipJointPtr->FindChildByName("L_footfingersMesh"));
assert(leftFootFingersMeshPtr != NULL);
hipJointPtr->FindPathTo(leftFootFingersMeshPtr, &pathToLFoot);
Point4D::xWeight = -0.1;
Point4D::yWeight = 3;
Point4D::zWeight = 2;
leftFootFingersMeshPtr->SmallerVertex(&lfFront); // Compute left foot front
Point4D::operatorLess = &Point4D::LexicographicalLess;
Dot* leftFootFrontDotPtr = new Dot(lfFront); // debug only
leftFootFrontDotPtr->color = Color::RED();
leftFootFingersMeshPtr->AddChild(*leftFootFrontDotPtr);
stickPositionPtr = &lfFront;
pathToStickPosPtr = &pathToLFoot;
// Load Rest Action
std::string restFile("");
restFile = VART::File::GetPathFromString(fileName) + "rest.xml";
restPtr = LoadAction(restFile);
if (restPtr)
{
restPtr->SetPriority(1);
restPtr->Activate();
//~ restPtr->SetSpeed(3);
}
// Load Breeth Action
std::string breethFile("");
breethFile = VART::File::GetPathFromString(fileName) + "breathe.xml";
breathePtr = LoadAction(breethFile);
if (breathePtr)
{
breathePtr->SetPriority(2);
breathePtr->Activate();
}
}
return result;
}
void Actor::doPlaceIntoScene(SceneNode* parent, const Vector3& position,
const Quaternion& orientation, const Ogre::String& physicsBone)
{
if( parent == NULL )
Throw(NullPointerException,
"Aktor "+mName+": Kann nicht an einen leeren parentNode angehängt werden.");
if( mBone )
Throw(IllegalArgumentException,
"Aktor "+mName+": Der Aktor ist bereits an einen Bone angehängt.");
if( mSceneNode && mSceneNode->isInSceneGraph() )
Throw(IllegalArgumentException,
"Aktor "+mName+": Der Aktor ist bereits in die Szene angehängt.");
// SceneNode erzeugen, falls nicht schon einer vorhanden
if( !mSceneNode )
mSceneNode = parent->createChildSceneNode( mName, position, orientation );
// Ansonsten am Parent befestigen
else
{
parent->addChild( mSceneNode );
mSceneNode->setPosition(position);
mSceneNode->setOrientation(orientation);
}
// Falls ein noch nicht befestigtes MovableObject vorhanden, dieses attachen
if( mActorControlledObject != NULL && !mActorControlledObject->isAttached() )
{
mActorControlledObject->_attachSceneNode(mSceneNode);
}
// Physikverknüpfung anpassen
if( mPhysicalThing != NULL && mActorControlledObject != NULL )
{
PhysicsManager::getSingleton().createPhysicsProxy(mPhysicalThing, mSceneNode);
// Knochen angegeben und handelt sich um ein Mesh
if( physicsBone.length() > 0 && mActorControlledObject->isMeshObject())
{
MeshObject* meshObj = dynamic_cast<MeshObject*>(mActorControlledObject);
Entity* ent = meshObj->getEntity();
// Braucht ein Skelett
if( !ent->hasSkeleton() )
Throw(IllegalArgumentException,
"Aktor "+mName+": Das kontrollierte MeshObject hat kein Skeleton." );
// Der Slot muss existieren
try
{
ent->getSkeleton()->getBone( physicsBone );
}
catch (Ogre::Exception) {
Throw(IllegalArgumentException,
"Aktor "+mName+": Der geforderte PhysicsBone '"+physicsBone+"' existiert nicht." );
}
mPhysicalThing->_attachToBone( meshObj, physicsBone );
}
// Dann an einem SceneNode befestigen
else
{
mPhysicalThing->_attachToSceneNode(mSceneNode);
}
}
_update();
}
bool PlayAnimationJob::execute(Ogre::Real time)
{
if (mActor && !mAnimationRunning)
{
MeshObject* mo = dynamic_cast<MeshObject*>(mActor->getControlledObject());
if (mReplaceAllAnims)
{
mo->stopAllAnimationsExcept(mAnimName);
}
if (mo->hasAnimation(mAnimName))
{
if (mDuration > 0)
{
mAnimation = mo->startAnimation(mAnimName, 1.0f, 0);
mTimeToGo = mDuration;
mAnimationRunning = true;
}
else
{
mAnimation = mo->startAnimation(mAnimName, 1.0f, mLoops);
mTimeToGo = mAnimation->getLength() * (float)mLoops;
mAnimationRunning = true;
}
}
else
{
mAnimation = NULL;
mTimeToGo = 0;
}
}
mTimeToGo -= time;
if (mTimeToGo <= 0.0f)
{
if (mAnimationRunning && mAnimation)
{
mAnimationRunning = false;
mAnimation->pause();
if (!mHoldOnEnd)
{
if( mActor )
{
MeshObject* mo = dynamic_cast<MeshObject*>(mActor->getControlledObject());
mo->stopAnimation(mAnimName);
}
else
{
//! TODO: what to do here?
}
}
mAnimation = NULL;
}
return true;
}
return false;
}
