Changeset 4890 for nanovis


Ignore:
Timestamp:
Dec 20, 2014, 2:37:04 AM (4 years ago)
Author:
ldelgass
Message:

merge r3627:3628 from trunk

Location:
nanovis/branches/1.1
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • nanovis/branches/1.1

  • nanovis/branches/1.1/FlowParticles.cpp

    r4889 r4890  
    1212#include <assert.h>
    1313
    14 #include <vrmath/Vector4f.h>
     14#include <vrmath/Color4f.h>
    1515
    1616#include "nanovis.h"        // For NMESH
     
    6161{
    6262    _renderer->setPos(Flow::getRelativePosition(&_sv.position));
    63     _renderer->setColor(Vector4f(_sv.color.r,
    64                                  _sv.color.g,
    65                                  _sv.color.b,
    66                                  _sv.color.a));
     63    _renderer->setColor(Color4f(_sv.color.r,
     64                                _sv.color.g,
     65                                _sv.color.b,
     66                                _sv.color.a));
    6767    _renderer->particleSize(_sv.particleSize);
    6868    _renderer->setAxis(_sv.position.axis);
  • nanovis/branches/1.1/Grid.cpp

    r4889 r4890  
    99#include <GL/glew.h>
    1010#include <GL/gl.h>
     11
     12#include <util/Fonts.h>
     13#include <vrmath/Color4f.h>
    1114
    1215#include "Grid.h"
     
    8689
    8790    glLineWidth(2.0f);
    88     glColor4f(_axisColor.red, _axisColor.green, _axisColor.blue,
    89               _axisColor.alpha);
     91    glColor4f(_axisColor.r, _axisColor.g, _axisColor.b,
     92              _axisColor.a);
    9093
    9194    glBegin(GL_LINES);
     
    101104
    102105    glLineWidth(1.0f);
    103     glColor4f(_majorColor.red, _majorColor.green, _majorColor.blue,
    104               _majorColor.alpha);
     106    glColor4f(_majorColor.r, _majorColor.g, _majorColor.b,
     107              _majorColor.a);
    105108
    106109    glBegin(GL_LINES);
     
    137140
    138141    // Set minor line color
    139     glColor4f(_minorColor.red, _minorColor.green, _minorColor.blue,
    140               _minorColor.alpha);
     142    glColor4f(_minorColor.r, _minorColor.g, _minorColor.b,
     143              _minorColor.a);
    141144
    142145    glBegin(GL_LINES);
  • nanovis/branches/1.1/Grid.h

    r4889 r4890  
    77#define NV_GRID_H
    88
    9 #include <util/Fonts.h>
     9#include <vrmath/Color4f.h>
    1010
    1111#include "Axis.h"
     
    1414namespace nv {
    1515
    16 class RGBA
    17 {
    18 public:
    19     RGBA(float r, float g, float b, float a) :
    20         red(r),
    21         green(g),
    22         blue(b),
    23         alpha(a)
    24     {}
    25 
    26     void set(float r, float g, float b, float a)
    27     {
    28         red   = r;
    29         green = g;
    30         blue  = b;
    31         alpha = a;
    32     }
    33 
    34     float red, green, blue, alpha;
    35 };
     16namespace util {
     17class Fonts;
     18}
    3619
    3720class Grid
     
    7154
    7255private:
    73     RGBA _axisColor, _majorColor, _minorColor;
     56    vrmath::Color4f _axisColor, _majorColor, _minorColor;
    7457    nv::util::Fonts *_font;
    7558    bool _visible;
  • nanovis/branches/1.1/Makefile.in

    r4889 r4890  
    283283FlowParticles.o: FlowParticles.cpp FlowParticles.h FlowTypes.h FlowCmd.h Switch.h Trace.h ParticleRenderer.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h
    284284GradientFilter.o: GradientFilter.cpp GradientFilter.h
    285 Grid.o: Grid.cpp Grid.h Axis.h Chain.h
     285Grid.o: Grid.cpp Grid.h Axis.h Chain.h $(UTIL_DIR)/Fonts.h $(VRMATH_DIR)/include/vrmath/Color4f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h
    286286HeightMap.o: HeightMap.cpp HeightMap.h
    287287LIC.o: LIC.cpp LIC.h define.h
     
    322322dxReader.o: dxReader.cpp ReaderCommon.h config.h nanovis.h Unirect.h ZincBlendeVolume.h ZincBlendeReconstructor.h
    323323md5.o: md5.h
    324 nanovis.o: nanovis.cpp nanovis.h nanovisServer.h config.h define.h Command.h Flow.h Grid.h HeightMap.h Camera.h LIC.h ZincBlendeReconstructor.h PerfQuery.h PlaneRenderer.h PointSetRenderer.h PointSet.h Switch.h Trace.h Unirect.h VelocityArrowsSlice.h VolumeInterpolator.h VolumeRenderer.h ZincBlendeVolume.h Axis.h Chain.h
     324nanovis.o: nanovis.cpp nanovis.h nanovisServer.h config.h define.h Command.h Flow.h Grid.h HeightMap.h Camera.h LIC.h ZincBlendeReconstructor.h PerfQuery.h PlaneRenderer.h PointSetRenderer.h PointSet.h Switch.h Trace.h Unirect.h VelocityArrowsSlice.h VolumeInterpolator.h VolumeRenderer.h ZincBlendeVolume.h Axis.h Chain.h $(UTIL_DIR)/Fonts.h
    325325nanovisServer.o: nanovisServer.cpp nanovisServer.h config.h nanovis.h define.h Command.h ReadBuffer.h Shader.h Trace.h
  • nanovis/branches/1.1/PCASplit.h

    r4889 r4890  
    1010
    1111#include <vrmath/Vector3f.h>
    12 #include <vrmath/Vector4f.h>
     12#include <vrmath/Color4f.h>
    1313
    1414namespace PCA {
     
    2323
    2424    vrmath::Vector3f position;
    25     vrmath::Vector4f color;
     25    vrmath::Color4f color;
    2626    float size;
    2727    float value;
     
    5757
    5858    vrmath::Vector3f centroid;
    59     vrmath::Vector4f color;
     59    vrmath::Color4f color;
    6060    float scale;
    6161
  • nanovis/branches/1.1/ParticleRenderer.cpp

    r4889 r4890  
    1212
    1313#include <GL/glew.h>
     14
     15#include <vrmath/Color4f.h>
    1416
    1517#include "ParticleRenderer.h"
  • nanovis/branches/1.1/ParticleRenderer.h

    r4889 r4890  
    1212
    1313#include <vrmath/Vector3f.h>
    14 #include <vrmath/Vector4f.h>
     14#include <vrmath/Color4f.h>
    1515
    1616#include "ParticleAdvectionShader.h"
     
    6363    }
    6464
    65     void setColor(const vrmath::Vector4f& color)
     65    void setColor(const vrmath::Color4f& color)
    6666    {
    6767        _color = color;
     
    122122    int _sliceAxis;
    123123
    124     vrmath::Vector4f _color;
     124    vrmath::Color4f _color;
    125125
    126126    //the storage of particles is implemented as a 2D array.
  • nanovis/branches/1.1/PointSet.cpp

    r4889 r4890  
    99#include <vrmath/Vector3f.h>
    1010#include <vrmath/Vector4f.h>
     11#include <vrmath/Color4f.h>
    1112
    1213#include "PointSet.h"
     
    5859
    5960    PCA::Point *points;
    60     vrmath::Vector4f *colors = (vrmath::Vector4f *)color;
     61    vrmath::Color4f *colors = (vrmath::Color4f *)color;
    6162    int numOfPoints;
    6263    int index;
  • nanovis/branches/1.1/PointSetRenderer.cpp

    r4889 r4890  
    6464    Point *p = points;
    6565    for (int i = 0; i < length; ++i, ++p) {
    66         glColor4f(p->color.x, p->color.y, p->color.z, p->color.w);
     66        glColor4f(p->color.r, p->color.g, p->color.b, p->color.a);
    6767        glVertex3f(p->position.x, p->position.y, p->position.z);
    6868    }
  • nanovis/branches/1.1/vrmath/BBox.cpp

    r3494 r4890  
    2020}
    2121
    22 BBox::BBox(const BBox& bbox)
     22BBox::BBox(const BBox& other) :
     23    min(other.min),
     24    max(other.max)
    2325{
    24     min = bbox.min;
    25     max = bbox.max;     
    2626}
    2727
    28 BBox::BBox(const Vector3f& minv, const Vector3f& maxv)
     28BBox::BBox(const Vector3f& minv, const Vector3f& maxv) :
     29    min(minv),
     30    max(maxv)
    2931{
    30     min = minv;
    31     max = maxv;
    3232}
    3333
     
    4040bool BBox::isEmpty()
    4141{
    42     if ((min.x > max.x) || (min.y > max.y) || (min.z > max.z)) {
    43         return true;
    44     }
     42    return (isEmptyX() && isEmptyY() && isEmptyZ());
     43}
    4544
    46     return false;
     45bool BBox::isEmptyX()
     46{
     47    return (min.x > max.x);
     48}
     49
     50bool BBox::isEmptyY()
     51{
     52    return (min.y > max.y);
     53}
     54
     55bool BBox::isEmptyZ()
     56{
     57    return (min.z > max.z);
    4758}
    4859
     
    95106void BBox::transform(const BBox& box, const Matrix4x4d& mat)
    96107{
    97     float halfSizeX = (box.max.x - box.min.x) * 0.5f;
    98     float halfSizeY = (box.max.y - box.min.y) * 0.5f;
    99     float halfSizeZ = (box.max.z - box.min.z) * 0.5f;
    100 
    101     float centerX = (box.max.x + box.min.x) * 0.5f;
    102     float centerY = (box.max.y + box.min.y) * 0.5f;
    103     float centerZ = (box.max.z + box.min.z) * 0.5f;
     108    float x0 = box.min.x;
     109    float y0 = box.min.y;
     110    float z0 = box.min.z;
     111    float x1 = box.max.x;
     112    float y1 = box.max.y;
     113    float z1 = box.max.z;
    104114
    105115    Vector4f points[8];
    106116
    107     points[0].set(centerX + halfSizeX, centerY + halfSizeY, centerZ + halfSizeZ, 1);
    108     points[1].set(centerX + halfSizeX, centerY + halfSizeY, centerZ - halfSizeZ, 1);
    109     points[2].set(centerX - halfSizeX, centerY + halfSizeY, centerZ - halfSizeZ, 1);
    110     points[3].set(centerX - halfSizeX, centerY + halfSizeY, centerZ + halfSizeZ, 1);
    111     points[4].set(centerX - halfSizeX, centerY - halfSizeY, centerZ + halfSizeZ, 1);
    112     points[5].set(centerX - halfSizeX, centerY - halfSizeY, centerZ - halfSizeZ, 1);
    113     points[6].set(centerX + halfSizeX, centerY - halfSizeY, centerZ - halfSizeZ, 1);
    114     points[7].set(centerX + halfSizeX, centerY - halfSizeY, centerZ + halfSizeZ, 1);
     117    points[0].set(x0, y0, z0, 1);
     118    points[1].set(x1, y0, z0, 1);
     119    points[2].set(x0, y1, z0, 1);
     120    points[3].set(x0, y0, z1, 1);
     121    points[4].set(x1, y1, z0, 1);
     122    points[5].set(x1, y0, z1, 1);
     123    points[6].set(x0, y1, z1, 1);
     124    points[7].set(x1, y1, z1, 1);
    115125
    116     float minX, minY, minZ;
    117     float maxX, maxY, maxZ;
     126    float minX = FLT_MAX, minY = FLT_MAX, minZ = FLT_MAX;
     127    float maxX = -FLT_MAX, maxY = -FLT_MAX, maxZ = -FLT_MAX;
    118128
    119     points[0] = mat.transform(points[0]);
    120 
    121     minX = maxX = points[0].x;
    122     minY = maxY = points[0].y;
    123     minZ = maxZ = points[0].z;
    124 
    125     for (int i = 1; i < 8; i++) {
     129    for (int i = 0; i < 8; i++) {
    126130        points[i] = mat.transform(points[i]);
    127131
    128132        if (points[i].x > maxX) maxX = points[i].x;
    129         else if (points[i].x < minX) minX = points[i].x;
    130 
     133        if (points[i].x < minX) minX = points[i].x;
    131134        if (points[i].y > maxY) maxY = points[i].y;
    132         else if (points[i].y < minY) minY = points[i].y;
    133 
     135        if (points[i].y < minY) minY = points[i].y;
    134136        if (points[i].z > maxZ) maxZ = points[i].z;
    135         else if (points[i].z < minZ) minZ = points[i].z;
     137        if (points[i].z < minZ) minZ = points[i].z;
    136138    }
    137139
     
    149151}
    150152
    151 bool BBox::intersect(const Vector3f& point)
     153bool BBox::contains(const Vector3f& point)
    152154{
    153155    if ((point.x < min.x) || (point.x > max.x)) return false;
  • nanovis/branches/1.1/vrmath/Makefile.in

    r3567 r4890  
    4040VRMATHLIB       = vrmath.a
    4141
    42 #               BBox.o \
    4342#               BPlane.o \
    4443#               Projection.o \
    4544
    4645OBJS            = \
     46                BBox.o \
    4747                LineSegment.o \
    4848                Matrix4x4f.o \
  • nanovis/branches/1.1/vrmath/Matrix4x4d.cpp

    r3492 r4890  
    946946}
    947947
    948 void Matrix4x4d::setFloat(float *m)
     948void Matrix4x4d::setFloat(const float *m)
    949949{
    950950    for (int i = 0; i < 16; ++i) {
  • nanovis/branches/1.1/vrmath/Matrix4x4f.cpp

    r3492 r4890  
    871871}
    872872
    873 void Matrix4x4f::setDouble(double *m)
     873void Matrix4x4f::setDouble(const double *m)
    874874{
    875875    for (int i = 0; i < 16; ++i) {
  • nanovis/branches/1.1/vrmath/include/vrmath/BBox.h

    r3494 r4890  
    3535    BBox(const Vector3f& min, const Vector3f& max);
    3636
     37    BBox& operator=(const BBox& other)
     38    {
     39        if (&other != this) {
     40            min = other.min;
     41            max = other.max;
     42        }
     43        return *this;
     44    }
     45
    3746    /**
    3847     * @brief make an empty bounding box
     
    5160     */
    5261    bool isEmpty();
     62    bool isEmptyX();
     63    bool isEmptyY();
     64    bool isEmptyZ();
    5365
    5466    /**
     
    6375
    6476    /**
    65      * @brief transform a bounding box with an matrix and set the bounding box
     77     * @brief transform a bounding box with a matrix and set the bounding box
    6678     */
    6779    void transform(const BBox& box, const Matrix4x4d& mat);
     
    7385
    7486    /**
    75      * @brief check if the bounding box intersect with a point
     87     * @brief check if the bounding box contains a point
    7688     */
    77     bool intersect(const Vector3f& point);
     89    bool contains(const Vector3f& point);
    7890
    7991    float getRadius() const;
     
    93105{
    94106    Vector3f temp;
    95     temp.x = (max.x+ min.x) * 0.5f;
     107    temp.x = (max.x + min.x) * 0.5f;
    96108    temp.y = (max.y + min.y) * 0.5f;
    97109    temp.z = (max.z + min.z) * 0.5f;
  • nanovis/branches/1.1/vrmath/include/vrmath/Matrix4x4d.h

    r3492 r4890  
    3030    {
    3131        set(m);
     32    }
     33
     34    Matrix4x4d(const Matrix4x4d& other)
     35    {
     36        set(other.get());
     37    }
     38
     39    Matrix4x4d& operator=(const Matrix4x4d& other)
     40    {
     41        if (&other != this) {
     42            set(other.get());
     43        }
     44        return *this;
    3245    }
    3346
     
    113126     * @param m float matrix values
    114127     */
    115     void set(double *m);
     128    void set(const double *m);
    116129
    117     void setFloat(float *m);
     130    void setFloat(const float *m);
    118131
    119132    void print() const;
     
    136149}
    137150
    138 inline void Matrix4x4d::set(double *m)
     151inline void Matrix4x4d::set(const double *m)
    139152{
    140153    memcpy(_data, m, sizeof(double) * 16);
  • nanovis/branches/1.1/vrmath/include/vrmath/Matrix4x4f.h

    r3492 r4890  
    3030    {
    3131        set(m);
     32    }
     33
     34    Matrix4x4f(const Matrix4x4f& other)
     35    {
     36        set(other.get());
     37    }
     38
     39    Matrix4x4f& operator=(const Matrix4x4f& other)
     40    {
     41        if (&other != this) {
     42            set(other.get());
     43        }
     44        return *this;
    3245    }
    3346
     
    113126     * @param m float matrix values
    114127     */
    115     void set(float *m);
     128    void set(const float *m);
    116129
    117130    /**
     
    119132     * @param m float matrix values
    120133     */
    121     void setDouble(double *m);
     134    void setDouble(const double *m);
    122135
    123136    void print() const;
     
    140153}
    141154
    142 inline void Matrix4x4f::set(float *m)
     155inline void Matrix4x4f::set(const float *m)
    143156{
    144157    memcpy(_data, m, sizeof(float) * 16);
  • nanovis/branches/1.1/vrmath/include/vrmath/Quaternion.h

    r3492 r4890  
    2121    Quaternion(double x, double y, double z, double w);
    2222
    23     void set(double x1, double y1, double z1, double w1);
     23    Quaternion(const Quaternion& other) :
     24        x(other.x), y(other.y), z(other.z), w(other.w)
     25    {}
     26
     27    Quaternion& operator=(const Quaternion& other)
     28    {
     29        if (&other != this) {
     30            set(other.x, other.y, other.z, other.w);
     31        }
     32        return *this;
     33    }
     34
     35    void set(double x, double y, double z, double w);
    2436
    2537    const Quaternion& set(const Rotation& rot);
     
    7789}
    7890
    79 inline void Quaternion::set(double x1, double y1, double z1, double w1)
     91inline void Quaternion::set(double x, double y, double z, double w)
    8092{
    81     x = x1;
    82     y = y1;
    83     z = z1;
    84     w = w1;
     93    this->x = x;
     94    this->y = y;
     95    this->z = z;
     96    this->w = w;
    8597}
    8698
  • nanovis/branches/1.1/vrmath/include/vrmath/Rotation.h

    r3492 r4890  
    2828    {}
    2929
    30     Rotation(const Rotation& rotation) :
    31         x(rotation.x), y(rotation.y), z(rotation.z), angle(rotation.angle)
     30    Rotation(const Rotation& other) :
     31        x(other.x), y(other.y), z(other.z), angle(other.angle)
    3232    {}
     33
     34    Rotation& operator=(const Rotation& other)
     35    {
     36        if (&other != this) {
     37            set(other.x, other.y, other.z, other.angle);
     38        }
     39        return *this;
     40    }
    3341
    3442    double getX() const
  • nanovis/branches/1.1/vrmath/include/vrmath/Vector2f.h

    r3492 r4890  
    2828    {}
    2929
    30     void set(float x1, float y1);
     30    Vector2f& operator=(const Vector2f& other)
     31    {
     32        if (&other != this) {
     33            set(other.x, other.y);
     34        }
     35        return *this;
     36    }
     37
     38    void set(float x, float y);
    3139
    3240    void set(const Vector2f& v);
     
    3846    double distance(const Vector2f& v) const;
    3947
    40     double distance(float x1, float y1) const;
     48    double distance(float x, float y) const;
    4149
    4250    double distanceSquare(const Vector2f& v) const;
    4351
    44     double distanceSquare(float x1, float y1) const;
     52    double distanceSquare(float x, float y) const;
    4553
    4654    float x, y;
    4755};
    4856
    49 inline void Vector2f::set(float x1, float y1)
     57inline void Vector2f::set(float x, float y)
    5058{
    51     x = x1;
    52     y = y1;
     59    this->x = x;
     60    this->y = y;
    5361}
    5462
     
    7583}
    7684
    77 inline double Vector2f::distance(float x1, float y1) const
     85inline double Vector2f::distance(float x, float y) const
    7886{       
    79     double x2 = ((double)x1 - (double)x) , y2 = ((double)y1 - (double)y);
    80     return sqrt(x2 * x2 + y2 * y2);
     87    double x1 = ((double)x - (double)this->x) , y1 = ((double)y - (double)this->y);
     88    return sqrt(x1 * x1 + y1 * y1);
    8189}
    8290
     
    8795}
    8896
    89 inline double Vector2f::distanceSquare(float x1, float y1) const
     97inline double Vector2f::distanceSquare(float x, float y) const
    9098{       
    91     double x2 = ((double)x1 - (double)x) , y2 = ((double)y1 - (double)y);
    92     return (x2 * x2 + y2 * y2);
     99    double x1 = ((double)x - (double)this->x) , y1 = ((double)y - (double)this->y);
     100    return (x1 * x1 + y1 * y1);
    93101}
    94102
  • nanovis/branches/1.1/vrmath/include/vrmath/Vector3f.h

    r4889 r4890  
    2727        x(x1), y(y1), z(z1)
    2828    {}
    29 
    30     void set(float x1, float y1, float z1);
    31 
    32     void set(const Vector3f& v3);
     29   
     30    Vector3f& operator=(const Vector3f& other)
     31    {
     32        if (&other != this) {
     33            set(other.x, other.y, other.z);
     34        }
     35        return *this;
     36    }
     37
     38    void set(float x, float y, float z);
     39
     40    void set(const Vector3f& v);
    3341
    3442    double length() const;
    3543
    36     double distance(const Vector3f& v3) const;
    37 
    38     double distance(float x1, float y1, float z1) const;
    39 
    40     double distanceSquare(const Vector3f& v3) const;
    41 
    42     double distanceSquare(float x1, float y1, float z1) const;
     44    double distance(const Vector3f& v) const;
     45
     46    double distance(float x, float y, float z) const;
     47
     48    double distanceSquare(const Vector3f& v) const;
     49
     50    double distanceSquare(float x, float y, float z) const;
    4351
    4452    double dot(const Vector3f& v) const;
    4553
    46     Vector3f cross(const Vector3f& v1) const;
     54    Vector3f cross(const Vector3f& v) const;
    4755
    4856    Vector3f normalize() const;
    4957
    50     Vector3f scale(const Vector3f& sc) const;
     58    Vector3f scale(const Vector3f& scale) const;
    5159
    5260    Vector3f scale(float scale) const;
     
    166174#endif
    167175
    168 inline void Vector3f::set(float x1, float y1, float z1)
    169 {
    170     x = x1;
    171     y = y1;
    172     z = z1;
    173 }
    174 
    175 inline void Vector3f::set(const Vector3f& v3)
    176 {
    177     x = v3.x;
    178     y = v3.y;
    179     z = v3.z;
     176inline void Vector3f::set(float x, float y, float z)
     177{
     178    this->x = x;
     179    this->y = y;
     180    this->z = z;
     181}
     182
     183inline void Vector3f::set(const Vector3f& v)
     184{
     185    x = v.x;
     186    y = v.y;
     187    z = v.z;
    180188}
    181189
     
    190198}
    191199
    192 inline double Vector3f::distance(const Vector3f& v3) const
    193 {
    194     double x1 = ((double)v3.x - (double)x) , y1 = ((double)v3.y - (double)y), z1 = ((double)v3.z - (double)z);
     200inline double Vector3f::distance(const Vector3f& v) const
     201{
     202    double x1 = ((double)v.x - (double)x) , y1 = ((double)v.y - (double)y), z1 = ((double)v.z - (double)z);
    195203    return sqrt(x1 * x1 + y1 * y1 + z1 * z1);
    196204}
    197205
    198 inline double Vector3f::distance(float x1, float y1, float z1) const
     206inline double Vector3f::distance(float x, float y, float z) const
    199207{       
    200     double x2 = ((double)x1 - (double)x) , y2 = ((double)y1 - (double)y), z2 = ((double)z1 - (double)z);
    201     return sqrt(x2 * x2 + y2 * y2 + z2 * z2);
    202 }
    203 
    204 inline double Vector3f::distanceSquare(const Vector3f& v3) const
     208    double x1 = ((double)x - (double)this->x) , y1 = ((double)y - (double)this->y), z1 = ((double)z - (double)this->z);
     209    return sqrt(x1 * x1 + y1 * y1 + z1 * z1);
     210}
     211
     212inline double Vector3f::distanceSquare(const Vector3f& v) const
    205213{       
    206     double x1 = ((double)v3.x - (double)x) , y1 = ((double)v3.y - (double)y), z1 = ((double)v3.z - (double)z);
     214    double x1 = ((double)v.x - (double)x) , y1 = ((double)v.y - (double)y), z1 = ((double)v.z - (double)z);
    207215    return (x1 * x1 + y1 * y1 + z1 * z1);
    208216}
    209217
    210 inline double Vector3f::distanceSquare(float x1, float y1, float z1) const
     218inline double Vector3f::distanceSquare(float x, float y, float z) const
    211219{       
    212     double x2 = ((double)x1 - (double)x) , y2 = ((double)y1 - (double)y), z2 = ((double)z1 - (double)z);
    213     return (x2 * x2 + y2 * y2 + z2 * z2);
     220    double x1 = ((double)x - (double)this->x) , y1 = ((double)y - (double)this->y), z1 = ((double)z - (double)this->z);
     221    return (x1 * x1 + y1 * y1 + z1 * z1);
    214222}
    215223
     
    236244}
    237245
    238 inline Vector3f Vector3f::scale(const Vector3f& sc) const
    239 {
    240     return Vector3f(x * sc.x, y * sc.y, z * sc.z);
     246inline Vector3f Vector3f::scale(const Vector3f& scale) const
     247{
     248    return Vector3f(x * scale.x, y * scale.y, z * scale.z);
    241249}
    242250
  • nanovis/branches/1.1/vrmath/include/vrmath/Vector4f.h

    r3567 r4890  
    2424    {}
    2525
    26     Vector4f(const Vector3f& v3, float w1) :
    27         x(v3.x), y(v3.y), z(v3.z), w(w1)
     26    Vector4f(const Vector3f& v, float w1) :
     27        x(v.x), y(v.y), z(v.z), w(w1)
    2828    {}
    2929
     
    3232    {}
    3333
    34     void set(float x1, float y1, float z1, float w1);
     34    void set(float x, float y, float z, float w);
    3535 
    3636    void set(const Vector3f& v, float w);
    3737
    38     void set(const Vector4f& v4);
     38    void set(const Vector4f& v);
     39
     40    Vector4f& operator=(const Vector4f& other)
     41    {
     42        if (&other != this) {
     43            set(other.x, other.y, other.z, other.w);
     44        }
     45        return *this;
     46    }
    3947
    4048    bool operator==(const Vector4f& op2) const
     
    9098}
    9199
    92 inline void Vector4f::set(float x1, float y1, float z1, float w1)
     100inline void Vector4f::set(float x, float y, float z, float w)
    93101{
    94     x = x1;
    95     y = y1;
    96     z = z1;
    97     w = w1;
     102    this->x = x;
     103    this->y = y;
     104    this->z = z;
     105    this->w = w;
    98106}
    99107
    100 inline void Vector4f::set(const Vector4f& v4)
    101 {
    102     x = v4.x;
    103     y = v4.y;
    104     z = v4.z;
    105     w = v4.w;
    106 }
    107 
    108 inline void Vector4f::set(const Vector3f& v, float w1)
     108inline void Vector4f::set(const Vector4f& v)
    109109{
    110110    x = v.x;
    111111    y = v.y;
    112112    z = v.z;
    113     w = w1;
     113    w = v.w;
    114114}
    115115
    116 inline float Vector4f::dot(const Vector4f& vec) const
     116inline void Vector4f::set(const Vector3f& v, float w)
    117117{
    118     return (x * vec.x + y * vec.y + z * vec.z + w * vec.w);
     118    x = v.x;
     119    y = v.y;
     120    z = v.z;
     121    this->w = w;
     122}
     123
     124inline float Vector4f::dot(const Vector4f& v) const
     125{
     126    return (x * v.x + y * v.y + z * v.z + w * v.w);
    119127}
    120128
Note: See TracChangeset for help on using the changeset viewer.