atria-soft/ege
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] correct all sample camera

Browse Source
This commit is contained in:
Edouard DUPIN 2017-05-24 22:01:55 +02:00
parent 28014b421a
commit afdcd183dc
21 changed files with 591 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
ege/camera/ControlBase.cpp Normal file
View File

@ -0,0 +1,186 @@
/** @file
* @author Edouard DUPIN
* @copyright 2013, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#include <ewol/object/Object.hpp>
#include <ewol/object/Manager.hpp>
#include <ege/camera/ControlBase.hpp>
#include <ege/debug.hpp>
ege::camera::ControlBase::ControlBase() :
m_destinationCameraOffset(0,0,0),
m_angleTetha(0.0f),
m_anglePsy(0.0f),
m_distance(1.0f) {
}
void ege::camera::ControlBase::setCamera(const ememory::SharedPtr<ege::camera::View>& _camera) {
m_camera.reset();
m_PCH.disconnect();
if (_camera == nullptr) {
return;
}
m_camera = _camera;
m_camera->setTarget(vec3(0,0,0));
m_camera->setEye(vec3(100*std::sin(m_angleTetha),80*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*m_distance);
m_PCH = ewol::Object::getObjectManager().periodicCall.connect(this, &ege::camera::ControlBase::periodicCall);
}
bool ege::camera::ControlBase::onEventEntry(const ewol::event::Entry& _event) {
if (_event.getType() == gale::key::keyboard::left) {
if (_event.getStatus() == gale::key::status::down) {
m_destinationCameraOffset += vec3(1,0,0);
} else if (_event.getStatus() == gale::key::status::up) {
m_destinationCameraOffset -= vec3(1,0,0);
}
return true;
}
if (_event.getType() == gale::key::keyboard::right) {
if (_event.getStatus() == gale::key::status::down) {
m_destinationCameraOffset -= vec3(1,0,0);
} else if (_event.getStatus() == gale::key::status::up) {
m_destinationCameraOffset += vec3(1,0,0);
}
return true;
}
if (_event.getType() == gale::key::keyboard::up) {
if (_event.getStatus() == gale::key::status::down) {
m_destinationCameraOffset += vec3(0,0,1);
} else if (_event.getStatus() == gale::key::status::up) {
m_destinationCameraOffset -= vec3(0,0,1);
}
return true;
}
if (_event.getType() == gale::key::keyboard::down) {
if (_event.getStatus() == gale::key::status::down) {
m_destinationCameraOffset -= vec3(0,0,1);
} else if (_event.getStatus() == gale::key::status::up) {
m_destinationCameraOffset += vec3(0,0,1);
}
return true;
}
if (_event.getType() == gale::key::keyboard::pageUp) {
if (_event.getStatus() == gale::key::status::down) {
m_destinationCameraOffset += vec3(0,1,0);
} else if (_event.getStatus() == gale::key::status::up) {
m_destinationCameraOffset -= vec3(0,1,0);
}
return true;
}
if (_event.getType() == gale::key::keyboard::pageDown) {
if (_event.getStatus() == gale::key::status::down) {
m_destinationCameraOffset -= vec3(0,1,0);
} else if (_event.getStatus() == gale::key::status::up) {
m_destinationCameraOffset += vec3(0,1,0);
}
return true;
}
if (_event.getType() == gale::key::keyboard::start) {
if (_event.getStatus() == gale::key::status::down) {
m_camera->setAngle(m_camera->getAngle() + 0.01f);
}
return true;
}
if (_event.getType() == gale::key::keyboard::end) {
if (_event.getStatus() == gale::key::status::down) {
m_camera->setAngle(m_camera->getAngle() - 0.01f);
}
return true;
}
if (_event.getType() == gale::key::keyboard::insert) {
if (_event.getStatus() == gale::key::status::down) {
m_camera->setXAngleView(m_camera->getXAngleView() + 0.01f);
}
return true;
}
if ( _event.getType() == gale::key::keyboard::character
&& _event.getChar() == u32char::Suppress) {
if (_event.getStatus() == gale::key::status::down) {
m_camera->setXAngleView(m_camera->getXAngleView() - 0.01f);
}
return true;
}
return false;
}
bool ege::camera::ControlBase::onEventInput(const ewol::event::Input& _event, const vec2& _relativePosition) {
if (m_camera == nullptr) {
return false;
}
if (_event.getId() == 4) {
// scrool button ==> zoom in
m_distance += 0.01f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),80*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*m_distance);
return true;
} else if (_event.getId() == 5) {
// scrool button ==> zoom OUT
m_distance -= 0.01f;
if (m_distance <= 0.05f) {
m_distance = 0.05f;
}
m_camera->setEye(vec3(100*std::sin(m_angleTetha),80*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*m_distance);
return true;
} else if (_event.getId() == 3) {
// Middle button ==> move around the target position
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = _relativePosition;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = _relativePosition;
m_angleTetha += (m_oldScreenPos.x()-pos.x())*0.02f;
m_anglePsy += (m_oldScreenPos.y()-pos.y())*0.01f;
m_camera->setEye(m_camera->getTarget() + vec3(100*std::sin(m_angleTetha),80*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*m_distance);
m_oldScreenPos = _relativePosition;
}
return true;
} else if (_event.getId() == 2) {
// Middle button ==> move the camera view axis
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = _relativePosition;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = _relativePosition*0.2;
pos -= m_oldScreenPos*0.2;
float cameraAngle = m_camera->getTetha();
vec3 newPos = vec3(std::sin(cameraAngle)*pos.x() + std::cos(cameraAngle)*pos.y(),
std::cos(cameraAngle)*pos.x() + std::sin(cameraAngle)*pos.y(),
0);
EGE_ERROR("apply offset = " << newPos << " from pos=" << pos << " angle=" << cameraAngle);
newPos += m_camera->getTarget();
newPos.setMin(vec3(200,200,200));
newPos.setMax(vec3(-200,-200,-200));
m_camera->setTarget(newPos);
m_oldScreenPos = _relativePosition;
}
return true;
}
return false;
}
void ege::camera::ControlBase::periodicCall(const ewol::event::Time& _event) {
if (m_camera == nullptr) {
return;
}
if ( m_destinationCameraOffset.x() < 0.7f
&& m_destinationCameraOffset.x() > -0.7f) {
m_destinationCameraOffset.setX(0.0f);
}
if ( m_destinationCameraOffset.y() < 0.7f
&& m_destinationCameraOffset.y() > -0.7f) {
m_destinationCameraOffset.setY(0.0f);
}
if ( m_destinationCameraOffset.z() < 0.7f
&& m_destinationCameraOffset.z() > -0.7f) {
m_destinationCameraOffset.setZ(0.0f);
}
float delta = _event.getDeltaCall();
vec3 tmp = m_destinationCameraOffset * delta * 30.0f;
m_camera->setTarget(m_camera->getTarget() + tmp);
m_camera->setEye(m_camera->getEye() + tmp);
}

46
ege/camera/ControlBase.hpp Normal file
View File

@ -0,0 +1,46 @@
/** @file
* @author Edouard DUPIN
* @copyright 2013, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <ege/camera/View.hpp>
#include <ewol/widget/Widget.hpp>
#include <ewol/event/Entry.hpp>
#include <ewol/event/Input.hpp>
namespace ege {
namespace camera {
/**
* The control position of the camera is principali a basic camera control to prototype an idea ...
*/
class ControlBase {
protected:
vec3 m_destinationCameraOffset;
float m_angleTetha;
float m_anglePsy;
float m_distance;
vec2 m_oldScreenPos;
esignal::Connection m_PCH; //!< Periodic Call Handle to remove it when needed
public:
/**
* @brief Constructor.
*/
ControlBase();
private:
ememory::SharedPtr<ege::camera::View> m_camera;
public:
void setCamera(const ememory::SharedPtr<ege::camera::View>& _camera);
bool onEventEntry(const ewol::event::Entry& _event);
bool onEventInput(const ewol::event::Input& _event, const vec2& _relativePosition);
/**
* @brief Periodic call to update grapgic display
* @param[in] _event Time generic event
*/
void periodicCall(const ewol::event::Time& _event);
};
}
}

8
ege/widget/Scene.cpp
View File

@ -51,7 +51,13 @@ ege::widget::Scene::~Scene() {
void ege::widget::Scene::onRegenerateDisplay() {
if (needRedraw() == true) {
// Update the curent camera with the aspect ratio
if (m_env != nullptr) {
ememory::SharedPtr<ege::Camera> camera = m_env->getCamera(m_cameraName);
if (camera != nullptr) {
camera->setSceenSize(getSize());
}
}
}
}

3
lutin_ege.py
View File

@ -25,6 +25,7 @@ def get_version():
return "version.txt"
def configure(target, my_module):
my_module.add_extra_flags()
my_module.add_src_file([
'ege/debug.cpp',
'ege/Engine.cpp',
@ -33,6 +34,7 @@ def configure(target, my_module):
'ege/camera/Camera.cpp',
'ege/camera/View.cpp',
'ege/camera/FPS.cpp',
'ege/camera/ControlBase.cpp',
'ege/position/Component.cpp',
'ege/physics/Component.cpp',
'ege/physics/Engine.cpp',
@ -87,6 +89,7 @@ def configure(target, my_module):
'ege/camera/Camera.hpp',
'ege/camera/View.hpp',
'ege/camera/FPS.hpp',
'ege/camera/ControlBase.hpp',
'ege/position/Component.hpp',
'ege/physics/Engine.hpp',
'ege/physics/Component.hpp',

42
sample/CameraPosition/appl/Windows.cpp
View File

@ -14,8 +14,15 @@
#include <ege/widget/Scene.hpp>
#include <ege/camera/View.hpp>
#include <etk/tool.hpp>
#include <ege/elements/ElementBase.hpp>
#include <ege/elements/ElementPhysic.hpp>
#include <ege/Entity.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Sphere.hpp>
#include <ege/physics/shape/Cylinder.hpp>
#include <ege/physics/shape/Capsule.hpp>
#include <ege/physics/shape/Cone.hpp>
#include <ege/position/Component.hpp>
#include <ege/render/Component.hpp>
#include <ege/physics/Component.hpp>
appl::Windows::Windows() {
addObjectType("appl::Windows");
@ -27,7 +34,7 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
ememory::SharedPtr<ege::resource::Mesh> out = ege::resource::Mesh::create("viewBoxStar", "DATA:texturedNoMaterial.prog");
if (out != nullptr) {
ememory::SharedPtr<ege::Material> material = ememory::makeShared<ege::Material>();
// set the element material properties :
// set the entity material properties :
material->setAmbientFactor(vec4(1,1,1,1));
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
@ -69,7 +76,7 @@ void appl::Windows::init() {
m_env = ege::Environement::create();
// Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,0));
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,-100,30), vec3(0,0,0));
m_env->addCamera("basic", m_camera);
ememory::SharedPtr<ege::widget::Scene> tmpWidget = ege::widget::Scene::create();
@ -83,14 +90,33 @@ void appl::Windows::init() {
setSubWidget(tmpWidget);
}
ememory::SharedPtr<ege::resource::Mesh> myMesh;
// Create an external box :
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
m_env->propertyStatus.set(ege::gameStart);
}
@ -101,7 +127,7 @@ void appl::Windows::onCallbackPeriodicUpdateCamera(const ewol::event::Time& _eve
offset += 0.01;
static float offset2 = 0;
offset2 += 0.003;
m_camera->setEye(vec3(100*std::sin(offset),100*std::cos(offset),40*std::cos(offset2)));
m_camera->setEye(vec3(100*std::sin(offset),40*std::cos(offset2),100*std::cos(offset)));
}

2
sample/CameraPosition/appl/Windows.hpp
View File

@ -18,7 +18,7 @@ namespace appl {
ememory::SharedPtr<ege::camera::View> m_camera;
protected:
Windows();
void init();
void init() override;
public:
DECLARE_FACTORY(Windows);
virtual ~Windows() { };

1
sample/CameraPosition/lutin_ege-sample-camera-position.py
View File

@ -31,6 +31,7 @@ def get_version():
return [0,1]
def configure(target, my_module):
my_module.add_extra_flags()
my_module.add_src_file([
'appl/debug.cpp',

157
sample/Collision/appl/Windows.cpp
View File

@ -38,7 +38,7 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
return out;
}
ememory::SharedPtr<ege::Material> material = ememory::makeShared<ege::Material>();
// set the element material properties :
// set the entity material properties :
material->setAmbientFactor(vec4(1,1,1,1));
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
@ -81,9 +81,9 @@ void appl::Windows::init() {
m_env->getEngine("physics")->properties.set("debug-AABB", "true");
m_env->getEngine("physics")->properties.set("debug-shape", "true");
// Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,0));
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),40*std::cos(m_anglePsy)));
m_camera = ememory::makeShared<ege::camera::View>();
m_env->addCamera("basic", m_camera);
m_cameraControler.setCamera(m_camera);
ememory::SharedPtr<ege::widget::Scene> tmpWidget = ege::widget::Scene::create();
if (tmpWidget == nullptr) {
@ -100,54 +100,54 @@ void appl::Windows::init() {
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
element->addComponent(componentPosition);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
element->addComponent(componentPosition);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
// create the 6 border that destroy the object when percuted:
// create cubes ...
myMesh = ege::resource::Mesh::createCube(vec3(200,0.2,200), "basics", etk::color::green);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(0,-200,0), etk::Quaternion::identity());
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
physic->setSize(vec3(200.01,0.21,200.01));
componentPhysics->addShape(physic);
// The element can not move
// The entity can not move
componentPhysics->setType(ege::physics::Component::type::bodyStatic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
@ -155,13 +155,13 @@ void appl::Windows::init() {
// create cubes ...
myMesh = ege::resource::Mesh::createCube(vec3(3,0.2,5), "basics", etk::color::green);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(0,0,2), etk::Quaternion::identity());
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
@ -169,21 +169,21 @@ void appl::Windows::init() {
physic->setMass(300000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCube(3, "basics", etk::color::orange);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20,-10,10), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
@ -191,21 +191,21 @@ void appl::Windows::init() {
physic->setMass(50000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createSphere(4, "basics", etk::color::blue);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(-20,10,10), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Sphere> physic = ememory::makeShared<ege::physics::shape::Sphere>();
@ -213,21 +213,21 @@ void appl::Windows::init() {
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCylinder(4, 8, "basics", etk::color::blue);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20,10,10), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Cylinder> physic = ememory::makeShared<ege::physics::shape::Cylinder>();
@ -236,21 +236,21 @@ void appl::Windows::init() {
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCapsule(4, 8, "basics", etk::color::purple);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20,-10,-10), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Capsule> physic = ememory::makeShared<ege::physics::shape::Capsule>();
@ -259,21 +259,21 @@ void appl::Windows::init() {
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCone(4, 8, "basics", etk::color::purple);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20, 20,-10), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Cone> physic = ememory::makeShared<ege::physics::shape::Cone>();
@ -282,16 +282,24 @@ void appl::Windows::init() {
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
m_env->propertyStatus.set(ege::gameStart);
}
bool appl::Windows::onEventEntry(const ewol::event::Entry& _event) {
if (m_cameraControler.onEventEntry(_event) == true) {
return true;
}
return false;
}
bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
static float ploppp=1;
if (m_cameraControler.onEventInput(_event, relativePosition(_event.getPos())) == true) {
return true;
}
if (_event.getId() == 1) {
if (_event.getStatus() == gale::key::status::down) {
vec2 pos = relativePosition(_event.getPos());
@ -300,15 +308,15 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
ememory::SharedPtr<ege::resource::Mesh> myMesh;
myMesh = ege::resource::Mesh::createCube(1, "basics", etk::color::orange);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(ray.getOrigin(), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
@ -320,59 +328,14 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
// set has dynamic object (can move)
//APPL_CRITICAL("velocity : " << ray.getDirection()*100);
componentPhysics->setLinearVelocity(ray.getDirection()*100);
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
return true;
}
} else if (_event.getId() == 4) {
ploppp += 0.01f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
} else if (_event.getId() == 5) {
ploppp -= 0.01f;
if (ploppp == 0) {
ploppp = 1.0f;
}
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
} else if (_event.getId() == 3) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos());
m_angleTetha -= (m_oldScreenPos.x()-pos.x())*0.05f;
m_anglePsy += (m_oldScreenPos.y()-pos.y())*0.01f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
} else if (_event.getId() == 2) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos())*0.2;
pos -= m_oldScreenPos*0.2;
float cameraAngle = m_camera->getTetha();
vec3 newPos = vec3(std::sin(cameraAngle)*pos.x() + std::cos(cameraAngle)*pos.y(),
std::cos(cameraAngle)*pos.x() + std::sin(cameraAngle)*pos.y(),
0);
APPL_ERROR("apply offset = " << newPos << " from pos=" << pos << " angle=" << cameraAngle);
newPos += m_camera->getTarget();
newPos.setMin(vec3(200,200,200));
newPos.setMax(vec3(-200,-200,-200));
m_camera->setTarget(newPos);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
} else if (_event.getId() == 10) {
m_camera->setAngle(m_camera->getAngle() + 0.01f);
} else if (_event.getId() == 11) {
m_camera->setAngle(m_camera->getAngle() - 0.01f);
}
}
return false;
}

12
sample/Collision/appl/Windows.hpp
View File

@ -10,6 +10,7 @@
#include <ewol/widget/Windows.hpp>
#include <ege/Environement.hpp>
#include <ege/camera/View.hpp>
#include <ege/camera/ControlBase.hpp>
#include <ewol/resource/Colored3DObject.hpp>
namespace appl {
@ -17,18 +18,17 @@ namespace appl {
private:
ememory::SharedPtr<ege::Environement> m_env;
ememory::SharedPtr<ege::camera::View> m_camera;
ege::camera::ControlBase m_cameraControler;
protected:
Windows();
void init();
void init() override;
public:
DECLARE_FACTORY(Windows);
virtual ~Windows() { };
private:
bool onEventInput(const ewol::event::Input& _event);
float m_angleTetha;
float m_anglePsy;
vec2 m_oldScreenPos;
void onCallbackPeriodicCheckCollision(const ewol::event::Time& _event);
// need this to forward if to the camera controler ...
bool onEventEntry(const ewol::event::Entry& _event) override;
bool onEventInput(const ewol::event::Input& _event) override;
};
}

1
sample/Collision/lutin_ege-sample-collision.py
View File

@ -31,6 +31,7 @@ def get_version():
return [0,1]
def configure(target, my_module):
my_module.add_extra_flags()
my_module.add_src_file([
'appl/debug.cpp',

174
sample/DoubleView/appl/Windows.cpp
View File

@ -15,10 +15,15 @@
#include <ege/widget/Scene.hpp>
#include <ege/camera/View.hpp>
#include <etk/tool.hpp>
#include <ege/elements/ElementBase.hpp>
#include <ege/elements/ElementPhysic.hpp>
#include <ege/physicsShape/PhysicsBox.hpp>
#include <ege/physicsShape/PhysicsSphere.hpp>
#include <ege/Entity.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Sphere.hpp>
#include <ege/physics/shape/Cylinder.hpp>
#include <ege/physics/shape/Capsule.hpp>
#include <ege/physics/shape/Cone.hpp>
#include <ege/position/Component.hpp>
#include <ege/render/Component.hpp>
#include <ege/physics/Component.hpp>
appl::Windows::Windows() {
addObjectType("appl::Windows");
@ -30,7 +35,7 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
ememory::SharedPtr<ege::resource::Mesh> out = ege::resource::Mesh::create("viewBoxStar", "DATA:texturedNoMaterial.prog");
if (out != nullptr) {
ememory::SharedPtr<ege::Material> material = ememory::makeShared<ege::Material>();
// set the element material properties :
// set the entity material properties :
material->setAmbientFactor(vec4(1,1,1,1));
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
@ -70,9 +75,9 @@ void appl::Windows::init() {
m_env = ege::Environement::create();
// Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,0));
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),40*std::cos(m_anglePsy)));
m_camera = ememory::makeShared<ege::camera::View>();
m_env->addCamera("basic", m_camera);
m_cameraControler.setCamera(m_camera);
// Create basic Camera
ememory::SharedPtr<ege::camera::View> camera2 = ememory::makeShared<ege::camera::View>(vec3(100,0,0), vec3(0,0,0));
m_env->addCamera("front", camera2);
@ -129,101 +134,92 @@ void appl::Windows::init() {
}
ememory::SharedPtr<ege::resource::Mesh> myMesh;
// Create an external box :
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
// create basic gird:
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCube(3);
myMesh = ege::resource::Mesh::createCube(3, "basics", etk::color::orange);
if (myMesh != nullptr) {
//ememory::SharedPtr<ege::ElementBase> element = ememory::makeShared<ege::ElementBase>(m_env);
ememory::SharedPtr<ege::ElementPhysic> element = ememory::makeShared<ege::ElementPhysic>(m_env);
// add physic interface:
ememory::SharedPtr<ege::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
physic->setSize(vec3(3.2,3.2,3.2));
myMesh->addPhysicElement(physic);
element->setMesh(myMesh);
element->createRigidBody(4000000);
element->setPosition(vec3(20,10,10));
m_env->addElement(element);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(-20,10,0), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
physic->setSize(vec3(3.01,3.01,3.01));
physic->setMass(50000);
componentPhysics->addShape(physic);
componentPhysics->generate();
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCube(3);
myMesh = ege::resource::Mesh::createSphere(4, "basics", etk::color::blue);
if (myMesh != nullptr) {
//element = ememory::makeShared<ege::ElementBase>(m_env);
ememory::SharedPtr<ege::ElementPhysic> element = ememory::makeShared<ege::ElementPhysic>(m_env);
// add physic interface:
ememory::SharedPtr<ege::PhysicsSphere> physic = ememory::makeShared<ege::PhysicsSphere>();
physic->setRadius(4.5f);
myMesh->addPhysicElement(physic);
element->setMesh(myMesh);
element->createRigidBody(4000000);
element->setPosition(vec3(20,-10,10));
element->iaEnable();
m_env->addElement(element);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20,10,0), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Sphere> physic = ememory::makeShared<ege::physics::shape::Sphere>();
physic->setRadius(4.01);
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(entity);
}
m_env->propertyStatus.set(ege::gameStart);
}
bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
static float ploppp=1;
if (_event.getId() == 4) {
ploppp += 0.01f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
} else if (_event.getId() == 5) {
ploppp -= 0.01f;
if (ploppp == 0) {
ploppp = 1.0f;
}
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
} else if (_event.getId() == 3) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos());
m_angleTetha -= (m_oldScreenPos.x()-pos.x())*0.05f;
m_anglePsy += (m_oldScreenPos.y()-pos.y())*0.01f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
} else if (_event.getId() == 2) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos())*0.2;
pos -= m_oldScreenPos*0.2;
float cameraAngle = m_camera->getTetha();
vec3 newPos = vec3(std::sin(cameraAngle)*pos.x() + std::cos(cameraAngle)*pos.y(),
std::cos(cameraAngle)*pos.x() + std::sin(cameraAngle)*pos.y(),
0);
APPL_ERROR("apply offset = " << newPos << " from pos=" << pos << " angle=" << cameraAngle);
newPos += m_camera->getTarget();
newPos.setMin(vec3(200,200,200));
newPos.setMax(vec3(-200,-200,-200));
m_camera->setTarget(newPos);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
} else if (_event.getId() == 10) {
m_camera->setAngle(m_camera->getAngle() + 0.01f);
} else if (_event.getId() == 11) {
m_camera->setAngle(m_camera->getAngle() - 0.01f);
}
bool appl::Windows::onEventEntry(const ewol::event::Entry& _event) {
if (m_cameraControler.onEventEntry(_event) == true) {
return true;
}
return false;
}
bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
if (m_cameraControler.onEventInput(_event, relativePosition(_event.getPos())) == true) {
return true;
}
return false;
}

11
sample/DoubleView/appl/Windows.hpp
View File

@ -10,6 +10,7 @@
#include <ewol/widget/Windows.hpp>
#include <ege/Environement.hpp>
#include <ege/camera/View.hpp>
#include <ege/camera/ControlBase.hpp>
#include <ewol/resource/Colored3DObject.hpp>
namespace appl {
@ -17,17 +18,17 @@ namespace appl {
private:
ememory::SharedPtr<ege::Environement> m_env;
ememory::SharedPtr<ege::camera::View> m_camera;
ege::camera::ControlBase m_cameraControler;
protected:
Windows();
void init();
void init() override;
public:
DECLARE_FACTORY(Windows);
virtual ~Windows() { };
private:
bool onEventInput(const ewol::event::Input& _event);
float m_angleTetha;
float m_anglePsy;
vec2 m_oldScreenPos;
// need this to forward if to the camera controler ...
bool onEventEntry(const ewol::event::Entry& _event) override;
bool onEventInput(const ewol::event::Input& _event) override;
};
}

1
sample/DoubleView/lutin_ege-sample-double-view.py
View File

@ -31,6 +31,7 @@ def get_version():
return [0,1]
def configure(target, my_module):
my_module.add_extra_flags()
my_module.add_src_file([
'appl/debug.cpp',

160
sample/LowPoly/appl/Windows.cpp
View File

@ -14,8 +14,15 @@
#include <ege/widget/Scene.hpp>
#include <ege/camera/View.hpp>
#include <etk/tool.hpp>
#include <ege/elements/ElementBase.hpp>
#include <ege/elements/ElementPhysic.hpp>
#include <ege/Entity.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Sphere.hpp>
#include <ege/physics/shape/Cylinder.hpp>
#include <ege/physics/shape/Capsule.hpp>
#include <ege/physics/shape/Cone.hpp>
#include <ege/position/Component.hpp>
#include <ege/render/Component.hpp>
#include <ege/physics/Component.hpp>
appl::Windows::Windows() {
addObjectType("appl::Windows");
@ -27,7 +34,7 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
ememory::SharedPtr<ege::resource::Mesh> out = ege::resource::Mesh::create("viewBoxStar", "DATA:texturedNoMaterial.prog");
if (out != nullptr) {
ememory::SharedPtr<ege::Material> material = ememory::makeShared<ege::Material>();
// set the element material properties :
// set the entity material properties :
material->setAmbientFactor(vec4(1,1,1,1));
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
@ -59,34 +66,6 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
return out;
}
namespace appl {
class Tree : public ege::ElementPhysic {
public:
Tree(const ememory::SharedPtr<ege::Environement>& _env) :
ege::ElementPhysic(_env, false) {
m_group = 1;
m_life = 100;
m_radius = 10;
loadMesh("DATA:tree_1.emf");
createRigidBody(10000);
///never deactivate the vehicle
m_body->setActivationState(DISABLE_DEACTIVATION);
// set the Element as an IA:
iaEnable();
}
void iaAction(float _step) {
}
void onLifeChange() {
APPL_DEBUG("Loose life " << m_life);
}
};
}
static ememory::SharedPtr<ege::Element> createTree(const ememory::SharedPtr<ege::Environement>& _env) {
return ememory::makeShared<appl::Tree>(_env);
}
void appl::Windows::init() {
@ -96,9 +75,9 @@ void appl::Windows::init() {
m_env = ege::Environement::create();
// Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,1));
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy)));
m_camera = ememory::makeShared<ege::camera::View>();
m_env->addCamera("basic", m_camera);
m_cameraControler.setCamera(m_camera);
ememory::SharedPtr<ege::widget::Scene> tmpWidget = ege::widget::Scene::create();
if (tmpWidget == nullptr) {
@ -111,20 +90,50 @@ void appl::Windows::init() {
setSubWidget(tmpWidget);
}
ememory::SharedPtr<ege::resource::Mesh> myMesh;
// Create an external box :
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
if (true) {
ememory::SharedPtr<ege::Element> myElement = createTree(m_env);
if (myElement != nullptr) {
m_env->addElement(myElement);
}
myMesh = ege::resource::Mesh::create("DATA:tree_1.emf");
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
componentPhysics->setShape(myMesh->getPhysicalProperties());
componentPhysics->generate();
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(entity);
}
m_env->propertyStatus.set(ege::gameStart);
tmpWidget->propertyDebugPhysic.set(false);
@ -132,63 +141,16 @@ void appl::Windows::init() {
}
void appl::Windows::onCallbackPeriodicUpdateCamera(const ewol::event::Time& _event) {
static float offset = 0;
offset += 0.01;
static float offset2 = 0;
offset2 += 0.003;
m_camera->setEye(vec3(10*std::sin(offset),10*std::cos(offset),4*std::cos(offset2)));
}
bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
static float ploppp=1;
if (_event.getId() == 1) {
} else if (_event.getId() == 4) {
ploppp += 0.001f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
} else if (_event.getId() == 5) {
ploppp -= 0.001f;
if (ploppp == 0) {
ploppp = 1.0f;
}
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
} else if (_event.getId() == 3) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos());
m_angleTetha -= (m_oldScreenPos.x()-pos.x())*0.05f;
m_anglePsy += (m_oldScreenPos.y()-pos.y())*0.01f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
} else if (_event.getId() == 2) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos())*0.2;
pos -= m_oldScreenPos*0.2;
float cameraAngle = m_camera->getTetha();
vec3 newPos = vec3(std::sin(cameraAngle)*pos.x() + std::cos(cameraAngle)*pos.y(),
std::cos(cameraAngle)*pos.x() + std::sin(cameraAngle)*pos.y(),
0);
APPL_ERROR("apply offset = " << newPos << " from pos=" << pos << " angle=" << cameraAngle);
newPos += m_camera->getTarget();
newPos.setMin(vec3(200,200,200));
newPos.setMax(vec3(-200,-200,-200));
m_camera->setTarget(newPos);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
} else if (_event.getId() == 10) {
m_camera->setAngle(m_camera->getAngle() + 0.01f);
} else if (_event.getId() == 11) {
m_camera->setAngle(m_camera->getAngle() - 0.01f);
}
bool appl::Windows::onEventEntry(const ewol::event::Entry& _event) {
if (m_cameraControler.onEventEntry(_event) == true) {
return true;
}
return false;
}
bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
if (m_cameraControler.onEventInput(_event, relativePosition(_event.getPos())) == true) {
return true;
}
return false;
}

10
sample/LowPoly/appl/Windows.hpp
View File

@ -10,12 +10,14 @@
#include <ewol/widget/Windows.hpp>
#include <ege/Environement.hpp>
#include <ege/camera/View.hpp>
#include <ege/camera/ControlBase.hpp>
namespace appl {
class Windows : public ewol::widget::Windows {
private:
ememory::SharedPtr<ege::Environement> m_env;
ememory::SharedPtr<ege::camera::View> m_camera;
ege::camera::ControlBase m_cameraControler;
protected:
Windows();
void init() override;
@ -24,10 +26,10 @@ namespace appl {
virtual ~Windows() { };
private:
void onCallbackPeriodicUpdateCamera(const ewol::event::Time& _event);
bool onEventInput(const ewol::event::Input& _event);
float m_angleTetha;
float m_anglePsy;
vec2 m_oldScreenPos;
private:
// need this to forward if to the camera controler ...
bool onEventEntry(const ewol::event::Entry& _event) override;
bool onEventInput(const ewol::event::Input& _event) override;
};
}

1
sample/LowPoly/lutin_ege-sample-low-poly.py
View File

@ -31,6 +31,7 @@ def get_version():
return [0,1]
def configure(target, my_module):
my_module.add_extra_flags()
my_module.add_src_file([
'appl/debug.cpp',

60
sample/MeshCreator/appl/Windows.cpp
View File

@ -14,8 +14,15 @@
#include <ege/widget/Scene.hpp>
#include <ege/camera/View.hpp>
#include <etk/tool.hpp>
#include <ege/elements/ElementBase.hpp>
#include <ege/elements/ElementPhysic.hpp>
#include <ege/Entity.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Sphere.hpp>
#include <ege/physics/shape/Cylinder.hpp>
#include <ege/physics/shape/Capsule.hpp>
#include <ege/physics/shape/Cone.hpp>
#include <ege/position/Component.hpp>
#include <ege/render/Component.hpp>
#include <ege/physics/Component.hpp>
appl::Windows::Windows() {
addObjectType("appl::Windows");
@ -26,7 +33,7 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
ememory::SharedPtr<ege::resource::Mesh> out = ege::resource::Mesh::create("---", "DATA:texturedNoMaterial.prog");
if (out != nullptr) {
ememory::SharedPtr<ege::Material> material = ememory::makeShared<ege::Material>();
// set the element material properties :
// set the entity material properties :
material->setAmbientFactor(vec4(1,1,1,1));
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
@ -81,7 +88,7 @@ void appl::Windows::init() {
m_env = ege::Environement::create();
// Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(50,0,0));
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,-100,30), vec3(50,0,0));
m_env->addCamera("basic", m_camera);
ememory::SharedPtr<ege::widget::Scene> tmpWidget = ege::widget::Scene::create();
@ -94,23 +101,48 @@ void appl::Windows::init() {
tmpWidget->setCamera("basic");
setSubWidget(tmpWidget);
}
// Create an external box :
ememory::SharedPtr<ege::resource::Mesh> myMesh = createViewBoxStar();
ememory::SharedPtr<ege::resource::Mesh> myMesh;
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
m_env->addStaticMeshToDraw(myMesh);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
if (true) {
myMesh = createMars();
if (myMesh != nullptr) {
ememory::SharedPtr<ege::ElementBase> element = ememory::makeShared<ege::ElementBase>(m_env);
//ememory::SharedPtr<ege::ElementPhysic> element = ememory::makeShared<ege::ElementPhysic>(m_env);
element->setPosition(vec3(50,0,0));
element->setMesh(myMesh);
m_env->addElement(element);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(5,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(entity);
}
}
m_env->propertyStatus.set(ege::gameStart);
@ -122,7 +154,7 @@ void appl::Windows::onCallbackPeriodicUpdateCamera(const ewol::event::Time& _eve
offset += 0.01;
static float offset2 = 0;
offset2 += 0.003;
m_camera->setEye(vec3(100*std::sin(offset),100*std::cos(offset),40*std::cos(offset2))+vec3(50,0,0));
m_camera->setEye(vec3(100*std::sin(offset),40*std::cos(offset2),100*std::cos(offset))+vec3(50,0,0));
}

2
sample/MeshCreator/appl/Windows.hpp
View File

@ -18,7 +18,7 @@ namespace appl {
ememory::SharedPtr<ege::camera::View> m_camera;
protected:
Windows();
void init();
void init() override;
public:
DECLARE_FACTORY(Windows);
virtual ~Windows() { };

79
sample/RayTest/appl/Windows.cpp
View File

@ -24,9 +24,7 @@
#include <ege/render/Component.hpp>
#include <ege/physics/Component.hpp>
appl::Windows::Windows() :
m_angleTetha(0),
m_anglePsy(0) {
appl::Windows::Windows() {
addObjectType("appl::Windows");
propertyTitle.setDirectCheck("example ege: RayTest");
}
@ -35,7 +33,7 @@ static ememory::SharedPtr<ege::resource::Mesh> createViewBoxStar() {
ememory::SharedPtr<ege::resource::Mesh> out = ege::resource::Mesh::create("viewBoxStar", "DATA:texturedNoMaterial.prog");
if (out != nullptr) {
ememory::SharedPtr<ege::Material> material = ememory::makeShared<ege::Material>();
// set the element material properties :
// set the entity material properties :
material->setAmbientFactor(vec4(1,1,1,1));
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
@ -77,9 +75,9 @@ void appl::Windows::init() {
m_env->getEngine("physics")->properties.set("debug-shape", "true");
// Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,0));
m_camera->setEye(vec3(100*std::sin(m_angleTetha),40*std::cos(m_anglePsy),100*std::cos(m_angleTetha)));
m_camera = ememory::makeShared<ege::camera::View>();
m_env->addCamera("basic", m_camera);
m_cameraControler.setCamera(m_camera);
ememory::SharedPtr<ege::widget::Scene> tmpWidget = ege::widget::Scene::create();
if (tmpWidget == nullptr) {
@ -96,43 +94,42 @@ void appl::Windows::init() {
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
element->addComponent(componentPosition);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
element->addComponent(componentPosition);
entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createCube(3, "basics", etk::color::orange);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(-20,10,0), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
@ -140,21 +137,21 @@ void appl::Windows::init() {
physic->setMass(50000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
myMesh = ege::resource::Mesh::createSphere(4, "basics", etk::color::blue);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
ememory::SharedPtr<ege::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20,10,0), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
//entity->addComponent(componentPosition);
// 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
entity->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::physics::shape::Sphere> physic = ememory::makeShared<ege::physics::shape::Sphere>();
@ -162,15 +159,24 @@ void appl::Windows::init() {
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
entity->addComponent(componentPhysics);
// add it ..
m_env->addEntity(element);
m_env->addEntity(entity);
}
m_env->propertyStatus.set(ege::gameStart);
}
bool appl::Windows::onEventEntry(const ewol::event::Entry& _event) {
if (m_cameraControler.onEventEntry(_event) == true) {
return true;
}
return false;
}
bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
static float ploppp=1;
if (m_cameraControler.onEventInput(_event, relativePosition(_event.getPos())) == true) {
return true;
}
if (_event.getId() == 1) {
if (_event.getStatus() == gale::key::status::down) {
vec2 pos = relativePosition(_event.getPos());
@ -194,27 +200,6 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
}
return true;
}
} else if (_event.getId() == 4) {
ploppp += 0.2f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),40*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*ploppp);
} else if (_event.getId() == 5) {
ploppp -= 0.2f;
if (ploppp == 0) {
ploppp = 1.0f;
}
m_camera->setEye(vec3(100*std::sin(m_angleTetha),40*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*ploppp);
} else if (_event.getId() == 3) {
if (_event.getStatus() == gale::key::status::down) {
m_oldScreenPos = relativePosition(_event.getPos());
return true;
} else if (_event.getStatus() == gale::key::status::move) {
vec2 pos = relativePosition(_event.getPos());
m_angleTetha -= (m_oldScreenPos.x()-pos.x())*0.05f;
m_anglePsy += (m_oldScreenPos.y()-pos.y())*0.05f;
m_camera->setEye(vec3(100*std::sin(m_angleTetha),40*std::cos(m_anglePsy),100*std::cos(m_angleTetha))*ploppp);
m_oldScreenPos = relativePosition(_event.getPos());
return true;
}
}
return false;
}

11
sample/RayTest/appl/Windows.hpp
View File

@ -11,6 +11,7 @@
#include <ege/Environement.hpp>
#include <ege/camera/View.hpp>
#include <ewol/resource/Colored3DObject.hpp>
#include <ege/camera/ControlBase.hpp>
#include <ege/Ray.hpp>
namespace appl {
@ -18,19 +19,19 @@ namespace appl {
private:
ememory::SharedPtr<ege::Environement> m_env;
ememory::SharedPtr<ege::camera::View> m_camera;
ege::camera::ControlBase m_cameraControler;
protected:
Windows();
void init();
void init() override;
public:
DECLARE_FACTORY(Windows);
virtual ~Windows() { };
private:
bool onEventInput(const ewol::event::Input& _event);
// need this to forward if to the camera controler ...
bool onEventEntry(const ewol::event::Entry& _event) override;
bool onEventInput(const ewol::event::Input& _event) override;
void onCallbackDisplayDebug(const ememory::SharedPtr<ewol::resource::Colored3DObject>& _obj);
std::pair<vec3,vec3> m_ray;
float m_angleTetha;
float m_anglePsy;
vec2 m_oldScreenPos;
std::pair<vec3,vec3> m_destination;
};
}

1
sample/RayTest/lutin_ege-sample-raytracing.py
View File

@ -31,6 +31,7 @@ def get_version():
return [0,2]
def configure(target, my_module):
my_module.add_extra_flags()
my_module.add_src_file([
'appl/debug.cpp',