size3.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_GF_SIZE3_H
#define PXR_BASE_GF_SIZE3_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/arch/inttypes.h"
#include "pxr/base/gf/vec3i.h"
#include "pxr/base/gf/api.h" 
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class GfSize3 {
public:
    GfSize3() {
        Set(0, 0, 0);
    }
 
    GfSize3(const GfSize3& o) {
        *this = o;
    }
 
    explicit GfSize3(const GfVec3i&o) {
        Set(o[0], o[1], o[2]);
    }
 
    GfSize3(const size_t v[3]) {
        Set(v);
    }
 
    GfSize3(size_t v0, size_t v1, size_t v2) {
        Set(v0, v1, v2);
    }
 
    GfSize3 & Set(const size_t v[3]) {
        _vec[0] = v[0]; 
        _vec[1] = v[1]; 
        _vec[2] = v[2]; 
        return *this;
    }
 
    GfSize3 & Set(size_t v0, size_t v1, size_t v2) {
        _vec[0] = v0; 
        _vec[1] = v1; 
        _vec[2] = v2; 
        return *this;
    }
 
    size_t & operator [](size_t i) {
        return _vec[i];
    }
 
    const size_t & operator [](size_t i) const {
        return _vec[i];
    }
 
    bool operator ==(const GfSize3 &v) const {
        return _vec[0] == v._vec[0] && _vec[1] == v._vec[1] &&
            _vec[2] == v._vec[2];
    }
 
    bool operator !=(const GfSize3 &v) const {
        return ! (*this == v);
    }
 
    GfSize3 & operator +=(const GfSize3 &v) {
        _vec[0] += v._vec[0]; 
        _vec[1] += v._vec[1]; 
        _vec[2] += v._vec[2]; 
        return *this;
    }
 
    GfSize3 & operator -=(const GfSize3 &v) {
        _vec[0] -= v._vec[0]; 
        _vec[1] -= v._vec[1]; 
        _vec[2] -= v._vec[2]; 
        return *this;
    }
 
    GfSize3 & operator *=(GfSize3 const &v) {
        _vec[0] *= v._vec[0];
        _vec[1] *= v._vec[1];
        _vec[2] *= v._vec[2];
        return *this;
    }
 
    GfSize3 & operator *=(size_t d) {
        _vec[0] = _vec[0] * d;
        _vec[1] = _vec[1] * d;
        _vec[2] = _vec[2] * d;
        return *this;
    }
 
    GfSize3 & operator /=(size_t d) {
        _vec[0] = _vec[0] / d;
        _vec[1] = _vec[1] / d;
        _vec[2] = _vec[2] / d;
        return *this;
    }
 
    friend GfSize3 operator +(const GfSize3 &v1, const GfSize3 &v3) {
        return GfSize3(v1._vec[0]+v3._vec[0],
                       v1._vec[1]+v3._vec[1],
                       v1._vec[2]+v3._vec[2]);
    }
 
    friend GfSize3 operator -(const GfSize3 &v1, const GfSize3 &v3) {
        return GfSize3(v1._vec[0]-v3._vec[0],
                       v1._vec[1]-v3._vec[1],
                       v1._vec[2]-v3._vec[2]);
    }
 
    friend GfSize3 operator *(const GfSize3 &v1, const GfSize3 &v3) {
        return GfSize3(v1._vec[0]*v3._vec[0],
                       v1._vec[1]*v3._vec[1],
                       v1._vec[2]*v3._vec[2]);
    }
 
    friend GfSize3 operator *(const GfSize3 &v1, size_t s) {
        return GfSize3(v1._vec[0]*s,
                       v1._vec[1]*s,
                       v1._vec[2]*s);
    }
 
    friend GfSize3 operator *(size_t s, const GfSize3 &v1) {
        return GfSize3(v1._vec[0]*s,
                       v1._vec[1]*s,
                       v1._vec[2]*s);
    }
 
    friend GfSize3 operator /(const GfSize3 &v1, size_t s) {
        return GfSize3(v1._vec[0]/s,
                       v1._vec[1]/s,
                       v1._vec[2]/s);
    }
 
    friend GF_API std::ostream &operator<<(std::ostream &o, GfSize3 const &v);
 
    operator GfVec3i() const {
        return GfVec3i(_vec[0],_vec[1],_vec[2]);
    }
private:
    size_t _vec[3];
};
 
// Friend functions must be declared
GF_API std::ostream &operator<<(std::ostream &o, GfSize3 const &v);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_SIZE3_H