[DEV] correct all sample camera

ege/camera/ControlBase.cpp

@@ -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);
+}
+

ege/camera/ControlBase.hpp

@@ -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);
+		};
+	}
+}
+

ege/widget/Scene.cpp

@@ -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());
+			}
+		}
 	}
 }
 

lutin_ege.py

@@ -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',

sample/CameraPosition/appl/Windows.cpp

@@ -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/Entity.hpp>
-#include <ege/elements/ElementPhysic.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)));
 }
 
 

sample/CameraPosition/appl/Windows.hpp

@@ -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() { };

sample/CameraPosition/lutin_ege-sample-camera-position.py

@@ -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',

sample/Collision/appl/Windows.cpp

@@ -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 = ememory::makeShared<ege::camera::View>();
-	m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),40*std::cos(m_anglePsy)));
 	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;
 }
 
 
-

sample/Collision/appl/Windows.hpp

@@ -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);
+			// need this to forward if to the camera controler ...
-			float m_angleTetha;
+			bool onEventEntry(const ewol::event::Entry& _event) override;
-			float m_anglePsy;
+			bool onEventInput(const ewol::event::Input& _event) override;
-			vec2 m_oldScreenPos;
-			void onCallbackPeriodicCheckCollision(const ewol::event::Time& _event);
 	};
 }
 

sample/Collision/lutin_ege-sample-collision.py

@@ -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',

sample/DoubleView/appl/Windows.cpp

@@ -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/Entity.hpp>
-#include <ege/elements/ElementPhysic.hpp>
+#include <ege/physics/shape/Box.hpp>
-#include <ege/physicsShape/PhysicsBox.hpp>
+#include <ege/physics/shape/Sphere.hpp>
-#include <ege/physicsShape/PhysicsSphere.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 = ememory::makeShared<ege::camera::View>();
-	m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),40*std::cos(m_anglePsy)));
 	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,100 +134,91 @@ 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::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
-		ememory::SharedPtr<ege::ElementPhysic> element = ememory::makeShared<ege::ElementPhysic>(m_env);
+		// add all component:
-		// add physic interface:
+		// 1st Position component:
-		ememory::SharedPtr<ege::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
+		etk::Transform3D transform(vec3(-20,10,0), etk::Quaternion::identity());
-		physic->setSize(vec3(3.2,3.2,3.2));
+		//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
-		myMesh->addPhysicElement(physic);
+		//entity->addComponent(componentPosition);
-		
+		// 2nd something to diplay:
-		element->setMesh(myMesh);
+		ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
-		element->createRigidBody(4000000);
+		entity->addComponent(componentRender);
-		element->setPosition(vec3(20,10,10));
+		// 3rd some physic:
-		
+		ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
-		m_env->addElement(element);
+		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::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
-		ememory::SharedPtr<ege::ElementPhysic> element = ememory::makeShared<ege::ElementPhysic>(m_env);
+		// add all component:
-		
+		// 1st Position component:
-		// add physic interface:
+		etk::Transform3D transform(vec3(20,10,0), etk::Quaternion::identity());
-		ememory::SharedPtr<ege::PhysicsSphere> physic = ememory::makeShared<ege::PhysicsSphere>();
+		//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
-		physic->setRadius(4.5f);
+		//entity->addComponent(componentPosition);
-		myMesh->addPhysicElement(physic);
+		// 2nd something to diplay:
-		
+		ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
-		
+		entity->addComponent(componentRender);
-		element->setMesh(myMesh);
+		// 3rd some physic:
-		element->createRigidBody(4000000);
+		ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
-		element->setPosition(vec3(20,-10,10));
+		ememory::SharedPtr<ege::physics::shape::Sphere> physic = ememory::makeShared<ege::physics::shape::Sphere>();
-		
+		physic->setRadius(4.01);
-		element->iaEnable();
+		physic->setMass(500000);
-		
+		componentPhysics->addShape(physic);
-		m_env->addElement(element);
+		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) {
+bool appl::Windows::onEventEntry(const ewol::event::Entry& _event) {
-	static float ploppp=1;
+	if (m_cameraControler.onEventEntry(_event) == true) {
-	if (_event.getId() == 4) {
+		return true;
-		ploppp += 0.01f;
+	}
-		m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy))*ploppp);
+	return false;
-	} else if (_event.getId() == 5) {
+}
-		ploppp -= 0.01f;
+
-		if (ploppp == 0) {
+bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
-			ploppp = 1.0f;
+	if (m_cameraControler.onEventInput(_event, relativePosition(_event.getPos())) == true) {
-		}
-		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;
 }

sample/DoubleView/appl/Windows.hpp

@@ -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);
+			// need this to forward if to the camera controler ...
-			float m_angleTetha;
+			bool onEventEntry(const ewol::event::Entry& _event) override;
-			float m_anglePsy;
+			bool onEventInput(const ewol::event::Input& _event) override;
-			vec2 m_oldScreenPos;
 	};
 }
 

sample/DoubleView/lutin_ege-sample-double-view.py

@@ -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',

sample/LowPoly/appl/Windows.cpp

@@ -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/Entity.hpp>
-#include <ege/elements/ElementPhysic.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 = ememory::makeShared<ege::camera::View>();
-	m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),80*std::cos(m_anglePsy)));
 	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:
-	if (true) {
+		etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
-		ememory::SharedPtr<ege::Element> myElement = createTree(m_env);
+		ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
-		if (myElement != nullptr) {
+		entity->addComponent(componentPosition);
-			m_env->addElement(myElement);
+		// 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::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) {
+bool appl::Windows::onEventEntry(const ewol::event::Entry& _event) {
-	static float offset = 0;
+	if (m_cameraControler.onEventEntry(_event) == true) {
-	offset += 0.01;
+		return true;
-	static float offset2 = 0;
+	}
-	offset2 += 0.003;
+	return false;
-	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) {
-
+	if (m_cameraControler.onEventInput(_event, relativePosition(_event.getPos())) == true) {
-
-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);
 	}
 	return false;
 }

sample/LowPoly/appl/Windows.hpp

@@ -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);
+		private:
-			float m_angleTetha;
+			// need this to forward if to the camera controler ...
-			float m_anglePsy;
+			bool onEventEntry(const ewol::event::Entry& _event) override;
-			vec2 m_oldScreenPos;
+			bool onEventInput(const ewol::event::Input& _event) override;
 	};
 }
 

sample/LowPoly/lutin_ege-sample-low-poly.py

@@ -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',

sample/MeshCreator/appl/Windows.cpp

@@ -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/Entity.hpp>
-#include <ege/elements/ElementPhysic.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;
-	ememory::SharedPtr<ege::resource::Mesh> myMesh = createViewBoxStar();
+	// 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::Entity> entity = ememory::makeShared<ege::Entity>(m_env);
-			//ememory::SharedPtr<ege::ElementPhysic> element = ememory::makeShared<ege::ElementPhysic>(m_env);
+			// 1st Position component:
-			element->setPosition(vec3(50,0,0));
+			etk::Transform3D transform(vec3(5,0,0), etk::Quaternion::identity());
-			element->setMesh(myMesh);
+			ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
-			m_env->addElement(element);
+			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));
 }
 
 

sample/MeshCreator/appl/Windows.hpp

@@ -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() { };

sample/RayTest/appl/Windows.cpp

@@ -24,9 +24,7 @@
 #include <ege/render/Component.hpp>
 #include <ege/physics/Component.hpp>
 
-appl::Windows::Windows() :
+appl::Windows::Windows() {
-  m_angleTetha(0),
-  m_anglePsy(0) {
 	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 = ememory::makeShared<ege::camera::View>();
-	m_camera->setEye(vec3(100*std::sin(m_angleTetha),40*std::cos(m_anglePsy),100*std::cos(m_angleTetha)));
 	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;
 }

sample/RayTest/appl/Windows.hpp

@@ -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;
 	};
 }

sample/RayTest/lutin_ege-sample-raytracing.py

@@ -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',