The Glade (Camera Angle Problem)

[dejai]

Ok this is the code for my game the glade. Now Its fairly functional, though I want to set the camera to stack behind the player_node at all times, yet at the moment the player can turn around and face the camera, I want this never to happen.

I have tried some rotation formulas, but it does not work 100%

So Have A Look at the Code and Tell Me What you think. I will Firstly Supply A Cut Version Just Relating to the Problem and then A Full Version of the entire Source.

Code: Select all

    bool up = false;
    bool down = false;
    bool right = false;
    bool left = false;
    bool jump = false;
    int speed =2;
    //Make an event Class



    class MyEventReceiver : public IEventReceiver
    {
    public:
    virtual bool OnEvent(SEvent event)
    {
    if (event.EventType == EET_KEY_INPUT_EVENT)
    {
    switch(event.KeyInput.Key)
    {
    case KEY_KEY_W:
    up = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_S:
    down = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_A:
    left = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_D:
    right = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_F:
    jump = event.KeyInput.PressedDown;

    }
    //return true;
    }

    return false;
    }
    };

 ICameraSceneNode* camera = // Declare the camera
    smgr->addCameraSceneNode();// Declare the pointer smgr( scene Manager) to add a FPS Camera.
    camera->setFOV(DEGTORAD *80.f);// Set FOV
    driver->setFog(video::SColor(0,138,125,81), true, 250, 1000, 0, true);

 IAnimatedMesh* player = smgr->getMesh("media/ninja.b3d");// Decalre Player
    IAnimatedMeshSceneNode* player_node = smgr->addAnimatedMeshSceneNode(player);


    if (player_node)
    {
    
    player_node->setScale(vector3df(13,13,13));
    player_node->setAnimationSpeed(f32 (500));
    player_node->setFrameLoop(0,1400);
    }

while (device->run())// While Device is Running Do..
    {

    driver->beginScene(true, true, SColor(221,122,212,221));// Start The Scene
    smgr->drawAll();// Draw all Scene Manager
    guienv->drawAll();// Draw All Gui Environment




    if (up)
    {
    playerpos.X += speed * cos((playerrot.Y) * 3.14/ 180);
    playerpos.Z -= speed * sin((playerrot.Y) * 3.14/180);

    }

    if (down)
    {
    playerpos.X -= speed * cos((playerrot.Y) * 3.14/180);
    playerpos.Z += speed * sin((playerrot.Y) * 3.14/180);
    }
    if (left)
    {
    playerrot.Y -= 1;

    }
    if (right)
    {
    playerrot.Y += 1;

    }

    if (jump)
    {
    bool havejumped = false;
    playerpos.Y = playerpos.Y + 3;
    //wait(1);
    playerpos.Y = playerpos.Y - 3;
    //player_node->setFrameLoop(1400, 2000);

    //player_node->setFrameLoop(0, 1400);


    }

    player_node->setPosition(playerpos);
    player_node->setRotation(playerrot);
    vector3df cameratarg = playerpos;
    cameratarg.Z = playerpos.Z + 200;
    cameratarg.X = playerpos.X +300;

    camera->setTarget(cameratarg);
    vector3df camerapos = playerpos;
    camerapos.Y = camerapos.Y - 200;
    camerapos.Z = camerapos.Z -200;
    camerapos.X = camerapos.X -300;
    camera->setPosition(camerapos);


    driver->endScene();// Driver End Scene

    }
    engine->drop(); // delete engine
    device->drop(); // Drop Device



    return 0;// End
    }

Now I am not sure exactly but I believe that the camera angle problem is associated with the formulas... I have followed based the camera RPG of Omars Tutorial.







///// Full Version////












Library.h

Code:

Code: Select all

    #include <irrlicht.h> // Declare Irrlicht
    #include <irrklang.h>
    #include <iostream> // Add Iostream Common header not really needed for this tutorial
    #include <time.h>
    #include <stdio.h>

    // Declare Using Namespace See Tutorial 1
    using namespace irr;
    using namespace core;
    using namespace video;
    using namespace scene;
    using namespace io;
    using namespace gui;
    using namespace audio;

    void wait ( int seconds )
    {
    clock_t endwait;
    endwait = clock () + seconds * CLOCKS_PER_SEC ;
    while (clock() < endwait) {}
    }

Main.CPP

Code:

Code: Select all

    /////////////////////////////////////
    // Author: Dejai //
    // Date: 1 Oct 2007 //
    // Purpose: Tutorial / Rpg Base //
    /////////////////////////////////

    #include "library.h"
    bool up = false;
    bool down = false;
    bool right = false;
    bool left = false;
    bool jump = false;
    int speed =2;
    //Make an event Class



    class MyEventReceiver : public IEventReceiver
    {
    public:
    virtual bool OnEvent(SEvent event)
    {
    if (event.EventType == EET_KEY_INPUT_EVENT)
    {
    switch(event.KeyInput.Key)
    {
    case KEY_KEY_W:
    up = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_S:
    down = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_A:
    left = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_D:
    right = event.KeyInput.PressedDown;
    break;

    case KEY_KEY_F:
    jump = event.KeyInput.PressedDown;

    }
    //return true;
    }

    return false;
    }
    };


    int main() // Start Int Main
    {
    MyEventReceiver receiver;
    // Start The Irrlicht Device Set driver, dimensions, resolution, colour depths,
    // deside wether to enable fullscreen, shadowing and if to enable event reciver
    IrrlichtDevice* device =
    createDevice(EDT_OPENGL,dimension2d<s32>(1200,960),16,
    true, false , false, &receiver);

    //Set The Window Caption to The Glade
    device->setWindowCaption(L" The Glade ");


    // Initialize the Drivers
    IVideoDriver* driver = device->getVideoDriver(); // Initialize the Video Driver
    ISceneManager* smgr = device->getSceneManager(); // Initialize the Scene Manager
    IGUIEnvironment* guienv = device->getGUIEnvironment();// Initialize the GUI Environment
    ISoundEngine* engine = createIrrKlangDevice();// Sound Environment


    // play Music stream, looped
    engine->play2D("media/music.wav", true);


    // Hide the cursor
    device->getCursorControl()->setVisible(false);



    // Add A Camera With FPS
    ICameraSceneNode* camera = // Declar the camera
    smgr->addCameraSceneNode();// Declare the pointer smgr( scene Manager) to add a FPS Camera.
    camera->setFOV(DEGTORAD *80.f);// Set FOV
    driver->setFog(video::SColor(0,138,125,81), true, 250, 1000, 0, true);


    // Start The Sky Dome Declare Texture of Skydome, distance and strech
    smgr->addSkyDomeSceneNode( driver->getTexture("media/sky.jpg"),16,
    16, 1.0f, 2.0f);



    ////////////// MESH DECLARATION /////////////////////////////
    // 1. Load The Base Map
    IAnimatedMesh* base = smgr->getMesh("media/base.obj"); // Declare The Floor
    IAnimatedMeshSceneNode* base_node = smgr->addAnimatedMeshSceneNode(base);

    IAnimatedMesh* house = smgr->getMesh("media/house.3ds");// Declare Hoyse Meshes
    IAnimatedMeshSceneNode* house_node = smgr->addAnimatedMeshSceneNode(house);

    IAnimatedMesh* wall = smgr->getMesh("media/wall.obj");// Declare Walls
    IAnimatedMeshSceneNode* wall_node = smgr->addAnimatedMeshSceneNode(wall);

    IAnimatedMesh* dwarf = smgr->getMesh("media/dwarf.x");// Decalre Dwarfs
    IAnimatedMeshSceneNode* dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);

    IAnimatedMesh* tree = smgr->getMesh("media/tree.x");// Declare Trees
    IAnimatedMeshSceneNode* tree_node = smgr->addAnimatedMeshSceneNode(tree);

    IAnimatedMesh* church = smgr->getMesh("media/Ravanica.max");// Declare Church
    IAnimatedMeshSceneNode* church_node = smgr->addAnimatedMeshSceneNode(church);

    IAnimatedMesh* player = smgr->getMesh("media/ninja.b3d");// Decalre Player
    IAnimatedMeshSceneNode* player_node = smgr->addAnimatedMeshSceneNode(player);


    if (player_node)
    {
    
    player_node->setScale(vector3df(13,13,13));
    player_node->setAnimationSpeed(f32 (500));
    player_node->setFrameLoop(0,1400);
    }

    ///////// META TRIANGLE SELECTOR ///////////

    ITriangleSelector* base_selector = 0;
    ITriangleSelector * house_selector = 0;
    ITriangleSelector* wall_selector = 0;
    ITriangleSelector* tree_selector = 0;
    IMetaTriangleSelector * metaSelector = smgr->createMetaTriangleSelector();



    /////////////// MESH INITIALIZATION ///////////////////////////////

    if (base_node) // 1. Base Map Initialization
    {

    base_node->setMaterialFlag(EMF_LIGHTING, false); // Don't Have lighting
    base_node->setMaterialTexture(0, driver->getTexture("media/paving.jpg"));// Choose a Texture
    base_node->setPosition(vector3df(0,-9,0));// Set Position
    base_node->setRotation(vector3df(90,180,180));// Set Rotation
    base_node->setScale(vector3df(3,4,3));// Set Scale


    base_node = smgr->addAnimatedMeshSceneNode(base);
    base_node->setMaterialFlag(EMF_LIGHTING, false); // Don't Have lighting
    base_node->setMaterialTexture(0, driver->getTexture("media/grass.jpg"));// Choose a Texture
    base_node->setPosition(vector3df(0,-10,0));// Set Position
    base_node->setRotation(vector3df(90,180,180));// Set Rotation
    base_node->setScale(vector3df(10,10,10));// Set Scale


    }



    if (house_node)// 2. Initialize Houses And Positions
    {

    house_node->setMaterialFlag(EMF_LIGHTING, false);// Dont Enable Lighting Effects
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));// Material
    house_node->setPosition(vector3df(0,-10,500));// Position
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(800,-10,500));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(1600,-10,500));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(-800,-10,500));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(-1600,-10,500));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(-1600,-10,-1000));
    house_node->setRotation(vector3df(0,180,0));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(-800,-10,-1000));
    house_node->setRotation(vector3df(0,180,0));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(0,-10,-1000));
    house_node->setRotation(vector3df(0,180,0));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(800,-10,-1000));
    house_node->setRotation(vector3df(0,180,0));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    house_node = smgr->addAnimatedMeshSceneNode(house);
    house_node->setMaterialFlag(EMF_LIGHTING, false);
    house_node->setMaterialTexture(0, driver->getTexture("media/house.jpg"));
    house_node->setPosition(vector3df(1600,-10,-1000));
    house_node->setRotation(vector3df(0,180,0));
    house_selector = smgr->createOctTreeTriangleSelector(house->getMesh(0), house_node, 128);
    metaSelector->addTriangleSelector(house_selector);
    house_selector->drop();

    }

    if (wall_node) ////// Wall Declaration /////////////
    {
    wall_node->setMaterialFlag(EMF_LIGHTING, false);
    wall_node->setRotation(vector3df(0,270,0));
    wall_node->setMaterialTexture(0,driver->getTexture("media/wall.jpg"));
    wall_node->setScale(vector3df(20,20,20));
    wall_node->setPosition(vector3df(-2500,0,0));
    }


    if(dwarf_node) //////Dwarf Declaration /////////////
    {
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,90,0));
    dwarf_node->setPosition(vector3df(0,-9,350));

    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(-60,-9,350));

    /////// Gate Guards ////////////////
    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(2850,-9,800));

    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(2850,-9,-800));

    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(2850,-9,880));
    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(2850,-9,-880));

    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(0, 0);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(2850,-9,0));


    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(2850,-9,120));

    // End Gate Guards/////////////

    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,90,0));
    dwarf_node->setPosition(vector3df(1700,-9,-900));

    dwarf_node = smgr->addAnimatedMeshSceneNode(dwarf);
    dwarf_node->setScale(vector3df(1.5,1.5,1.5));
    dwarf_node->setFrameLoop(23,55);
    dwarf_node->setRotation(vector3df(0,270,0));
    dwarf_node->setPosition(vector3df(1630,-9,-900));
    ///////////////////////////////////////////////////


    }

    if (tree_node)////// Trees ////////////
    {
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(3999,200,1000));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();


    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(4300,200,1200));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();


    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(4000,200,-1233));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();


    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(5300,200,1800));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();


    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(4399,200,-1450));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(4999,200,-1600));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(5300,200,-1000));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(6300,200,1000));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(5300,200,-1000));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(6300,200,-1599));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(5399,200,1699));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();

    tree_node = smgr->addAnimatedMeshSceneNode(tree);
    tree_node->setMaterialFlag(EMF_LIGHTING, false);
    tree_node->setScale(vector3df(100,100,100));
    tree_node->setPosition(vector3df(5399,200,-1700));
    tree_selector = smgr->createOctTreeTriangleSelector(tree->getMesh(0), tree_node, 128);
    metaSelector->addTriangleSelector(tree_selector);
    tree_selector->drop();
    }
    /////////////////////////////////////////

    if (church_node)// Church
    {
    church_node->setMaterialFlag(EMF_LIGHTING, false);
    church_node->setRotation(vector3df(0,270,0));
    church_node->setPosition(vector3df(-1750,0,-200));

    }

    ///////////////////////// Triangle Selection /////////////////////////////
    // Basically Collisions With Objects.

    ////////////// Triangle Selector/////////////////

    //// Base ////////
    // Declare Selector

    base_selector = smgr->createOctTreeTriangleSelector(
    base->getMesh(0), base_node, 128); // Declares which mesh and node it is assigned to

    camera->setTriangleSelector(base_selector);// Sets the camera to the bass selector


    base_selector->drop(); // Drop selector
    // create collision response animator and attach it to the camera
    ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
    base_selector, camera, core::vector3df(60,100,60),
    core::vector3df(-1,-1,-1), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));

    camera->addAnimator(anim);// Canera add animatior
    anim->drop();// drop animator

    /////// End Of Base/////////

    /////////// House//////////////////
    // Declare Selector


    house_selector = smgr->createOctTreeTriangleSelector(
    house->getMesh(0), house_node, 128); // Declares which mesh and node it is assigned to


    player_node->setTriangleSelector(house_selector);// Sets the camera to the bass selector

    house_selector->drop();
    // Drop selector
    // create collision response animator and attach it to the camera
    ISceneNodeAnimator* anim2 = smgr->createCollisionResponseAnimator(
    metaSelector, player_node, core::vector3df(60,100,60),
    core::vector3df(0,0,0), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));
    metaSelector->drop();
    player_node->addAnimator(anim2);// Player add animatior
    anim2->drop();// drop animator

    camera->setTriangleSelector(house_selector);
    ISceneNodeAnimator* anim6 = smgr->createCollisionResponseAnimator(
    metaSelector, camera, core::vector3df(60,100,60),
    core::vector3df(0,0,0), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));
    metaSelector->drop();
    camera->addAnimator(anim6);// Canera add animatior
    anim6->drop();// drop animator

    //////// End of House/////////

    ///////// Start Of Wall ///////////////////
    // Declare Selector

    wall_selector = smgr->createOctTreeTriangleSelector(
    wall->getMesh(0),wall_node, 128); // Declares which mesh and node it is assigned to

    camera->setTriangleSelector(wall_selector);// Sets the camera to the bass selector

    wall_selector->drop(); // Drop selector
    // create collision response animator and attach it to the camera
    ISceneNodeAnimator* anim3 = smgr->createCollisionResponseAnimator(
    wall_selector, camera, core::vector3df(60,100,60),
    core::vector3df(0,0,0), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));

    camera->addAnimator(anim3);// Canera add animatior
    anim3->drop();


    player_node->setTriangleSelector(wall_selector);
    ISceneNodeAnimator* anim7 = smgr->createCollisionResponseAnimator(
    wall_selector, player_node, core::vector3df(60,100,60),
    core::vector3df(0,0,0), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));

    player_node->addAnimator(anim7);// Canera add animatior
    anim7->drop();
    ////////// End Of Wall ///////////////

    /////////////Start Of Tree ///////////////
    tree_selector = smgr->createOctTreeTriangleSelector(
    tree->getMesh(0), tree_node, 128); // Declares which mesh and node it is assigned to


    camera->setTriangleSelector(tree_selector);// Sets the camera to the bass selector

    tree_selector->drop();

    // Drop selector
    // create collision response animator and attach it to the camera

    ISceneNodeAnimator* anim4 = smgr->createCollisionResponseAnimator(
    metaSelector, camera, core::vector3df(60,100,60),
    core::vector3df(0,0,0), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));
    metaSelector->drop();
    camera->addAnimator(anim4);// Canera add animatior
    anim4->drop();// drop animatorw


    player_node->setTriangleSelector(tree_selector);// Sets the camera to the bass selector
    ISceneNodeAnimator* anim8 = smgr->createCollisionResponseAnimator(
    metaSelector,player_node, core::vector3df(60,100,60),
    core::vector3df(0,0,0), // This Sets Gravity VERY important, -1 keeps you grounded
    core::vector3df(0,0,0));
    metaSelector->drop();
    player_node->addAnimator(anim8);// Canera add animatior
    anim8->drop();
    ///////////End Of Tree
    // Event Declaration


    vector3df playerpos = player_node->getPosition();
    vector3df playerrot = player_node->getRotation();


    /////////// Game While Loop /////////////
    while (device->run())// While Device is Running Do..
    {

    driver->beginScene(true, true, SColor(221,122,212,221));// Start The Scene
    smgr->drawAll();// Draw all Scene Manager
    guienv->drawAll();// Draw All Gui Environment




    if (up)
    {
    playerpos.X += speed * cos((playerrot.Y) * 3.14/ 180);
    playerpos.Z -= speed * sin((playerrot.Y) * 3.14/180);

    }

    if (down)
    {
    playerpos.X -= speed * cos((playerrot.Y) * 3.14/180);
    playerpos.Z += speed * sin((playerrot.Y) * 3.14/180);
    }
    if (left)
    {
    playerrot.Y -= 1;

    }
    if (right)
    {
    playerrot.Y += 1;

    }

    if (jump)
    {
    bool havejumped = false;
    playerpos.Y = playerpos.Y + 3;
    //wait(1);
    playerpos.Y = playerpos.Y - 3;
    //player_node->setFrameLoop(1400, 2000);

    //player_node->setFrameLoop(0, 1400);


    }

    player_node->setPosition(playerpos);
    player_node->setRotation(playerrot);
    vector3df cameratarg = playerpos;
    cameratarg.Z = playerpos.Z + 200;
    cameratarg.X = playerpos.X +300;

    camera->setTarget(cameratarg);
    vector3df camerapos = playerpos;
    camerapos.Y = camerapos.Y - 200;
    camerapos.Z = camerapos.Z -200;
    camerapos.X = camerapos.X -300;
    camera->setPosition(camerapos);


    driver->endScene();// Driver End Scene

    }
    engine->drop(); // delete engine
    device->drop(); // Drop Device



    return 0;// End
    }

[rogerborg]

Code: Select all

// How far ahead of the player the camera will look 
static const f32 FAR_DISTANCE = 100000.f;

// Adjust these value based on how big your meshes are and
// how far behind/above the player you want the camera
static const f32 CAMERA_DISTANCE_BEHIND_PLAYER = 200.f;

static const f32 CAMERA_HEIGHT_ABOVE_PLAYER = 200.f;

// Have the camera look into the distance in front of the player
vector3df cameratarg(playerpos);

cameratarg.X += FAR_DISTANCE * cos((playerrot.Y) * DEGTORAD);
cameratarg.Z -= FAR_DISTANCE * sin((playerrot.Y) * DEGTORAD);
camera->setTarget(cameratarg);


// Have the camera place itself behind and above the player.
vector3df camerapos(playerpos);

camerapos.X -= CAMERA_DISTANCE_BEHIND_PLAYER * cos((playerrot.Y) * DEGTORAD);
camerapos.Z += CAMERA_DISTANCE_BEHIND_PLAYER * sin((playerrot.Y) * DEGTORAD);
camerapos.Y += CAMERA_HEIGHT_ABOVE_PLAYER;

camera->setPosition(camerapos);

You'll want to stop the camera from clipping through the scene when the player has his back to a wall. I guess we can cross that bridge when you come to it.

Another (and simpler) finesse would be to maintain a camera rotation independently of playerrot, and have it follow it about half the speed that the player can rotate so that the camera rotation lags the player's rotation slightly. Clamp it so that it can't get more than (e.g.) 20 degrees away from the player rotation though.

[dejai]

Thanks for the help, I can grasp the meaning of the programming, though the formulas are a bit confusing to me I will have to look into it.

[rogerborg]

It's the same trig that you're already using to move the player.

[TheGameMaker]

what about just linking the camera to the player??

[rogerborg]

Sure, making it a child of the player node would work, and he'd only have to do the positioning once, using fixed Y and Z values.

What I figure though is that dejai will (at some point) want to reposition the camera (to stop it clipping through walls, or to have it lag the player slightly) in which case he'll have to do some calculations each frame (but basing the camerapos on 0,0,0 rather than playerpos if it's a child of the player node).

[dejai]

Hmm, both are good Ideas. I think that for now I may, go with the child node. Idea but I want to as you say eventually get that little lag so it looks like the camera is active behind the player. Though for now the child should be fine. Thanks heaps for the feed back.

[rogerborg]

Yup, they'll both work, and the child node will be easier to implement for now. It's just a personal preference of mine to conceptualise the camera as an independent entity, as eventually you'll want to start doing something clever with it, and I find that's easier to do if you've been thinking of it floating around on its own. It's largely just a conceptual difference though.

[dejai]

While where on the post I have been looking at adding text to nodes.

Now say I have a dwarf

like

Code: Select all

if (dwarf_node)
{
smgr->addTextSceneNode (guienv->getBuiltInFont(),
L" Dwarf",
SColor(22,22,22,22), dwarf_node);

}

Is it possible to change this Y axis / position in which the text appears?
[/code]

[hybrid]

What about setPosition()?

[dejai]

Wow That Was Stupid of Me anyway. I am equipted now with my C++ for Dummies book, and time