Войти
ПрограммированиеФорумОбщее

хочу создать универсальные математические классы типа : Vector , Matrix , и т д

Страницы: 1 2 3 Следующая »
#0
2:33, 19 мар. 2013

пока что я только успел собрать класс вектор !

что я подразумеваю пот словом универсальный чтоб работал и в 2D и в 3D!

буду суда ставить класс , матрицы  , кватерниона и т д.

а вы мне помогите совет ! или луче допишите сами что не так!


PS: пусть тут будут готовые математические классы!
     


ну вот пока что только  класс Vecotr3

+ Показать

так следующий этап это Mtarix Qaternion .
от которых меня кидает в под , мягко говоря !
ну вот помогите сделать матрицы и кватернионы
, а лучше вообще позбавиться от кватернионов !?

что тут лишние Quaternion

class Quaternion
{

  friend class cCompressedQuat;

  private:
    Vector3  V;
    float  R;

  public:
    Quaternion(void){};
    Quaternion(const Vector3 &InitV,const float InitR):V(InitV),R(InitR) {};
    Quaternion(const Matrix  &Mat)  {*this = Mat;}
    Quaternion(const Vector3 &InitRPY);


    //------------------------------------------------------------//

      inline Quaternion &operator *= (const float Scalar)
        {
        V *= Scalar;
        R *= Scalar;

        return *this;
      }


     inline Quaternion &Conjugate(Quaternion &Quat)
      {
        V.x = -Quat.V.x;  V.y = -Quat.V.y;  V.z = -Quat.V.z;
        R = Quat.R;
        return *this;
      }

    inline Quaternion &operator += (const Quaternion &OtherQuat)
      {
        V.x += OtherQuat.V.x;  V.y += OtherQuat.V.y;  V.z += OtherQuat.V.z;
        R += OtherQuat.R;

        return *this;
      }

    inline Quaternion &operator -= (const Quaternion &OtherQuat)
      {
        V.x -= OtherQuat.V.x;  V.y -= OtherQuat.V.y;  V.z -= OtherQuat.V.z;
        R -= OtherQuat.R;

        return *this;
      }



    Quaternion &operator *=(const Quaternion &OtherQuat);
   //--------------------------------------------------------------//


    Quaternion &operator = (const Matrix& Mat);
    Quaternion &operator = (const cCompressedQuat &CQuat);


  //---------------------------------------------------------//

          inline float DotProduct(const Quaternion &OtherQuat) const  //4 dimensional dot product
      {
        return ( (V * OtherQuat.V) + (R * OtherQuat.R) );
      }

          inline Quaternion operator * (const Quaternion &OtherQuat) const  //4 dimensional dot product
          {
            Quaternion Temp = *this;
            return     Temp *= OtherQuat;
          }



      Quaternion operator * (float k) const
      {
        Quaternion Temp = *this;
        return     Temp *= k;
      }


      Quaternion operator + (const Quaternion &OtherQuat) const
      {
        Quaternion Temp = *this;
        return     Temp += OtherQuat;
      }

      Quaternion operator - (const Quaternion &OtherQuat) const
      {
        Quaternion Temp = *this;
        return     Temp -= OtherQuat;
      }


      //-----------------------------------//
      inline float GetLengthSquared(void)const
      {
        float  ret = (V.LengthSquared() + (R * R) );
        return ret;
      }


      float GetLength(void)const
      {
        float  Ret = sqrt( GetLengthSquared() );
        return Ret;
      }
   //----------------------------------------------------------------//


      inline bool  operator == (const Quaternion &Other) const
        {
          if ((GetR() == Other.GetR()) &&
            (GetV() == Other.GetV()))
          {
            return true;
          }

          return false;
        }


      inline bool  operator != (const Quaternion &Other) const
        {
          if ((GetR() == Other.GetR()) &&
            (GetV() == Other.GetV()))
          {
            return false;
          }

          return true;
        }
  //----------------------------------------------------------------//


          float  GetR      (void) const { return R;}
        const  Vector3  &GetV  (void) const { return V;}
        bool  Normalise    (void);
        bool  Interpolate    (const Quaternion &Quat1,const Quaternion &Quat2,float Fraction);

        bool  LookAt      (const Vector3 &TargetPos, const Vector3 &CameraPos,Vector3 &UpDir, bool IsUpDirReallyRightDir = false);
        //bool  LookTowards    (const Vector3& NormalisedDirToTarget, Vector3& UpDir, bool IsUpDirReallyRightDir);
        void  CreateRotation  (const Vector3& RotAxis, float AngleInRads);
        void  Orientate    (const Vector3 &NormStartVec, const Vector3 &NormEndVec);


};




Quaternion::Quaternion(const Vector3 &InitRPY)
{
  float SinX = sinf(InitRPY.x * 0.5f);
  float CosX = cosf(InitRPY.x * 0.5f);
  float SinY = sinf(InitRPY.y * 0.5f);
  float CosY = cosf(InitRPY.y * 0.5f);
  float SinZ = sinf(InitRPY.z * 0.5f);
  float CosZ = cosf(InitRPY.z * 0.5f);

  V.x = CosZ * SinX * CosY + SinZ * CosX * SinY;
  V.y = CosZ * CosX * SinY - SinZ * SinX * CosY;
  V.z = SinZ * CosX * CosY - CosZ * SinX * SinY;

  R = CosZ * CosX * CosY + SinZ * SinX * SinY;
}



bool Quaternion::Normalise(void)
{
  float Length = GetLength();
  if (Length == 0.0f)
    return false;

  (*this) *= (1.0f / Length);
  return true;
}



Quaternion &Quaternion::operator *= (const Quaternion &OtherQuat)
{
  Vector3 D1 = OtherQuat.V;
  Vector3 D2 = V;

  D1 *= R;
  D2 *= OtherQuat.R;

  R = (R * OtherQuat.R) - (V * OtherQuat.V);

  V.cross(OtherQuat.V);
  V += D1;
  V += D2;

  return *this;
}




//--------------------------------------------------------------------------------
// Matrix to Quaternion (Source: Baraff)
//--------------------------------------------------------------------------------

Quaternion &Quaternion::operator =(const Matrix &Mat)
{




  return *this;
}








//-------------------------------function-------------------------------------------//





bool Quaternion::Interpolate(const Quaternion &Quat1,const Quaternion &Quat2,float Fraction)
{

  Quaternion NormQuat2 = Quat2;              //Used to get rid of degenerate case

  if ((Quat1.DotProduct(NormQuat2)) < 0.0f)
    NormQuat2 *= -1.0f;                  //See comment above

  V.Interpolate(Quat1.V, NormQuat2.V, Fraction);

  R  = Quat1.R * Fraction;
  R += NormQuat2.R * (1.0f - Fraction);

  return Normalise();
}







void Quaternion::CreateRotation(const Vector3& RotAxis, float AngleInRads)
{
  float  Thetad2 = AngleInRads * 0.5f;
  float  SinTd2  = sinf(Thetad2);
  float  CosTd2  = cosf(Thetad2);

//  RotAxis.Normalise();        // this shouldn't be necessary!

  R = CosTd2;
  V = (SinTd2 *  RotAxis);
}

что лишнего  матрицы 3х3

class Matrix
{
public:
  inline Matrix(   float a00, float a01, float a02,
                        float a10, float a11, float a12,
                        float a20, float a21, float a22)
  {
    Mat[0][0] = a00; Mat[0][1] = a01; Mat[0][2] = a02;
    Mat[1][0] = a10; Mat[1][1] = a11; Mat[1][2] = a12;
    Mat[2][0] = a20; Mat[2][1] = a21; Mat[2][2] = a22;
  }
  
  inline Matrix(void)
  {}
}


#1
2:42, 19 мар. 2013

какой-то дурной у тебя вектор. что за метод SetAndScale? Cross тоже странный.

#2
2:45, 19 мар. 2013

SetAndScale чтоб  сразу длину сказать 
а в Cross что не так ?
и главный вопрос такой вектор хватит для 3д двига ?
ну понятно что матрицы потом допишу !
удалил SetAndScale

#3
2:48, 19 мар. 2013

Suslik
скажи пожалуйста чего не хватает и что добавить?
ето очень важно а то как я напишу 3д двиг без вектора

#4
4:44, 19 мар. 2013

werasaimon
> а в Cross что не так
ЛОгично возвращать результат продукта, а не делать результатом себя. Тоже и с интерполяцией. Я бы ее даже не включал в класс вектора, для этого можно использовать и отдельную функцию (набор перегруженных функций). К примеру cross:

  
const mlVector3 cross (const mlVector3 &vector)const
{  
  return mlVector3(
    y * vector.z - z * vector.y,
    z * vector.x - x * vector.z,
    x * vector.y - y * vector.x
  );

Оперетор "*". Не смотря код, многие не предположат, что это dot product. Или заменить другим оператором, или сделать обычным методом. Аргумент - шейдеры, данная операция перемножает покомпонентно 2 вектора. У тебя это метод Scale.

Также методы BoundMin, BoundMax не нужны в самом классе. Вектор должен выполнять те операции, которые на него возложены. Не стоит из него делать убер класс, умеющий все. Lenght + Normal + операторы для удобной записи вполне хватит.

И еще, себе я сделал 2 метода нормализации, один нормирует себя, другой константный, возвращает нормированный вектор.

Еще такой вариант записи:

vector3 a,b,c;
a + b = c;
Данная запись не должна компилироваться, у тебя же скомпилируется, от того, что оператор сложения возвращает не константный объект.
#5
4:45, 19 мар. 2013

Пиши свой двиг, а то что необходимо вектору прийдет со временем.

#6
8:13, 19 мар. 2013

Volodar

> ЛОгично возвращать результат продукта, а не делать результатом себя
а в чом разница !
и где мне заделать константы

#7
8:22, 19 мар. 2013

werasaimon
> а в чом разница !
В читаемости кода. Сравни

с = cross(a, b);
c.cross(a,b);
c = a ^ b;

Первая запись понятна интуитивно, то что вектор С является результатом векторного перемножения.
Вторая запись уже не понятно что есть С и куда идет результат выполнения. Может С это вектор, может объект, выполняющий операции с векторами. Надо идти и смотреть декларацию
Третья запись удобна в сложных выражениях, но только после того, как посмотреть что означает оператор для твоей реализации вектора.

Какие константы? Направления осей, начало координат?

#8
8:24, 19 мар. 2013

что какие ещё начало координат:,?
вот я как раз думаю всегда использование 3 варианта

#9
8:45, 19 мар. 2013

werasaimon
> ето очень важно а то как я напишу 3д двиг без вектора
скачай любой движок и посмотри. А я вот лично вообще взял DirectXMath и обертку над ним SampleMath - мне хватает, да еще и оптимизирован. На OGL есть glm, хотя лично мне она не понравилась

#10
13:40, 19 мар. 2013

werasaimon
Какова цель размещения здесь класса? Получить советы или показать, что ты его сделал и тебе все позавидовали?
Удаляюсь.

#11
15:55, 19 мар. 2013

Volodar
> vector3 a,b,c;
> a + b = c;
> Данная запись не должна компилироваться, у тебя же скомпилируется, от того, что оператор сложения возвращает не константный объект.
не всегда. это может быть полезно для глупых компиляторов, которые не умеют rvalue optimization:
вместо двух временных объектов, которые будут созданы при
d = a + b + c, иногда может быть удобнее
d = ((a + b) += c);
иногда.

#12
1:54, 20 мар. 2013

Volodar
цель слушать советы
а я знаю что вы знаете как правильно !
вообще с чего ты взял что я решил хвастаться ??
яж даже по твоему сделал cross

#13
1:57, 20 мар. 2013

Suslik
а Mini Gw глупый или нет ??

#14
1:58, 20 мар. 2013

war_zes
там куча левого !!!

Страницы: 1 2 3 Следующая »
ПрограммированиеФорумОбщее

Тема в архиве.