vlvoxelopvalue.h

Go to the documentation of this file.

// $Id: vlvoxelopvalue.h,v 1.6 2003/08/13 19:58:06 sarang Exp $
//
// OpenVL - A Library for working with volumetric datasets.
//          http://openvl.sf.net
//
// Copyright (C) 2000-2003  Sarang Lakare <sarang#users.sf.net>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA.
//
// Please report all bugs and problems to openvl-devel@lists.sf.net or
// at the OpenVL website.
//

#ifndef _vlVoxelOpValue_h
#define _vlVoxelOpValue_h

#include "vlenums.h"
#include "vlvector.h"
#include "vlnormal.h"
#include "vlcolor.h"

class vlVoxelOpValue {
public:
  vlVoxelOpValue()
    : m_color4ub(0,0,0,0),
      m_color4us(0,0,0,0),
      m_datatype(0x0000),
      m_autoDelete(true) { };

  ~vlVoxelOpValue() {
    if((m_datatype & Pointer) && m_autoDelete)
      delete [] m_realValue.ptr;
  };

  int32 i() const
  {
    if(m_datatype & Int32)
      return m_realValue.i32;
    else
      return 0;
  };

  uint32 ui() const
  {
    if(m_datatype & UInt32)
      return m_realValue.ui32;
    else
      return 0;
  };

  double dl() const
  {
    if(m_datatype & Double)
      return m_realValue.dl;
    else
      return 0.0;
  };

  vlVector3f vector3f() const
  {
    return m_vector3f;
  };

  vlNormal3f normal3f() const
  {
    return m_normal3f;
  };

  vlColor4f color4f() const
  {
    return m_color4f;
  };

  vlColor4ub color4ub() const
  {
    return m_color4ub;
  };

  vlColor4us color4us() const
  {
    return m_color4us;
  };

  uint8 * ptr(bool autoDelete=true) const
  {
    m_autoDelete = autoDelete;
    if(m_datatype & Pointer)
      return m_realValue.ptr;
    else
      return 0;
  };

  void setI(const int32 & value) { m_datatype |= Int32; m_realValue.i32 = value; };

  void setUi(const uint32 & value) { m_datatype |= UInt32; m_realValue.ui32 = value; };

  void setDl(const double & value) { m_datatype |= Double; m_realValue.dl = value; };

  void setVector3f(const vlVector3f & value) { m_datatype |= Vector3f; m_vector3f = value; };

  void setNormal3f(const vlNormal3f & value) { m_datatype |= Normal3f; m_normal3f = value; };

  void setColor4f(const vlColor4f & value) { m_datatype |= Color4f; m_color4f = value; };

  void setColor4ub(const vlColor4ub & value) { m_datatype |= Color4ub; m_color4ub = value; };

  void setColor4us(const vlColor4us & value) { m_datatype |= Color4us; m_color4us = value; };

  void setPtr(uint8 * ptr) { m_datatype |= Pointer; m_realValue.ptr = ptr; };

protected:
  union ReturnData_ {
    int32 i32;
    uint32 ui32;
    double dl;
    uint8 * ptr;
  } m_realValue;

  vlVector3f m_vector3f;
  vlNormal3f m_normal3f;
  vlColor4f m_color4f;
  vlColor4ub m_color4ub;
  vlColor4us m_color4us;

  enum ReturnType {
    Int32 = 0x0001,
    UInt32 = 0x0002,
    Double = 0x0004,
    Vector3f = 0x0008,
    Normal3f = 0x0010,
    Color4f = 0x0020,
    Color4ub = 0x0040,
    Color4us = 0x0080,
    Pointer = 0x0100
  };

  int m_datatype;

  mutable bool m_autoDelete;
};


#endif // _vlVoxelOpValue_h

---