| texte initial |
correction |
date |
Bonjour tout les monde,
Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.
Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)
Code c++ :#ifndef CAMERA_H
#define CAMERA_H
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <irr/irrlicht.h>
/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
class Camera
{
public:
//! constructeur
Camera();
//! destructeur
~Camera();
void moveCameraControl(ICameraSceneNode *camera,
ISceneManager *smgr,
IAnimatedMeshSceneNode* Node,
float Horizontal,float Vertical,float VitesseCamera);
private:
float direction;
float zdirection;
protected:
};
#endif // CAMERA_H
En suite le fichier camera.cpp qui va avec :
Code c++ :#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <cstring>
#include <sstream>
#include <irr/irrlicht.h>
#include <irrklang/irrKlang.h>
#include "Camera.h"
using namespace irr;
using namespace gui;
using namespace scene;
using namespace video;
using namespace core;
using namespace io;
enum ///***Enumeration des ID
{
};
//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}
//! destructeur
Camera::~Camera()
{
}
void Camera::moveCameraControl(ICameraSceneNode *camera, //-----> camera crée dans le scene
ISceneManager *smgr, //-----> sceneManager
IAnimatedMeshSceneNode* Node, //-----> Node du personnage
float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{
core::vector3df cameraPos = camera->getAbsolutePosition();
direction = direction + VitesseCamera *(Horizontal);
zdirection = zdirection - VitesseCamera * (Vertical);
if( zdirection <- 90 )
zdirection = -90;
else
if( zdirection > 90 )
zdirection = 90;
core::vector3df playerPos = Node->getPosition();
float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;
camera->setPosition( core::vector3df( xf, yf, zf ) );
camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
//Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}
Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...
Code c++ :#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <irr/irrlicht.h>
#include "Camera.h" // -------------------------------> A ne pas oublier
/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
public:
//! constructeur
Application();
//! destructeur
virtual ~Application();
//! créé l'environnement Irrlicht
bool run();
//! Boucle de rendu
void rendu();
//! gestion des événements
bool OnEvent(const irr::SEvent& event);
//! Mouvement de la camera
void UpdateCameraMovement(); //-------------------------> Pour mettre a jour la position de la camera
protected:
//! MEMBRES
irr::IrrlichtDevice *device;
irr::video::IVideoDriver *driver;
irr::scene::ISceneManager *smgr;
irr::gui::IGUIEnvironment *env;
//cameras
ICameraSceneNode *camera[2]={0,0}; //----> Deux camera mais une seule suffit ;)
IAnimatedMeshSceneNode *model_node; //----> le personnage
bool cameraH_Positif; //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
bool cameraH_Negatif;
bool cameraV_Positif;
bool cameraV_Negatif;
Camera came; // ---------------------------> On cree un objet camera
private:
};
#endif // APPLICATION_H
Et pour finir la partie du jeux .cpp
Code c++ : void Application::UpdateCameraMovement(){
if(cameraV_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
}
if(cameraV_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
}
if(cameraH_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
}
if(cameraH_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
}
if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
came.moveCameraControl(camera[0],smgr,model_node,0,0,0);
}
}
bool Application::OnEvent(const SEvent& event){
switch(event.EventType)
{
case EET_KEY_INPUT_EVENT:
{
// si on appuie sur echap
if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
{
// on ferme l'application
printf("FERMETURE");
device->closeDevice();
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_Z)
{
if(event.KeyInput.PressedDown == true) //Si il s'agit d'un appui
cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
//Sinon c'est un relachement
else cameraV_Positif = false;
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_S)
{
if(event.KeyInput.PressedDown == true)
cameraV_Negatif = true; //-------------------------------------------------> Mouvement vertical negatif
else cameraV_Negatif = false;
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_Q)
{
if(event.KeyInput.PressedDown == true) //Si il s'agit d'un appui
cameraH_Positif = true; //-------------------------------------------------> Mouvement horizontal positif
//Sinon c'est un relachement
else cameraH_Positif = false;
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_D)
{
if(event.KeyInput.PressedDown == true)
cameraH_Negatif = true; //-------------------------------------------------> Mouvement horizontal negatif
else cameraH_Negatif = false;
return true;
}
}
break;
default: break;
}
}
Puis dans la boucle de rendu :
UpdateCameraMovement();
Voila même si c'est pas grand chose, j’espère que çà sera utile...
Bonne continuation. |
Bonjour tout les monde,
Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.
Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)
Code c++ :#ifndef CAMERA_H
#define CAMERA_H
#include <irr/irrlicht.h>
/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
class Camera
{
public:
//! constructeur
Camera();
//! destructeur
~Camera();
void moveCameraControl(ICameraSceneNode *camera,
ISceneManager *smgr,
IAnimatedMeshSceneNode* Node,
float Horizontal,float Vertical,float VitesseCamera);
private:
float direction;
float zdirection;
protected:
};
#endif // CAMERA_H
En suite le fichier camera.cpp qui va avec :
Code c++ :
#include "Camera.h"
//using namespace ...
//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}
//! destructeur
Camera::~Camera()
{
}
void Camera::moveCameraControl(ICameraSceneNode *camera, //-----> camera crée dans le scene
ISceneManager *smgr, //-----> sceneManager
IAnimatedMeshSceneNode* Node, //-----> Node du personnage
float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{
core::vector3df cameraPos = camera->getAbsolutePosition();
direction = direction + VitesseCamera *(Horizontal);
zdirection = zdirection - VitesseCamera * (Vertical);
if( zdirection <- 90 )
zdirection = -90;
else
if( zdirection > 90 )
zdirection = 90;
core::vector3df playerPos = Node->getPosition();
float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;
camera->setPosition( core::vector3df( xf, yf, zf ) );
camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
//Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}
Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...
[Code=cpp]#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <irr/irrlicht.h>
#include "Camera.h" // --------------------------
|
15-03-2014 07:54:50 |
Bonjour tout les monde,
Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.
Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)
Code c++ :#ifndef CAMERA_H
#define CAMERA_H
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <irr/irrlicht.h>
/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
class Camera
{
public:
//! constructeur
Camera();
//! destructeur
~Camera();
void moveCameraControl(ICameraSceneNode *camera,
ISceneManager *smgr,
IAnimatedMeshSceneNode* Node,
float Horizontal,float Vertical,float VitesseCamera);
private:
float direction;
float zdirection;
protected:
};
#endif // CAMERA_H
En suite le fichier camera.cpp qui va avec :
Code c++ :#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <cstring>
#include <sstream>
#include <irr/irrlicht.h>
#include <irrklang/irrKlang.h>
#include "Camera.h"
using namespace irr;
using namespace gui;
using namespace scene;
using namespace video;
using namespace core;
using namespace io;
enum ///***Enumeration des ID
{
};
//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}
//! destructeur
Camera::~Camera()
{
}
void Camera::moveCameraControl(ICameraSceneNode *camera, //-----> camera crée dans le scene
ISceneManager *smgr, //-----> sceneManager
IAnimatedMeshSceneNode* Node, //-----> Node du personnage
float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{
core::vector3df cameraPos = camera->getAbsolutePosition();
direction = direction + VitesseCamera *(Horizontal);
zdirection = zdirection - VitesseCamera * (Vertical);
if( zdirection <- 90 )
zdirection = -90;
else
if( zdirection > 90 )
zdirection = 90;
core::vector3df playerPos = Node->getPosition();
float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;
camera->setPosition( core::vector3df( xf, yf, zf ) );
camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
//Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}
Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...
Code c++ :#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <irr/irrlicht.h>
#include "Camera.h" // -------------------------------> A ne pas oublier
/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
public:
//! constructeur
Application();
//! destructeur
virtual ~Application();
//! créé l'environnement Irrlicht
bool run();
//! Boucle de rendu
void rendu();
//! gestion des événements
bool OnEvent(const irr::SEvent& event);
//! Mouvement de la camera
void UpdateCameraMovement(); //-------------------------> Pour mettre a jour la position de la camera
protected:
//! MEMBRES
irr::IrrlichtDevice *device;
irr::video::IVideoDriver *driver;
irr::scene::ISceneManager *smgr;
irr::gui::IGUIEnvironment *env;
//cameras
ICameraSceneNode *camera[2]={0,0}; //----> Deux camera mais une seule suffit ;)
IAnimatedMeshSceneNode *model_node; //----> le personnage
bool cameraH_Positif; //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
bool cameraH_Negatif;
bool cameraV_Positif;
bool cameraV_Negatif;
Camera came; // ---------------------------> On cree un objet camera
private:
};
#endif // APPLICATION_H
Et pour finir la partie du jeux .cpp
Code c++ : void Application::UpdateCameraMovement(){
if(cameraV_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
}
if(cameraV_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
}
if(cameraH_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
}
if(cameraH_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
}
if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
came.moveCameraControl(camera[0],smgr,model_node,0,0,0);
}
}
bool Application::OnEvent(const SEvent& event){
switch(event.EventType)
{
case EET_KEY_INPUT_EVENT:
{
// si on appuie sur echap
if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
{
// on ferme l'application
printf("FERMETURE");
device->closeDevice();
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_Z)
{
if(event.KeyInput.PressedDown == true) //Si il s'agit d'un appui
cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
//Sinon c'est un relachement
else cameraV_Positif = false;
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_S)
{
if(event.KeyInput.PressedDown == true)
cameraV_Negatif = true; //-------------------------------------------------> Mouvement vertical negatif
else cameraV_Negatif = false;
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_Q)
{
if(event.KeyInput.PressedDown == true) //Si il s'agit d'un appui
cameraH_Positif = true; //-------------------------------------------------> Mouvement horizontal positif
//Sinon c'est un relachement
else cameraH_Positif = false;
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_D)
{
if(event.KeyInput.PressedDown == true)
cameraH_Negatif = true; //-------------------------------------------------> Mouvement horizontal negatif
else cameraH_Negatif = false;
return true;
}
}
break;
default: break;
}
}
Puis dans la boucle de rendu :
UpdateCameraMovement();
Voila même si c'est pas grand chose, j’espère que çà sera utile...
Bonne continuation. |
Bonjour tout les monde,
Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.
Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)
Code c++ :#ifndef CAMERA_H
#define CAMERA_H
#include <irr/irrlicht.h>
/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
class Camera
{
public:
//! constructeur
Camera();
//! destructeur
~Camera();
void moveCameraControl(ICameraSceneNode *camera,
ISceneManager *smgr,
IAnimatedMeshSceneNode* Node,
float Horizontal,float Vertical,float VitesseCamera);
private:
float direction;
float zdirection;
protected:
};
#endif // CAMERA_H
En suite le fichier camera.cpp qui va avec :
Code c++ :
#include "Camera.h"
//using namespace ...
//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}
//! destructeur
Camera::~Camera()
{
}
void Camera::moveCameraControl(ICameraSceneNode *camera, //-----> camera crée dans le scene
ISceneManager *smgr, //-----> sceneManager
IAnimatedMeshSceneNode* Node, //-----> Node du personnage
float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{
core::vector3df cameraPos = camera->getAbsolutePosition();
direction = direction + VitesseCamera *(Horizontal);
zdirection = zdirection - VitesseCamera * (Vertical);
if( zdirection <- 90 )
zdirection = -90;
else
if( zdirection > 90 )
zdirection = 90;
core::vector3df playerPos = Node->getPosition();
float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;
camera->setPosition( core::vector3df( xf, yf, zf ) );
camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
//Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}
Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...
Code c++ :#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <irr/irrlicht.h>
#include "Camera.h" // -------------------------------> A ne pas oublier
/** Déclarations anticipées **/
//using namespace ...
class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
public:
//! constructeur
Application();
//! destructeur
virtual ~Application();
//! créé l'environnement Irrlicht
bool run();
//! Boucle de rendu
void rendu();
//! gestion des événements
bool OnEvent(const irr::SEvent& event);
//! Mouvement de la camera
void UpdateCameraMovement(); //-------------------------> Pour mettre a jour la position de la camera
protected:
//! MEMBRES
irr::IrrlichtDevice *device;
irr::video::IVideoDriver *driver;
irr::scene::ISceneManager *smgr;
irr::gui::IGUIEnvironment *env;
//cameras
ICameraSceneNode *camera[2]={0,0}; //----> Deux camera mais une seule suffit ;)
IAnimatedMeshSceneNode *model_node; //----> le personnage
bool cameraH_Positif; //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
bool cameraH_Negatif;
bool cameraV_Positif;
bool cameraV_Negatif;
Camera came; // ---------------------------> On cree un objet camera
private:
};
#endif // APPLICATION_H
Et pour finir la partie du jeux application.cpp
[Code=cpp] void Application::UpdateCameraMovement(){
if(cameraV_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
}
if(cameraV_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
}
if(cameraH_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
}
if(cameraH_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
}
if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
came.moveCameraControl(camera[0],smgr,model_node,0,0,0);
}
}
bool Application::OnEvent(const SEvent& event){
switch(event.EventType)
{
case EET_KEY_INPUT_EVENT:
{
// si on appuie sur echap
if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
{
// on ferme l'application
printf("FERMETURE");
device->closeDevice();
return true;
}
if(event.KeyInput.Key == irr::KEY_KEY_Z)
{
if(event.KeyInput.PressedDown == true) //Si il s'agit d'un appui
cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
//Sinon c'est un relachement
else cameraV_Positif = false;
%
|
15-03-2014 07:52:23 |
En gros tu veux que j'arrive a un truc comme ca ? 
void Map::constructMap(float lenght, float width, irr::video::IVideoDriver *driver, irr::scene::ISceneManager *sceneManager)
{
Terrain_ = sceneManager->addTerrainSceneNode("./ressources/HeightMap.bmp", 0, -1, irr::core::vector3df(0.f, 0.f, 0.f), irr::core::vector3df(0.f, 0.f, 0.f), irr::core::vector3df(lenght, 0.0f, width), irr::video::SColor ( 255, 255, 255, 255 ), 5, irr::scene::ETPS_17, 3);
Terrain_->setMaterialFlag(irr::video::EMF_LIGHTING, true);
Terrain_->setMaterialFlag(irr::video::EMF_ANISOTROPIC_FILTER , true);
Terrain_->setMaterialTexture(0, driver->getTexture("./ressources/terrdirtgrass.jpg"));
Terrain_->setPosition(irr::core::vector3df(0, 0 , 0));
Terrain_->scaleTexture( 1.063f * lenght, 0.0f);
mapSizeX_ = lenght;
mapSizeZ_ = width;
} |
En gros tu veux que j'arrive a un truc comme ca ?
void Map::constructMap(float lenght, float width, irr::video::IVideoDriver *driver, irr::scene::ISceneManager *sceneManager)
{
Terrain_ = sceneManager->addTerrainSceneNode("./ressources/HeightMap.bmp", 0, -1, irr::core::vector3df(0.f, 0.f, 0.f), irr::core::vector3df(0.f, 0.f, 0.f), irr::core::vector3df(lenght, 0.0f, width), irr::video::SColor ( 255, 255, 255, 255 ), 5, irr::scene::ETPS_17, 3);
Terrain_->setMaterialFlag(irr::video::EMF_LIGHTING, true);
Terrain_->setMaterialFlag(irr::video::EMF_ANISOTROPIC_FILTER , true);
Terrain_->setMaterialTexture(0, driver->getTexture("./ressources/terrdirtgrass.jpg"));
Terrain_->setPosition(irr::core::vector3df(0, 0 , 0));
Terrain_->scaleTexture( 1.063f * lenght, 0.0f);
mapSizeX_ = lenght;
mapSizeZ_ = width;
}
Edit : Je suis en version 1.7.2
|
29-06-2012 12:33:24 |
Finalement j'ai eu une bonne idée et je vais arrêter cette camera spéciale pour un une autre plus... RPG |
Finalement j'ai eu une bonne idée et je vais arrêter cette camera spéciale pour un une autre plus... RPG
|
07-12-2011 13:38:30 |
ok d'ac. Alors, en reprenant l'exemple d'irrlicht sur le moteur de terrain, voici la texture principale :
La texturedetail :
Et enfin la heightmap :
j'ai juste piqué ça dans le dossier media du zip d'irrlicht  |
ok d'ac. Alors, en reprenant l'exemple d'irrlicht sur le moteur de terrain, voici la texture principale :
[img width="500" height="500" ]http://dl.dropbox.com/u/17233643/irrlicht/terrain-texture.jpg[/img]
La texturedetail :
Et enfin la heightmap :
j'ai juste piqué ça dans le dossier media du zip d'irrlicht
|
26-06-2011 10:22:09 |
ok d'ac. Alors, en reprenant l'exemple d'irrlicht sur le moteur de terrain, voici la texture principale :
La texturedetail :
Et enfin la heightmap :
j'ai juste piqué ça dans le dossier media du zip d'irrlicht |
ok d'ac. Alors, en reprenant l'exemple d'irrlicht sur le moteur de terrain, voici la texture principale :
[img width = 500 height=500 ]http://dl.dropbox.com/u/17233643/irrlicht/terrain-texture.jpg[/img]
La texturedetail :
Et enfin la heightmap :
j'ai juste piqué ça dans le dossier media du zip d'irrlicht
|
26-06-2011 10:21:33 |
ok je te remercie, c'est se que j'ai fais pour la lumière par contre bah pg pour les traits, si par hasard, quelqu'un ou sais si c'est possible et qu'il le sais, qu'il me le dise merci, sinon bah pg c'est déjà mieux que rien :p |
ok je te remercie, c'est se que j'ai fais pour la lumière par contre bah pas grave pour les traits, si par hasard, quelqu'un ou sais si c'est possible et qu'il le sais, qu'il me le dise merci, sinon bah pas grave c'est déjà mieux que rien :p
|
22-10-2010 20:32:46 |
oui oui je sais que ce n'est pas utilisable t'en fais pas mis ça dans mon code en me disant "ça marche poooo...)
non en fait j'ai du mal m'expliquer: j'arrive créer mon terrain et à mettre la texture principale dessus:
***************************************************************************
scene::ITerrainSceneNode* terrain = sceneManager->addTerrainSceneNode(
"da.bmp",
0,
core::vector3df(0.f, 0.f, 0.f),
core::vector3df(0.f, 0.f, 0.f),
core::vector3df(40.f, 40.f, 40.f),
video::SColor ( 255, 255, 255, 255 ),
5,
scene::ETPS_17,
5
);
terrain->setMaterialType(video::EMT_DETAIL_MAP);
terrain->setMaterialTexture(0, driver->getTexture("da_tex.jpg"));
terrain->setMaterialFlag(video::EMF_LIGHTING, false);
**************************************************************************
jusque là ça va mais par contre je ne sais pas comment déclarer l'alpha de ma texture "détail" et sa texture associée
je me doute qu'il faut utilser un truc du genre : >setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL); mais après....
merci pour ton aide en tout cas, c'est bien sympa |
oui oui je sais que ce n'est pas utilisable t'en fais pas mis ça dans mon code en me disant "ça marche poooo...)
non en fait j'ai du mal m'expliquer: j'arrive créer mon terrain et à mettre la texture principale dessus:
***************************************************************************
scene::ITerrainSceneNode* terrain = sceneManager->addTerrainSceneNode(
"da.bmp",
0,
-1,
core::vector3df(0.f, 0.f, 0.f),
core::vector3df(0.f, 0.f, 0.f),
core::vector3df(40.f, 40.f, 40.f),
video::SColor ( 255, 255, 255, 255 ),
5,
scene::ETPS_17,
5
);
terrain->setMaterialType(video::EMT_DETAIL_MAP);
terrain->setMaterialTexture(0, driver->getTexture("da_tex.jpg"));
terrain->setMaterialFlag(video::EMF_LIGHTING, false);
**************************************************************************
jusque là ça va mais par contre je ne sais pas comment déclarer l'alpha de ma texture "détail" et sa texture associée
je me doute qu'il faut utilser un truc du genre : >setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL); mais après....
merci pour ton aide en tout cas, c'est bien sympa
|
27-08-2010 10:51:21 |
![http://dl.dropbox.com/u/17233643/irrlicht/terrain-texture.jpg[/img]](http://dl.dropbox.com/u/17233643/irrlicht/terrain-texture.jpg[/img]){kind=link}