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; }