Hatte zuanfang das selbe Problem, dass ich keine gescheite 3rd Person Cam gefunden habe. Habe mir dann auch selber eine gebastelt. Bei meiner wird der Player mit wasd gesteuert und mit der Maus kann man sich umgucken/drehen.
Ich poste dir mal ein "fertiges Spiel" (hust) von mir. Ist leider sehr schlecht kommentiert und nicht gerade gut gestalltet, aber ich hoffe das es dir etwas bringt.
Main
Code:
#include <irrlicht.h>
#include <math.h>
#include <iostream>
#include "MastEventReceiver.cpp"
using namespace irr;
using namespace std;
using namespace io;
using namespace gui;
using namespace core;
using namespace scene;
using namespace video;
#ifdef _MSC_VER
#pragma comment(lib, "Irrlicht.lib")
#endif
int main()
{
MastEventReceiver eventReceiver;
eventReceiver.init();
IrrlichtDevice* device = createDevice(video::EDT_DIRECT3D9,core::dimension2d<s32>(1400, 1050), 32, true, false, false, &eventReceiver);
if (device == 0)
return 1;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
gui::IGUIEnvironment* gui = device->getGUIEnvironment();
//Level Map
device->getFileSystem()->addZipFileArchive("media/map-20kdm2.pk3");
IAnimatedMesh* levelmesh = smgr->getMesh("20kdm2.bsp");
ISceneNode* level = 0;
if (levelmesh)
level = smgr->addOctTreeSceneNode(levelmesh->getMesh(0));
ITriangleSelector* selector = 0;
if (level)
{
level->setPosition(core::vector3df(-2800,-200,-2650));
level->setRotation(core::vector3df(0,0,0));
level->setScale(core::vector3df(2.f,2.f,2.f));
selector = smgr->createOctTreeTriangleSelector(levelmesh->getMesh(0), level, 128);
level->setTriangleSelector(selector);
}
//Skymap
ISceneNode* SkyBox = smgr->addSkyBoxSceneNode(
driver->getTexture("media/irrlicht2_up.jpg"),
driver->getTexture("media/irrlicht2_dn.jpg"),
driver->getTexture("media/irrlicht2_lf.jpg"),
driver->getTexture("media/irrlicht2_rt.jpg"),
driver->getTexture("media/irrlicht2_ft.jpg"),
driver->getTexture("media/irrlicht2_bk.jpg"));
//Player
IAnimatedMesh* playermesh = smgr->getMesh("media/faerie.md2");
IAnimatedMeshSceneNode* player = smgr->addAnimatedMeshSceneNode( playermesh );
if (player)
{
player->setPosition(core::vector3df(0,0,0));
player->setRotation(core::vector3df(0,-90,0));
player->setScale(core::vector3df(2.f,2.f,2.f));
player->setMD2Animation(scene::EMAT_STAND);
player->setMaterialFlag(video::EMF_LIGHTING, false);
player->setAnimationSpeed(2);
player->setMaterialTexture( 0, driver->getTexture("media/faerie2.bmp"));
}
if (selector)
{
ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
selector, player,
vector3df(30,50,30),
vector3df(0,-20,0),
vector3df(0,0,0));
player->addAnimator(anim);
anim->drop();
}
//Camera
ICameraSceneNode* camera = smgr->addCameraSceneNode();
camera->setPosition(vector3df(0,0,0));
//Mousecouser
device->getCursorControl()->setVisible(false);
device->getCursorControl()->setPosition(400,300);
core::position2d<s32> cursorOld = device->getCursorControl()->getPosition();
//Crosshair
video::ITexture* images = driver->getTexture("media/crosshair03.png");
driver->makeColorKeyTexture(images, core::position2d<s32>(0,0));
//Font
IGUIFont* font = device->getGUIEnvironment()->getFont("media/myfont.xml");
//Shoot
core::line3d<f32> line;
line.start = camera->getPosition();
line.end = line.start +(camera->getTarget() - line.start).normalize() * 1000.0f;
//Variablen
//Player
float speed = 400.0;
float sidespeed = 300.0;
float rotationspeed = 200.0;
float jumpspeed = 500.0;
float highjumpspeed = 4000.0;
int move = 0;
bool moveSTANDaktiv = 0;
bool moveRUNaktiv = 0;
bool moveJUMPaktiv = 0;
//Camera
f32 cameraOffset = 0.0;
f32 cameraZoom = 70.0;
f32 cameraAngle = 0.0;
f32 cameraDist;
//Selector
scene::ISceneNode* selectedSceneNode = 0;
scene::ISceneNode* lastSelectedSceneNode = 0;
//FPS
int lastFPS = -1;
u32 then = device->getTimer()->getTime();
while(device->run())
{
if (device->isWindowActive())
{
eventReceiver.endEventProcess();
const u32 now = device->getTimer()->getTime();
const f32 frameDeltaTime = (f32)(now - then) / 1000.f; // Time in seconds
then = now;
//Cameraposition
vector3df playerPosition = player->getPosition();
vector3df playerRotation = player->getRotation();
camera->setTarget (vector3df(player->getPosition().X,player->getPosition().Y + 75,player->getPosition().Z));
cameraDist = cameraZoom * cos(cameraAngle * 3.14159265f/180.f );
camera->setPosition (vector3df(
playerPosition.X - cameraDist * cos((playerRotation.Y + cameraOffset) * 3.14159265f/180.f),
playerPosition.Y + cameraZoom * sin(cameraAngle * 3.14159265f/180.f) + 75,
playerPosition.Z + cameraDist * sin((playerRotation.Y + cameraOffset) * 3.14159265f/180.f)
));
//Playermovement/Key
if(eventReceiver.keyDown('W'))
{
playerPosition.X += ( speed * frameDeltaTime * cos(playerRotation.Y * 3.14159265f/180.f));
playerPosition.Z -= ( speed * frameDeltaTime * sin(playerRotation.Y * 3.14159265f/180.f));
move = 2;
player->setPosition(playerPosition);
}
if(eventReceiver.keyUp('W'))
{
move = 1;
}
if(eventReceiver.keyDown('S'))
{
playerPosition.X -= (speed * frameDeltaTime * cos(playerRotation.Y * 3.14159265f/180.f));
playerPosition.Z += (speed * frameDeltaTime * sin(playerRotation.Y * 3.14159265f/180.f));
move = 2;
player->setPosition(playerPosition);
}
if(eventReceiver.keyDown('Q'))
{
playerRotation.Y -= rotationspeed * frameDeltaTime;
player->setRotation(playerRotation);
}
if(eventReceiver.keyDown('E'))
{
playerRotation.Y += rotationspeed * frameDeltaTime;
player->setRotation(playerRotation);
}
if(eventReceiver.keyDown('A'))
{
playerPosition.X += (sidespeed * frameDeltaTime * cos((playerRotation.Y-90) * 3.14159265f/180.f));
playerPosition.Z -= (sidespeed * frameDeltaTime * sin((playerRotation.Y-90) * 3.14159265f/180.f));
move = 2;
player->setPosition(playerPosition);
}
if(eventReceiver.keyDown('D'))
{
playerPosition.X += (sidespeed * frameDeltaTime * cos((playerRotation.Y+90) * 3.14159265f/180.f));
playerPosition.Z -= (sidespeed * frameDeltaTime * sin((playerRotation.Y+90) * 3.14159265f/180.f));
move = 2;
player->setPosition(playerPosition);
}
if(eventReceiver.keyDown(' '))
{
playerPosition.Y += jumpspeed * frameDeltaTime;
move = 3;
player->setPosition(playerPosition);
}
if(eventReceiver.keyDown('F'))
{
playerPosition.Y += highjumpspeed * frameDeltaTime;
player->setPosition(playerPosition);
}
//Cameramovement/Mouse
core::position2d<s32> cursor = device->getCursorControl()->getPosition();
int cursorDeltaX = (cursor.X) - (cursorOld.X);
int cursorDeltaY = (cursor.Y) - (cursorOld.Y);
cursorDeltaX *= 4;
cursorDeltaY *= 4;
if((cursor.X) > (cursorOld.X))
{
playerRotation.Y += cursorDeltaX * frameDeltaTime;
player->setRotation(playerRotation);
}
if((cursor.X) < (cursorOld.X))
{
playerRotation.Y += cursorDeltaX * frameDeltaTime;
player->setRotation(playerRotation);
}
if((cursor.Y) > (cursorOld.Y))
{
if ( cameraAngle < 70.0 )cameraAngle += cursorDeltaY * frameDeltaTime;
player->setRotation(playerRotation);
}
if((cursor.Y) < (cursorOld.Y))
{
if ( cameraAngle > -65.0 )cameraAngle += cursorDeltaY * frameDeltaTime;
player->setRotation(playerRotation);
}
device->getCursorControl()->setPosition(cursorOld);
//Move
if(move == 1)
if(moveSTANDaktiv == false)
{
player->setMD2Animation(scene::EMAT_STAND);
moveSTANDaktiv = true;
moveRUNaktiv = false;
moveJUMPaktiv = false;
}
if(move == 2)
if(moveRUNaktiv == false)
{
player->setMD2Animation(scene::EMAT_RUN);
moveSTANDaktiv = false;
moveRUNaktiv = true;
moveJUMPaktiv = false;
}
if(move == 3)
if(moveJUMPaktiv == false)
{
player->setMD2Animation(scene::EMAT_JUMP);
moveSTANDaktiv = false;
moveRUNaktiv = false;
moveJUMPaktiv = true;
}
driver->beginScene(true, true, video::SColor(255,200,200,200));
smgr->drawAll();
gui->drawAll();
//Draw Crosshair and Points
driver->draw2DImage(images, core::position2d<s32>(384,284), core::rect<s32>(0,0,32,32), 0, video::SColor(255,255,255,255), true);
int fps2 = driver->getFPS();
int posX = playerPosition.X;
int posY = playerPosition.Y;
int posZ = playerPosition.Z;
stringw buf = L"FPS: ";
buf += fps2;
buf += " ";
buf += " Player Position [";
buf += posX;
buf += ",";
buf += posY;
buf += ",";
buf += posZ;
buf += "]";
font->draw(buf.c_str(), core::rect<s32>(10 , 10, 400, 400), video::SColor(255,0, 0,0));
driver->endScene();
int fps = driver->getFPS();
if (lastFPS != fps)
{
stringw str = L"Third-Person-Shooter by Shades";
str += " FPS:";
str += fps;
str += " Player_Position [";
str += posX;
str += ",";
str += posY;
str += ",";
str += posZ;
str += "]";
device->setWindowCaption(str.c_str());
lastFPS = fps;
}
eventReceiver.startEventProcess();
}
else
device->yield();
}
device->drop();
return 0;
}
MastEventReciver:
Code:
/// ==================================================================================================
/// MastEventReceiver code is © (Copyright) Robert E. Demarest, AKA Mastiff or Mastiff Odit
/// This file may be used in any non-commercial or commercial project as long as the following conditions are met:
/// You may not claim this code as being your own.
/// You may not use this code for any harmful, malicious or otherwise damaging programs.
///
/// This is version 1.2a of the class.
/// This class is designed for use with the Irrlicht Engine, it was written for version 1.3 of the engine.
/// ==================================================================================================
//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// To use this Class just add #include "MastEventReceiver.cpp" to the end of your includes list. (or add the class in-line into your program)
// Then create an instance of it like so: MastEventReceiver eventReceiver;
// Then call the initialization fucntion like so: eventReceiver.init();
// Then inside your Main Game Loop place "eventReceiver.endEventProcess();" in the beginning of your game loop, before anything -
// that would require input, then put "eventReceiver.startEventProcess();" at the very end of your Main Game Loop.
// yeah I know it's confusing, but it makes alot more sense in the internals of the class.
//
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Change this to the path where your Irrlicht Header Files are.
#include <irrlicht.h>
using namespace std;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
/// ==============================
/// MastEventReceiver
/// ==============================
class MastEventReceiver : public IEventReceiver
{
protected:
// Enumeration for UP, DOWN, PRESSED and RELEASED key states. Also used for mouse button states.
enum keyStatesENUM {UP, DOWN, PRESSED, RELEASED};
// Enumeration for Event Handling State.
enum processStateENUM {STARTED, ENDED};
// Mouse button states.
keyStatesENUM mouseButtonState[2]; //Left(0), Middle(1) and Right(2) Buttons.
// Keyboard key states.
keyStatesENUM keyState[KEY_KEY_CODES_COUNT];
// Mouse X/Y coordinates and Wheel data.
struct mouseData
{
int X;
int Y;
float wheel; //wheel is how far the wheel has moved
};
struct mouseData mouse;
processStateENUM processState; // STARTED = handling events, ENDED = not handling events
//virtual bool OnEvent(SEvent event)
virtual bool OnEvent(const SEvent& event)
{
bool eventprocessed = false;
//////////////////////////////
// Keyboard Input Event
//////////////////////////////
if (event.EventType == EET_KEY_INPUT_EVENT)
{
if (processState == STARTED)
{
// if key is Pressed Down
if (event.KeyInput.PressedDown == true)
{
// If key was not down before
if (keyState[event.KeyInput.Key] != DOWN)
{
keyState[event.KeyInput.Key] = PRESSED; // Set to Pressed
}
else
{
// if key was down before
keyState[event.KeyInput.Key] = DOWN; // Set to Down
}
}
else
{
// if the key is down
if (keyState[event.KeyInput.Key] != UP)
{
keyState[event.KeyInput.Key] = RELEASED; // Set to Released
}
}
}
eventprocessed = true;
}
//////////////////////////////
// Mouse Input Event
//////////////////////////////
if (event.EventType == EET_MOUSE_INPUT_EVENT)
{
if (processState == STARTED)
{
//Mouse changed position
if (event.MouseInput.Event == EMIE_MOUSE_MOVED)
{
mouse.Y = event.MouseInput.Y;
mouse.X = event.MouseInput.X;
}
//Wheel moved.
if (event.MouseInput.Event == EMIE_MOUSE_WHEEL)
{
mouse.wheel += event.MouseInput.Wheel;
}
//Left Mouse Button Pressed
if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
{
//
if (mouseButtonState[0] == UP || mouseButtonState[0] == RELEASED)
{
mouseButtonState[0] = PRESSED;
}
else
{
mouseButtonState[0] = DOWN;
}
}
//Left Mouse Button Rleased
if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
{
//
if (mouseButtonState[0] != UP)
{
mouseButtonState[0] = RELEASED;
}
}
//Middle Mouse Button Pressed
if (event.MouseInput.Event == EMIE_MMOUSE_PRESSED_DOWN)
{
//
if (mouseButtonState[1] == UP || mouseButtonState[1] == RELEASED)
{
mouseButtonState[1] = PRESSED;
}
else
{
mouseButtonState[1] = DOWN;
}
}
//Middle Mouse Button Rleased
if (event.MouseInput.Event == EMIE_MMOUSE_LEFT_UP)
{
//
if (mouseButtonState[1] != UP)
{
mouseButtonState[1] = RELEASED;
}
}
//Right Mouse Button Pressed
if (event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
{
//
if (mouseButtonState[2] == UP || mouseButtonState[2] == RELEASED)
{
mouseButtonState[2] = PRESSED;
}
else
{
mouseButtonState[2] = DOWN;
}
}
//Right Mouse Button Rleased
if (event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
{
//
if (mouseButtonState[2] != UP)
{
mouseButtonState[2] = RELEASED;
}
}
}
eventprocessed = true;
}
return eventprocessed;
}
//////////////////////
// Public functions
//////////////////////
public:
float mouseWheel()
{
return mouse.wheel;
}
int mouseX()
{
return mouse.X;
}
int mouseY()
{
return mouse.Y;
}
bool leftMouseReleased()
{
if (mouseButtonState[0] == RELEASED)
{
return true;
}
else
{
return false;
}
}
bool leftMouseUp()
{
if (mouseButtonState[0] == RELEASED || mouseButtonState[0] == UP)
{
return true;
}
else
{
return false;
}
}
bool leftMousePressed()
{
if (mouseButtonState[0] == PRESSED)
{
return true;
}
else
{
return false;
}
}
bool leftMouseDown()
{
if (mouseButtonState[0] == PRESSED || mouseButtonState[0] == DOWN)
{
return true;
}
else
{
return false;
}
}
bool middleMouseReleased()
{
if (mouseButtonState[1] == RELEASED)
{
return true;
}
else
{
return false;
}
}
bool middleMouseUp()
{
if (mouseButtonState[1] == RELEASED || mouseButtonState[1] == UP)
{
return true;
}
else
{
return false;
}
}
bool middleMousePressed()
{
if (mouseButtonState[1] == PRESSED)
{
return true;
}
else
{
return false;
}
}
bool middleMouseDown()
{
if (mouseButtonState[1] == PRESSED || mouseButtonState[1] == DOWN)
{
return true;
}
else
{
return false;
}
}
bool rightMouseReleased()
{
if (mouseButtonState[2] == RELEASED)
{
return true;
}
else
{
return false;
}
}
bool rightMouseUp()
{
if (mouseButtonState[2] == RELEASED || mouseButtonState[2] == UP)
{
return true;
}
else
{
return false;
}
}
bool rightMousePressed()
{
if (mouseButtonState[2] == PRESSED)
{
return true;
}
else
{
return false;
}
}
bool rightMouseDown()
{
if (mouseButtonState[2] == PRESSED || mouseButtonState[2] == DOWN)
{
return true;
}
else
{
return false;
}
}//
bool keyPressed(char keycode)
{
if (keyState[keycode] == PRESSED)
{
return true;
}
else
{
return false;
}
}
bool keyDown(char keycode)
{
if (keyState[keycode] == DOWN || keyState[keycode] == PRESSED)
{
return true;
}
else
{
return false;
}
}
bool keyUp(char keycode)
{
if (keyState[keycode] == UP || keyState[keycode] == RELEASED)
{
return true;
}
else
{
return false;
}
}
bool keyReleased(char keycode)
{
if (keyState[keycode] == RELEASED)
{
return true;
}
else
{
return false;
}
}
// This is used so that the Key States will not be changed during execution of your Main game loop.
// Place this at the very START of your Main Loop
void endEventProcess()
{
processState = ENDED;
}
// This is used so that the Key States will not be changed during execution of your Main game loop.
// Place this function at the END of your Main Loop.
void startEventProcess()
{
processState = STARTED;
//Keyboard Key States
for (int i = 0; i < KEY_KEY_CODES_COUNT; i++)
{
if (keyState[i] == RELEASED)
{
keyState[i] = UP;
}
if (keyState[i] == PRESSED)
{
keyState[i] = DOWN;
}
}
//Mouse Button States
for (int i = 0; i <= 2; i++)
{
if (mouseButtonState[i] == RELEASED)
{
mouseButtonState[i] = UP;
}
if (mouseButtonState[i] == PRESSED)
{
mouseButtonState[i] = DOWN;
}
}
//Mouse Wheel state
mouse.wheel = 0.0f;
}
void init()
{
//KeyBoard States.
for (int i = 0; i <= KEY_KEY_CODES_COUNT; i++)
{
keyState[i] = UP;
}
//Mouse states
for (int i = 0; i <= 2; i++)
{
mouseButtonState[i] = UP;
}
//Mouse X/Y coordenates.
mouse.X = 0;
mouse.Y = 0;
mouse.wheel = 0.0f;
}
};
/// ==========================================
/// END OF MastEventReceiver
/// ==========================================
(MastEventReciver hab ich natürlich nicht selbst gemacht.(Gibts im englischem Wiki.))
Bei fragen, einfach posten.
Anmelden
Registrieren
FAQ
Suche
