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