tools::sg::base_camera Class Reference

Inheritance diagram for tools::sg::base_camera:

Collaboration diagram for tools::sg::base_camera:

Public Member Functions
virtual const desc_fields &	node_desc_fields () const
virtual float	near_height () const =0
virtual void	zoom (float)=0
virtual camera_type	type () const =0
virtual void	get_lrbt (unsigned int, unsigned int, float &, float &, float &, float &)=0
virtual void	render (render_action &a_action)
virtual void	pick (pick_action &a_action)
virtual void	event (event_action &a_action)
virtual void	get_matrix (get_matrix_action &a_action)
virtual void	is_visible (visible_action &a_action)
virtual	~base_camera ()
void	direction (vec3f &a_dir) const
void	rotate_around_direction (float a_delta)
void	rotate_around_z (float a_delta)
void	rotate_around_up (float a_delta)
void	rotate_around_x (float a_delta)
void	rotate_around_x_at_focal (float a_delta)
void	rotate_around_y_at_focal (float a_delta)
void	rotate_around_z_at_focal (float a_delta)
void	rotate_to_dir (const vec3f &a_dir)
void	pane_to (float a_x, float a_y, float a_z)
void	translate_along_side (float a_delta)
void	translate_along_up (float a_delta)
void	translate_along_dir (float a_delta)
bool	look_at (const vec3f &a_dir, const vec3f &a_up)
void	dump (std::ostream &a_out)
bool	is_type_ortho () const
bool	height_at_focal (float &a_h) const
void	astro_orientation (float a_ra, float a_dec)
bool	update_motion (int a_move)
Public Member Functions inherited from tools::sg::node
virtual void *	cast (const std::string &a_class) const
virtual const std::string &	s_cls () const =0
virtual node *	copy () const =0
virtual unsigned int	cls_version () const
virtual void	bbox (bbox_action &)
virtual void	search (search_action &a_action)
virtual bool	write (write_action &a_action)
virtual bool	read (read_action &a_action)
virtual void	protocol_one_fields (std::vector< field * > &a_fields) const
virtual bool	draw_in_frame_buffer () const
virtual bool	touched ()
virtual void	reset_touched ()
	node ()
virtual	~node ()
void	touch ()
field &	field_from_desc (const field_desc &a_desc) const
void	dump_field_descs (std::ostream &a_out) const
field *	find_field_by_name (const std::string &a_name) const

Public Attributes
sf< float >	znear
sf< float >	zfar
sf_vec3f	position
sf_rotf	orientation
sf< float >	dx
sf< float >	da
sf< float >	ds
sf< float >	focal

Protected Member Functions
	base_camera ()
	base_camera (const base_camera &a_from)
base_camera &	operator= (const base_camera &a_from)
bool	operator== (const base_camera &a_from) const
void	update_sg (std::ostream &a_out)
void	_mult_matrix (matrix_action &a_action)
void	set_state (matrix_action &a_action)
Protected Member Functions inherited from tools::sg::node
	node (const node &)
node &	operator= (const node &)
void	add_field (field *a_field)
bool	write_fields (write_action &a_action)
bool	read_fields (read_action &a_action)
field_desc::offset_t	field_offset (const field *a_field) const
field *	find_field (const field_desc &a_rdesc) const
void	check_fields (std::ostream &a_out) const

Static Protected Member Functions
static const vec4< float > &	id_orientation ()

Protected Attributes
sf_vec4f	m_lrbt
mat4f	m_proj
float	m_tmp [16]

Detailed Description

Definition at line 24 of file base_camera.

Constructor & Destructor Documentation

base_camera() [1/2]

tools::sg::base_camera::base_camera ( )

inlineprotected

Definition at line 100 of file base_camera.

  :parent()
  ,znear(1)
  ,zfar(10)
  ,position(vec3f(0,0,1))
  ,orientation(rotf(vec3f(0,0,1),0)) //quat = vec4f(0,0,0,1)
  ,dx(0.01f)
  ,da(0.017f) //one degree.
  ,ds(0.99f)
  ,focal(1)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    add_fields();
  }

~base_camera()

virtual tools::sg::base_camera::~base_camera ( )

inlinevirtual

Definition at line 117 of file base_camera.

                        {
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }

base_camera() [2/2]

tools::sg::base_camera::base_camera ( const base_camera &  a_from )

inlineprotected

Definition at line 123 of file base_camera.

  :parent(a_from)
  ,znear(a_from.znear)
  ,zfar(a_from.zfar)
  ,position(a_from.position)
  ,orientation(a_from.orientation)
  ,dx(a_from.dx)
  ,da(a_from.da)
  ,ds(a_from.ds)
  ,focal(a_from.focal)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    add_fields();
  }

Member Function Documentation

_mult_matrix()

void tools::sg::base_camera::_mult_matrix ( matrix_action &  a_action )

inlineprotected

Definition at line 507 of file base_camera.

                                             {
    float l,r,b,t;
    get_lrbt(a_action.ww(),a_action.wh(),l,r,b,t);
    m_lrbt.set_value(l,r,b,t);
 
    if(touched()||m_lrbt.touched()) {
      update_sg(a_action.out());
      reset_touched();
      m_lrbt.reset_touched();
    }
 
    a_action.projection_matrix().mul_mtx(m_proj,m_tmp);
  }

astro_orientation()

void tools::sg::base_camera::astro_orientation ( float  a_ra, float  a_dec  )

inline

Definition at line 351 of file base_camera.

                                                  {
    // a_ra, a_dec are in decimal degrees.
 
    // Camera default point toward -z with up along +y and +x at right.
 
    // Arrange so that camera points toward x with up along +z :
    rotf r(vec3f::s_y(),-fhalf_pi());
    r *= rotf(vec3f::s_x(),fhalf_pi());
    // Now -y is at right.
 
    // Then rotate it so that it points toward given (ra,dec) by keeping up upward +z direction.
    r *= rotf(vec3f::s_y(),-a_dec*fdeg2rad());
    r *= rotf(vec3f::s_z(),a_ra*fdeg2rad());
    orientation = r;
 
/*
    position = a_center*0.99f;
    znear = 0.1f;
    zfar = 200.0f;
    focal = (a_center-position).length();
*/
/*
    position = vec3f(0,0,0);
    znear = 1.0f;
    zfar = 2000.0f; //2*sky_radius.
    focal = a_center.length();
    da = 0.017f/100; //1/100 of a degree
*/
  }

direction()

void tools::sg::base_camera::direction ( vec3f &  a_dir ) const

inline

Definition at line 165 of file base_camera.

                                     {
    orientation.value().mul_vec(vec3f(0,0,-1),a_dir);
  }

dump()

void tools::sg::base_camera::dump ( std::ostream &  a_out )

inline

Definition at line 331 of file base_camera.

                               {
    a_out << " znear " << znear.value() << std::endl;
    a_out << " zfar " << zfar.value() << std::endl;
    vec3f& pos = position.value();
    a_out << " pos " << pos[0] << " " << pos[1] << " " << pos[2] << std::endl;
    //FIXME : dump orientation.
  }

event()

virtual void tools::sg::base_camera::event ( event_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 87 of file base_camera.

                                            {
    _mult_matrix(a_action);
    set_state(a_action);
  }

get_lrbt()

virtual void tools::sg::base_camera::get_lrbt ( unsigned int  , unsigned int  , float &  , float &  , float &  , float &    )

pure virtual

Implemented in tools::sg::perspective, and tools::sg::ortho.

get_matrix()

virtual void tools::sg::base_camera::get_matrix ( get_matrix_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 91 of file base_camera.

                                                      {
    _mult_matrix(a_action);
    set_state(a_action);
  }

height_at_focal()

bool tools::sg::base_camera::height_at_focal ( float &  a_h ) const

inline

Definition at line 341 of file base_camera.

                                         {
    if(is_type_ortho()) {
      a_h = near_height();
    } else {
      if(!znear.value()) {a_h = near_height();return false;}
      a_h = focal.value()*near_height()/znear.value();
    }
    return true;
  }

id_orientation()

static const vec4<float>& tools::sg::base_camera::id_orientation ( )

inlinestaticprotected

Definition at line 536 of file base_camera.

{static const vec4<float> s_v(0,0,0,1);return s_v;}

is_type_ortho()

bool tools::sg::base_camera::is_type_ortho ( ) const

inline

Definition at line 339 of file base_camera.

{return type()==camera_ortho?true:false;}

is_visible()

virtual void tools::sg::base_camera::is_visible ( visible_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 95 of file base_camera.

                                                   {
    _mult_matrix(a_action);
    set_state(a_action);
  }

look_at()

bool tools::sg::base_camera::look_at ( const vec3f &  a_dir, const vec3f &  a_up  )

inline

Definition at line 298 of file base_camera.

                                                     {
    vec3f z = -a_dir;
    vec3f y = a_up;
    vec3f x;y.cross(z,x);
 
    // recompute y to create a valid coordinate system
    z.cross(x,y);
 
    // normalize x and y to create an orthonormal coord system
    if(!x.normalize()) return false;
    if(!y.normalize()) return false;
    if(!z.normalize()) return false;
 
    // create a rotation matrix
    mat4f rot;
    rot.set_identity();
    rot.set_value(0,0,x[0]);
    rot.set_value(1,0,x[1]);
    rot.set_value(2,0,x[2]);
 
    rot.set_value(0,1,y[0]);
    rot.set_value(1,1,y[1]);
    rot.set_value(2,1,y[2]);
 
    rot.set_value(0,2,z[0]);
    rot.set_value(1,2,z[1]);
    rot.set_value(2,2,z[2]);
 
    orientation.value().set_value(rot);
    return true;
  }

near_height()

virtual float tools::sg::base_camera::near_height ( ) const

pure virtual

Implemented in tools::sg::perspective, and tools::sg::ortho.

node_desc_fields()

virtual const desc_fields& tools::sg::base_camera::node_desc_fields ( ) const

inlinevirtual

Reimplemented from tools::sg::node.

Reimplemented in tools::sg::perspective, and tools::sg::ortho.

Definition at line 41 of file base_camera.

                                                      {
    TOOLS_FIELD_DESC_NODE_CLASS(tools::sg::base_camera)
    static const desc_fields s_v(parent::node_desc_fields(),8, //WARNING : take care of count.
      TOOLS_ARG_FIELD_DESC(znear),
      TOOLS_ARG_FIELD_DESC(zfar),
      TOOLS_ARG_FIELD_DESC(position),
      TOOLS_ARG_FIELD_DESC(orientation),
      TOOLS_ARG_FIELD_DESC(dx),
      TOOLS_ARG_FIELD_DESC(da),
      TOOLS_ARG_FIELD_DESC(ds),
      TOOLS_ARG_FIELD_DESC(focal)
    );
    return s_v;
  }

operator=()

base_camera& tools::sg::base_camera::operator= ( const base_camera &  a_from )

inlineprotected

Definition at line 139 of file base_camera.

                                                   {
    parent::operator=(a_from);
    znear = a_from.znear;
    zfar = a_from.zfar;
    position = a_from.position;
    orientation = a_from.orientation;
    dx = a_from.dx;
    da = a_from.da;
    ds = a_from.ds;
    focal = a_from.focal;
    m_lrbt.set_value(0,0,0,0);
    return *this;
  }

operator==()

bool tools::sg::base_camera::operator== ( const base_camera &  a_from ) const

inlineprotected

Definition at line 153 of file base_camera.

                                                  {
    if(znear!=a_from.znear) return false;
    if(zfar!=a_from.zfar) return false;
    if(position!=a_from.position) return false;
    if(orientation!=a_from.orientation) return false;
    //we do not test dx,da,ds.
    return true;
  }

pane_to()

void tools::sg::base_camera::pane_to ( float  a_x, float  a_y, float  a_z  )

inline

Definition at line 258 of file base_camera.

                                             {
    //translate in view plane so that (a_x,a_y,a_z) is on direction.
 
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f up;
    orientation.value().mul_vec(vec3f(0,1,0),up);
    vec3f side;dir.cross(up,side);
 
    vec3f d(a_x,a_y,a_z);
    d.subtract(position.value());
 
    vec3f pos = position.value() + side * (side.dot(d)) + up * (up.dot(d));
    position.value(pos);
  }

pick()

virtual void tools::sg::base_camera::pick ( pick_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 83 of file base_camera.

                                           {
    _mult_matrix(a_action);
    set_state(a_action);
  }

render()

virtual void tools::sg::base_camera::render ( render_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 74 of file base_camera.

                                               {
    _mult_matrix(a_action);
    set_state(a_action);
 //{mat4f& _mtx = a_action.projection_matrix();
 // a_action.out() << "debug : tools::sg::base_camera::render : proj :" << std::endl;
 // a_action.out() << _mtx << std::endl;}
    a_action.load_proj_matrix(a_action.projection_matrix());
    a_action.load_model_matrix(a_action.model_matrix());
  }

rotate_around_direction()

void tools::sg::base_camera::rotate_around_direction ( float  a_delta )

inline

Definition at line 169 of file base_camera.

                                              {
  //vec3f dir;
  //orientation.value().mul_vec(vec3f(0,0,-1),dir);
  //orientation.value(rotf(dir,a_delta) * orientation.value());
    orientation.value(rotf(vec3f(0,0,-1),a_delta) * orientation.value());
  }

rotate_around_up()

void tools::sg::base_camera::rotate_around_up ( float  a_delta )

inline

Definition at line 183 of file base_camera.

                                      {
    vec3f up;
    orientation.value().mul_vec(vec3f(0,1,0),up);
  //orientation.value(rotf(up,a_delta) * orientation.value());
    // must be the below so that rot-cam works for exlib/cbk/[astro,cfitsio] astro setup.
    // (astro setup change camera orientation).
    orientation.value(orientation.value() * rotf(up,a_delta));
  }

rotate_around_x()

void tools::sg::base_camera::rotate_around_x ( float  a_delta )

inline

Definition at line 192 of file base_camera.

                                     {
    orientation.value(rotf(vec3f(1,0,0),a_delta) * orientation.value());
  }

rotate_around_x_at_focal()

void tools::sg::base_camera::rotate_around_x_at_focal ( float  a_delta )

inline

Definition at line 196 of file base_camera.

                                              {
    //from coin SoGuiExaminerViewerP::rotXWheelMotion.
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f focalpoint = position.value() + focal * dir;
    orientation.value(rotf(vec3f(1,0,0),a_delta) * orientation.value());
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    position = focalpoint - focal * dir;
  }

rotate_around_y_at_focal()

void tools::sg::base_camera::rotate_around_y_at_focal ( float  a_delta )

inline

Definition at line 206 of file base_camera.

                                              {
    //from coin SoGuiExaminerViewerP::rotYWheelMotion.
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f focalpoint = position.value() + focal * dir;
    orientation.value(rotf(vec3f(0,1,0),a_delta) * orientation.value());
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    position = focalpoint - focal * dir;
  }

rotate_around_z()

void tools::sg::base_camera::rotate_around_z ( float  a_delta )

inline

Definition at line 176 of file base_camera.

                                      {
  //vec3f z;
  //orientation.value().mul_vec(vec3f(0,0,1),z);
  //orientation.value(rotf(z,a_delta) * orientation.value());
    orientation.value(rotf(vec3f(0,0,1),a_delta) * orientation.value());
  }

rotate_around_z_at_focal()

void tools::sg::base_camera::rotate_around_z_at_focal ( float  a_delta )

inline

Definition at line 216 of file base_camera.

                                              {
    //from coin SoGuiExaminerViewerP::rotYWheelMotion.
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f focalpoint = position.value() + focal * dir;
    orientation.value(rotf(vec3f(0,0,1),a_delta) * orientation.value());
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    position = focalpoint - focal * dir;
  }

rotate_to_dir()

void tools::sg::base_camera::rotate_to_dir ( const vec3f &  a_dir )

inline

Definition at line 226 of file base_camera.

                                         {
    //rotate around up so that a_dir is in (dir,up) plane
 
    //NOTE : it is the invert of orientation which is used
    //       in projection matrix.
 
   {vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f up;
    orientation.value().mul_vec(vec3f(0,1,0),up);
    vec3f side;dir.cross(up,side);
    vec3f v = side * (side.dot(a_dir)) + dir * (dir.dot(a_dir));
    if(v.normalize()) orientation.value(orientation.value()*rotf(dir,v));}
 
    //rotate around dir^up so that a_dir matches dir.
   {vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    orientation.value(orientation.value()*rotf(dir,a_dir));}
 
/*
    //check that dir is on a_dir :
   {vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    float cos_angle; //it should be 1
    if(!dir.cos_angle(a_dir,cos_angle)) {
      ::printf("debug : can't get angle\n");
      return;
    }
    ::printf("debug : cos_angle %g\n",cos_angle);}
*/
  }

set_state()

void tools::sg::base_camera::set_state ( matrix_action &  a_action )

inlineprotected

Definition at line 521 of file base_camera.

                                          {
    state& _state = a_action.state();
    _state.m_camera_ortho = is_type_ortho();
    _state.m_camera_znear = znear;
    _state.m_camera_zfar = zfar;
    _state.m_camera_position = position.value();
    _state.m_camera_orientation = orientation.value();
    //_state.m_camera_near_height = near_height();
    _state.m_camera_lrbt = m_lrbt.value();
    _state.m_proj = a_action.projection_matrix();
  }

translate_along_dir()

void tools::sg::base_camera::translate_along_dir ( float  a_delta )

inline

Definition at line 291 of file base_camera.

                                         {
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f pos = position.value() + dir * a_delta;
    position.value(pos);
  }

translate_along_side()

void tools::sg::base_camera::translate_along_side ( float  a_delta )

inline

Definition at line 274 of file base_camera.

                                          {
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f up;
    orientation.value().mul_vec(vec3f(0,1,0),up);
    vec3f side;dir.cross(up,side);
    vec3f pos = position.value() + side * a_delta;
    position.value(pos);
  }

translate_along_up()

void tools::sg::base_camera::translate_along_up ( float  a_delta )

inline

Definition at line 283 of file base_camera.

                                        {
    vec3f dir;
    orientation.value().mul_vec(vec3f(0,0,-1),dir);
    vec3f up;
    orientation.value().mul_vec(vec3f(0,1,0),up);
    vec3f pos = position.value() + up * a_delta;
    position.value(pos);
  }

type()

virtual camera_type tools::sg::base_camera::type ( ) const

pure virtual

Implemented in tools::sg::perspective, and tools::sg::ortho.

update_motion()

bool tools::sg::base_camera::update_motion ( int  a_move )

inline

Definition at line 381 of file base_camera.

                                 {
    float _dx = dx;
    float _da = da;
    float _ds = ds;
 
    if(a_move==move_rotate_right) { //should match camera_yaw().
      rotate_around_up(_da);
      return true;
    }
    if(a_move==move_rotate_left) {
      rotate_around_up(-_da);
      return true;
    }
 
    if(a_move==move_rotate_up) {  //should match camera_pitch().
      rotate_around_x(_da);
      return true;
    }
    if(a_move==move_rotate_down) {
      rotate_around_x(-_da);
      return true;
    }
 
    if(a_move==move_roll_plus) {  //should match camera_roll().
      rotate_around_direction(-_da);  //direction = -z, then the minus.
      return true;
    }
    if(a_move==move_roll_minus) {
      rotate_around_direction(_da);
      return true;
    }
 
    if(a_move==move_translate_right) {
      translate_along_side(_dx);
      return true;
    }
    if(a_move==move_translate_left) {
      translate_along_side(-_dx);
      return true;
    }
 
    if(a_move==move_up) {
      translate_along_up(_dx);
      return true;
    }
    if(a_move==move_down) {
      translate_along_up(-_dx);
      return true;
    }
    if(a_move==move_forward) {
      translate_along_dir(_dx);
      return true;
    }
    if(a_move==move_backward) {
      translate_along_dir(-_dx);
      return true;
    }
    if(a_move==move_zoom_in) {
      zoom(_ds);
      return true;
    }
    if(a_move==move_zoom_out) {
      zoom(1.0f/_ds);
      return true;
    }
 
    if(a_move==move_rotate_around_focal_right) {  //yaw around focal.
      rotate_around_y_at_focal(_da);
      return true;
    }
    if(a_move==move_rotate_around_focal_left) {
      rotate_around_y_at_focal(-_da);
      return true;
    }
    if(a_move==move_rotate_around_focal_up) {  //pitch around focal.
      rotate_around_x_at_focal(_da);
      return true;
    }
    if(a_move==move_rotate_around_focal_down) {
      rotate_around_x_at_focal(-_da);
      return true;
    }
    if(a_move==move_roll_around_focal_plus) {
      rotate_around_z_at_focal(_da);
      return true;
    }
    if(a_move==move_roll_around_focal_minus) {
      rotate_around_z_at_focal(-_da);
      return true;
    }
 
    return false;
  }

update_sg()

void tools::sg::base_camera::update_sg ( std::ostream &  a_out )

inlineprotected

Definition at line 475 of file base_camera.

                                    {
 
   {const vec4f& v = m_lrbt.value();
    float l = v[0];
    float r = v[1];
    float b = v[2];
    float t = v[3];
    float n = znear.value();
    float f = zfar.value();
    if(is_type_ortho()) {
      m_proj.set_ortho(l,r,b,t,n,f);
    } else {
      m_proj.set_frustum(l,r,b,t,n,f);
    }}
 
    if(orientation.value().quat()!=id_orientation()) //OPTIMIZATION
   {rotf rinv;
    if(orientation.value().inverse(rinv)) {
      mat4f mtx;
      rinv.value(mtx);
      m_proj.mul_mtx(mtx,m_tmp);
    } else {
      a_out << "update_sg :"
            << " get orientation inverse failed."
            << std::endl;
    }}
 
    m_proj.mul_translate(-position.value()[0],
                         -position.value()[1],
                         -position.value()[2]);
  }

zoom()

virtual void tools::sg::base_camera::zoom ( float  )

pure virtual

Implemented in tools::sg::perspective, and tools::sg::ortho.

Member Data Documentation

da

sf<float> tools::sg::base_camera::da

Definition at line 37 of file base_camera.

ds

sf<float> tools::sg::base_camera::ds

Definition at line 38 of file base_camera.

dx

sf<float> tools::sg::base_camera::dx

Definition at line 36 of file base_camera.

focal

sf<float> tools::sg::base_camera::focal

Definition at line 39 of file base_camera.

m_lrbt

sf_vec4f tools::sg::base_camera::m_lrbt

protected

Definition at line 541 of file base_camera.

m_proj

mat4f tools::sg::base_camera::m_proj

protected

Definition at line 542 of file base_camera.

m_tmp

float tools::sg::base_camera::m_tmp[16]

protected

Definition at line 543 of file base_camera.

orientation

sf_rotf tools::sg::base_camera::orientation

Definition at line 33 of file base_camera.

position

sf_vec3f tools::sg::base_camera::position

Definition at line 29 of file base_camera.

zfar

sf<float> tools::sg::base_camera::zfar

Definition at line 28 of file base_camera.

znear

sf<float> tools::sg::base_camera::znear

Definition at line 27 of file base_camera.

---

The documentation for this class was generated from the following file:

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/sg/base_camera