Форум программистов [Powered by Invision Power Board]

Цитата

Sic luceat lux...

Код

//=============================================================================

#ifndef AAUX_H
  #define AAUX_H

//=============================================================================

#include <math.h>
#include "aVector.h"

//=============================================================================

class aAux
{
  private:
    aAux();

Код

  public:
    inline float aaGetPi() {return pi;} //получить значение числа пи. ~3.14
    inline float aaGetPid() {return pid;}

Код

inline float aaGetPidi() {return pidi;}

Код

inline float aaGetMagnitude(const aVector& vec) {return sqrt(vec.x*vec.x + vec.y*vec.y + vec.z*vec.z);}

Код

    inline float aaDotMulty(const aVector& vec, const aVector& vec2) {return (vec.x*vec2.x + vec.y*vec2.y + vec.z*vec2.z);}

Код

    inline float ator(float angle) {return (angle*pid);}// как я и говорил: иногда надо переводить угол из градусов в радианы. Именно этим и занимается функция
    inline float aaFloatAbs(float f) {return (f < 0.0 ? (-f):f);}// данная функция, как нетрудно понять, просто возвращает модуль числа.
    inline aVector aaGetVectorProjection(const aVector& vec, const aVector& vec2) {return (vec2* (/*тут вам надо подумать совсем немного*/) );}

Код

    inline aVector aaVVVXYZ2pos(const aVector& i, const aVector& j, const aVector& k, const aVector& vec) {return ((i*vec.x) + (j*vec.y + k*vec.z));}

Код

    inline aVector aaGetNormal(const aVector& vec, const aVector& vec2, const aVector& vec3) {return aaNormalize(aaCrossMulty((vec2 - vec), (vec3 - vec)));}

Код

    inline bool aaVectorOnLine(const aVector& l1, const aVector& l2, const aVector& p) {/*здесь будет ваша реклама*/}

Код

    static aAux& aaGetInstance()
    {
      static aAux aux;

      return aux;
    }//получаем наш синглтон

    //uVector
    aVector aaCrossMulty(const aVector& vec, const aVector& vec2);//функция получения векторного произведения двух векторов
    aVector aaNormalize(const aVector& vec);//функция нормализации вектора
    float aaGetAngle(const aVector& v, const aVector& v2);//получение угла между векторами
    aVector aaRotateAroundVector(const aVector& v, const aVector& v2, float angle); //вращение вектора v, относительно вектора v2 на угол angle
    bool aaCompareFloat(float f1, float f2);//функция сравнения двух чисел с плавующей точкой
    float aaGetLength(const aVector& vec, const aVector& vec2);//получение расстояния от одной точки до другой
    bool aaCheckVectorIn(const aVector& p, const aVector& vec, const aVector& vec2, const aVector& vec2);//функция проверки лежит ли данная точка в заданном треугольнике
    aVector aaGetIntersection(const aVector& l1, const aVector& l2, const aVector& s1, const aVector& s2, const aVector& s3);//пересекает ли линия плоскость, заданную тремя точками

    ~aAux();

  private:
    float pi; //наше число pi
    float pid; // (pi/180.0)
    float pidi; // (180.0/pi)
};

//=============================================================================

#endif

//=============================================================================

Код

//=============================================================================

#include <math.h>
#include "../inc/aAux.h"

//=============================================================================

aAux::aAux()
{
  pi = 3.1415926535f; //наши постоянные значения
  pid = 0.017453292f;
  pidi = 57.2957795f;
}

//=============================================================================

aVector aAux::aaCrossMulty(const aVector& vec, const aVector& vec2)
{
  /*
    Векторное произведение векторов, на выходе даёт вектор,
    перпендикулярный двум данным.
  */
  aVector res;

  res.x = (vec.y*vec2.z) - (vec.z*vec2.y);
  res.y = (vec.z*vec2.x) - (vec.x*vec2.z);
  res.z = (vec.x*vec2.y) - (vec.y*vec2.x);

  return res;
}

//=============================================================================

aVector aAux::aaNormalize(const aVector& v)
{
  /*
    Нормализация вектора - это процесс получения длинны
    вектора и деление каждой координаты на неё.
    Необходимо для того, чтобы длинна вектора
    была не больше 1. Это необходимое условие,
    например, для нормалей.
  */
  aVector vec(v);
  float m = aaGetMagnitude(vec);

  if (aaCompareFloat(m, 0.0f))
    return aVector(0.0f, 0.0f, 0.0f);

  vec.x /= m;
  vec.y /= m;
  vec.z /= m;

  return vec;
}

//=============================================================================

float aAux::aaGetAngle(const aVector& v, const aVector& v2)
{
  /*
    Получить угол между двумя векторами.
    Мы сначала нормализуем векторы, а затем
    получаем угол через арккосинус от длинны
    их скалярного произведения.
    осильте сами.
  */
  float scal = 0.0f;
  //... ?
  return scal;
}

//=============================================================================

aVector aAux::aaRotateAroundVector(const aVector& v, const aVector& v2, float angle)
{
  /*
    Функция, которая поворачивает вектор v,
    относительно вектора v2 на угол angle.
    Что это значит? Чтобы разобраться, сделайте
    след.: нарисуйте на листе бумаги стандартные
    базисы. Если вы возьмёте ось абсцисс и повернёте
    на (-90/270) градусов относительно оси ординат,
    то получите ось аппликат. Пробуйте.
  */
  aVector dx, dy, dz;
  aVector vec(v);
  aVector vec2(v2);
  float dot = aaDotMulty(vec, vec2);
  float angle2 = ator(angle);

  dz.x = vec2.x * dot;
  dz.y = vec2.y * dot;
  dz.z = vec2.z * dot;

  dx.x = vec.x - dz.x;
  dx.y = vec.y - dz.y;
  dx.z = vec.z - dz.z;

  dy = aaCrossMulty(dx, vec2);

  vec.x = dx.x*cos(angle2) + dy.x*sin(angle2) + dz.x;
  vec.y = dx.y*cos(angle2) + dy.y*sin(angle2) + dz.y;
  vec.z = dx.z*cos(angle2) + dy.z*sin(angle2) + dz.z;

  return vec;
}

//=============================================================================


bool aAux::aaCompareFloat(float f1, float f2)
{
  /*
    Весьма важная функция: сравнение двух
    чисел с плавующей точкой. По причинам, которые
    я предлогаю назвать вам в этом топике,
    сам компьютер не может сравнить их достоверно.
    Поэтому приходится брать модуль разницы чисел
    и сравнивать с достаточно маленькой величиной.
  */
  if (aaFloatAbs((f1) - (f2)) < 0.0001f)
    return 1;

  return 0;
}

//=============================================================================

float aAux::aaGetLength(const aVector& vec, const aVector& vec2)
{
  /*
    Получение расстояния между точками похоже на получение
    длинны вектора.
  */
  float vx = vec2.x - vec.x;
  float vy = vec2.y - vec.y;
  float vz = vec2.z - vec.z;

  return sqrt(vx*vx + vy*vy + vz*vz);
}

//=============================================================================


bool aAux::aaCheckVectorIn(const aVector& p, const aVector& vec1, const aVector& vec2, const aVector& vec3)
{
  /*
    Проверка, находится ли данная вершина p,
    в треугольнике, заданном вершинами vec1,
    vec2, vec3. Чтобы понять процесс, нарисуйте
    на листе бумаги треугольник и точку (в нём,
    или вне его), после чего проведите от неё
    линии к каждой вершине треугольника. А теперь
    узнайте угол между каждой получившейся прямой
    и соседней к ней. Если их сумма ~= 360 градусов,
    то точка лежит внутри треугольника.
  */
  aVector tmpVector2, tmpVector3, tmpVector4;

  tmpVector2 = vec1 - p;
  tmpVector3 = vec2 - p;
  tmpVector4 = vec3 - p;

  float angle = aAux::aaGetInstance().aaGetAngle(tmpVector2, tmpVector3)*aAux::aaGetInstance().aaGetPidi();

  angle += aAux::aaGetInstance().aaGetAngle(tmpVector3, tmpVector4)*aAux::aaGetInstance().aaGetPidi();
  angle += aAux::aaGetInstance().aaGetAngle(tmpVector4, tmpVector2)*aAux::aaGetInstance().aaGetPidi();

  if ((angle >= 359.9f) && (angle <= 360.1f))
    return 1;

  return 0;
}

//=============================================================================

aVector aAux::aaGetIntersection(const aVector& l1, const aVector& l2, const aVector& s1, const aVector& s2, const aVector& s3)
{
  /*
    Проверяем: пересекает ли данная линия l1 - l2
    плоскость, заданную тремя вершинами s1, s2, s3.
    Как это получается? Подумайте...
  */
  aVector tmpVector = aaGetNormal(s1, s2, s3);

  float r1 = aaDotMulty(tmpVector, (l1 - s1));
  float r2 = aaDotMulty(tmpVector, (l2 - s1));

  tmpVector = aaAdd(l1, aaMultiply((l2 - l1), -r1/(r2 - r1)));

  if (aaVectorOnTriangleEdges(tmpVector, s1, s2, s3))
    return tmpVector; 

  if ((r1*r2) < 0.0)
    return tmpVector;

  return aVector(0.0f, 0.0f, 0.0f);
}

//=============================================================================

aAux::~aAux()
{
  //деструктор, он и в африке деструктор
}

//=============================================================================

Цитата(Rickert @ 20.10.2008, 08:29

)

Но вот вопрос: как это лучше сделать? Половина ответят - засунуть функции работы с векторами в класс векторов, а другая половина скажет: засунуть их в отдельный синглтон. Я солидарен со вторыми, хотябы потому что этот метод избавит на от бессмысленного копирования одних и тех же функций тысячи раз, при создании объектов.

Цитата(Rickert @ 20.10.2008, 08:29

)

Три точки, три вектора - это минимум, с помощью которого можно конкретно задать плоскость в трёхмерном пространстве.

Цитата(mr.DUDA @ 10.11.2008, 11:14

)

P.S. а функцию aaVVVXYZ2pos ты часто используешь?

Цитата(mr.DUDA @ 10.11.2008, 11:14

)

Можно вектором и флоатом задать (нормаль и расстояние от {0,0,0}).

Цитата(mr.DUDA @ 10.11.2008, 11:14

)

Код функций не копируется при создании объекта.

Цитата(Rickert @ 10.11.2008, 11:25

)

Разве?

Код

class CSome
{
public:
    int Func(int arg)
    {
        return arg;
    }
};

int main()
{
    CSome x;
    CSome y;
    CSome *z = new CSome();

    x.Func(0);
    y.Func(1);
    z->Func(2);
}

Цитата(Rickert @ 10.11.2008, 11:25

)

Да, когда будем разбирать скелетную анимацию