Hartmut/pixwerx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update on design of scenegraph

Browse source
This commit is contained in:
Hartmut Seichter 2019-01-01 21:47:35 +01:00
parent f7043fc0cb
commit 62b2302a32
18 changed files with 342 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
share/doc/pixwerx.xmind
View file

Binary file not shown.

3
src/core/include/pw/core/globals.hpp
View file

@ -4,10 +4,13 @@
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
namespace pw {
using std::shared_ptr;
using std::unique_ptr;
using std::weak_ptr;
typedef float real_t;

128
src/core/include/pw/core/matrix.hpp
View file

@ -35,7 +35,7 @@
namespace pw {
template <unsigned int R, unsigned int C, typename T>
class matrix : public matrixbase<T> {
class matrix_ : public matrixbase<T> {
T m[R*C];
@ -44,37 +44,37 @@ public:
using typename matrixbase<T>::value_type;
using typename matrixbase<T>::size_type;
matrix();
matrix_();
matrix(const matrix& mtc);
matrix_(const matrix_& mtc);
matrix& operator = (const matrix& other);
matrix_& operator = (const matrix_& other);
matrix transposed() const;
matrix_ transposed() const;
inline matrix& operator *= (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) *= b; return *this; }
inline matrix& operator /= (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) /= b; return *this; }
inline matrix& operator += (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) += b; return *this; }
inline matrix& operator -= (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) -= b; return *this; }
inline matrix_& operator *= (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) *= b; return *this; }
inline matrix_& operator /= (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) /= b; return *this; }
inline matrix_& operator += (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) += b; return *this; }
inline matrix_& operator -= (const T& b) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) -= b; return *this; }
inline matrix& operator += (const matrix& other) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) += other.at(i); return *this; }
inline matrix& operator -= (const matrix& other) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) -= other.at(i); return *this; }
inline matrix_& operator += (const matrix_& other) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) += other.at(i); return *this; }
inline matrix_& operator -= (const matrix_& other) { for (unsigned int i = this->cells(); i--> 0;) this->at(i) -= other.at(i); return *this; }
inline const matrix normalized() const {
inline const matrix_ normalized() const {
const T one_over_n = T(1) / this->norm();
return *this * one_over_n;
}
inline const matrix
inline const matrix_
get_inverse() const
{
matrix resMat;
matrix_ resMat;
for ( unsigned int r = 0; r < C; ++r) {
for ( unsigned int j = 0; j < R; ++j) {
short sgn = ( (r+j)%2) ? -1 : 1;
matrix<R-1,C-1,T> minor;
matrix_<R-1,C-1,T> minor;
this->get_minor(minor,r,j);
resMat.at(r,j) = minor.determinant() * sgn;
}
@ -86,12 +86,12 @@ public:
}
inline
matrix& invert() {
matrix_& invert() {
*this = this->get_inverse();
return *this;
}
void get_minor(matrix<R-1,C-1,T>& res, unsigned int r0, unsigned int c0) const;
void get_minor(matrix_<R-1,C-1,T>& res, unsigned int r0, unsigned int c0) const;
T determinant() const;
@ -99,29 +99,29 @@ public:
T norm() const;
matrix<R,C,T>& operator *= (const matrix<R,C,T>& rhs);
matrix_<R,C,T>& operator *= (const matrix_<R,C,T>& rhs);
matrix<R,C,T>& copy_from_data(const T* src) { for (unsigned int i = 0; i < R*C; ++i) { (*this).at(i) = src[i]; } return *this; }
matrix_<R,C,T>& copy_from_data(const T* src) { for (unsigned int i = 0; i < R*C; ++i) { (*this).at(i) = src[i]; } return *this; }
matrix<R,C,T> operator * (const matrix<R,C,T>& rhs) const {
matrix_<R,C,T> operator * (const matrix_<R,C,T>& rhs) const {
return mul(*this,rhs);
}
const matrix<C,R,T> reshape() const {
matrix<C,R,T> m;
const matrix_<C,R,T> reshape() const {
matrix_<C,R,T> m;
for (unsigned int r = 0; r < R; ++r)
for (unsigned int c = 0; c < C; ++c)
m(r,c) = (*this)(c,r);
return m;
}
const matrix<R,1,T> get_column(unsigned int col) const {
matrix<R,1,T> c; for (unsigned int r = 0; r < R; ++r) c(r,0) = (this)(r,col);
const matrix_<R,1,T> get_column(unsigned int col) const {
matrix_<R,1,T> c; for (unsigned int r = 0; r < R; ++r) c(r,0) = (this)(r,col);
return c;
}
const matrix<1,C,T> get_row(unsigned int row) const {
matrix<1,C,T> r; for (unsigned int c = 0; c < C; ++c) r(0,c) = (this)(row,c);
const matrix_<1,C,T> get_row(unsigned int row) const {
matrix_<1,C,T> r; for (unsigned int c = 0; c < C; ++c) r(0,c) = (this)(row,c);
return r;
}
@ -131,49 +131,49 @@ public:
/////////////////////////////////////////////////////////////////////////////
template <unsigned int aR, unsigned int aC, typename T>
inline matrix<aR,aC,T> operator * (const matrix<aR,aC,T>& a, const T& b)
inline matrix_<aR,aC,T> operator * (const matrix_<aR,aC,T>& a, const T& b)
{
matrix<aR,aC,T> res;
matrix_<aR,aC,T> res;
for (unsigned int i = res.cells(); i--> 0;) res.at(i) = a.at(i) * b;
return res;
}
template <unsigned int aR, unsigned int aC, typename T>
inline matrix<aR,aC,T> operator / (const matrix<aR,aC,T>& a, const T& b)
inline matrix_<aR,aC,T> operator / (const matrix_<aR,aC,T>& a, const T& b)
{
matrix<aR,aC,T> res; T oneOverB(1./b);
matrix_<aR,aC,T> res; T oneOverB(1./b);
for (unsigned int i = res.cells(); i--> 0;) res.at(i) = a.at(i) * oneOverB;
return res;
}
template <unsigned int aR, unsigned int aC, typename T>
inline matrix<aR,aC,T> operator + (const matrix<aR,aC,T>& a, const T& b)
inline matrix_<aR,aC,T> operator + (const matrix_<aR,aC,T>& a, const T& b)
{
matrix<aR,aC,T> res;
matrix_<aR,aC,T> res;
for (unsigned int i = res.cells(); i--> 0;) res.at(i) = a.at(i) + b;
return res;
}
template <unsigned int aR, unsigned int aC, typename T>
inline matrix<aR,aC,T> operator - (const matrix<aR,aC,T>& a, const T& b)
inline matrix_<aR,aC,T> operator - (const matrix_<aR,aC,T>& a, const T& b)
{
matrix<aR,aC,T> res;
matrix_<aR,aC,T> res;
for (unsigned int i = res.cells(); i--> 0;) res.at(i) = a.at(i) - b;
return res;
}
template <unsigned int R, unsigned int C, typename T>
inline matrix<R,C,T> operator + (const matrix<R,C,T>& a, const matrix<R,C,T>& b)
inline matrix_<R,C,T> operator + (const matrix_<R,C,T>& a, const matrix_<R,C,T>& b)
{
matrix<R,C,T> res;
matrix_<R,C,T> res;
for (unsigned int i = res.cells(); i--> 0;) res.at(i) = a.at(i) + b.at(i);
return res;
}
template <unsigned int R, unsigned int C, typename T>
inline matrix<R,C,T> operator - (const matrix<R,C,T>& a, const matrix<R,C,T>& b)
inline matrix_<R,C,T> operator - (const matrix_<R,C,T>& a, const matrix_<R,C,T>& b)
{
matrix<R,C,T> res;
matrix_<R,C,T> res;
for (unsigned int i = res.cells(); i--> 0;) res.at(i) = a.at(i) - b.at(i);
return res;
}
@ -181,12 +181,12 @@ inline matrix<R,C,T> operator - (const matrix<R,C,T>& a, const matrix<R,C,T>& b)
/////////////////////////////////////////////////////////////////////////////
template <unsigned int aR,unsigned int aCbR, unsigned int bC, typename T>
matrix<aR,bC,T> static inline
mul(const matrix<aR,aCbR,T>& A, const matrix<aCbR,bC,T>& B)
matrix_<aR,bC,T> static inline
mul(const matrix_<aR,aCbR,T>& A, const matrix_<aCbR,bC,T>& B)
{
// aC == bR
// set all null
matrix<aR,bC,T> res;
matrix_<aR,bC,T> res;
res.fill(0);
// compute all resulting cells
@ -206,7 +206,7 @@ mul(const matrix<aR,aCbR,T>& A, const matrix<aCbR,bC,T>& B)
/////////////////////////////////////////////////////////////////////////////
template <unsigned int R, unsigned int C,typename T>
matrix<R,C,T>& matrix<R,C,T>::operator *= (const matrix& rhs)
matrix_<R,C,T>& matrix_<R,C,T>::operator *= (const matrix_& rhs)
{
*this = mul(*this,rhs);
return *this;
@ -215,20 +215,20 @@ matrix<R,C,T>& matrix<R,C,T>::operator *= (const matrix& rhs)
/////////////////////////////////////////////////////////////////////////////
template <unsigned int R, unsigned int C,typename T>
matrix<R,C,T>::matrix()
matrix_<R,C,T>::matrix_()
: matrixbase<T>(R,C,&m[0],true)
{
}
template <unsigned int R, unsigned int C,typename T>
matrix<R,C,T>::matrix(const matrix &mtc) :
matrix_<R,C,T>::matrix_(const matrix_ &mtc) :
matrixbase<T>(R,C,&m[0],true)
{
*this = mtc;
}
template <unsigned int R, unsigned int C,typename T>
matrix<R,C,T> &matrix<R,C,T>::operator = (const matrix<R,C,T> &other)
matrix_<R,C,T> &matrix_<R,C,T>::operator = (const matrix_<R,C,T> &other)
{
if (this != &other)
for (unsigned int r = 0; r < R;++r)
@ -238,9 +238,9 @@ matrix<R,C,T> &matrix<R,C,T>::operator = (const matrix<R,C,T> &other)
}
template <unsigned int R, unsigned int C,typename T>
matrix<R,C,T> matrix<R,C,T>::transposed() const
matrix_<R,C,T> matrix_<R,C,T>::transposed() const
{
matrix<C,R,T> res;
matrix_<C,R,T> res;
for (unsigned int r = this->rows();r-->0;)
for (unsigned int c = this->cols();c-->0;)
res.at(c,r) = this->at(r,c);
@ -248,7 +248,7 @@ matrix<R,C,T> matrix<R,C,T>::transposed() const
}
template <unsigned int R, unsigned int C,typename T>
void matrix<R,C,T>::get_minor(matrix<R-1,C-1,T>& res,unsigned int r0, unsigned int c0) const
void matrix_<R,C,T>::get_minor(matrix_<R-1,C-1,T>& res,unsigned int r0, unsigned int c0) const
{
unsigned int r = 0;
for (unsigned int ri = 0; ri < R; ri++)
@ -266,11 +266,11 @@ void matrix<R,C,T>::get_minor(matrix<R-1,C-1,T>& res,unsigned int r0, unsigned i
}
template <unsigned int R, unsigned int C,typename T> inline
T matrix<R,C,T>::determinant() const
T matrix_<R,C,T>::determinant() const
{
T res(0);
matrix<R-1,C-1,T> minor;
matrix_<R-1,C-1,T> minor;
// using Laplace Expansion at compile time
for (unsigned int c = 0; c < C; c++) {
@ -282,7 +282,7 @@ T matrix<R,C,T>::determinant() const
}
template <unsigned int R, unsigned int C,typename T> inline
T matrix<R,C,T>::squared_norm() const
T matrix_<R,C,T>::squared_norm() const
{
T res(0);
@ -294,7 +294,7 @@ T matrix<R,C,T>::squared_norm() const
template <unsigned int R, unsigned int C,typename T> inline
T matrix<R,C,T>::norm() const
T matrix_<R,C,T>::norm() const
{
using std::sqrt;
@ -302,7 +302,7 @@ T matrix<R,C,T>::norm() const
}
template <unsigned int R, unsigned int C,typename T> inline
void matrix<R,C,T>::normalize()
void matrix_<R,C,T>::normalize()
{
T n = norm();
if (n > 0) {
@ -319,19 +319,19 @@ void matrix<R,C,T>::normalize()
// 4x4
template <typename T>
class matrix44 : public matrix<4,4,T>
class matrix44 : public matrix_<4,4,T>
{
public:
using matrix<4,4,T>::matrix;
using matrix_<4,4,T>::matrix_;
matrix44(const matrix<4,4,T>& i)
matrix44(const matrix_<4,4,T>& i)
{
*this = i;
}
matrix44& operator = (const matrix<4,4,T>& rhs) {
matrix44& operator = (const matrix_<4,4,T>& rhs) {
if (this != &rhs){
this->at(0,0) = rhs.at(0,0);this->at(0,1) = rhs.at(0,1);this->at(0,2) = rhs.at(0,2);this->at(0,3) = rhs.at(0,3);
this->at(1,0) = rhs.at(1,0);this->at(1,1) = rhs.at(1,1);this->at(1,2) = rhs.at(1,2);this->at(1,3) = rhs.at(1,3);
@ -343,9 +343,9 @@ public:
}
inline static
matrix<4,4,T> projection_from_frustum(T Left,T Right,T Bottom,T Top,T zNear,T zFar)
matrix_<4,4,T> projection_from_frustum(T Left,T Right,T Bottom,T Top,T zNear,T zFar)
{
matrix<4,4,T> frustum;
matrix_<4,4,T> frustum;
frustum.fill(0);
@ -363,12 +363,12 @@ public:
}
inline static
matrix<4,4,T> orthogonal_projection(T Left, T Right,
matrix_<4,4,T> orthogonal_projection(T Left, T Right,
T Bottom,T Top,
T Near, T Far)
{
matrix<4,4,T> ortho;
matrix_<4,4,T> ortho;
ortho.fill(0);
ortho(0,0) = 2 / (Right-Left);
@ -386,7 +386,7 @@ public:
inline static
matrix<4,4,T> perspective_projection(T fovY, T aspectRatio, T zNear, T zFar)
matrix_<4,4,T> perspective_projection(T fovY, T aspectRatio, T zNear, T zFar)
{
const T height = zNear * tan(fovY/T(360) * pi<T>()); // half height of near plane
const T width = height * aspectRatio; // half width of near plane
@ -496,13 +496,13 @@ public:
//
template <> inline
float matrix<1,1,float>::determinant() const
float matrix_<1,1,float>::determinant() const
{
return this->at(0);
}
template <> inline
double matrix<1,1,double>::determinant() const
double matrix_<1,1,double>::determinant() const
{
return this->at(0);
}

10
src/core/include/pw/core/quaternion.hpp
View file

@ -126,10 +126,10 @@ public:
inline void normalize() { *this = this->normalized(); }
//! conversion from a matrix
inline static const quaternion from_matrix(const matrix<4,4,T> &m);
inline static const quaternion from_matrix(const matrix_<4,4,T> &m);
//! conversion to a matrix
const matrix<4,4,T> to_matrix() const;
const matrix_<4,4,T> to_matrix() const;
//! return identiy quaternion
static const quaternion<T> identity();
@ -173,7 +173,7 @@ const T quaternion<T>::_sqrt90 = std::sqrt(0.5);
template <typename T>
const quaternion<T> quaternion<T>::from_matrix(const matrix<4,4,T> &m) {
const quaternion<T> quaternion<T>::from_matrix(const matrix_<4,4,T> &m) {
using std::sqrt;
@ -188,9 +188,9 @@ const quaternion<T> quaternion<T>::from_matrix(const matrix<4,4,T> &m) {
}
template <typename T>
const matrix<4,4,T> quaternion<T>::to_matrix() const {
const matrix_<4,4,T> quaternion<T>::to_matrix() const {
matrix<4,4,T> m; m.set_identity();
matrix_<4,4,T> m; m.set_identity();
T xx = x() * x();
T xy = x() * y();

12
src/core/include/pw/core/vector.hpp
View file

@ -31,17 +31,17 @@
namespace pw {
template <unsigned int components,typename T>
class vector : public matrix<components,1,T> {
class vector : public matrix_<components,1,T> {
public:
using typename matrix<components,1,T>::value_type;
using matrix<components,1,T>::operator = ;
using typename matrix_<components,1,T>::value_type;
using matrix_<components,1,T>::operator = ;
vector() : matrix<components,1,T>() {}
vector() : matrix_<components,1,T>() {}
vector(const vector& other) : matrix<components,1,T>(other) {}
vector(const vector& other) : matrix_<components,1,T>(other) {}
vector(const matrix<components,1,T>& other) : matrix<components,1,T>(other) {}
vector(const matrix_<components,1,T>& other) : matrix_<components,1,T>(other) {}
T& operator()(unsigned int c) { return matrixbase<T>::at(c); }
const T& operator()(unsigned int c) const { return matrixbase<T>::at(c); }

4
src/scene/CMakeLists.txt
View file

@ -4,6 +4,8 @@ set(hdrs
include/pw/scene/component.hpp
include/pw/scene/node.hpp
include/pw/scene/nodepath.hpp
include/pw/scene/mesh.hpp
include/pw/scene/scene.hpp
include/pw/scene/transform.hpp
include/pw/scene/traverser.hpp
)
@ -13,6 +15,8 @@ set(srcs
src/nodepath.cpp
src/camera.cpp
src/component.cpp
src/mesh.cpp
src/scene.cpp
src/transform.cpp
src/traverser.cpp
)

34
src/scene/include/pw/scene/camera.hpp
View file

@ -1,3 +1,27 @@
/*
* Copyright (C) 1999-2017 Hartmut Seichter
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef PW_SCENE_CAMERA_HPP
#define PW_SCENE_CAMERA_HPP
@ -28,13 +52,15 @@ public:
void set_projection(const matrix44d &projection);
const matrix44d& projection() const;
// void set_field_of_view(float)
protected:
double _fov;
double _near_plane;
double _far_plane;
real_t _fov;
real_t _near_plane;
real_t _far_plane;
double _ortho_size = 2;
real_t _ortho_size = 2;
private:

24
src/scene/include/pw/scene/component.hpp
View file

@ -1,3 +1,27 @@
/*
* Copyright (C) 1999-2017 Hartmut Seichter
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef PW_SCENE_COMPONENT_HPP
#define PW_SCENE_COMPONENT_HPP

45
src/scene/include/pw/scene/mesh.hpp Normal file
View file

@ -0,0 +1,45 @@
#ifndef PW_SCENE_MESH_HPP
#define PW_SCENE_MESH_HPP
#include <pw/core/matrix.hpp>
#include <pw/scene/component.hpp>
namespace pw {
class mesh : public component {
public:
using component::component;
typedef std::vector<int32_t> index_t;
typedef std::vector<float> vertex_t;
enum topology_type {
triangles,
triangle_strip,
triangle_fan,
quads,
lines,
line_strip,
points
};
protected:
// index data
// vertex d ata
// normal data
// color data
// uv data
// tangents data
// boundary
};
}
#endif

37
src/scene/include/pw/scene/node.hpp
View file

@ -28,20 +28,24 @@
#include <pw/core/globals.hpp>
#include <pw/scene/component.hpp>
#include <string>
#include <vector>
namespace pw {
/**
* @brief nodes represent the structure for the scene graph
*
* Unlike earlier designs the scenegraph here is not a DAG
* but uses multiple references to components like Unity. This makes the
* design of the scenegraph and traversal much more straight-forward.
*/
class node {
public:
typedef shared_ptr<node> ref;
typedef std::vector<ref> ref_array;
typedef std::vector<node*> ptr_array;
typedef std::vector<ref> ref_array;
typedef node *ptr;
typedef std::vector<ptr> ptr_array;
friend class component;
@ -60,12 +64,15 @@ public:
std::string name() const; //!< get name
void set_name(const std::string &name); //!< set name
//! return list of parents
inline const ptr_array& parents() const { return _parents; }
//! return parent of this node
inline ptr parent() const { return _path.back(); }
//! add a child node
ref add_child(ref anode);
//! remove a child
void remove_child(ref child_node);
//! get the list of children
inline const ref_array& children() const { return _children; }
@ -76,7 +83,7 @@ public:
inline bool is_leaf() const { return children().empty(); }
//! check if this is the root node
inline bool is_root() const { return parents().empty(); }
inline bool is_root() const { return _path.empty(); }
//! list of components
const component::array& components() const;
@ -87,20 +94,20 @@ public:
//! remove a node component
void remove_component(component::ref c);
//! paths to root
const ptr_array& path() const;
protected:
ref_array _children;
ptr_array _parents;
ref_array _children; //!< list of children
ptr_array _path; //!< path to root
component::array _components;
component::array _components; //<! components
std::string _name;
private:
//! add a node as parent node
void add_parent(node *anode);
// change mask
// layer mask
};
}

50
src/scene/include/pw/scene/scene.hpp Normal file
View file

@ -0,0 +1,50 @@
/*
* Copyright (C) 1999-2017 Hartmut Seichter
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef PW_SCENE_SCENE_HPP
#define PW_SCENE_SCENE_HPP
#include <pw/core/globals.hpp>
#include <pw/scene/node.hpp>
namespace pw {
class scene {
public:
//! set root node
void set_root(node::ref root);
// request the root node
inline node::ref root() const { return _root; }
protected:
node::ref _root; //!< root node
};
}
#endif

4
src/scene/include/pw/scene/transform.hpp
View file

@ -18,6 +18,10 @@ public:
void update();
inline void translate(const real_t &x, const real_t &y, const real_t &z) {
_local.at(0,3) += x;_local.at(1,3) += y;_local.at(2,3) += z;
}
protected:
matrix44d _local;

9
src/scene/src/mesh.cpp Normal file
View file

@ -0,0 +1,9 @@
#include "pw/scene/mesh.hpp"
namespace pw {
}

52
src/scene/src/node.cpp
View file

@ -9,7 +9,6 @@ node::node(const std::string &name)
node::node(const node &node)
: _children(node.children())
, _parents(node._parents)
, _name(node._name)
{
}
@ -31,43 +30,33 @@ void node::set_name(const std::string &name)
node::ref node::add_child(ref anode)
{
anode->add_parent(this);
// remove old nodepath
anode->_path.clear();
// take parent nodepath ...
if (!this->is_root()) anode->_path = this->_path;
// add itself
anode->_path.push_back(this);
// add as child
_children.push_back(anode);
// return
return anode;
}
void node::add_parent(node *anode)
void node::remove_child(ref child_node)
{
_parents.push_back(anode);
node::ref_array::iterator it = _children.end();
while ((it = std::find(_children.begin(),_children.end(),child_node)) != _children.end()) {
_children.erase(it);
}
}
//void node::visit(visitor& visitor)
//{
// visitor.enter(this);
// if (visitor.direction == node::visitor::direction::up)
// this->ascend(visitor);
// else {
// this->descend(visitor);
// }
// visitor.leave(this);
//}
//void node::ascend(visitor& visitor)
//{
// for (auto p : this->parents()) p->visit(visitor);
//}
//void node::descend(visitor& visitor)
//{
// for (auto c : this->children()) c->visit(visitor);
//}
node::~node()
{
_children.clear();
_parents.clear();
}
//
@ -82,11 +71,16 @@ void node::remove_component(component::ref c)
{
component::array::iterator it = _components.end();
while ((it = std::find(_components.begin(),_components.end(),std::shared_ptr<component>(c))) != _components.end()) {
while ((it = std::find(_components.begin(),_components.end(),c)) != _components.end()) {
_components.erase(it);
}
}
const node::ptr_array &node::path() const
{
return _path;
}
const component::array& node::components() const
{
return _components;

11
src/scene/src/scene.cpp Normal file
View file

@ -0,0 +1,11 @@
#include "pw/scene/scene.hpp"
namespace pw {
void scene::set_root(node::ref root)
{
this->_root = root;
}
}

14
src/scene/src/traverser.cpp
View file

@ -5,11 +5,8 @@
#include <iostream>
#include <queue>
namespace pw {
traverser t = traverser();
void traverser::visit(node *node)
@ -18,7 +15,7 @@ void traverser::visit(node *node)
on_enter(node);
// visit
if (direction::up == _direction)
for (auto p : node->parents()) this->visit(p);
this->visit(node->parent());
else
for (auto c : node->children()) this->visit(c.get());
@ -35,16 +32,17 @@ void traverser::bfs(node::ref root)
while (!q.empty())
{
// get the top
node::ref n = q.top();
std::cout << "d:" << q.size() << " l:" << n->is_leaf() << " n:" << n->name();
// visit n
// remove from stack
q.pop();
// std::cout << "d:" << q.size() << " l:" << n->is_leaf() << " n:" << n->name();
// add all children
for(auto c : n->children()) q.push(c);
std::cout << std::endl;
// std::cout << std::endl;
}
}

15
src/scene/tests/pwscene_test_node.cpp
View file

@ -6,6 +6,19 @@
#include <iostream>
void print_node_path(pw::node::ref node) {
auto parents = node->path();
std::cout << node->name() << " - ";
for (auto p : node->path()) {
std::cout << " p:'" << p->name() << "'";
}
std::cout << std::endl;
}
int main(int argc,char **argv) {
using namespace pw;
@ -33,7 +46,7 @@ int main(int argc,char **argv) {
std::cout << "n components: " << n->components().size() << std::endl;
print_node_path((n));
return 0;

26
src/scene/tests/pwscene_test_traverser.cpp
View file

@ -23,6 +23,20 @@
#include <iostream>
void print_node_path(pw::node::ref node) {
auto parents = node->path();
std::cout << node->name() << " - ";
for (auto p : node->path()) {
std::cout << " p:'" << p->name() << "'";
}
std::cout << std::endl;
}
int main(int argc,char **argv) {
using namespace pw;
@ -32,15 +46,19 @@ int main(int argc,char **argv) {
node::ref sub_2_1 = std::make_shared<node>("sub-2-1");
root->add_child(std::make_shared<node>("sub-2"))->add_child(std::make_shared<node>("sub-2-1"));
root->add_child(std::make_shared<node>("sub-3"))->add_child(sub_2_1);
root->add_child(std::make_shared<node>("sub-2"))->add_child(std::make_shared<node>("sub-2-2"));
std::cout << "sub-2-1 parent count: " << sub_2_1->parents().size() << std::endl;
// std::cout << "sub-2-1 parent count: " << sub_2_1->parents().size() << std::endl;
traverser tv;
// traverser tv;
// tv.bfs(root);
// print_node_path(sub_2_1);
// print_node_path(root->children()[2]->children().front());
tv.bfs(root);
return 0;
}