void updateTransform() { m_transform.localToParent() = g_matrix4_identity; if(isModel()) { matrix4_translate_by_vec3(m_transform.localToParent(), m_originKey.m_origin); matrix4_multiply_by_matrix4(m_transform.localToParent(), rotation_toMatrix(m_rotationKey.m_rotation)); } m_transformChanged(); if(!isModel()) { m_funcStaticOrigin.originChanged(); } }
void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const { renderSolid(renderer, volume, localToWorld, selected); if(g_showNames && isModel()) { renderer.addRenderable(m_renderName, localToWorld); } }
void Doom3Group::freezeTransform() { m_originKey.m_origin = m_origin; m_originKey.write(&_entity); if (!isModel()) { ChildTransformFreezer freezer; _owner.traverse(freezer); } else { m_rotationKey.m_rotation = m_rotation; m_rotationKey.write(&_entity, isModel()); } m_curveNURBS.freezeTransform(); m_curveNURBS.saveToEntity(_entity); m_curveCatmullRom.freezeTransform(); m_curveCatmullRom.saveToEntity(_entity); }
void Doom3Group::rotate(const Quaternion& rotation) { if (!isModel()) { ChildRotator rotator(rotation); _owner.traverse(rotator); } else { m_rotation.rotate(rotation); } }
void skinChanged() { if(isModel()) { scene::Node* node = m_model.getNode(); if(node != 0) { Node_modelSkinChanged(*node); } } }
void Doom3Group::translate(const Vector3& translation, bool rotation) { bool freeModelRotation = GlobalRegistry().get(RKEY_FREE_MODEL_ROTATION) == "1"; // greebo: If the translation does not originate from // a pivoted rotation, translate the origin as well (this is a bit hacky) // This also applies for models, which should always have the // rotation-translation applied (except for freeModelRotation set to TRUE) if (!rotation || (isModel() && !freeModelRotation)) { m_origin = m_originKey.m_origin + translation; } // Only non-models should have their rendered origin different than <0,0,0> if (!isModel()) { m_nameOrigin = m_origin; } m_renderOrigin.updatePivot(); translateChildren(translation); }
void Doom3Group::translateOrigin(const Vector3& translation) { m_origin = m_originKey.m_origin + translation; // Only non-models should have their rendered origin different than <0,0,0> if (!isModel()) { m_nameOrigin = m_origin; } m_renderOrigin.updatePivot(); }
void Doom3Group::originChanged() { m_origin = m_originKey.m_origin; updateTransform(); // Only non-models should have their origin different than <0,0,0> if (!isModel()) { m_nameOrigin = m_origin; // Update the renderable name _owner._renderableName.setOrigin(getOrigin()); } m_renderOrigin.updatePivot(); }
void Chunk::createObjects(const math::ivec3 &chunkPos, const cyberCubes::model::ModelTextures &modelTextures) { for (uint16_t i = 0; i < CHUNK_SIZE *CHUNK_SIZE *CHUNK_SIZE; ++i) { CubeType c = cubes[i]; if (isModel(c)) { math::ivec3 p = ind2c(i); BlockData data = getBlockData(i); updateObjects(chunkPos, p, c, data, modelTextures); } } }
void modelChanged(const char* value) { m_modelKey = value; updateIsModel(); if(isModel()) { m_model.modelChanged(value); } else { m_model.modelChanged(""); } }
void Doom3Group::updateTransform() { _owner.localToParent() = Matrix4::getIdentity(); if (isModel()) { _owner.localToParent().translateBy(m_origin); _owner.localToParent().multiplyBy(m_rotation.getMatrix4()); } // Notify the Node about this transformation change to update the local2World matrix _owner.transformChanged(); }
void Doom3Group::modelChanged(const std::string& value) { m_modelKey = value; updateIsModel(); if (isModel()) { m_model.modelChanged(value); m_nameOrigin = Vector3(0,0,0); } else { m_model.modelChanged(""); m_nameOrigin = m_origin; } m_renderOrigin.updatePivot(); }
void destroy() { m_entity.detach(m_keyObservers); if(isModel()) { detachModel(); } else { detachTraverse(); } m_traverseObservers.detach(m_funcStaticOrigin); }
void Doom3Group::freezeTransform() { m_originKey.set(m_origin); m_originKey.write(_entity); if (!isModel()) { scene::foreachTransformable(_owner.shared_from_this(), [] (ITransformable& child) { child.freezeTransform(); }); } else { m_rotationKey.m_rotation = m_rotation; m_rotationKey.write(&_entity, isModel()); } m_curveNURBS.freezeTransform(); m_curveNURBS.saveToEntity(_entity); m_curveCatmullRom.freezeTransform(); m_curveCatmullRom.saveToEntity(_entity); }
void Doom3Group::revertTransform() { m_origin = m_originKey.m_origin; // Only non-models should have their origin different than <0,0,0> if (!isModel()) { m_nameOrigin = m_origin; } else { m_rotation = m_rotationKey.m_rotation; } m_renderOrigin.updatePivot(); m_curveNURBS.revertTransform(); m_curveCatmullRom.revertTransform(); }
void Doom3Group::scale(const Vector3& scale) { if (!isModel()) { // Scale all child nodes too scene::foreachTransformable(_owner.shared_from_this(), [&] (ITransformable& child) { child.setType(TRANSFORM_PRIMITIVE); child.setScale(scale); }); m_origin *= scale; m_nameOrigin = m_origin; m_renderOrigin.updatePivot(); } }
void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const { if(isModel() && selected) { m_renderOrigin.render(renderer, volume, localToWorld); } renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly); renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eFullMaterials); if(!m_curveNURBS.m_renderCurve.m_vertices.empty()) { renderer.addRenderable(m_curveNURBS.m_renderCurve, localToWorld); } if(!m_curveCatmullRom.m_renderCurve.m_vertices.empty()) { renderer.addRenderable(m_curveCatmullRom.m_renderCurve, localToWorld); } }
void Doom3Group::rotate(const Quaternion& rotation) { if (!isModel()) { // Rotate all child nodes too scene::foreachTransformable(_owner.shared_from_this(), [&] (ITransformable& child) { child.setType(TRANSFORM_PRIMITIVE); child.setRotation(rotation); }); m_origin = rotation.transformPoint(m_origin); m_nameOrigin = m_origin; m_renderOrigin.updatePivot(); } else { m_rotation.rotate(rotation); } }
void prepare(const char * fname){ bTrack *tmp=new bTrack(); if(isModel(fname)){ Model *tmpModel=new Model(); tmpModel->readModel(fname); for(int i=0 ; i < tmpModel->form->nTracks; i++){ char *bfname=tmpModel->getTrackName(i); if(!tmp->check(bfname)){ tmp->makeBinTrack(bfname); nPrepare++; } } del(tmpModel); } else if(!tmp->check(fname)) { tmp->makeBinTrack(fname); nPrepare++; } del(tmp); }
bool isAbsolute() const { return ( ! theComponents.empty() && theComponents.front()[0] == DELIMITER ) || isModel(); }
SystemPath SystemPath::toRelative( SystemPath const& aBaseSystemPath ) const { // 1. "" (empty) means Model itself, which is invalid for this method. // 2. Not absolute is invalid (not absolute implies not empty). if( ! isAbsolute() || isModel() ) { return *this; } if( ! aBaseSystemPath.isAbsolute() || aBaseSystemPath.isModel() ) { THROW_EXCEPTION( BadSystemPath, "[" + aBaseSystemPath.asString() + "] is not an absolute SystemPath" ); } SystemPath aThisPathCopy; SystemPath const* thisPath; if ( !isCanonicalized() ) { aThisPathCopy = *this; aThisPathCopy.canonicalize(); thisPath = &aThisPathCopy; } else { thisPath = this; } SystemPath aBaseSystemPathCopy; SystemPath const* aCanonicalizedBaseSystemPath; if ( !aBaseSystemPath.isCanonicalized() ) { aCanonicalizedBaseSystemPath = &aBaseSystemPath; } else { aBaseSystemPathCopy = aBaseSystemPath; aBaseSystemPathCopy.canonicalize(); aCanonicalizedBaseSystemPath = &aBaseSystemPathCopy; } SystemPath aRetval; StringVector::const_iterator j( thisPath->theComponents.begin() ), je( thisPath->theComponents.end() ); StringVector::const_iterator i( aCanonicalizedBaseSystemPath->theComponents.begin() ), ie( aCanonicalizedBaseSystemPath->theComponents.end() ); while ( i != ie && j != je ) { String const& aComp( *i ); if ( aComp != *j ) { break; } ++i, ++j; } if ( i != ie ) { while ( i != ie ) { aRetval.theComponents.push_back( ".." ); ++i; } } std::copy( j, je, std::back_inserter( aRetval.theComponents ) ); if ( aRetval.theComponents.empty() ) { aRetval.theComponents.push_back( "." ); } return aRetval; }