void CScene::eraseScene()
{
LOG_DEBUG("Erasing scene\n");
setActiveCamera(NULL);
for(u32 Type = 0; Type < ENT_COUNT; Type++)
{
u32 ListSize = SceneNode_Types_list[Type].size();
for(u32 i = 0; i < ListSize; i++)
{
// Store node in temp varible and set pointer in null
// because SceneNode::UnRegisterNode recall Scene::UnRegisterNode
ISceneNode* Node = SceneNode_Types_list[Type][i];
SceneNode_Types_list[Type][i] = NULL;
if(Node == NULL)
break;
Node->UnRegisterNode(false);
Node->release();
}
SceneNode_Types_list[Type].clear();
}
SceneNode_Full_list.clear();
}
int Java_zte_irrlib_scene_Scene_nativeAddBillboardSceneNode(
JNIEnv *env, jobject defaultObj, jdouble px, jdouble py, jdouble pz,
jdouble sx, jdouble sy, jint id, jint parent, jboolean isLight)
{
core::vector3df pos = core::vector3df(px,py,pz);
core::dimension2d<f32> size = core::dimension2d<f32>(sx,sy);
ISceneNode* node = NULL;
ISceneNode* parentNode = NULL;
if(parent != 0){
parentNode = smgr->getSceneNodeFromId(parent);
if (!parentNode)
{
WARN_PARENT_NOT_FOUND(parent, AddBillboardSceneNode);
return -1;
}
}
node = smgr->addBillboardSceneNode(parentNode,size,pos,id);
if (node)
{
if (!isLight) node->setMaterialFlag(video::EMF_LIGHTING, false);
return 0;
}
else
{
ERROR_ADD_FAILD(id, AddBillboardSceneNode);
return -3;
}
}
void EditorScene::PickingObject(u32 sx, u32 sy)
{
math::SRay ray = computePickingRay(sx, sy);
f32 dist;
ISceneNode* node = mSceneManager->intersectRayWithTag(ray, &dist, 1, ENT_SOLID_NODE);
if (node)
{
mPickingCubeNode->setVisible(true);
//mPickingCubeNode->setPosition(node->getPosition());
math::SOrientedBox obb = node->getOrientedBox();
XMMATRIX scaleMatrix = XMMatrixScaling(obb.Extents.x * 2, obb.Extents.y * 2, obb.Extents.z * 2);
XMMATRIX rotMatrix = XMMATRIX(
obb.Axis[0].x, obb.Axis[0].y, obb.Axis[0].z, 0,
obb.Axis[1].x, obb.Axis[1].y, obb.Axis[1].z, 0,
obb.Axis[2].x, obb.Axis[2].y, obb.Axis[2].z, 0,
0, 0, 0, 1.0f);
XMMATRIX transMatrix = XMMatrixTranslation(obb.Center.x, obb.Center.y, obb.Center.z);
XMMATRIX M = scaleMatrix * rotMatrix * transMatrix;
mPickingCubeNode->setTransform(M);
}
else
{
mPickingCubeNode->setVisible(false);
}
}
int Java_zte_irrlib_scene_Scene_nativeAddLightSceneNode(
JNIEnv *env, jobject defaultObj, jdouble px, jdouble py, jdouble pz,
jdouble radius, jint r, jint g, jint b, jint id, jint parent, jboolean isLight)
{
ISceneNode* node = NULL;
ISceneNode* parentNode = NULL;
if(parent != 0){
parentNode = smgr->getSceneNodeFromId(parent);
if (!parentNode)
{
WARN_PARENT_NOT_FOUND(parent, AddLightSceneNode);
return -2;
}
}
node = smgr->addLightSceneNode(parentNode,vector3df(px,py,pz),SColor(0xff,r,g,b),radius,id);
if (node)
{
if (!isLight) node->setMaterialFlag(video::EMF_LIGHTING, false);
return 0;
}
else
{
ERROR_ADD_FAILD(id, AddLightSceneNode);
return -3;
}
}
void CPlayer::Create()
{
m_pHead->Create();
ISceneNode *pRootNode = SCENEMGR->GetCurrentScene()->GetRootNode();
pRootNode->AddChild(m_pHead);
}
// ----------------------------------------------------------------------------
void Editor::addItem(u32 id)
{
ISceneNode* node = 0;
switch (id)
{
case ExtraPanel::BTN_BANANA:
node = m_scene_manager->addAnimatedMeshSceneNode(
m_scene_manager->getMesh("models/banana.b3d"));
node->setName("banana");
break;
case ExtraPanel::BTN_ITEM:
node = m_scene_manager->addAnimatedMeshSceneNode(
m_scene_manager->getMesh("models/gift-box.b3d"));
node->setName("item");
break;
case ExtraPanel::BTN_SNITRO:
node = m_scene_manager->addAnimatedMeshSceneNode(
m_scene_manager->getMesh("models/nitrotank-small.b3d"));
node->setName("small-nitro");
break;
case ExtraPanel::BTN_BNITRO:
node = m_scene_manager->addAnimatedMeshSceneNode(
m_scene_manager->getMesh("models/nitrotank-big.b3d"));
node->setName("big-nitro");
break;
default:
break;
}
m_viewport->setNewEntity(node);
} // addItem
//-----------------------------------------------------------------------
Bool CCSEntityLineMoveAcion::isNeedMoveToStartPos()
{
if ( !mEntity )
return false;
if ( !mEntity->getEntity() )
return false ;
ISceneNode* sceneNode = mEntity->getEntity()->getSceneNode();
if( !sceneNode )
{
return false ;
}
Vec3 currPos;
sceneNode->getPosition(currPos);
Vec3 ec = mEndPos - currPos;
Vec3 es = mEndPos - mStartPos;
ec.y = 0;
es.y = 0;
Flt currDis = ec.length();
Flt dis = es.length();
if ( currDis > dis )
return true;
return false;
}
void IrrGameObjectImpl::addChild(GameObject *o)
{
ISceneNode *n = ((IrrGameObjectImpl*)o->getImplementor())->node;
children->insert(std::pair<GameObject*,ISceneNode*>(o,n));
node->addChild(n);
n->setParent(node);
}
int Java_zte_irrlib_scene_Scene_nativeAddCubeSceneNode(
JNIEnv* env, jobject defaultObj, jdouble x, jdouble y, jdouble z,
jdouble size, jint id, jint parent, jboolean isLight)
{
core::vector3df pos = core::vector3df(x,y,z);
ISceneNode* node = NULL;
ISceneNode* parentNode = NULL;
if(parent != 0){
parentNode = smgr->getSceneNodeFromId(parent);
if (!parentNode)
{
WARN_PARENT_NOT_FOUND(parent, AddCubeSceneNode);
return -2;
}
}
node = smgr->addCubeSceneNode(size,parentNode,id,pos);
if (node)
{
if (!isLight) node->setMaterialFlag(video::EMF_LIGHTING, false);
return 0;
}
else
{
ERROR_ADD_FAILD(id, AddCubeSceneNode);
return -3;
}
}
static bool runTestWithDriver(E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice( driverType, dimension2d<s32>(640, 480));
if (!device)
return true; // Treat a failure to create a driver as benign; this saves a lot of #ifdefs
IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
// Draw a cube to check that the pixels' alpha is working.
ISceneNode * cube = smgr->addCubeSceneNode(50.f, 0, -1, vector3df(0, 0, 60));
cube->setMaterialTexture(0, driver->getTexture("../media/wall.bmp"));
cube->setMaterialFlag(video::EMF_LIGHTING, false);
(void)smgr->addCameraSceneNode();
driver->beginScene(true, true, SColor(255,100,101,140));
smgr->drawAll();
// Test for offscreen values as well as onscreen.
for(s32 x = -10; x < 650; ++x)
{
s32 y = 480 * x / 640;
driver->drawPixel((u32)x, (u32)y, SColor(255, 255 * x / 640, 255 * (640 - x) / 640, 0));
y = 480 - y;
driver->drawPixel((u32)x, (u32)y, SColor(255 * x / 640, 0, 255, 255));
}
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-drawPixel.jpg");
device->drop();
return result;
}
void CPlayer::Increase()
{
if (!m_pHead)
{
m_pHead = new CSphereEntity(m_pReflectObject, GetHeadRadius(), GetSlice(), GetSlice());
CSphereEntity *pBody = new CSphereEntity(m_pColorLightObject, GetBodyRadius(), GetSlice(), GetSlice());
pBody->Create();
m_listBody.push_back(pBody);
m_pTail = new CSphereEntity(m_pColorLightObject, GetBodyRadius(), GetSlice(), GetSlice());
m_pTail->Create();
ISceneNode *pRootNode = SCENEMGR->GetCurrentScene()->GetRootNode();
pRootNode->AddChild(pBody);
pRootNode->AddChild(m_pTail);
InitPosition();
}
else
{
CSphereEntity *body = new CSphereEntity(m_pColorLightObject, GetBodyRadius(), GetSlice(), GetSlice());
body->Create();
CVector3 vBackBody = m_listBody.back()->GetPosition();
CVector3 vSrcTail = m_pTail->GetPosition();
body->SetPosition(vSrcTail);
m_listBody.push_back(body);
m_pTail->SetPosition(vBackBody + 1.5f * (vSrcTail - vBackBody));
ISceneNode *pRootNode = SCENEMGR->GetCurrentScene()->GetRootNode();
pRootNode->AddChild(body);
}
}
ISceneNode* BinaryStreamArchiveReader::ReadNode() {
SceneNodeTags tag = SceneNodeTags(ReadInt(TAG_KEY));
ISceneNode *node = NULL;
// Read a node
switch (tag) {
#define SCENE_NODE(type) \
case NODE_##type : \
node = new type(); \
break;
#include <Scene/SceneNodes.def>
#undef SCENE_NODE
case NODE_NULL:
return NULL;
case NODE_END:
throw Core::Exception("Unknown node tag in ReadScene");
break;
}
// Read children...
unsigned int size = Begin(CHILD_KEY);
for (unsigned int i=0; i<size; i++) {
node->AddNode(ReadNode());
}
End(CHILD_KEY);
node->Deserialize(*this);
return node;
}
// pick a node using the mouse cursor location
ISceneNode* CSLevel::selectNode(int screenX, int screenY, long objectflags)
{
// attempt to select a node. use the passed in mask
ISceneNode* node = getCollMan()->getSceneNodeFromScreenCoordinatesBB(position2d<s32>(screenX, screenY), objectflags, true);
if (node) CS_LOG(CSLOGTYPE::CSL_DEBUG, "SELECTED NODE %i", node->getID());
return node;
}
int Java_zte_irrlib_scene_SceneNode_nativeSetParent(
JNIEnv *env, jobject defaultObj, jint parent, jint id)
{
//LOGD("PARENT %d", id);
ISceneNode *node = smgr->getSceneNodeFromId(id);
ISceneNode *parentNode = NULL;
if (!node)
{
WARN_NODE_NOT_FOUND(id, SetParent);
return -1;
}
if (parent == 0)
{
node->setParent(smgr->getRootSceneNode());
}
else
{
parentNode = smgr->getSceneNodeFromId(parent);
if (!parentNode)
{
WARN_PARENT_NOT_FOUND(id, SetParent);
return -2;
}
node->setParent(parentNode);
}
return 0;
}
// Create a box rigid body
void Application::CreateBox(const btVector3 &TPosition, const vector3df &TScale, btScalar TMass, const char *texture) {
ISceneNode *Node = irrScene->addCubeSceneNode(1.0f);
Node->setScale(TScale);
Node->setMaterialFlag(EMF_LIGHTING, 1);
Node->setMaterialFlag(EMF_NORMALIZE_NORMALS, true);
Node->setMaterialTexture(0, irrDriver->getTexture(texture));
// Set the initial position of the object
btTransform Transform;
Transform.setIdentity();
Transform.setOrigin(TPosition);
btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);
// Create the shape
btVector3 HalfExtents(TScale.X * 0.5f, TScale.Y * 0.5f, TScale.Z * 0.5f);
btCollisionShape *Shape = new btBoxShape(HalfExtents);
// Add mass
btVector3 LocalInertia;
Shape->calculateLocalInertia(TMass, LocalInertia);
// Create the rigid body object
btRigidBody *RigidBody = new btRigidBody(TMass, MotionState, Shape, LocalInertia);
// Store a pointer to the irrlicht node so we can update it later
RigidBody->setUserPointer((void *)(Node));
// Add it to the world
World->addRigidBody(RigidBody);
Objects.push_back(RigidBody);
}
int Java_zte_irrlib_scene_Scene_nativeAddCameraSceneNode(
JNIEnv* env, jobject defaultObj, jdouble px, jdouble py, jdouble pz,
jdouble lx, jdouble ly, jdouble lz, jboolean isActive, jint id, jint parent, jboolean isLight)
{
core::vector3df pos = core::vector3df(px,py,pz);
core::vector3df lookat = core::vector3df(lx,ly,lz);
ISceneNode* node = NULL;
ISceneNode* parentNode = NULL;
if(parent != 0){
parentNode = smgr->getSceneNodeFromId(parent);
if (!parentNode)
{
WARN_PARENT_NOT_FOUND(parent, AddCameraSceneNode);
return -1;
}
}
node = smgr->addCameraSceneNode(parentNode,pos,lookat,id);
if (node)
{
if (!isLight) node->setMaterialFlag(video::EMF_LIGHTING, false);
return 0;
}
else
{
ERROR_ADD_FAILD(id, AddCameraSceneNode);
return -3;
}
}
// ----------------------------------------------------------------------------
ISceneNode* Track::loadItem(stringc name)
{
ISceneManager* sm = Editor::getEditor()->getSceneManager();
ISceneNode* node = 0;
if (name == "banana")
{
node = sm->addAnimatedMeshSceneNode(sm->getMesh("models/banana.b3d"));
node->setName("banana");
}
if (name == "item")
{
node = sm->addAnimatedMeshSceneNode(sm->getMesh("models/gift-box.b3d"));
node->setName("item");
}
if (name == "small-nitro")
{
node = sm->addAnimatedMeshSceneNode(sm->getMesh("models/nitrotank-small.b3d"));
node->setName("small-nitro");
}
if (name == "big-nitro")
{
node = sm->addAnimatedMeshSceneNode(sm->getMesh("models/nitrotank-big.b3d"));
node->setName("big-nitro");
}
return node;
} // loadItem
void PhysicsSim::setTexture(PhysicalObject* object, stringw tex_file){
ISceneNode* isn = object->getSceneNode();
tex_file = mediaDirectory + tex_file;
if(smgr->getFileSystem()->existFile(tex_file))
isn->setMaterialTexture(0, driver->getTexture(tex_file));
isn->setMaterialFlag(EMF_LIGHTING, true);
isn->setMaterialFlag(EMF_TEXTURE_WRAP, false);
isn->setMaterialFlag(EMF_BACK_FACE_CULLING, true);
}
CNPC::CNPC(float color[4], float radius)
{
m_pColorLightObject = new CColorPointLightObject(color);
m_pBody = new CSphereEntity(m_pColorLightObject, radius, 50, 25);
m_pBody->Create();
ISceneNode *pRootNode = SCENEMGR->GetCurrentScene()->GetRootNode();
pRootNode->AddChild(m_pBody);
}
// Support function for finding collided nodes using a subset of nodes in the scene
// recursive method for going through all scene nodes
void getNodeRayBB(ISceneNode* root,
const core::line3df& ray,
s32 bits,
bool recurse,
f32& outbestdistance,
ISceneNode*& outbestnode)
{
core::vector3df edges[8];
const core::list<ISceneNode*>& children = root->getChildren();
core::list<ISceneNode*>::ConstIterator it = children.begin();
for (; it != children.end(); ++it)
{
ISceneNode* current = *it;
if (current->isVisible() &&
// (bNoDebugObjects ? !current->isDebugObject() : true) &&
(bits==0 || (bits != 0 && (current->getID() & bits))))
{
// get world to object space transform
core::matrix4 mat;
if (!current->getAbsoluteTransformation().getInverse(mat))
continue;
// transform vector from world space to object space
core::line3df line(ray);
mat.transformVect(line.start);
mat.transformVect(line.end);
const core::aabbox3df& box = current->getBoundingBox();
// do intersection test in object space
if (box.intersectsWithLine(line))
{
box.getEdges(edges);
f32 distance = 0.0f;
for (s32 e=0; e<8; ++e)
{
f32 t = edges[e].getDistanceFromSQ(line.start);
if (t > distance)
distance = t;
}
if (distance < outbestdistance)
{
outbestnode = current;
outbestdistance = distance;
}
}
}
if ( recurse )
getNodeRayBB(current, ray, bits, recurse, outbestdistance, outbestnode);
}
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Lens Flare", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
IAnimatedMeshSceneNode* node2 = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node2->setMaterialFlag( EMF_LIGHTING, false );
node2->setMD2Animation( scene::EMAT_STAND );
node2->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node2->setPosition( vector3df( 20.0f, 0.0f, 0.0f ) );
ICameraSceneNode* cam = smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
ISceneNode* sun = smgr->addSphereSceneNode( 50.0f, 16 );
sun->setPosition( vector3df( 0.0f, 50.0f, 1000.0f ) );
sun->setMaterialFlag( EMF_LIGHTING, false );
sun->setMaterialTexture( 0, driver->getTexture("sun.png") );
// Interesting stuff
// As before, we make a renderer
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
// Now make a flare effect:
// (render from, output size, sun scene node)
// can also use a vector instead of a scene node - when using a scene node the position will follow node automatically
CLensFlarePostProc* ppFlare1 = new CLensFlarePostProc( ppRenderer, dimension2di( 1024, 512 ), driver->getTexture("flare.png"), sun, 50.0f );
CLensFlarePostProc* ppFlare2 = new CLensFlarePostProc( ppFlare1, dimension2di( 1024, 512 ), driver->getTexture("flare.png"), vector3df( -2000.0f, 50.0f, 1000.0f ) );
ppFlare2->setQuality( PPQ_CRUDE ); // Setting the quality to crude avoids pixel checking, which is slow (expecially when more than one lens flare), so if you use >1 flare, set most of them to crude.
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
cam->setPosition( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, -70.0f ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppFlare2->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppFlare1;
delete ppFlare2;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
//for test only
void Java_zte_irrlib_Engine_nativeTestCreate(
JNIEnv *env, jobject thiz)
{
LOGD("test begin");
ISceneNode *node = smgr->addCubeSceneNode();
io::path p(io::PATH_ASSETS); p.append("ext");
device->getFileSystem()->addFileArchive(p, true, false);
node->setMaterialTexture(0, driver->getTexture("ext/ext_1.png"));
node->setMaterialFlag(EMF_LIGHTING, false);
LOGD("test end");
}
void Java_zte_irrlib_scene_Scene_nativeRemoveNode(
JNIEnv *env, jobject defaultObj, jint id)
{
ISceneNode* node = smgr->getSceneNodeFromId(id);
if (!node) return;
ISceneNode* parentNode = node->getParent();
if (!parentNode) return;
parentNode->removeChild(node);
}
int Java_zte_irrlib_scene_SceneNode_nativeRemoveAllAnimator(
JNIEnv *env, jobject defaultObj, jint id)
{
ISceneNode* node = smgr->getSceneNodeFromId(id);
if (!node)
{
WARN_NODE_NOT_FOUND(id, RemoveAllAnimator);
return -1;
}
node->removeAnimators();
return 0;
}
int Java_zte_irrlib_scene_SceneNode_nativeGetAbsoluteMatrix(
JNIEnv* env, jobject thiz, jobject jmat, jint Id)
{
ISceneNode* node = smgr->getSceneNodeFromId(Id);
if (!node)
{
WARN_NODE_NOT_FOUND(Id, GetAbsoluteMatrix);
return -1;
}
utils->setMatrix4Frommatrix4(env, jmat, node->getAbsoluteTransformation());
return 0;
}
bool GUIManager::updateNodeInformation(const INodeObject* obj)
{
ISceneNode* node = nullptr;
if (!obj || !(node = obj->getNode())
|| _currentObj == obj)
return false;
_currentObj = obj;
_information->clear();
//Check id ?
(this->*(_objDisplayers[static_cast<Ids>(node->getID())]))(obj);
}
void SceneNode_GetChildren(IntPtr scenenode, IntPtr *list)
{
ISceneNode *node = GetSceneNodeFromIntPtr(scenenode);
//u32 size = node->getChildren().getSize();
core::list<ISceneNode*>::ConstIterator it = node->getChildren().begin();
int c = 0;
for (; it != node->getChildren().end(); ++it)
{
list[c] = (*it);
c++;
}
}
ISceneNode* ArrowPrototypeFactory::getArrowPrototype(unsigned char type,
float offset) {
ISceneNode* newArrow = prototypes[type]->clone(parent, smgr);
newArrow->setVisible(true);
//if (offest != 0.0) {
newArrow->setPosition(
vector3df(newArrow->getPosition().X, ARROW_HEIGHT - offset,
newArrow->getPosition().Z));
// printf ("offset is %f. \n", offset);
//}
return newArrow;
}
int Java_zte_irrlib_scene_SceneNode_nativeSetVisible(
JNIEnv* env, jobject defaultObj, jboolean isVisible, jint id)
{
ISceneNode* node = smgr->getSceneNodeFromId(id);
//LOGD("VISIBLE %d", id);
if (!node)
{
WARN_NODE_NOT_FOUND(id, SetVisible);
return -1;
}
node->setVisible(isVisible);
return 0;
}
int Java_zte_irrlib_scene_SceneNode_nativeSetPosition(
JNIEnv* env, jobject defaultObj, jdouble x, jdouble y, jdouble z, jint id)
{
ISceneNode* node = smgr->getSceneNodeFromId(id);
//LOGD("POSITION %d", id);
if (!node)
{
WARN_NODE_NOT_FOUND(id, SetPosition);
return -1;
}
node->setPosition(core::vector3df(x,y,z));
return 0;
}
