/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sg/sfs

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_sg_sfs
#define inlib_sg_sfs

#include "sf"

#include "../vec3f"
#include "../sg/enums" //hjust,vjust
#include "../rotf"
#include "../img"
#include "../vdata"
#include "../cstr"

namespace inlib {
namespace sg {

template <class T,class TT>  //exa sf_vec<colorf,float>
class sf_vec : public bsf<T> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    const std::vector<TT>& vec = bsf<T>::m_value.vector();
    return a_buffer.write_vec(vec.size(),vec_data(vec));
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector<TT>& vec = bsf<T>::m_value.vector();
    return a_buffer.read_std_vec(vec);
  }
  virtual bool dump(std::ostream& a_out) {
    a_out << bsf<T>::m_value << std::endl;
    return true;
  }
public:
  sf_vec(): bsf<T>(){}
  sf_vec(const T& a_value): bsf<T>(a_value){}
  virtual ~sf_vec(){}
public:
  sf_vec(const sf_vec& a_from)
  : bsf<T>(a_from){}
  sf_vec& operator=(const sf_vec& a_from){
    bsf<T>::operator=(a_from);
    return *this;
  }
public:
  sf_vec& operator=(const T& a_value){
    bsf<T>::operator=(a_value);
    return *this;
  }
};

template <class T>
class sf_enum : public bsf<T> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    return a_buffer.write((uint16)bsf<T>::m_value);
  }
  virtual bool read(io::irbuf& a_buffer) {
    uint16 v;
    if(!a_buffer.read(v)) return false;
    bsf<T>::m_value = (T)v;
    return true;
  }
  virtual bool dump(std::ostream&) {
    //a_out << bsf<T>::m_value << std::endl;
    return true;
  }
public:
  sf_enum(): bsf<T>(){}
  sf_enum(const T& a_value): bsf<T>(a_value){}
  virtual ~sf_enum(){}
public:
  sf_enum(const sf_enum& a_from): bsf<T>(a_from){}
  sf_enum& operator=(const sf_enum& a_from){
    bsf<T>::operator=(a_from);
    return *this;
  }
public:
  sf_enum& operator=(const T& a_value){
    bsf<T>::operator=(a_value);
    return *this;
  }
};

class sf_string : public bsf<std::string> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    return a_buffer.write_cstr(m_value.c_str());
  }
  virtual bool read(io::irbuf& a_buffer) {
    char* cstr = 0;
    if(!a_buffer.read_cstr(cstr)) return false;
    m_value = cstr;
    str_del(cstr);
    return true;
  }
  virtual bool dump(std::ostream&) {
    //a_out << bsf<T>::m_value << std::endl;
    return true;
  }
public:
  sf_string(): bsf<std::string>(){}
  sf_string(const std::string& a_value): bsf<std::string>(a_value){}
  virtual ~sf_string(){}
public:
  sf_string(const sf_string& a_from): bsf<std::string>(a_from){}
  sf_string& operator=(const sf_string& a_from){
    bsf<std::string>::operator=(a_from);
    return *this;
  }
public:
  sf_string& operator=(const std::string& a_value){
    bsf<std::string>::operator=(a_value);
    return *this;
  }
};

class sf_rotf : public bsf<rotf> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    const std::vector<float>& vec = m_value.quat().vector();
    return a_buffer.write_vec(vec.size(),vec_data(vec));
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector<float>& vec = m_value.quat().vector();
    return a_buffer.read_std_vec(vec);
  }
  virtual bool dump(std::ostream&) {
    //a_out << bsf<T>::m_value << std::endl;
    return true;
  }
public:
  sf_rotf(): bsf<rotf>(){}
  sf_rotf(const rotf& a_value): bsf<rotf>(a_value){}
  virtual ~sf_rotf(){}
public:
  sf_rotf(const sf_rotf& a_from): bsf<rotf>(a_from){}
  sf_rotf& operator=(const sf_rotf& a_from){
    bsf<rotf>::operator=(a_from);
    return *this;
  }
public:
  sf_rotf& operator=(const rotf& a_value){
    bsf<rotf>::operator=(a_value);
    return *this;
  }
};

template <class T>
class sf_img : public bsf< img<T> > {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    //FIXME : have a iwbuf.write_img<T> ?
    img<T>& im = bsf< img<T> >::m_value;
    if(!a_buffer.write((uint32)im.width())) return false;
    if(!a_buffer.write((uint32)im.height())) return false;
    if(!a_buffer.write((uint32)im.bpp())) return false;
    return a_buffer.write_vec(im.size(),im.buffer());
  }
  virtual bool read(io::irbuf& /*a_buffer*/) {
    //FIXME : have a iwbuf.write_img<T> ?
/*
    img<T>& im = bsf< img<T> >::m_value;
    if(!a_buffer.read((uint32)im.width())) return false;
    if(!a_buffer.read((uint32)im.height())) return false;
    if(!a_buffer.read((uint32)im.bpp())) return false;
    return a_buffer.read_vec(im.size(),im.buffer());
*/
    return false;    
  }
  virtual bool dump(std::ostream&) {
    //a_out << bsf<T>::m_value << std::endl;
    return true;
  }
public:
  sf_img(): bsf< img<T> >(){}
  sf_img(const img<T>& a_value): bsf< img<T> >(a_value){}
  virtual ~sf_img(){}
public:
  sf_img(const sf_img& a_from): bsf< img<T> >(a_from){}
  sf_img& operator=(const sf_img& a_from){
    bsf< img<T> >::operator=(a_from);
    return *this;
  }
public:
  sf_img& operator=(const img<T>& a_value){
    bsf< img<T> >::operator=(a_value);
    return *this;
  }
};

}}

#endif