void CScene::UpdateScene(vector<vector3df> otherClientPosition, ICameraSceneNode* camera)
{
ISceneManager* smgr=device->getSceneManager();
IVideoDriver* driver=device->getVideoDriver();
// 测试用
IAnimatedMesh* personMeshTest=smgr->getMesh("../../media/sydney.md2");
IAnimatedMeshSceneNode* personNode = smgr->addAnimatedMeshSceneNode( personMeshTest );
if (!personMeshTest)
{
device->drop();
return ;
}
if (personNode)
{
personNode->setScale(vector3df(0.4f,0.4f,0.4f));
personNode->setPosition(vector3df(0.0f,10.0f,0.0f));
personNode->setMaterialTexture( 0, driver->getTexture("../../media/sydney.bmp") );
personNode->setMaterialFlag(EMF_LIGHTING, false);
personNode->getMaterial(0).Shininess=28.0f;
personNode->getMaterial(0).NormalizeNormals=true;
personNode->setMD2Animation ( scene::EMAT_STAND );
}
personMeshTest->setMaterialFlag(EMF_LIGHTING,false);
// 显示其他客户端
for (int i=0;i!=otherClientPosition.size();i++)
{
IAnimatedMesh* personMesh=smgr->getMesh("../../media/sydney.md2");
IAnimatedMeshSceneNode* personNode = smgr->addAnimatedMeshSceneNode( personMesh );
if (!personMesh)
{
device->drop();
return ;
}
if (personNode && personNode->getPosition()!=camera->getPosition())
{
// personNode->setPosition(vector3df(10,20,0));
// personNode->setScale(vector3df(0.5,0.5,0.5));
personNode->setPosition(otherClientPosition[i]);
personNode->setMaterialTexture( 0, driver->getTexture("../../media/sydney.bmp") );
personNode->setMaterialFlag(EMF_LIGHTING, false);
personNode->getMaterial(0).Shininess=28.0f;
personNode->getMaterial(0).NormalizeNormals=true;
personNode->setMD2Animation ( scene::EMAT_STAND );
}
personMesh->setMaterialFlag(EMF_LIGHTING,false);
}
}
ISceneNode* Render::createNode(bool isMD2, IAnimatedMesh* mesh, ITexture* texture, bool light,core::vector3df scale, core::vector3df pos, core::vector3df rotation)
{
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(mesh, NULL, IDFlag_IsPickable);
if(node)
{
pos.Y += -node->getBoundingBox().MinEdge.Y * scale.Y;
node->setPosition(pos);
node->setRotation(rotation);
node->setScale(scale);
node->setAnimationSpeed(20.f);
scene::ITriangleSelector* selector = 0;
selector = smgr->createTriangleSelector(node);
node->setTriangleSelector(selector);
selector->drop();
//Autoscale
//f32 scale = 0.25f;
node->setScale(scale);
if (texture)
{
//node->setMaterialFlag(EMF_LIGHTING, false);
node->setMaterialTexture(0, texture);
}
node->setMD2Animation(EMAT_STAND);
}
return node;
}
void TestLevel::init() {
IAnimatedMesh* mesh = smgr->getMesh("img/sydney.md2");
IAnimatedMeshSceneNode * tmpnode = smgr->addAnimatedMeshSceneNode(mesh);
if (tmpnode) {
tmpnode->setMaterialFlag(EMF_LIGHTING, false);
tmpnode->setMD2Animation(scene::EMAT_STAND);
tmpnode->setMaterialTexture(0, driver->getTexture("img/sydney.bmp"));
}
tmpnode->setPosition(vector3df(-222,0,0));
vector3df wsp(0,5,-10);
ship = new TestPlayerShip(TestPlayerShip::createTestPlayerShipNode(context));
ship->attachNewCamera(new StaticCamera(context,ship));
// ship.attachCamera(cam);
this->node = new NonPlayerShip(tmpnode);
testPlanet = Planet::createTestPlanet(context);
}
static ISceneNode* addNinja(ISceneManager* smgr, core::vector3df pos)
{
IAnimatedMeshSceneNode* ninja = smgr->addAnimatedMeshSceneNode(
smgr->getMesh("Assets/model/ninja/ninja.b3d"));
ninja->setFrameLoop(182, 204);
ninja->setMaterialFlag(video::EMF_LIGHTING, false);
ninja->setAnimationSpeed(12);
ninja->setPosition(pos);
return ninja;
}
//loads the player and sets initial position
IAnimatedMeshSceneNode* Player::loadPlayerNode(IrrlichtDevice* device, ISceneManager* smgr)
{
IAnimatedMesh* player = smgr->getMesh("Assets/player.x");
if (!player) { device->drop(); return NULL; }
IAnimatedMeshSceneNode *plyrNode = smgr->addAnimatedMeshSceneNode(player);
for (int i = 0; i < plyrNode->getMaterialCount(); i++)
{
plyrNode->getMaterial(i).NormalizeNormals = true;
}
plyrNode->setPosition(vector3df(5.0f, 0.1f, 5.0f));
return plyrNode;
}
void Game::setupHud(){
IAnimatedMesh* gunmesh = smgr->getMesh("resources/models/weapons/test.obj");
IAnimatedMeshSceneNode* gunnode;
if(gunmesh)
{
gunnode = smgr->addAnimatedMeshSceneNode(gunmesh, gunnode);
gunnode->setParent(camera);
gunnode->setPosition(vector3df(50, 0, 1000));
gunnode->setRotation(vector3df(0, 0, 1000));
gunnode->updateAbsolutePosition();
std::cout << gunnode->getAbsolutePosition().X << ", " << gunnode->getAbsolutePosition().Y << ", "
<< gunnode->getAbsolutePosition().Z;
//gunnode->setScale(vector3df(1, 1, 1));
}
}
IAnimatedMeshSceneNode* MyIrrlichtComposition::mLoadMesh(vector3df pos,vector3df rot,vector3df scale, std::string name1, std::string name2)
{
IAnimatedMeshSceneNode* obj = smgr->addAnimatedMeshSceneNode(smgr->getMesh(name1.c_str()));
if(obj)
{
obj->setPosition(pos);
obj->setMD2Animation(scene::EMAT_RUN);
obj->setRotation(rot);
obj->setScale(scale);
obj->setMaterialTexture(0, driver->getTexture(name2.c_str()));
obj->addShadowVolumeSceneNode();
return obj;
}
else
exit(2);
}
void Game::addCheckPoint(const vector3df& position, const vector3df& rotation)
{
string<char> str = "checkpoint" + checkpoint->size();
IAnimatedMesh *cp1 = smgr->addHillPlaneMesh(str.c_str(), dimension2d<f32>(1000,1000), dimension2d<u32>(1,1));
IAnimatedMeshSceneNode *c = smgr->addAnimatedMeshSceneNode(cp1);
c->setRotation(rotation);
c->setPosition(position);
//c->setDebugDataVisible(EDS_BBOX);
checkpoint->push_back(c);
if (checkpoint->size() == 1)
{
first_checkpoint = c;
}
c->setMaterialType(EMT_TRANSPARENT_ADD_COLOR);
//c->setMaterialFlag(EMF_BACK_FACE_CULLING, false);
}
/** At the moment, this just verifies that the last frame of the animation produces the expected bitmap. */
bool md2Animation(void)
{
// Use EDT_BURNINGSVIDEO since it is not dependent on (e.g.) OpenGL driver versions.
IrrlichtDevice *device = createDevice( EDT_BURNINGSVIDEO, dimension2d<u32>(160, 120), 32);
assert(device);
if (!device)
return false;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
IAnimatedMeshSceneNode* node;
assert(mesh);
if(mesh)
{
node = smgr->addAnimatedMeshSceneNode(mesh);
assert(node);
if(node)
{
node->setPosition(vector3df(20, 0, 30));
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMaterialTexture(0, driver->getTexture("../media/sydney.bmp"));
node->setLoopMode(false);
(void)smgr->addCameraSceneNode();
// Just jump to the last frame since that's all we're interested in.
node->setMD2Animation(EMAT_DEATH_FALLBACK);
node->setCurrentFrame((f32)(node->getEndFrame()));
device->run();
driver->beginScene(true, true, SColor(255, 255, 255, 0));
smgr->drawAll();
driver->endScene();
}
}
bool result = takeScreenshotAndCompareAgainstReference(driver, "-md2Animation.png");
device->drop();
return result;
}
void Unit::addModel() {
IAnimatedMeshSceneNode* modelNode = Game::getInstance().sceneManager->addAnimatedMeshSceneNode( model, node );
if (modelNode)
{
modelNode->setMaterialTexture( 0, texture );
modelNode->getMaterial(0).Shininess = 0;
modelNode->setScale(vector3df(0.15f, 0.15f, 0.15f) );
modelNode->addShadowVolumeSceneNode(0, 0, false);
modelNode->setID(0);
currentAnimation = IDLE_ANIMATION;
float randX = rand() % 8 - 4;
float randZ =rand() % 8 - 4;
modelNode->setPosition(vector3df(randX, 0.0f, randZ));
}
modelNodes.push_back(modelNode);
}
void AnnyFactory::produce(int x,int y,int z){
std::string sydneyMesh = "monkey.obj";
std::string sydneyMaterial = "unwrappedPainted.png";//"monkey.bmp";
IAnimatedMesh* mesh = sceneManager->getMesh((RESOURCES+sydneyMesh).c_str());
if (!mesh)
{
exit(1);
}
IAnimatedMeshSceneNode* node = sceneManager->addAnimatedMeshSceneNode( mesh );
const wchar_t* name = L"Monkey head";
objectList->addObject(name);
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_RUN);
node->setMaterialTexture( 0, driver->getTexture((RESOURCES+sydneyMaterial).c_str()) );
node->setName(name);
node->setPosition(core::vector3df(x,y,z));
node->setScale(core::vector3df(10,10,10));
node->setRotation(core::vector3df(0,200,0));
}
}
void PhysicsSim::drawVector(Vector3D init, Vector3D end, Color c)
{
Vector3D vec = end-init;
float length = vec.getLength();
stringw meshname("ArrowMesh");
meshname += (int)arrows.size();
IAnimatedMesh* arrow = smgr->addArrowMesh (meshname, c, c, 4, 8, length, (length - 0.4 < 0.0) ? length*0.4 : (length-0.4));
IAnimatedMeshSceneNode *arrownode = smgr->addAnimatedMeshSceneNode(arrow);
arrownode->setPosition(init);
//arrownode->setScale(vector3df(1.0, length, 1.0));
vec.normalize();
quaternion q;
q.rotationFromTo(vector3df(0,1,0), vec);
vector3df rot;
q.toEuler(rot);
arrownode->setRotation(vector3df(rot.X*180.0/M_PI, rot.Y*180.0/M_PI, rot.Z*180.0/M_PI));
arrows.push_back(arrownode);
}
unsigned prioq_idx;
int owner_family;
union in_addr_union owner_address;
LIST_FIELDS(DnsCacheItem, by_key);
};
static void dns_cache_item_free(DnsCacheItem *i) {
if (!i)
return;
dns_resource_record_unref(i->rr);
dns_resource_key_unref(i->key);
free(i);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(DnsCacheItem*, dns_cache_item_free);
static void dns_cache_item_remove_and_free(DnsCache *c, DnsCacheItem *i) {
DnsCacheItem *first;
assert(c);
if (!i)
return;
first = hashmap_get(c->by_key, i->key);
LIST_REMOVE(by_key, first, i);
if (first)
assert_se(hashmap_replace(c->by_key, first->key, first) >= 0);
else
hashmap_remove(c->by_key, i->key);
prioq_remove(c->by_expiry, i, &i->prioq_idx);
dns_cache_item_free(i);
}
void dns_cache_flush(DnsCache *c) {
DnsCacheItem *i;
assert(c);
while ((i = hashmap_first(c->by_key)))
dns_cache_item_remove_and_free(c, i);
assert(hashmap_size(c->by_key) == 0);
assert(prioq_size(c->by_expiry) == 0);
hashmap_free(c->by_key);
c->by_key = NULL;
prioq_free(c->by_expiry);
c->by_expiry = NULL;
}
static void dns_cache_remove(DnsCache *c, DnsResourceKey *key) {
DnsCacheItem *i;
assert(c);
assert(key);
while ((i = hashmap_get(c->by_key, key)))
dns_cache_item_remove_and_free(c, i);
}
static void dns_cache_make_space(DnsCache *c, unsigned add) {
assert(c);
void dns_cache_prune(DnsCache *c) {
usec_t t = 0;
assert(c);
/* Remove all entries that are past their TTL */
for (;;) {
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
DnsCacheItem *i;
i = prioq_peek(c->by_expiry);
if (!i)
break;
if (t <= 0)
t = now(CLOCK_BOOTTIME);
if (i->until > t)
break;
/* Take an extra reference to the key so that it
* doesn't go away in the middle of the remove call */
key = dns_resource_key_ref(i->key);
dns_cache_remove(c, key);
}
}
static int dns_cache_item_prioq_compare_func(const void *a, const void *b) {
const DnsCacheItem *x = a, *y = b;
if (x->until < y->until)
return -1;
if (x->until > y->until)
return 1;
return 0;
}
static int dns_cache_init(DnsCache *c) {
int r;
assert(c);
r = prioq_ensure_allocated(&c->by_expiry, dns_cache_item_prioq_compare_func);
if (r < 0)
return r;
r = hashmap_ensure_allocated(&c->by_key, &dns_resource_key_hash_ops);
if (r < 0)
return r;
return r;
}
static int dns_cache_link_item(DnsCache *c, DnsCacheItem *i) {
DnsCacheItem *first;
int r;
assert(c);
assert(i);
r = prioq_put(c->by_expiry, i, &i->prioq_idx);
if (r < 0)
return r;
first = hashmap_get(c->by_key, i->key);
if (first) {
LIST_PREPEND(by_key, first, i);
assert_se(hashmap_replace(c->by_key, first->key, first) >= 0);
} else {
r = hashmap_put(c->by_key, i->key, i);
if (r < 0) {
prioq_remove(c->by_expiry, i, &i->prioq_idx);
return r;
}
}
return 0;
}
static DnsCacheItem* dns_cache_get(DnsCache *c, DnsResourceRecord *rr) {
DnsCacheItem *i;
assert(c);
assert(rr);
LIST_FOREACH(by_key, i, hashmap_get(c->by_key, rr->key))
if (i->rr && dns_resource_record_equal(i->rr, rr) > 0)
return i;
return NULL;
}
static void dns_cache_item_update_positive(DnsCache *c, DnsCacheItem *i, DnsResourceRecord *rr, usec_t timestamp) {
assert(c);
assert(i);
assert(rr);
i->type = DNS_CACHE_POSITIVE;
if (!i->by_key_prev) {
/* We are the first item in the list, we need to
* update the key used in the hashmap */
assert_se(hashmap_replace(c->by_key, rr->key, i) >= 0);
}
dns_resource_record_ref(rr);
dns_resource_record_unref(i->rr);
i->rr = rr;
dns_resource_key_unref(i->key);
i->key = dns_resource_key_ref(rr->key);
i->until = timestamp + MIN(rr->ttl * USEC_PER_SEC, CACHE_TTL_MAX_USEC);
prioq_reshuffle(c->by_expiry, i, &i->prioq_idx);
}
static int dns_cache_put_positive(
DnsCache *c,
DnsResourceRecord *rr,
usec_t timestamp,
int owner_family,
const union in_addr_union *owner_address) {
_cleanup_(dns_cache_item_freep) DnsCacheItem *i = NULL;
DnsCacheItem *existing;
int r;
assert(c);
assert(rr);
assert(owner_address);
/* New TTL is 0? Delete the entry... */
if (rr->ttl <= 0) {
dns_cache_remove(c, rr->key);
return 0;
}
if (rr->key->class == DNS_CLASS_ANY)
return 0;
if (rr->key->type == DNS_TYPE_ANY)
return 0;
/* Entry exists already? Update TTL and timestamp */
existing = dns_cache_get(c, rr);
if (existing) {
dns_cache_item_update_positive(c, existing, rr, timestamp);
return 0;
}
/* Otherwise, add the new RR */
r = dns_cache_init(c);
if (r < 0)
return r;
dns_cache_make_space(c, 1);
i = new0(DnsCacheItem, 1);
if (!i)
return -ENOMEM;
i->type = DNS_CACHE_POSITIVE;
i->key = dns_resource_key_ref(rr->key);
i->rr = dns_resource_record_ref(rr);
i->until = timestamp + MIN(i->rr->ttl * USEC_PER_SEC, CACHE_TTL_MAX_USEC);
i->prioq_idx = PRIOQ_IDX_NULL;
i->owner_family = owner_family;
i->owner_address = *owner_address;
r = dns_cache_link_item(c, i);
if (r < 0)
return r;
i = NULL;
return 0;
}
static int dns_cache_put_negative(
DnsCache *c,
DnsResourceKey *key,
int rcode,
usec_t timestamp,
uint32_t soa_ttl,
int owner_family,
const union in_addr_union *owner_address) {
_cleanup_(dns_cache_item_freep) DnsCacheItem *i = NULL;
int r;
assert(c);
assert(key);
assert(owner_address);
dns_cache_remove(c, key);
if (key->class == DNS_CLASS_ANY)
return 0;
if (key->type == DNS_TYPE_ANY)
return 0;
if (soa_ttl <= 0)
return 0;
if (!IN_SET(rcode, DNS_RCODE_SUCCESS, DNS_RCODE_NXDOMAIN))
return 0;
r = dns_cache_init(c);
if (r < 0)
return r;
dns_cache_make_space(c, 1);
i = new0(DnsCacheItem, 1);
if (!i)
return -ENOMEM;
i->type = rcode == DNS_RCODE_SUCCESS ? DNS_CACHE_NODATA : DNS_CACHE_NXDOMAIN;
i->key = dns_resource_key_ref(key);
i->until = timestamp + MIN(soa_ttl * USEC_PER_SEC, CACHE_TTL_MAX_USEC);
i->prioq_idx = PRIOQ_IDX_NULL;
i->owner_family = owner_family;
i->owner_address = *owner_address;
r = dns_cache_link_item(c, i);
if (r < 0)
return r;
i = NULL;
return 0;
}
int dns_cache_put(
DnsCache *c,
DnsQuestion *q,
int rcode,
DnsAnswer *answer,
unsigned max_rrs,
usec_t timestamp,
int owner_family,
const union in_addr_union *owner_address) {
unsigned i;
int r;
assert(c);
assert(q);
void Tile::addTile(float x, float y, float z) {
IAnimatedMeshSceneNode* tempnode = smgr->addAnimatedMeshSceneNode(tile[0]);
tempnode->setPosition(core::vector3df(x,y,z));
entity.insert(tempnode);
}
IAnimatedMeshSceneNode* MyIrrlichtComposition::mLoadMesh(vector3df pos, std::string name)
{
IAnimatedMeshSceneNode* obj = smgr->addAnimatedMeshSceneNode(smgr->getMesh(name.c_str()));
obj->setPosition(pos);
return obj;
}
int main()
{
IrrlichtDevice *device = createDevice( video::EDT_OPENGL, dimension2d<u32>(1024, 768), 32, false, false, true, 0);
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
smgr->addCameraSceneNodeFPS();
const s32 randLength = 1024;
srand(device->getTimer()->getRealTime());
//Creating the grid for unit measure, etc
u32 tileNumber = 128;
IAnimatedMesh* groundMesh = smgr->addHillPlaneMesh("", dimension2d<float>(8,8),dimension2d<u32>(tileNumber,tileNumber),0,0.0f,dimension2df(0,0),dimension2df(tileNumber,tileNumber));
IAnimatedMeshSceneNode * groundNode = smgr->addAnimatedMeshSceneNode(groundMesh);
groundNode->setMaterialTexture(0,driver->getTexture("../media/grid2.png"));
groundNode->setMaterialFlag(EMF_LIGHTING,false);
groundNode->setPosition(vector3df(0,-2,0));
//obstacles for stuff
EntityGroup obstacles;
for(int i = 0; i < 20; i++)
{
ISceneNode* s = smgr->addSphereSceneNode(20);
IrrlichtBaseEntity * e = new IrrlichtBaseEntity(s);
s->setPosition(vector3df(rand()%randLength - (randLength/2),0,rand()%randLength - (randLength/2)));
obstacles.push_back(e);
}
//Nodes for vehicles
ISceneNode * cube = smgr->addCubeSceneNode(4);
ISceneNode * cube2 = smgr->addCubeSceneNode(4);
cube->setMaterialFlag(EMF_LIGHTING,false);
cube->setMaterialTexture(0,driver->getTexture("../media/v1-solid.png"));
cube2->setMaterialFlag(EMF_LIGHTING,false);
cube2->setMaterialTexture(0,driver->getTexture("../media/v2-solid.png"));
//Creating the actual vehicles
IrrlichtMobileEntity * Entity1 = new IrrlichtMobileEntity(cube ,vector3df(0,0,0), 1, 90, 40);
IrrlichtMobileEntity * Entity2 = new IrrlichtMobileEntity(cube2,vector3df(0,0,300), 1, 100, 50);
//Creating the steering conrollers, constructor also sets steering on entity
SimpleSteeringController* Entity1Steering = new SimpleSteeringController(Entity1);
SimpleSteeringController * Entity2Steering = new SimpleSteeringController(Entity2);
//Setting up other params for behaviors
Entity1Steering->SetObstacles(obstacles);
Entity1Steering->SetHideTarget(Entity2);
Entity1Steering->SetBehaviorFlag(EBF_HIDE,true);
Entity1Steering->SetBehaviorFlag(EBF_AVOID,true);
Entity2Steering->SetObstacles(obstacles);
Entity2Steering->SetPursuitTarget(Entity1);
Entity2Steering->SetBehaviorFlag(EBF_PURSUIT,true);
Entity2Steering->SetBehaviorFlag(EBF_AVOID,true);
//vars for tracking time between frames. This allows framerate independent motion state updates.
u32 then = device->getTimer()->getTime();
float timeUpdate = 0;
while(device->run())
{
const u32 now = device->getTimer()->getTime();
const float frameDeltaTime = (float)(now - then) / 1000.f; // Time in seconds
then = now;
timeUpdate += frameDeltaTime;
if(timeUpdate > 1)
{
core::stringw str = L"desteer v0.0.1 FPS: ";
str += (s32)driver->getFPS();
device->setWindowCaption(str.c_str());
timeUpdate = 0;
}
//Do behavior updates before the rendering.
Entity1->Update(frameDeltaTime);
Entity2->Update(frameDeltaTime);
driver->beginScene(true, true, SColor(255,100,101,140));
smgr->drawAll();
driver->endScene();
}
//Clean up irrlicht.
device->drop();
return 0;
}
void Tile::removeTile(float x, float y, float z) {
IAnimatedMeshSceneNode* tempnode = smgr->addAnimatedMeshSceneNode(tile[0]);
tempnode->setPosition(core::vector3df(x,y,z));
//entity.erase(entity.find(tempnode)); // <-- kaatuu
}
int main()
{
// create device
EventHandler receiver;
Init();
Output();
ISceneNode* objects [MAX_OBJECTS];
IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2d<u32>(ResX, ResY), 32, fullscreen, false, vsync, &receiver);
receiver.device = device;
if (!device)
return 1;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
HMDDescriptor HMD;
// Parameters from the Oculus Rift DK1
HMD.hResolution = ResX;
HMD.vResolution = ResY;
HMD.hScreenSize = 0.14976;
HMD.vScreenSize = 0.0936;
HMD.interpupillaryDistance = 0.064;
HMD.lensSeparationDistance = 0.064;
HMD.eyeToScreenDistance = 0.041;
HMD.distortionK[0] = 1.0;
HMD.distortionK[1] = 0.22;
HMD.distortionK[2] = 0.24;
HMD.distortionK[3] = 0.0;
HMDStereoRender renderer(device, HMD, 10);
#ifdef OCCULUS
ICameraSceneNode* camera = smgr->addCameraSceneNode();
camera->bindTargetAndRotation(false);
camera->setTarget(vector3df(1,0,0));
#else
ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
#endif
device->getCursorControl()->setVisible(false);
// load a faerie
IAnimatedMesh* faerie = smgr->getMesh("media/faerie.md2");
IAnimatedMeshSceneNode* faerieNode = smgr->addAnimatedMeshSceneNode(faerie);
faerieNode->setMaterialTexture(0, driver->getTexture("media/faerie2.bmp"));
faerieNode->setMaterialFlag(EMF_LIGHTING, false);
faerieNode->setPosition(vector3df(40,190,-1030));
faerieNode->setRotation(vector3df(0,-90,0));
faerieNode->setMD2Animation(EMAT_SALUTE);
// load a dwarf
IAnimatedMesh* dwarf = smgr->getMesh("media/dwarf.x");
IAnimatedMeshSceneNode* dwarfNode = smgr->addAnimatedMeshSceneNode(dwarf);
dwarfNode->setPosition(vector3df(40,-25,20));
Level currentLevel(device);
currentLevel.makeLevel(0);
smgr->setAmbientLight(video::SColorf(0.1,0.1,0.1,1));
ILightSceneNode* light1 = smgr->addLightSceneNode( camera , vector3df(0,0,0), video::SColorf(0.3f,0.4f,0.4f), 80.0f, 1 );
vector3df pos = vector3df(0,0,0);
//naplníme tunel pøekážkama
srand (time(NULL));
/* generate secret number between 1 and 10: */
for(int i = 0; i < MAX_OBJECTS; i++){
objects[i] = smgr->addCubeSceneNode(2);
objects[i]->setMaterialFlag(EMF_LIGHTING, false);
objects[i]->setPosition( vector3df( (rand() % 30) - 5, (rand() % 30) - 5, rand() % 80) );
}
//device->setInputReceivingSceneManager(smgr);
//použivane pro
vector3df tempRot;
irr::core::quaternion tempQ;
irr::core::matrix4 tempM;
float round = 0;
while(device->run())
{
round += 0.01;
driver->beginScene(true, true, SColor(255,100,101,140));
for(int i = 0; i < MAX_OBJECTS; i++){
vector3df tmpPos = objects[i]->getPosition();
if(tmpPos.Z > pos.Z) continue;
objects[i]->setPosition( vector3df( (rand() % 30) - 15, (rand() % 30) - 15, rand() % 80 + pos.Z) );
}
#ifndef OCCULUS
tempM.setRotationDegrees(vector3df(sin(round*0.5)*360-180, sin(round)*360-180, cos(round*0.8)*360-180));
// transform forward vector of camera
irr::core::vector3df frv = irr::core::vector3df (0.0f, 0.0f, 1.0f);
tempM.transformVect(frv);
// transform upvector of camera
irr::core::vector3df upv = irr::core::vector3df (0.0f, 1.0f, 0.0f);
tempM.transformVect(upv);
camera->setUpVector(upv); //set up vector of camera
camera->setTarget(frv); //set target of camera (look at point) (thx Zeuss for correcting it)
#endif
if(pSensor){
Quatf quaternion = FusionResult.GetOrientation();
ICameraSceneNode* camera = smgr->getActiveCamera();
tempQ.set(-quaternion.z,quaternion.y,-quaternion.x, quaternion.w);
tempQ.normalize();
tempQ.toEuler(tempRot);
tempM.setRotationDegrees(tempRot);
// transform forward vector of camera
irr::core::vector3df frv = irr::core::vector3df (0.0f, 0.0f, 1.0f);
tempM.transformVect(frv);
// transform upvector of camera
irr::core::vector3df upv = irr::core::vector3df (0.0f, 1.0f, 0.0f);
tempM.transformVect(upv);
camera->setUpVector(upv); //set up vector of camera
camera->setTarget(frv); //set target of camera (look at point) (thx Zeuss for correcting it)
// update absolute position
camera->updateAbsolutePosition();
float yaw, pitch, roll;
quaternion.GetEulerAngles<Axis_Y, Axis_X, Axis_Z>(&yaw, &pitch, &roll);
camera->getParent()->setRotation( vector3df(RadToDegree(pitch),RadToDegree(yaw),RadToDegree(roll)));
//camera->setRotation( vector3df(RadToDegree(-pitch),RadToDegree(-yaw),RadToDegree(roll)));
//camera->setProjectionMatrix(ToMatrix(quaternion));
cout << " Yaw: " << RadToDegree(yaw) <<
", Pitch: " << RadToDegree(pitch) <<
", Roll: " << RadToDegree(roll) << endl;
if (_kbhit()) exit(0);
}
#ifdef OCCULUS
renderer.drawAll(smgr);
#else
smgr->drawAll();
#endif
guienv->drawAll();
driver->endScene();
}
device->drop();
Clear();
return 0;
}
///////////////////////////////////////////函数实现////////////////////////////////////////////////
bool LoadModels(ISceneNode* m_ICamera,std::map<std::string,IAnimatedMeshSceneNode*>& myNode)
{
_finddata_t file;
long longf;
//读取文件夹下文件名字
if((longf = _findfirst("..\\model\\*.3ds", &file))==-1l)
{
std::cout<<"没有找到模型!\n";
}
else
{
std::cout<<"\n加载模型\n";
std::string tempName;
tempName = "";
tempName = file.name;
m_vecStrModelName.push_back(tempName);//加载第一个模型名字
while( _findnext( longf, &file ) == 0 )
{
tempName = "";
tempName = file.name;
if (tempName == "..")
{
continue;
}
m_vecStrModelName.push_back(tempName);
}
}
_findclose(longf);
//模型库模型节点的ID(从1000开始)
int storeModelID=1000;
//加载模型创建场景节点
auto iter(m_vecStrModelName.begin());
while(iter!=m_vecStrModelName.end())
{
std::string myPath=*iter;
myPath="..\\model\\"+myPath;
scene::IAnimatedMesh* mesh = m_IrrSmgr->getMesh((char*)myPath.c_str());
//模型设为摄像头的子节点
IAnimatedMeshSceneNode* modelNode = m_IrrSmgr->addAnimatedMeshSceneNode(mesh,m_ICamera);
// 设置自发光强度大小（即镜面渲染中的亮度大小）
modelNode->getMaterial(0).Shininess = 20.0f;
modelNode->setMaterialFlag(EMF_LIGHTING, true);
modelNode->setRotation(vector3df(90, 0, 0));
modelNode->setPosition(vector3df(90, 0, 0));
//创建三角选择器
m_ItriElector = m_IrrSmgr->createTriangleSelector(modelNode);
modelNode->setTriangleSelector(m_ItriElector);
m_ItriElector->drop(); // We're done with this m_ItriElector, so drop it now.
myNode[(*iter)]=modelNode;//插入模型名字和模型库结点对
iter++;
//设置模型为不可见
modelNode->setVisible(false);
//设置模型库模型ID
modelNode->setID(storeModelID);
++storeModelID;
}
//计算模型库的页数(三个模型一页)
m_iTotalPageNumber=m_vecStrModelName.size()/m_iPageModelCount;
if(m_vecStrModelName.size()%m_iPageModelCount!=0)
{
m_iTotalPageNumber+=1;
}
//添加翻页标志模型
for(int i=0;i<2;i++)
{
scene::IAnimatedMesh* mesh;
if(0==i)
{
mesh = m_IrrSmgr->getMesh("left.3ds");
}
else
{
mesh = m_IrrSmgr->getMesh("right.3ds");
}
//模型设为摄像头的子节点
IAnimatedMeshSceneNode* modelNode = m_IrrSmgr->addAnimatedMeshSceneNode(mesh,m_ICamera);
// 设置自发光强度大小（即镜面渲染中的亮度大小）
modelNode->getMaterial(0).Shininess = 20.0f;
modelNode->setMaterialFlag(EMF_LIGHTING, true);
modelNode->setRotation(vector3df(90, 0, 0));
//创建三角选择器
m_ItriElector = m_IrrSmgr->createTriangleSelector(modelNode);
modelNode->setTriangleSelector(m_ItriElector);
m_ItriElector->drop(); // We're done with this m_ItriElector, so drop it now.
//设置模型为不可见
modelNode->setVisible(false);
//设置模型库模型ID
if(0==i)
{
modelNode->setID(2000);
}
else
{
modelNode->setID(2001);
}
}
return true;
}
void CCharacterExample::runExample()
{
for(s32 i=0; i<KEY_KEY_CODES_COUNT; i++)
KeyIsDown[i] = false;
debugDraw = true;
drawProperties = true;
drawWireFrame = false;
rows = 10;
columns = 10;
device =
createDevice( video::EDT_OPENGL, dimension2d<u32>(640, 480), 16,
false, false, false, this);
device->setWindowCaption(L"irrBullet Character Example - Josiah Hartzell");
device->getFileSystem()->addFileArchive("./media/");
device->getSceneManager()->addLightSceneNode(0, vector3df(20, 40, -50), SColorf(1.0f, 1.0f, 1.0f), 4000.0f);
////////////////////////////
// Create irrBullet World //
////////////////////////////
world = createIrrBulletWorld(device, true, debugDraw);
world->setDebugMode(EPDM_DrawAabb |
EPDM_DrawContactPoints);
world->setGravity(vector3df(0,-10,0));
camera = device->getSceneManager()->addCameraSceneNodeMaya();
camera->setPosition(vector3df(50,15,200));
camera->bindTargetAndRotation(true);
createGround();
createBoxes();
IKinematicCharacterController* character = new IKinematicCharacterController(world);
IAnimatedMeshSceneNode* sydney = device->getSceneManager()->addAnimatedMeshSceneNode(device->getSceneManager()->getMesh("sydney.md2"));
sydney->setScale(vector3df(0.14,0.14,0.14));
sydney->getMaterial(0).setTexture(0, device->getVideoDriver()->getTexture("sydney.bmp"));
sydney->setMD2Animation(scene::EMAT_STAND);
// Set our delta time and time stamp
u32 TimeStamp = device->getTimer()->getTime();
u32 DeltaTime = 0;
EMD2_ANIMATION_TYPE animation = EMAT_STAND;
EMD2_ANIMATION_TYPE newAnimation = EMAT_RUN;
bool jump = false;
while(device->run())
{
device->getVideoDriver()->beginScene(true, true, SColor(255,100,101,140));
DeltaTime = device->getTimer()->getTime() - TimeStamp;
TimeStamp = device->getTimer()->getTime();
/*sydney->setPosition(character->getWorldTransform().getTranslation()+vector3df(0,-((sydney->getBoundingBox().MaxEdge.Y-sydney->getBoundingBox().MinEdge.Y)*0.1*0.5f),0));
vector3df dir = camera->getAbsolutePosition()-sydney->getAbsolutePosition();
dir.normalize();
dir.Y = 0;
dir *= -1;
character->setWalkDirection(dir*0.3f);*/
if(IsKeyDown(KEY_KEY_W))
{
DirZ = -1.0f;
}
else if(IsKeyDown(KEY_KEY_S))
{
DirZ = 1.0f;
}
else
{
DirZ = 0.0f;
}
if(IsKeyDown(KEY_KEY_A))
{
DirX = 1.0f;
}
else if(IsKeyDown(KEY_KEY_D))
{
DirX = -1.0f;
}
else
{
DirX = 0.0f;
}
if(IsKeyDown(KEY_SPACE))
{
character->jump();
jump = true;
}
if(DirZ != 0 || DirX != 0)
newAnimation = EMAT_RUN;
else
newAnimation = EMAT_STAND;
if(!character->isOnGround())
{
newAnimation = jump ? EMAT_JUMP:EMAT_CROUCH_STAND;
}
else
jump = false;
if(animation != newAnimation)
{
animation = newAnimation;
sydney->setMD2Animation(animation);
}
sydney->setPosition(character->getWorldTransform().getTranslation());
vector3df rot(0, camera->getRotation().Y-90.0f, 0);
sydney->setRotation(rot);
vector3df direction(DirX, 0.0f, DirZ);
irr::core::matrix4 m;
m.setRotationDegrees(vector3df(0, camera->getRotation().Y-180.0f, 0));
m.transformVect(direction);
character->setPositionIncrementPerSimulatorStep(direction*0.3f);
camera->setTarget(sydney->getPosition());
// Step the simulation with our delta time
world->stepSimulation(DeltaTime*0.001f, 120);
world->debugDrawWorld(debugDraw);
// This call will draw the technical properties of the physics simulation
// to the GUI environment.
world->debugDrawProperties(true);
device->getSceneManager()->drawAll();
device->getGUIEnvironment()->drawAll();
device->getVideoDriver()->endScene();
}
delete character;
// We're done with the IrrBullet world, so we free the memory that it takes up.
if(world)
delete world;
if(device)
device->drop();
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
// To make things more interesting, we add many Sydneys and a textured floor this time
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"Heat Haze (with Depth dependence)", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
ISceneManager* smgr2 = smgr->createNewSceneManager( false );
ISceneNode* rootnode2 = smgr2->getRootSceneNode( );
IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices( );
u32 matid, matid2;
switch( driver->getDriverType( ) ) {
case EDT_OPENGL:
matid = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_PLAIN, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_SOLID, 1 );
matid2 = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_HEATSOURCE, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_TRANSPARENT_ALPHA_CHANNEL, 1 );
break;
case EDT_DIRECT3D8:
case EDT_DIRECT3D9:
default:
matid = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_PLAIN, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_SOLID, 0 );
matid2 = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_HEATSOURCE, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_TRANSPARENT_ALPHA_CHANNEL, 0 );
}
for( u8 x = 0u; x != 2u; ++ x )
for( u8 i = 0u; i != 5u; ++ i ) {
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setMaterialType( (E_MATERIAL_TYPE) matid );
node->setPosition( vector3df( -x * 20.0f, 0.0f, i * 40.0f ) );
ISceneNode* node2 = smgr2->addBillboardSceneNode( rootnode2, dimension2df( 30.0f, 80.0f ), vector3df( -x * 20.0f, 30.0f, i * 40.0f ) );
node2->setMaterialFlag(EMF_LIGHTING, false);
node2->setMaterialType( EMT_TRANSPARENT_ADD_COLOR );
node2->setMaterialTexture( 0, driver->getTexture("fireball.bmp") );
node2->setMaterialType( (E_MATERIAL_TYPE) matid2 );
}
ISceneNode* nodeF = smgr->addMeshSceneNode( smgr->addHillPlaneMesh( "", dimension2df( 200.0f, 200.0f ), dimension2d<u32>( 10, 10 ), NULL, 0.0f, dimension2df( 0.0f, 0.0f ), dimension2df( 100.0f, 100.0f ) ) );
nodeF->setMaterialFlag(EMF_LIGHTING, false);
nodeF->setMaterialTexture( 0, driver->getTexture("terrain-heightmap.bmp") );
nodeF->setPosition( vector3df( 0.0f, -22.0f, 0.0f ) );
nodeF->setMaterialType( (E_MATERIAL_TYPE) matid );
ICameraSceneNode* cam1 = smgr->addCameraSceneNode( 0, vector3df( 40.0f, 60.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
ICameraSceneNode* cam2 = smgr2->addCameraSceneNode( rootnode2, vector3df( 40.0f, 60.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
IPostProc* ppRenderer2 = new CRendererPostProc( smgr2, dimension2di( 1024, 512 ), true, true, SColor( 255u, 0u, 0u, 0u ) );
CEffectPostProc* ppHaze = new CEffectPostProc( ppRenderer1, dimension2di( 1024, 512 ), PP_HAZEDEPTH );
ppHaze->setInput( 1, ppRenderer2 );
ppHaze->setTimer( device->getTimer( ) );
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
cam1->setPosition( vector3df( 40.0f, 60.0f - (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, -40.0f ) );
cam1->setTarget( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, 50.0f ) );
cam2->setPosition( cam1->getPosition( ) );
cam2->setTarget( cam1->getTarget( ) );
cam2->setUpVector( cam1->getUpVector( ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppHaze->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 ppHaze;
delete ppRenderer1;
delete ppRenderer2;
// Back to boring stuff
device->drop();
return 0;
}
int main()
{
/* shadowDimen = dimension2du(1024,1024);
shadowDimen = dimension2du(2048,2048);
shadowDimen = dimension2du(4096,4096);
shadowDimen = dimension2du(2048,2048);
filterType = EFT_NONE;
filterType = EFT_4PCF;
filterType = EFT_8PCF;
filterType = EFT_4PCF;
*/
dimension2du shadowDimen = dimension2du(1024,1024);
E_FILTER_TYPE filterType = EFT_4PCF;
filterType = EFT_NONE;
////
IrrlichtDevice* device = createDevice(EDT_OPENGL,dimension2du(800,600),32);
ISceneManager* smgr = device->getSceneManager();
IVideoDriver* driver = device->getVideoDriver();
ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(0,100,.5);
cam->setPosition(vector3df(0,10,0));
// Create the effect handler, passing the device and RTT size (as a dimension2d) .
effectHandler* effect = new effectHandler(device,shadowDimen);
ITerrainSceneNode* terrain = smgr->addTerrainSceneNode("media/terrain.bmp",0,-1,vector3df(0,0,0),vector3df(0,0,0),vector3df(1,1,1),SColor(255,255,255,255),1,ETPS_33);
terrain->setMaterialTexture(0,driver->getTexture("media/terrain.jpg"));
terrain->setMaterialTexture(1, driver->getTexture("media/detailmap.jpg"));
terrain->scaleTexture(1,10);
terrain->setScale(core::vector3df(4, 0.01f, 4));
terrain->setPosition(vector3df(-120,-1.5f,-120));
terrain->setMaterialType(EMT_DETAIL_MAP);
// Make the terrain recieve a shadow with the specified filter type.
// (NOTE: 12PCF is only available in Direct3D9, all others work with OpenGL)
effect->addShadowToNode(terrain,filterType);
IAnimatedMeshSceneNode* sydney;
IAnimatedMesh* sydneymesh = smgr->getMesh("media/dwarf.x");
for(int g = 0;g < 1;g++)
{
for(int v = 0;v < 3;v++)
{
sydney = smgr->addAnimatedMeshSceneNode(sydneymesh);
sydney->setScale(vector3df(0.05f,0.05f,0.05f));
sydney->setPosition(vector3df(g * 4,0.5f,v * 4));
sydney->setMaterialFlag(EMF_NORMALIZE_NORMALS,true);
sydney->setAutomaticCulling(EAC_FRUSTUM_BOX);
sydney->setMaterialType(EMT_SOLID);
// Add the nodes to the depth pass so that they cast a shadow.
effect->addNodeToDepthPass(sydney);
}
}
effect->getLightCamera()->addAnimator(smgr->createFlyCircleAnimator(sydney->getPosition() + vector3df(0,15,0),25,0.0002f));
effect->getLightCamera()->setNearValue(5);
effect->setMaxShadowDistanceFromLight(120);
smgr->addLightSceneNode(effect->getLightCamera());
MyEventReceiver receiver(cam);
device->setEventReceiver(&receiver);
// Parent a sphere to the light camera so we can see its position.
smgr->addSphereSceneNode(1,8,effect->getLightCamera())->setMaterialFlag(EMF_LIGHTING,false);
while(device->run())
{
wchar_t tmp[255];
swprintf(tmp,255,L"Shadow Map Demo (FPS: %d)",driver->getFPS());
device->setWindowCaption(tmp);
driver->beginScene(true,true,SColor(0,0,0,0));
// Point the light camera at one of the nodes as it rotates around them.
effect->setLightTarget(sydney->getPosition());
// Update the effect handler, remember to always do this BEFORE smgr->drawAll and AFTER beginscene!
effect->update();
smgr->drawAll();
// If user wishes we can display the shadow map to the screen. (May not work in OpenGL)
if(disp2d)
driver->draw2DImage(effect->getShadowMapTexture(),position2d<s32>(0,0));
driver->endScene();
// device->sleep(5);
}
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
// To make things more interesting, we add many Sydneys and a textured floor this time
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"Sandbox", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices( );
u32 matid;
switch( driver->getDriverType( ) ) {
case EDT_OPENGL:
matid = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_PLAIN, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_SOLID, 1 );
break;
case EDT_DIRECT3D8:
case EDT_DIRECT3D9:
default:
matid = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_PLAIN, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_SOLID, 0 );
}
for( u8 x = 0u; x != 2u; ++ x )
for( u8 i = 0u; i != 5u; ++ i ) {
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setMaterialType( (E_MATERIAL_TYPE) matid );
node->setPosition( vector3df( -x * 20.0f, 0.0f, i * 40.0f ) );
}
ISceneNode* nodeF = smgr->addTerrainSceneNode( "terrain-heightmap.bmp" );
nodeF->setMaterialFlag(EMF_LIGHTING, false);
nodeF->setMaterialTexture( 0, driver->getTexture("terrain-heightmap.bmp") );
nodeF->setPosition( vector3df( -512.0f, -50.0f, -512.0f ) );
nodeF->setScale( vector3df( 4.0f, 0.2f, 4.0f ) );
nodeF->setMaterialType( (E_MATERIAL_TYPE) matid );
ICameraSceneNode* cam1 = smgr->addCameraSceneNode( 0, vector3df( 0.0f, 0.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255, 130u, 180u, 230u ) );
CWaterPostProc* ppWater = new CWaterPostProc( ppRenderer1, dimension2di( 1024, 512 ), -22.0f );
ppWater->setTimer( device->getTimer( ) );
wchar_t tmp[255];
u8 t = 0u;
while( device->run( ) ) {
// cam1->setPosition( vector3df( 40.0f, 60.0f - (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, -40.0f ) );
cam1->setPosition( vector3df( (device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, -40.0f ) );
// cam1->setTarget( vector3df( (device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, 0.0f ) );
// cam1->setTarget( cam1->getPosition( ) + vector3df( 0.0f, 0.0f, 10.0f ) );
// cam1->setTarget( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, 50.0f ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppWater->render( NULL );
guienv->drawAll( );
driver->endScene( );
if( ++ t == 30u ) {
t = 0u;
swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() );
device->setWindowCaption( tmp );
}
}
delete ppWater;
delete ppRenderer1;
// Back to boring stuff
device->drop();
return 0;
}
bool
ProcTitle::OnInit(irr::IrrlichtDevice& device)
{
device.setWindowCaption(L"Pair - title");
//device.getCursorControl()->setVisible(false);
u32 width = IrrDvc.GetDriver()->getScreenSize().Width;
u32 height = IrrDvc.GetDriver()->getScreenSize().Height;
scene::ISceneManager* pSmgr = IrrDvc.GetSmgr();
IVideoDriver* pDriver = IrrDvc.GetDriver();
// camera setting
{
irr::scene::ICameraSceneNode* pCamera = pSmgr->addCameraSceneNode(0, core::vector3df(0,0,-100), core::vector3df(0,0,0));
//f32 zNear = 1;
//f32 zFar = 3000;
//f32 zNear = pCamera->getNearValue();
//f32 zFar = pCamera->getFarValue();
#if 0
CMatrix4<f32> matOrtho;
matOrtho.buildProjectionMatrixOrthoLH(width, height, zNear, zFar);
pCamera->setProjectionMatrix(matOrtho, true);
#else
//CMatrix4<f32> matPerspective;
//matPerspective.buildProjectionMatrixPerspectiveLH((f32)width, (f32)height, zNear, zFar);
//pCamera->setProjectionMatrix(matPerspective, false);
#endif
}
// title
{
m_p2DSprite = pSmgr->addBillboardSceneNode();
video::ITexture* pTexture = pDriver->getTexture("Rsrc/title.png");
m_p2DSprite->setMaterialTexture(0, pTexture);
m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
m_p2DSprite->setMaterialFlag(video::EMF_ANTI_ALIASING, true);
m_p2DSprite->setMaterialFlag(video::EMF_BILINEAR_FILTER, true);
m_p2DSprite->setSize(dimension2df((f32)width, (f32)height));
m_p2DSprite->setPosition(vector3df(0.f, 0.f, 300.f));
m_p2DSprite->setID(1004);
m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(1.0f, 1.0f);
// animation test
//scene::ISceneNodeAnimator* pAni = pSmgr->createFlyCircleAnimator(core::vector3df(0,0,200), 20.0f);
//m_p2DSprite->addAnimator(pAni);
}
// card
{
for (int i = 0; i < 3; i++)
{
IMeshSceneNode* pCard = pSmgr->addCubeSceneNode();
char buff[20];
sprintf_s(buff, 20, "Rsrc/card%d.png", i);
video::ITexture* pTexture = pDriver->getTexture(buff);
pCard->setMaterialTexture(0, pTexture);
pCard->setScale(vector3df(4.f, 4.f * 1.618f, 0.1f));
pCard->setPosition(vector3df(-60.f + 60.f * i, 0.f, 0.f));
pCard->setMaterialFlag(video::EMF_LIGHTING, false);
// animation test
scene::ISceneNodeAnimator* pAni = pSmgr->createRotationAnimator(vector3df(0.f, 1.f, 0.f));
pCard->addAnimator(pAni);
pAni->drop();
}
}
// mesh
{
IAnimatedMesh* mesh = pSmgr->getMesh("Rsrc/sydney.md2");
IAnimatedMeshSceneNode* pNode = pSmgr->addAnimatedMeshSceneNode(mesh);
if (pNode)
{
//pNode->setScale(vector3df(10.f, 10.f, 10.f));
pNode->setMaterialFlag(EMF_LIGHTING, false);
//pNode->setMaterialFlag(EMF_ZBUFFER, false);
pNode->setMD2Animation(scene::EMAT_STAND);
pNode->setMaterialTexture( 0, pDriver->getTexture("Rsrc/sydney.bmp") );
pNode->setPosition(vector3df(0.0f, -5.f, -55.f));
}
}
// button
{
IGUIEnvironment* env = device.getGUIEnvironment();
video::ITexture* pTexture = pDriver->getTexture("Rsrc/new_game_btn_normal.PNG"); // refcount = 1
dimension2d<u32> dim = pTexture->getOriginalSize();
s32 offsetX = width / 2 - dim.Width / 2;
s32 offsetY = height - dim.Height * 3;
IGUIButton* pButton = env->addButton(rect<s32>(offsetX, offsetY, offsetX + dim.Width, offsetY + dim.Height), 0, GUI_ID_START_BUTTON);
pButton->setDrawBorder(false);
pButton->setImage(pTexture); // refcount += 2, means when button released refcount will be 1
pButton->setUseAlphaChannel(true); // 1 will be decreased pDriver->removeAllTextures();
{
ITexture* pTexture = pDriver->getTexture("Rsrc/new_game_btn_pressed.PNG");
pButton->setPressedImage(pTexture);
}
}
// sound test
IrrSnd.GetSndEngine()->play2D("Rsrc/getout.ogg", true);
return true;
}
void CRaycastTankExample::createTank(const stringw file, const stringw collFile, const vector3df &pos, const f32 mass)
{
IAnimatedMeshSceneNode *Node = device->getSceneManager()->addAnimatedMeshSceneNode(
device->getSceneManager()->getMesh(file.c_str()));
Node->setPosition(pos);
//Node->setRotation(vector3df(-40,90,0));
Node->setMaterialFlag(video::EMF_LIGHTING, true);
//Node->setScale(vector3df(2,2,4));
IGImpactMeshShape *shape = new IGImpactMeshShape(Node, device->getSceneManager()->getMesh(collFile.c_str()), mass);
tank = world->addRigidBody(shape);
// When using a raycast vehicle, we don't want this rigid body to deactivate.
tank->setActivationState(EAS_DISABLE_DEACTIVATION);
// Set some damping on the rigid body because the raycast vehicles tend to bounce a lot without a lot of tweaking.
// (cheap fix for the example only)
tank->setDamping(0.4, 0.4);
// We create our vehicle, passing our newly created rigid body as a parameter.
vehicle = world->addRaycastVehicle(tank);
// Set up our wheel construction info. These values can be changed for each wheel,
// and the values that you want to keep will stay the same, that way
// all parameters for each wheel can stay the same for what needs to remain equal,
// such as directions and suspension rest length.
SWheelInfoConstructionInfo wheel;
wheel.chassisConnectionPointCS = vector3df(0.0,-0.88,4.0);
wheel.wheelDirectionCS = vector3df(0.0,-0.1,0.0);
wheel.wheelAxleCS = vector3df(-0.5,0.0,0.0);
wheel.suspensionRestLength = 0.6;
wheel.wheelRadius = 8.0;
wheel.isFrontWheel = true;
// The bones are in the center of the mesh on the X axis, so we just set the width ourselves.
// Do the left row of wheels.
for(u32 i=0; i < Node->getJointCount(); i++)
{
// The bones that we need in this mesh are all named "RoadWheels" with a numerical suffix.
// So we do a quick check to make sure that no unwanted bones get through as wheels.
if(Node->getJointNode(i)->getName()[0] == 'R')
{
wheel.chassisConnectionPointCS = vector3df(-4, Node->getJointNode(i)->getPosition().Y,Node->getJointNode(i)->getPosition().Z);
vehicle->addWheel(wheel);
}
}
wheel.wheelAxleCS = vector3df(0.5,0.0,0.0);
// Do the right row of wheels.
for(u32 i=0; i < Node->getJointCount(); i++)
{
if(Node->getJointNode(i)->getName()[0] == 'R')
{
wheel.chassisConnectionPointCS = vector3df(4, Node->getJointNode(i)->getPosition().Y,Node->getJointNode(i)->getPosition().Z);
vehicle->addWheel(wheel);
}
}
for (u32 i=0;i<vehicle->getNumWheels();i++)
{
SWheelInfo &info = vehicle->getWheelInfo(i);
info.suspensionStiffness = 0.08f;
info.wheelDampingRelaxation = 20.0f;
info.wheelDampingCompression = 20.0f;
info.frictionSlip = 1000;
info.rollInfluence = 0.1f;
// We call updateWheel, which takes SWheelInfo as the first parameter,
// and the ID of the wheel to apply that info to. This must
// be called after any changes in order for the changes to actually take effect.
vehicle->updateWheelInfo(i);
}
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
// To make things more interesting, we add many Sydneys and a textured floor this time
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"Depth of Field", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
// Create the required material. This is a simple shader which draws the texture with no lights.
// Use GL_PLAIN1 / DX_PLANE1 or GL_PLAIN2 / DX_PLANE2 to support 1 or 2 basic point-lights
u32 matid;
IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices( );
switch( driver->getDriverType( ) ) {
case EDT_OPENGL:
matid = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_PLAIN, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_SOLID, 1 );
break;
case EDT_DIRECT3D8:
case EDT_DIRECT3D9:
default:
matid = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_PLAIN, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_SOLID, 0 );
}
for( u8 x = 0u; x != 2u; ++ x )
for( u8 i = 0u; i != 5u; ++ i ) {
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setMaterialType( (E_MATERIAL_TYPE) matid );
node->setPosition( vector3df( -x * 20.0f, 0.0f, i * 40.0f ) );
}
ISceneNode* node2 = smgr->addMeshSceneNode( smgr->addHillPlaneMesh( "", dimension2df( 200.0f, 200.0f ), dimension2d<u32>( 10, 10 ), NULL, 0.0f, dimension2df( 0.0f, 0.0f ), dimension2df( 100.0f, 100.0f ) ) );
node2->setMaterialFlag(EMF_LIGHTING, false);
node2->setMaterialTexture( 0, driver->getTexture("terrain-heightmap.bmp") );
node2->setMaterialType( (E_MATERIAL_TYPE) matid );
node2->setPosition( vector3df( 0.0f, -22.0f, 0.0f ) );
ICameraSceneNode* cam = smgr->addCameraSceneNode( 0, vector3df( 40.0f, 60.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
CEffectPostProc* ppBlurDOF = new CEffectPostProc( ppRenderer, dimension2di( 1024, 512 ), PP_BLURDOF );
// We could set parameters on creation, but no need since we will animate it anyway.
// Parameters are: near blur, near focus, far focus, far blur, blur level
// You can also use PP_BLURDOFNEAR or PP_BLURDOFFAR to have only near or far blurring
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
// Change the camera angle
cam->setTarget( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, 0.0f ) );
// Animate the depth of field:
f32 p = sinf( device->getTimer( )->getTime( ) * 0.0005f ) * 0.5f - 0.2f;
ppBlurDOF->setParameters( p * 100.0f + 80.0f, p * 100.0f + 110.0f, p * 100.0f + 160.0f, p * 100.0f + 240.0f, 0.01f );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppBlurDOF->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 ppBlurDOF;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
int main()
{
order_map<S3DVertex, int> map;
S3DVertex s = S3DVertex(Vector3(23, 12, 14), Vector3(231, 33, 22), ColourValue::getColourValue(255,255,255,255), Vector2(12, 34));
map.insert(s, 1);
order_map<S3DVertex, int>::Node* nofe = map.find(s);
int i = nofe->getValue();
/*
The most important function of the engine is the createDevice()
function. The IrrlichtDevice is created by it, which is the root
object for doing anything with the engine. createDevice() has 7
parameters:
- deviceType: Type of the device. This can currently be the Null-device,
one of the two software renderers, D3D8, D3D9, or OpenGL. In this
example we use EDT_SOFTWARE, but to try out, you might want to
change it to EDT_BURNINGSVIDEO, EDT_NULL, EDT_DIRECT3D8,
EDT_DIRECT3D9, or EDT_OPENGL.
- windowSize: Size of the Window or screen in FullScreenMode to be
created. In this example we use 640x480.
- bits: Amount of color bits per pixel. This should be 16 or 32. The
parameter is often ignored when running in windowed mode.
- fullscreen: Specifies if we want the device to run in fullscreen mode
or not.
- stencilbuffer: Specifies if we want to use the stencil buffer (for
drawing shadows).
- vsync: Specifies if we want to have vsync enabled, this is only useful
in fullscreen mode.
- eventReceiver: An object to receive events. We do not want to use this
parameter here, and set it to 0.
Always check the return value to cope with unsupported drivers,
dimensions, etc.
*/
Device *device =
createDevice(EDT_OPENGL, dimension2d<Sapphire::UINT32>(1920, 1080), 32,
false, false, false, 0);
if (!device)
return 1;
/*
Set the caption of the window to some nice text. Note that there is an
'L' in front of the string. The Irrlicht Engine uses wide character
strings when displaying text.
*/
device->setWindowCaption(L"HELLO WORLD!");
/*
Get a pointer to the VideoDriver, the SceneManager and the graphical
user interface environment, so that we do not always have to write
device->getVideoDriver(), device->getSceneManager(), or
device->getGUIEnvironment().
*/
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
/*
We add a hello world label to the window, using the GUI environment.
The text is placed at the position (10,10) as top left corner and
(260,22) as lower right corner.
*/
guienv->addStaticText(L"Hello World!",
rect<SINT32>(10, 10, 260, 22), true);
/*
To show something interesting, we load a Quake 2 model and display it.
We only have to get the Mesh from the Scene Manager with getMesh() and add
a SceneNode to display the mesh with addAnimatedMeshSceneNode(). We
check the return value of getMesh() to become aware of loading problems
and other errors.
Instead of writing the filename sydney.md2, it would also be possible
to load a Maya object file (.obj), a complete Quake3 map (.bsp) or any
other supported file format. By the way, that cool Quake 2 model
called sydney was modelled by Brian Collins.
*/
//IAnimatedMesh* mesh = smgr->getMesh("../../media/sydney.md2");
//IAnimatedMesh* mesh = smgr->getMesh("media/q2mdl-wham/tris.md2");
//IAnimatedMesh* mesh = smgr->getMesh("media/sydney.md2");
IAnimatedMesh* mesh = smgr->getMesh("media/kokoro/kokoro.obj");
if (!mesh)
{
device->drop();
return 1;
}
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(mesh);
//node->setDebugDataVisible(EDS_BBOX );
/*
To let the mesh look a little bit nicer, we change its material. We
disable lighting because we do not have a dynamic light in here, and
the mesh would be totally black otherwise. Then we set the frame loop,
such that the predefined STAND animation is used. And last, we apply a
texture to the mesh. Without it the mesh would be drawn using only a
color.
*/
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
// node->setMD2Animation(EMAT_STAND);
//node->setMaterialTexture(0, driver->getTexture("../../media/sydney.bmp"));
//node->setMaterialTexture(0, driver->getTexture("media/sydney.bmp"));
// node->setMaterialTexture(0, driver->getTexture("media/q2mdl-wham/tundra.bmp"));
//node->setMaterialTexture(0, driver->getTexture("media/kokoro/kok_face_d.tga"));
//node->setMaterialTexture(0, driver->getTexture("media/kokoro/kok_acc1_d.tga"));
//node->setMaterialTexture(0, driver->getTexture("media/kokoro/kok_body_d.tga"));
//node->setMaterialTexture(0, driver->getTexture("media/kokoro/kok_body_d.tga"));
//node->setMaterialTexture(0, driver->getTexture("media/kokoro/kok_hairback_s.tga"));
node->setPosition(Vector3(1, 29, -39));
node->setRotation(Vector3(Math::DegreesToRadians(45), 0, 0));
node->setRotation(Vector3(0, Math::DegreesToRadians(180), 0));
}
/*
To look at the mesh, we place a camera into 3d space at the position
(0, 30, -40). The camera looks from there to (0,5,0), which is
approximately the place where our md2 model is.
*/
//smgr->addCameraSceneNode(0, Vector3(0, 30, -40), Vector3(0, 5, 0));
ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS(0, 50.0f, 0.01f);
camera->setTarget(Vector3(5, 10, 0));
camera->setPosition(Vector3(0, 30, -40));
/*
Ok, now we have set up the scene, lets draw everything: We run the
device in a while() loop, until the device does not want to run any
more. This would be when the user closes the window or presses ALT+F4
(or whatever keycode closes a window).
*/
while (device->run())
{
/*
Anything can be drawn between a beginScene() and an endScene()
call. The beginScene() call clears the screen with a color and
the depth buffer, if desired. Then we let the Scene Manager and
the GUI Environment draw their content. With the endScene()
call everything is presented on the screen.
*/
driver->beginScene(true, true, ColourValue::getColourValue(255, 100, 101, 140));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
}
/*
After we are done with the render loop, we have to delete the Irrlicht
Device created before with createDevice(). In the Irrlicht Engine, you
have to delete all objects you created with a method or function which
starts with 'create'. The object is simply deleted by calling ->drop().
See the documentation at irr::IReferenceCounted::drop() for more
information.
*/
device->drop();
return 0;
return 0;
}