void PasteCommand::execute(void)
{
NodeRefPtr ClonedNodeInCopyClipboard = _ApplicationPlayer->getClonedNodeInCopyClipboard();
if(_DeepClone)
{
_PastedNode = deepCloneTree(_ApplicationPlayer->getClonedNodeInCopyClipboard());
}
else
{
_PastedNode = cloneTree(_ApplicationPlayer->getClonedNodeInCopyClipboard());
}
const Char8* NameChar = getName(_ApplicationPlayer->getClonedNodeInCopyClipboard());
std::string _Name= (NameChar == NULL ? "UNNAMED NODE" : NameChar);
_Name+=" copy";
setName(_PastedNode,_Name);
if(_PastedNode!=NULL)
{
_HierarchyPanel->getSceneGraphTreeModel()->addNode(_ParentNode,_PastedNode);
}
_HasBeenDone = true;
}
OSG_USING_NAMESPACE
Particles::Particles(std::string fileName, bool makeClone)
{
int i;
particleSystemInfo.pConfigFile = new char[512];
sprintf( (char *)particleSystemInfo.pConfigFile, "%s/effect.xml", fileName.c_str());
particleSystemInfo.rUpdatesPerSecond = 30;
particleSystemInfo.iRandomSeed = time( NULL );
particleSystemInfo.rSynchronisationInterval = 1.0f;
particleSystemInfo.iForwardThreshold = 50;
pParticles = pCreateParticleSystem( particleSystemInfo );
// delete particleSystemInfo.pConfigFile;
particleNode = Node::create();
particleModelNode = pParticles != 0 ? pParticles->pGetNodePtr() : Node::create();
// particleNode = pParticles != 0 ? pParticles->pGetNodePtr() : Node::create();
Vec3f boundingBoxSize = pParticles->GetSize();
particleTransNode = Node::create();
particleTrans = Transform::create();
particleModelTrans = Transform::create();
Matrix m;
m.setIdentity();
beginEditCP(particleTrans, Transform::MatrixFieldMask);
particleTrans->setMatrix(m);
endEditCP(particleTrans, Transform::MatrixFieldMask);
beginEditCP(particleModelTrans, Transform::MatrixFieldMask);
particleModelTrans->setMatrix(m);
endEditCP(particleModelTrans, Transform::MatrixFieldMask);
beginEditCP(particleNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
particleNode->setCore(particleModelTrans);
particleNode->addChild(particleModelNode);
endEditCP(particleNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode);
particleTransNode->setCore(particleTrans);
if (makeClone)
particleTransNode->addChild(cloneTree(particleNode));
else
particleTransNode->addChild(particleNode);
// set volume static to prevent constant update
Volume &v = particleTransNode->getVolume( false ).getInstance();
v.setEmpty();
v.extendBy( Pnt3f( -boundingBoxSize[0], -boundingBoxSize[1], -boundingBoxSize[2] ) );
v.extendBy( Pnt3f( boundingBoxSize[0], boundingBoxSize[1], boundingBoxSize[2] ) );
v.setStatic();
((DynamicVolume&)particleTransNode->getVolume()).instanceChanged();
endEditCP(particleTransNode);
cloned = false;
} // Particles
/* recursively clone a tree */
static stTree *cloneTree(stTree *srcNode, stTree *destParent, struct malnCompCompMap *srcDestCompMap) {
stTree *destNode = cloneNode(srcNode, srcDestCompMap);
stTree_setParent(destNode, destParent);
for (int i = 0; i < stTree_getChildNumber(srcNode); i++) {
cloneTree(stTree_getChild(srcNode, i), destNode, srcDestCompMap);
}
return destNode;
}
/* Clone tree1 and then attach the children of tree2 at the copy of the
* specified attachment point. */
static stTree *joinTrees(stTree *srcRoot1, stTree *srcAttach1, stTree *srcRoot2, struct malnCompCompMap *srcDestCompMap) {
assertJoinCompatible(srcAttach1, srcRoot2);
assert(stTree_getParent(srcRoot2) == NULL);
stTree *joinedRoot = cloneTree(srcRoot1, NULL, srcDestCompMap);
struct mafTreeNodeCompLink *srcAttach1NcLink = getNodeCompLink(srcAttach1);
stTree *joinLeaf = searchByComp(joinedRoot, malnCompCompMap_get(srcDestCompMap, srcAttach1NcLink->comp));
cloneChildren(srcRoot2, joinLeaf, srcDestCompMap);
return joinedRoot;
}
NodeTransitPtr cloneTree(const OSG::Node *rootNode,
const std::vector<OSG::UInt16> &cloneGroupIds,
const std::vector<OSG::UInt16> &ignoreGroupIds)
{
std::vector<const ReflexiveContainerType *> cloneTypes;
std::vector<const ReflexiveContainerType *> ignoreTypes;
return cloneTree(rootNode, cloneTypes, ignoreTypes,
cloneGroupIds, ignoreGroupIds);
}
//////////////////////////////////////////////////////////////////////////
//! trimesh defined by filenode will be loaded
//////////////////////////////////////////////////////////////////////////
void buildTriMesh(void)
{
NodeRefPtr tri = cloneTree(TriGeometryBase);
if(tri!=NULL)
{
GeometryRefPtr triGeo = dynamic_cast<Geometry*>(tri->getCore());
Matrix m;
SimpleMaterialRefPtr tri_mat = SimpleMaterial::create();
tri_mat->setAmbient(Color3f(0.1,0.1,0.2));
tri_mat->setDiffuse(Color3f(1.0,0.1,0.7));
triGeo->setMaterial(tri_mat);
TransformRefPtr triTrans;
NodeRefPtr triTransNode = makeCoredNode<Transform>(&triTrans);
m.setIdentity();
Real32 randX = (Real32)(rand()%10)-5.0;
Real32 randY = (Real32)(rand()%10)-5.0;
m.setTranslate(randX, randY, 18.0);
triTrans->setMatrix(m);
//create ODE data
Vec3f GeometryBounds(calcMinGeometryBounds(triGeo));
PhysicsBodyRefPtr triBody = PhysicsBody::create(physicsWorld);
triBody->setPosition(Vec3f(randX, randY, 18.0));
triBody->setLinearDamping(0.0001);
triBody->setAngularDamping(0.0001);
triBody->setBoxMass(1.0,GeometryBounds.x(), GeometryBounds.y(), GeometryBounds.z());
PhysicsGeomRefPtr triGeom;
if(true)
{
triGeom = PhysicsTriMeshGeom::create();
triGeom->setBody(triBody);
//add geom to space for collision
triGeom->setSpace(physicsSpace);
//set the geometryNode to fill the ode-triMesh
NodeRefPtr TorusGeometryNode(makeTorus(0.55, 1.05, 6, 6));
dynamic_pointer_cast<PhysicsTriMeshGeom>(triGeom)->setGeometryNode(TorusGeometryNode);
}
//add attachments
tri->addAttachment(triGeom);
triTransNode->addAttachment(triBody);
//add to SceneGraph
triTransNode->addChild(tri);
spaceGroupNode->addChild(triTransNode);
}
else
{
SLOG << "Could not read MeshData!" << endLog;
}
commitChanges();
}
void Particles::createSymmetricEmitterLine(Vec3f dir, Real32 dist, UInt16 num)
{
NodePtr localTransNode;
TransformPtr localTrans;
Matrix m;
dir.normalize();
for (int i = 1; i < num; i++)
{
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(-i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
} // for
} // createSymmetricEmitterLine
void VRMLFile::use(const Char8 *szName)
{
SceneFileHandler::the()->updateReadProgress();
Time beginUse = getSystemTime();
FieldContainerUnrecPtr pUsedFC;
// try to find a container with the given name attachment
#ifdef OSG_DEBUG_VRML
indentLog(VRMLNodeHelper::getIndent(), PINFO);
PINFO << "VRMLFile::use : looking for "
<< szName
<< std::endl;
VRMLNodeHelper::incIndent();
#endif
pUsedFC = findReference(szName);
if(pUsedFC == NULL)
{
PWARNING << "No fieldContainer with name found to use"
<< szName
<< std::endl;
}
else
{
// assign nodepointer to current sf|mf field
if(_pCurrNodeHelper != NULL)
{
if(pUsedFC->getType().isNode())
{
Node *pRootNode = dynamic_pointer_cast<Node>(pUsedFC);
pUsedFC = cloneTree(pRootNode);
}
_pCurrNodeHelper->setContainerFieldValue( pUsedFC,
_pCurrentFieldDesc,
_pCurrentFieldFC );
}
}
#ifdef OSG_DEBUG_VRML
VRMLNodeHelper::decIndent();
#endif
useTime += (getSystemTime() - beginUse);
}
Particles::Particles(Particles* src)
{
int i;
particleSystemInfo = src->particleSystemInfo;
pParticles = src->pParticles;
// particleNode = pParticles != 0 ? pParticles->pGetNodePtr() : Node::create();
particleNode = Node::create();
particleModelNode = pParticles->pGetNodePtr();
assert(particleModelNode != NullFC);
Vec3f boundingBoxSize = pParticles->GetSize();
particleTransNode = Node::create();
particleTrans = Transform::create();
particleModelTrans = Transform::create();
Matrix m;
m.setIdentity();
beginEditCP(particleTrans, Transform::MatrixFieldMask);
particleTrans->setMatrix(m);
endEditCP(particleTrans, Transform::MatrixFieldMask);
beginEditCP(particleModelTrans, Transform::MatrixFieldMask);
particleModelTrans->setMatrix(m);
endEditCP(particleModelTrans, Transform::MatrixFieldMask);
beginEditCP(particleNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
particleNode->setCore(particleModelTrans);
particleNode->addChild(particleModelNode);
endEditCP(particleNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode);
particleTransNode->setCore(particleTrans);
particleTransNode->addChild(cloneTree(particleNode));
// set volume static to prevent constant update
Volume &v = particleTransNode->getVolume( false ).getInstance();
v.setEmpty();
v.extendBy( Pnt3f( -boundingBoxSize[0], -boundingBoxSize[1], -boundingBoxSize[2] ) );
v.extendBy( Pnt3f( boundingBoxSize[0], boundingBoxSize[1], boundingBoxSize[2] ) );
v.setStatic();
((DynamicVolume&)particleTransNode->getVolume()).instanceChanged();
endEditCP(particleTransNode);
cloned = true;
} // Particles
NodeTransitPtr cloneTree(const OSG::Node *rootNode,
const std::string &cloneTypesString,
const std::string &ignoreTypesString)
{
std::vector<const ReflexiveContainerType *> cloneTypes;
std::vector<const ReflexiveContainerType *> ignoreTypes;
std::vector<UInt16> cloneGroupIds;
std::vector<UInt16> ignoreGroupIds;
appendTypesString(cloneTypesString, cloneTypes);
appendTypesString(ignoreTypesString, ignoreTypes);
return cloneTree(rootNode, cloneTypes, ignoreTypes,
cloneGroupIds, ignoreGroupIds);
}
void Particles::reset(bool makeClone)
{
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->subChild(0);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
delete pParticles;
pParticles = pCreateParticleSystem( particleSystemInfo );
particleNode = pParticles != 0 ? pParticles->pGetNodePtr() : Node::create();
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
if (makeClone)
particleTransNode->addChild(cloneTree(particleNode));
else
particleTransNode->addChild(particleNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
} // reset
void Particles::duplicate(Vec3f deltaPos, Quaternion deltaRot)
{
NodePtr copyTransNode = cloneTree(particleTransNode);
TransformPtr copyTrans = Transform::create();
Matrix m;
m.setIdentity();
m.setRotate(deltaRot);
m.setTranslate(deltaPos);
beginEditCP(copyTrans);
copyTrans->setMatrix(m);
endEditCP(copyTrans);
beginEditCP(copyTransNode);
copyTransNode->setCore(copyTrans);
endEditCP(copyTransNode);
beginEditCP(particleTransNode);
particleTransNode->addChild(copyTransNode);
endEditCP(particleTransNode);
} // duplicate
Node *
ColladaNode::createInstance(ColladaInstanceElement *colInstElem)
{
OSG_COLLADA_LOG(("ColladaNode::createInstance\n"));
NodeUnrecPtr retVal = NULL;
// if(getInstStore().empty() == true)
// {
// retVal = _topN;
// }
// else
// {
retVal = cloneTree(_topN);
// }
editInstStore().push_back(retVal);
return retVal;
}
Node *
ColladaNode::createInstance(ColladaInstInfo *colInstInfo)
{
Node *retVal = NULL;
domNodeRef node = getDOMElementAs<domNode>();
#if 0 // old trunk patch
if(_topN->getParent() != NULL)
{
retVal = cloneTree(_topN);
}
#endif
if(node->getType() == NODETYPE_JOINT)
{
retVal = createInstanceJoint(colInstInfo, node);
}
else
{
retVal = createInstanceNode(colInstInfo, node);
}
return retVal;
}
/* clone child and append clones to a give parent node */
static void cloneChildren(stTree *srcParent, stTree *destParent, struct malnCompCompMap *srcDestCompMap) {
for (int i = 0; i < stTree_getChildNumber(srcParent); i++) {
stTree_setParent(cloneTree(stTree_getChild(srcParent, i), destParent, srcDestCompMap), destParent);
}
}
tree_sTable *
tree_CloneTable(pwr_tStatus *sts, tree_sTable *tp)
{
return cloneTree(sts, tp);
}
// Initialize GLUT & OpenSG and set up the rootNode
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseMoved(boost::bind(mouseMoved, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
UInt32 SceneMask(1),
NanobotMask(2),
PathMask(4);
BoostPath SceneFilePath(".//Data//CellParts.osb");
if(argc >= 2)
{
SceneFilePath = BoostPath(argv[1]);
if(!boost::filesystem::exists(SceneFilePath))
{
SceneFilePath = BoostPath(".//Data//CellParts.osb");
}
}
//Make Base Geometry Node
NodeRecPtr SceneGeometryNode =
SceneFileHandler::the()->read(SceneFilePath.string().c_str());
SceneGeometryNode->setTravMask(SceneMask);
if(SceneGeometryNode == NULL)
{
SceneGeometryNode = makeTorus(1.0, 10.0, 24, 24);
}
//Construct the Root Node
NodeRecPtr RootNode = makeCoredNode<Group>();
RootNode->addChild(SceneGeometryNode);
commitChanges();
//Create the Octree
SLOG << "Started Building Octree" << std::endl;
SLOG << "This may take some time ..." << std::endl;
Time StartTime;
StartTime = getSystemTime();
OctreePtr TheOctree =
Octree::buildTree(RootNode,SceneMask,6,0.5,true);
SLOG << "Building Octree: " << getSystemTime() - StartTime << " s" << std::endl;
Pnt3f Min,Max;
TheOctree->getRoot()->getVolume();
SLOG << "Octree: "<< std::endl
<< " Depth: " << TheOctree->getDepth() << std::endl
<< " Bounds: " << TheOctree->getRoot()->getVolume().getMin() << " : " << TheOctree->getRoot()->getVolume().getMax() << std::endl
<< " NodeCount: " << TheOctree->getNodeCount() << std::endl
<< " LeafNodeCount: " << TheOctree->getLeafNodeCount() << std::endl
<< " BranchNodeCount: " << TheOctree->getBranchNodeCount() << std::endl
<< " IntersectingNodeCount: " << TheOctree->getIntersectingNodeCount() << std::endl
<< " IntersectingLeafNodeCount: " << TheOctree->getIntersectingLeafNodeCount() << std::endl;
//Make the Nanobot Nodes
BoostPath NanobotFilePath(".//Data//Nanobot.osb");
NodeRecPtr NanobotGeoNode =
SceneFileHandler::the()->read(NanobotFilePath.string().c_str());
NanobotVector Nanobots;
UInt32 NumNanobots(3);
for(UInt32 i(0) ; i<NumNanobots ; ++i)
{
NanobotDetails TheDetails;
//Get the Transform node for the Nanobot
TheDetails._Transform = Transform::create();
Matrix NanobotMatrix;
Pnt3f Min,Max;
SceneGeometryNode->getVolume().getBounds(Min,Max);
Min = Min + ShrinkFactor;
Max = Max - ShrinkFactor;
NanobotMatrix.setTranslate(randomOpenPosition(Min,Max,TheOctree).subZero());
NanobotMatrix.setScale(0.06f);
TheDetails._Transform->setMatrix(NanobotMatrix);
TheDetails._Node = makeNodeFor(TheDetails._Transform);
TheDetails._Node->addChild(cloneTree(NanobotGeoNode));
TheDetails._Node->setTravMask(NanobotMask);
TheDetails._PathVisNode = Node::create();
Nanobots.push_back(TheDetails);
makeNanobotPath(Nanobots.back(), TheOctree, TutorialWindow, Min,Max);
}
for(UInt32 i(0) ; i<Nanobots.size() ; ++i)
{
RootNode->addChild(Nanobots[i]._Node);
RootNode->addChild(Nanobots[i]._PathVisNode);
}
commitChanges();
//NodeRecPtr StartNode = makeSphere(1.0, 2);
//TransformRecPtr StartNodeTransform = Transform::create();
//Matrix StartNodeMatrix;
//StartNodeMatrix.setTranslate(Start);
//StartNodeMatrix.setScale(0.1f);
//StartNodeTransform->setMatrix(StartNodeMatrix);
//NodeRecPtr StartNodeTransformNode = makeNodeFor(StartNodeTransform);
//StartNodeTransformNode->addChild(StartNode);
//StartNodeTransformNode->setTravMask(PathMask);
//RootNode->addChild(StartNodeTransformNode);
//NodeRecPtr GoalNode = makeSphere(1.0, 2);
//TransformRecPtr GoalNodeTransform = Transform::create();
//Matrix GoalNodeMatrix;
//GoalNodeMatrix.setScale(0.1f);
//GoalNodeMatrix.setTranslate(Goal);
//GoalNodeTransform->setMatrix(GoalNodeMatrix);
//NodeRecPtr GoalNodeTransformNode = makeNodeFor(GoalNodeTransform);
//GoalNodeTransformNode->addChild(GoalNode);
//GoalNodeTransformNode->setTravMask(PathMask);
//RootNode->addChild(GoalNodeTransformNode);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1,
TutorialWindow.get(),
SceneGeometryNode.get(),
TheOctree,
Nanobots));
//Set the background
SolidBackgroundRecPtr TheBackground = SolidBackground::create();
TheBackground->setColor(Color3f(0.0f,0.0f,0.0f));
// tell the manager what to manage
sceneManager.setRoot (RootNode);
sceneManager.getWindow()->getPort(0)->setBackground(TheBackground);
// show the whole RootNode
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"01AStarPathing");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(int argc, char **argv)
{
printf("Press key '9' or '0' to toggle light sources.\n");
printf("Set the shadow mode with key '1' ... '8'\n");
printf("Change MapSize with keys 'y' = 512, 'x' = 1024, 'c' = 2048\n");
printf("NOTE: Real point lights only supported for ShadowMode 1...6!\n");
// OSG init
OSG::osgInit(argc, argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
gwin = OSG::GLUTWindow::create();
//Erstellen der ben�tigten Komponenten--------------------------------------
rootNode = OSG::makeCoredNode<OSG::Group>();
OSG::NodeUnrecPtr scene = OSG::makeCoredNode<OSG::Group>();
/*
// create lights
//Directional Light 1
OSG::NodeUnrecPtr light1 = OSG::makeCoredNode<OSG::DirectionalLight>(&_light1_core);
OSG::NodeUnrecPtr light1_beacon = OSG::makeCoredNode<OSG::Transform>(&_light1_trans);
_light1_trans->editMatrix().setTranslate(0.0, 0.0, 0.0);
_light1_core->setDirection(0.8,0.8,0.5);
_light1_core->setAmbient(0.15,0.15,0.15,1);
_light1_core->setDiffuse(0.5,0.5,0.5,1);
_light1_core->setSpecular(0.0,0.0,0.0,1);
_light1_core->setBeacon(light1_beacon);
_light1_core->setShadowIntensity(0.7);
_light1_core->setOn(true);
*/
// Point Light 1
OSG::NodeUnrecPtr light1 = OSG::makeCoredNode<OSG::PointLight>(&_light1_core);
OSG::NodeUnrecPtr light1_beacon = OSG::makeCoredNode<OSG::Transform >(&_light1_trans);
_light1_trans->editMatrix().setTranslate(50.0, 50.0, 10.0);
_light1_core->setAmbient(0.15f, 0.15f, 0.15f, 1);
_light1_core->setDiffuse(0.5f, 0.5f, 0.5f, 1);
_light1_core->setSpecular(0.0f, 0.0f, 0.0f, 1);
_light1_core->setBeacon(light1_beacon);
_light1_core->setOn(true);
_light1_core->setShadowIntensity(0.8f);
// Spot Light 2
OSG::NodeUnrecPtr light2 = OSG::makeCoredNode<OSG::SpotLight>(&_light2_core);
OSG::NodeUnrecPtr light2_beacon = OSG::makeCoredNode<OSG::Transform>(&_light2_trans);
//_light2_trans->editMatrix().setTranslate(75.0, 0.0, 25.0);
_light2_trans->editMatrix().setTranslate(250.0, -250.0, 300.0);
_light2_core->setAmbient(0.15,0.15,0.15,1);
_light2_core->setDiffuse(0.5,0.5,0.5,1);
_light2_core->setSpecular(0.0,0.0,0.0,1);
_light2_core->setSpotCutOffDeg(40.0);
_light2_core->setSpotDirection(-0.85,0.85,-1.0);
_light2_core->setBeacon(light2_beacon);
_light2_core->setShadowIntensity(0.7);
_light2_core->setOn(true);
/*
// Point Light 2
OSG::NodeUnrecPtr light2 = OSG::makeCoredNode<OSG::PointLight>(&_light2_core);
OSG::NodeUnrecPtr light2_beacon = OSG::makeCoredNode<OSG::Transform> (&_light2_trans);
_light2_trans->editMatrix().setTranslate(40.0, 0.0, 40.0);
_light2_core->setAmbient(0.15f, 0.15f, 0.15f, 1);
_light2_core->setDiffuse(0.5f, 0.5f, 0.5f, 1);
_light2_core->setSpecular(0.0f, 0.0f, 0.0f, 1);
_light2_core->setBeacon(light2_beacon);
_light2_core->setOn(false);
_light2_core->setShadowIntensity(0.7f);
*/
light1->addChild(light2);
light2->addChild(scene);
//Eigene Kamera erstellen
Pcamera = OSG::PerspectiveCamera::create();
cam_beacon = OSG::makeCoredNode<OSG::Transform>(&cam_trans);
cam_trans->editMatrix().setTranslate(0.0, 0.0, 25.0);
Pcamera->setBeacon(cam_beacon);
Pcamera->setFov(OSG::osgDegree2Rad(60));
Pcamera->setNear(1.0);
Pcamera->setFar(1000);
// create scene
// bottom
OSG::NodeUnrecPtr plane = OSG::makePlane(300.0, 300.0, 256, 256);
OSG::ImageUnrecPtr plane_img = OSG::Image::create();
plane_img->read("gras.jpg");
OSG::TextureObjChunkUnrecPtr plane_tex_obj = OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr plane_tex_env = OSG::TextureEnvChunk::create();
plane_tex_obj->setImage(plane_img);
plane_tex_obj->setMinFilter(GL_LINEAR);
plane_tex_obj->setMagFilter(GL_LINEAR);
plane_tex_obj->setWrapS(GL_REPEAT);
plane_tex_obj->setWrapT(GL_REPEAT);
plane_tex_env->setEnvMode(GL_MODULATE);
OSG::SimpleMaterialUnrecPtr plane_mat = OSG::SimpleMaterial::create();
plane_mat->setAmbient(OSG::Color3f(0.3f, 0.3f, 0.3f));
plane_mat->setDiffuse(OSG::Color3f(1.0f, 1.0f, 1.0f));
plane_mat->addChunk(plane_tex_obj);
plane_mat->addChunk(plane_tex_env);
OSG::Geometry *plane_geo = dynamic_cast<OSG::Geometry *>(plane->getCore());
plane_geo->setMaterial(plane_mat);
//load Tree Objects
OSG::NodeUnrecPtr tree1_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree1_trans);
OSG::NodeUnrecPtr tree2_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree2_trans);
OSG::NodeUnrecPtr tree3_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree3_trans);
OSG::NodeUnrecPtr tree4_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree4_trans);
OSG::NodeUnrecPtr tree5_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree5_trans);
OSG::NodeUnrecPtr tree6_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree6_trans);
OSG::NodeUnrecPtr tree7_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree7_trans);
OSG::NodeUnrecPtr tree8_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree8_trans);
OSG::NodeUnrecPtr tree9_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree9_trans);
_tree1_trans->editMatrix().setTranslate(-80.0, -80.0, 0.0);
_tree1_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree2_trans->editMatrix().setTranslate(0.0, -80.0, 0.0);
_tree2_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree3_trans->editMatrix().setTranslate(80.0, -80.0, 0.0);
_tree3_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree4_trans->editMatrix().setTranslate(-80.0, 0.0, 0.0);
_tree4_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree5_trans->editMatrix().setTranslate(0.0, 0.0, 0.0);
_tree5_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree6_trans->editMatrix().setTranslate(80.0, 0.0, 0.0);
_tree6_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree7_trans->editMatrix().setTranslate(-80.0, 80.0, 0.0);
_tree7_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree8_trans->editMatrix().setTranslate(0.0, 80.0, 0.0);
_tree8_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree9_trans->editMatrix().setTranslate(80.0, 80.0, 0.0);
_tree9_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
OSG::NodeUnrecPtr tree1 = OSG::SceneFileHandler::the()->read("tree1.3ds");
// NodeUnrecPtr tree1 = makeSphere(2, 2.0);
tree1_trans_node->addChild(tree1);
tree2_trans_node->addChild(cloneTree(tree1));
tree3_trans_node->addChild(cloneTree(tree1));
tree4_trans_node->addChild(cloneTree(tree1));
tree5_trans_node->addChild(cloneTree(tree1));
tree6_trans_node->addChild(cloneTree(tree1));
tree7_trans_node->addChild(cloneTree(tree1));
tree8_trans_node->addChild(cloneTree(tree1));
tree9_trans_node->addChild(cloneTree(tree1));
OSG::NodeUnrecPtr trees = OSG::makeCoredNode<OSG::Group>();
trees->addChild(tree1_trans_node);
trees->addChild(tree2_trans_node);
trees->addChild(tree3_trans_node);
trees->addChild(tree4_trans_node);
trees->addChild(tree5_trans_node);
trees->addChild(tree6_trans_node);
trees->addChild(tree7_trans_node);
trees->addChild(tree8_trans_node);
trees->addChild(tree9_trans_node);
/*//load Airplane Object
NodePtr obj1_trans_node = makeCoredNode<Transform>(&_obj1_trans);
_obj1_trans->editMatrix().setTranslate(0.0, 0.0, 10.0);
_obj1_trans->editMatrix().setScale(Vec3f(0.15,0.15,0.15));
NodePtr object1 = SceneFileHandler::the().read("triplane.3ds");
obj1_trans_node->addChild(object1);
*/
//Load a Quad as Pointlight
OSG::GeometryUnrecPtr boxGeo = OSG::makeBoxGeo(15, 15, 15, 1, 1, 1);
OSG::NodeUnrecPtr boxNode = OSG::Node::create();
boxNode->setCore(boxGeo);
OSG::SimpleMaterialUnrecPtr box_mat = OSG::SimpleMaterial::create();
box_mat->setAmbient(OSG::Color3f(0.95f, 1.0f, 0.2f));
box_mat->setDiffuse(OSG::Color3f(0.95f, 1.0f, 0.2f));
boxGeo->setMaterial(box_mat);
OSG::NodeUnrecPtr obj1_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_obj1_trans);
obj1_trans_node->addChild(boxNode);
//load Dino Objects
OSG::NodeUnrecPtr dino1_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino1_trans);
OSG::NodeUnrecPtr dino2_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino2_trans);
OSG::NodeUnrecPtr dino3_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino3_trans);
OSG::NodeUnrecPtr dino4_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino4_trans);
_dino1_trans->editMatrix().setTranslate(-20.0, -20.0, 10.0);
_dino1_trans->editMatrix().setScale(OSG::Vec3f(5.0, 5.0, 5.0));
_dino2_trans->editMatrix().setTranslate(-20.0, -20.0, 6.0);
_dino2_trans->editMatrix().setScale(OSG::Vec3f(3.0, 3.0, 3.0));
_dino3_trans->editMatrix().setTranslate(-20.0, -20.0, 6.0);
_dino3_trans->editMatrix().setScale(OSG::Vec3f(3.0, 3.0, 3.0));
_dino4_trans->editMatrix().setTranslate(-20.0, -20.0, 6.0);
_dino4_trans->editMatrix().setScale(OSG::Vec3f(3.0, 3.0, 3.0));
OSG::NodeUnrecPtr dino1 = OSG::SceneFileHandler::the()->read("dinopet.3ds");
// NodeUnrecPtr dino1 = makeBox(2., 2., 2., 4, 4, 4);
dino1_trans_node->addChild(dino1);
dino2_trans_node->addChild(cloneTree(dino1));
dino3_trans_node->addChild(cloneTree(dino1));
dino4_trans_node->addChild(cloneTree(dino1));
OSG::NodeUnrecPtr dinos = OSG::makeCoredNode<OSG::Group>();
dinos->addChild(dino1_trans_node);
dinos->addChild(dino2_trans_node);
dinos->addChild(dino3_trans_node);
dinos->addChild(dino4_trans_node);
//load Stone Objects
OSG::TransformUnrecPtr _stone_trans1, _stone_trans2, _stone_trans3,
_stone_trans4, _stone_trans5, _stone_trans6,
_stone_trans7, _stone_trans8,
_stone_trans9;
OSG::NodeUnrecPtr stone_trans_node1 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans1);
OSG::NodeUnrecPtr stone_trans_node2 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans2);
OSG::NodeUnrecPtr stone_trans_node3 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans3);
OSG::NodeUnrecPtr stone_trans_node4 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans4);
OSG::NodeUnrecPtr stone_trans_node5 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans5);
OSG::NodeUnrecPtr stone_trans_node6 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans6);
OSG::NodeUnrecPtr stone_trans_node7 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans7);
OSG::NodeUnrecPtr stone_trans_node8 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans8);
OSG::NodeUnrecPtr stone_trans_node9 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans9);
_stone_trans1->editMatrix().setTranslate(-70, -70, 0);
_stone_trans2->editMatrix().setTranslate(10, -70, 0);
_stone_trans3->editMatrix().setTranslate(90, -70, 0);
_stone_trans4->editMatrix().setTranslate(-70, 10, 0);
_stone_trans5->editMatrix().setTranslate(10, 10, 0);
_stone_trans6->editMatrix().setTranslate(90, 10, 0);
_stone_trans7->editMatrix().setTranslate(-70, 90, 0);
_stone_trans8->editMatrix().setTranslate(10, 90, 0);
_stone_trans9->editMatrix().setTranslate(90, 90, 0);
OSG::NodeUnrecPtr stone1 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone2 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone3 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone4 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone5 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone6 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone7 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone8 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone9 = OSG::makeSphere(1, 7.0);
OSG::ImageUnrecPtr plane_img2 = OSG::Image::create();
plane_img2->read("stone.jpg");
OSG::TextureObjChunkUnrecPtr plane_tex2_obj = OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr plane_tex2_env = OSG::TextureEnvChunk::create();
plane_tex2_obj->setImage(plane_img2);
plane_tex2_obj->setMinFilter(GL_LINEAR);
plane_tex2_obj->setMagFilter(GL_LINEAR);
plane_tex2_obj->setWrapS(GL_REPEAT);
plane_tex2_obj->setWrapT(GL_REPEAT);
plane_tex2_env->setEnvMode(GL_MODULATE);
OSG::SimpleMaterialUnrecPtr plane_mat2 = OSG::SimpleMaterial::create();
plane_mat2->setAmbient(OSG::Color3f(0.3f, 0.3f, 0.3f));
plane_mat2->setDiffuse(OSG::Color3f(1.0f, 1.0f, 1.0f));
plane_mat2->addChunk(plane_tex2_obj);
plane_mat2->addChunk(plane_tex2_env);
OSG::Geometry *plane_geo3 = dynamic_cast<OSG::Geometry *>(stone1->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone2->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone3->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone4->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone5->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone6->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone7->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone8->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone9->getCore());
plane_geo3->setMaterial(plane_mat2);
stone_trans_node1->addChild(stone1);
stone_trans_node2->addChild(stone2);
stone_trans_node3->addChild(stone3);
stone_trans_node4->addChild(stone4);
stone_trans_node5->addChild(stone5);
stone_trans_node6->addChild(stone6);
stone_trans_node7->addChild(stone7);
stone_trans_node8->addChild(stone8);
stone_trans_node9->addChild(stone9);
OSG::NodeUnrecPtr stones = OSG::makeCoredNode<OSG::Group>();
stones->addChild(stone_trans_node1);
stones->addChild(stone_trans_node2);
stones->addChild(stone_trans_node3);
stones->addChild(stone_trans_node4);
stones->addChild(stone_trans_node5);
stones->addChild(stone_trans_node6);
stones->addChild(stone_trans_node7);
stones->addChild(stone_trans_node8);
stones->addChild(stone_trans_node9);
scene->addChild(plane);
scene->addChild(obj1_trans_node);
scene->addChild(trees);
scene->addChild(stones);
scene->addChild(dinos);
svp = OSG::ShadowStage::create();
OSG::GradientBackgroundUnrecPtr gbg = OSG::GradientBackground::create();
OSG::SolidBackgroundUnrecPtr sbg = OSG::SolidBackground::create();
gbg->addLine(OSG::Color3f(0.7f, 0.7f, 0.8f), 0);
gbg->addLine(OSG::Color3f(0.0f, 0.1f, 0.3f), 1);
rootNode->setCore(svp);
rootNode->addChild(light1);
rootNode->addChild(light1_beacon);
rootNode->addChild(light2_beacon);
rootNode->addChild(cam_beacon);
// Shadow viewport
#ifdef SHADOW_CHECK
svp->setBackground(gbg);
svp->setRoot(rootNode);
svp->setSize(0, 0, 1, 1);
#endif
//svp->setOffFactor(4.0);
//svp->setOffBias(8.0);
//used to set global shadow intensity, ignores shadow intensity from light sources if != 0.0
//svp->setGlobalShadowIntensity(0.8);
svp->setMapSize(1024);
//ShadowSmoothness used for PCF_SHADOW_MAP and VARIANCE_SHADOW_MAP, defines Filter Width. Range can be 0.0 ... 1.0.
//ShadowSmoothness also used to define the light size for PCSS_SHADOW_MAP
svp->setShadowSmoothness(0.5);
// add light sources here
//svp->editMFLightNodes ()->push_back(light1);
//svp->editMFLightNodes ()->push_back(light2);
svp->editMFExcludeNodes()->push_back(obj1_trans_node);
svp->setAutoSearchForLights(true);
//one active light at startup
_light2_core->setOn(true);
_light2_core->setAmbient(0.3f, 0.3f, 0.3f, 1);
_light2_core->setDiffuse(0.8f, 0.8f, 0.8f, 1);
_light1_core->setOn(false);
_light1_core->setAmbient(0.3, 0.3, 0.3, 1);
_light1_core->setDiffuse(0.8, 0.8, 0.8, 1);
gwin->setGlutId(winid);
#ifdef SHADOW_CHECK
gwin->addPort(svp);
#endif
gwin->init();
OSG::Vec3f min, max;
rootNode->updateVolume();
rootNode->getVolume().getBounds(min, max);
// create the SimpleSceneManager helper
mgr = OSG::SimpleSceneManager::create();
mgr->setWindow(gwin);
mgr->setCamera(Pcamera);
mgr->setRoot(rootNode);
_navigator.setMode(OSG::Navigator::TRACKBALL);
#ifdef SHADOW_CHECK
_navigator.setViewport(svp);
#endif
_navigator.setCameraTransformation(cam_beacon);
OSG::Vec3f up(0,1,0);
OSG::Pnt3f at(0,0,0);
OSG::Pnt3f from(0.0f,-100.1f,20.0f);
_navigator.set(from, at, up);
_navigator.setMotionFactor(0.5f);
#ifdef SHADOW_CHECK
svp->setCamera(Pcamera);
#endif
//activate Framecounter
startFpsCounter();
// dynamic_cast<RenderAction *>(mgr->getAction())->setLocalLights(true);
mgr->turnHeadlightOff();
mgr->showAll();
mgr->getCamera()->setNear( 1.0f);
mgr->getCamera()->setFar (1000000.f );
_navigator.setViewport(gwin->getPort(0));
return 0;
}
NodeTransitPtr cloneTree(
const OSG::Node *rootNode,
const std::vector<const OSG::ReflexiveContainerType *> &cloneTypes,
const std::vector<const OSG::ReflexiveContainerType *> &ignoreTypes,
const std::vector<OSG::UInt16> &cloneGroupIds,
const std::vector<OSG::UInt16> &ignoreGroupIds)
{
NodeUnrecPtr rootClone(NULL);
if(rootNode != NULL)
{
NodeUnrecPtr childClone;
NodeCore *core = rootNode->getCore();
rootClone = Node::create();
rootClone->setTravMask(rootNode->getTravMask());
cloneAttachments(rootNode, rootClone,
cloneTypes, ignoreTypes,
cloneGroupIds, ignoreGroupIds);
if(core != NULL)
{
NodeCoreUnrecPtr coreClone = NULL;
const FieldContainerType &coreType = core->getType();
// test if core type should NOT be ignored
if(!TypePredicates::typeInGroupIds(
ignoreGroupIds.begin(),
ignoreGroupIds.end(), coreType) &&
!TypePredicates::typeDerivedFrom(
ignoreTypes.begin(),
ignoreTypes.end(), coreType) )
{
// test if core should cloned
if(TypePredicates::typeInGroupIds (
cloneGroupIds.begin(),
cloneGroupIds.end(), coreType) ||
TypePredicates::typeDerivedFrom(
cloneTypes.begin(),
cloneTypes.end(), coreType) )
{
// clone core
coreClone =
dynamic_pointer_cast<NodeCore>(
deepClone(core,
cloneTypes, ignoreTypes,
cloneGroupIds, ignoreGroupIds));
}
else
{
// share core
coreClone = core;
}
}
rootClone->setCore(coreClone);
}
for(UInt32 i = 0; i < rootNode->getNChildren(); ++i)
{
childClone = cloneTree(rootNode->getChild(i),
cloneTypes, ignoreTypes,
cloneGroupIds, ignoreGroupIds);
rootClone->addChild(childClone);
}
}
return NodeTransitPtr(rootClone);
}
/* Insert one or more shallow copies of a block (created by DXFBlock as
* Transform Group) into a layer (created by DXFLayer as MaterialGroup) or
* another block.
* \todo
* Could there be a INSERT inside a block referring to another block which has
* not been read yet? We then have to find a solution to enable deferred
* instantiation of INSERT entities :-(
*/
DXFResult DXFInsert::endEntity(void)
{
NodeUnrecPtr ctrafoNodeP = NULL;
// ComponentTransformUnrecPtr ctrafoCoreP = NULL;
TransformUnrecPtr ctrafoCoreP = NULL;
NodeUnrecPtr blockNodeP = NULL;
Node *parentNodeP = getParentNode();
StringToNodePtrMap::iterator itr = _blocksMapP->find(_blockName);
if (itr != _blocksMapP->end() && parentNodeP != NULL)
{
blockNodeP = itr->second;
// TODO: check fetched INSERT Data for consistency!
// Insert multiple times in a grid...
Vec3f offset(0.0, 0.0, 0.0);
for(Int16 column = 0; column < _columnCount; ++ column)
{
offset[0] = column * _columnSpacing;
for(Int16 row = 0; row < _rowCount; ++ row)
{
offset[1] = row * _rowSpacing;
// TODO: find out about DXF insert semantics!
ctrafoNodeP = Node::create();
ctrafoCoreP = Transform::create();
#if 0
beginEditCP(ctrafoCoreP);
#endif
{
if(_blockName == std::string("Rectangular Mullion - 64 x 128 rectangular-V1-Level 1"))
{
std::cout << blockNodeP->getNChildren() << std::endl;
}
OSG::TransformationMatrix<Real32> transMat;
transMat.setIdentity();
transMat.setTranslate(_insertionPoint + offset);
OSG::TransformationMatrix<Real32> rotMat;
rotMat.setIdentity();
OSG::Quaternion rot(OSG::Vec3f(0,0,1),osgDegree2Rad(_rotationAngle));
rotMat.setRotate(rot);
OSG::TransformationMatrix<Real32> scaleMat;
scaleMat.setIdentity();
scaleMat.setScale(_scaleFactor);
OSG::Vec3f vin(-40, 65, 0);
OSG::Vec3f vout;
transMat.mult(rotMat);
transMat.mult(scaleMat);
if(_extrusionDirection[2]<0)
{
transMat[0][0] *= -1.0;
transMat[1][0] *= -1.0;
transMat[2][0] *= -1.0;
transMat[3][0] *= -1.0;
}
ctrafoCoreP->setMatrix(transMat);
}
#if 0
endEditCP(ctrafoCoreP);
#endif
#if 0
beginEditCP(ctrafoNodeP);
#endif
{
ctrafoNodeP->setCore(ctrafoCoreP);
#if 0
ctrafoNodeP->addChild(blockNodeP->clone());
#endif
NodeUnrecPtr pClone = cloneTree(blockNodeP);
ctrafoNodeP->addChild(pClone);
}
#if 0
endEditCP(ctrafoNodeP);
#endif
#if 0
beginEditCP(parentNodeP);
#endif
{
parentNodeP->addChild(ctrafoNodeP);
}
#if 0
endEditCP(parentNodeP);
#endif
}
}
// Warn for details not implemented or assured yet! TODO: better
// implement missing features!
/*if(fabs(_rotationAngle) > Eps)
FWARNING(("DXF Loader: before line %d: "
"DXFInsert does not yet support ROTATION "
"(group code 50). "
"Most likely the graphics are incorrect!\n",
DXFRecord::getLineNumber()
));*/
/*if(_scaleFactor != Vec3f(1.0,1.0,1.0))
FWARNING(("DXF Loader: before line %d: "
"DXFInsert may not interpret SCALING "
"(group codes 41, 42, 43) correctly."
"Graphics may be incorrect!\n",
DXFRecord::getLineNumber()
));*/
if(_columnCount != 1 || _rowCount != 1)
FWARNING(("DXF Loader: before line %d: "
"DXFInsert may not interpret REPEATED INSERTION "
"(group codes 70, 71, 44, 45) correctly."
"Graphics may be incorrect!\n",
DXFRecord::getLineNumber()
));
}
else
{
if(itr == _blocksMapP->end())
FWARNING(("DXF Loader: before line %d (inside %s section): "
"BLOCK '%s' to be inserted not found!\n",
DXFRecord::getLineNumber(),
_parent->getEntityTypeName(),
_blockName.c_str()
));
if(parentNodeP == NULL)
FWARNING(("DXF Loader: before line %d (inside %s section): "
"layer %s to be inserted to not found!\n",
DXFRecord::getLineNumber(),
_parent->getEntityTypeName(),
_layerName.c_str()
));
}
//set back to default value;
_insertionPoint.setNull(),
_scaleFactor[0]=_scaleFactor[1]=_scaleFactor[2]=1.0;
_rotationAngle=0.0;
_columnCount=1;
_rowCount=1;
_columnSpacing=0.0;
_rowSpacing=0.0;
_extrusionDirection[0]=0;
_extrusionDirection[1]=0;
_extrusionDirection[2]=1;
return DXFStateContinue;
}
