spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

__declspec(align(16)) class Vector3 
    {
    public:
        union{
            struct{
                F32 x,y,z;
            };
            F32 f[3];
        };

        Vector3(){}
        Vector3(Vector3& v):x(v.x),y(v.y),z(v.z){}
        Vector3(F32 fx,F32 fy,F32 fz):x(fx),y(fy),z(fz){}
        Vector3(F32 af[3]):x(af[0]),y(af[1]),z(af[2]){}
        Vector3(F32 xyz):x(xyz),y(xyz),z(xyz){}
        Vector3(__m128& v);

                //usw. nen Paar Operatoren und so


               //Hier das Problem:

              //Vektor mit Matrix

        Vector3 operator * (Matrix& m)
               {
           __m128 result;
           result = _mm_mul_ps (_mm_replicate_x((__m128)(*this)),m(1));
           result = _mm_madd_ps(_mm_replicate_y((__m128)(*this)),m(2),result);
           result = _mm_madd_ps(_mm_replicate_z((__m128)(*this)),m(3),result);
           result = _mm_madd_ps(_mm_replicate_z((__m128)(*this)),m(4),result);
           return Vector3(result);
    }

        //Vektor mit Matrix

        Vector3 operator *= (Matrix& m);
               //In ähnlicher Form definiert

}

//Die Matrix-Klasse ist jetzt im Grunde genau so aufgebaut, nur dass sie 

//für Methoden zur Translation einen Vector& Parameter benutzt

C-/C++-Quelltext

#ifndef __VECTOR_H
#define __VECTOR_H

#include <xmmintrin.h>
#include "Include.h"

namespace testit
{
    class Matrix;

#   define _mm_shuffle_param(x,y,z,w)   \
    (x) | ((y)<<2) | ((z)<<4) | ((w)<<6)
#   define _mm_replicate_x(v)   \
    _mm_shuffle_ps((v),(v),_mm_shuffle_param(0,0,0,0))
#   define _mm_replicate_y(v)   \
    _mm_shuffle_ps((v),(v),_mm_shuffle_param(1,1,1,1))
#   define _mm_replicate_z(v)   \
    _mm_shuffle_ps((v),(v),_mm_shuffle_param(2,2,2,2))
#   define _mm_replicate_w(v)   \
    _mm_shuffle_ps((v),(v),_mm_shuffle_param(3,3,3,3))
#   define  _mm_madd_ps(a,b,c)  \
    _mm_add_ps(_mm_mul_ps((a),(b)),(c))
#   define  _mm_madd_ss(a,b,c)  \
    _mm_add_ss(_mm_mul_ss((a),(b)),(c))


    __declspec(align(16)) class Vector3 
    {
    public:
        union{
            struct{
                float x,y,z;
            };
            float f[3];
        };

        Vector3(){}
        Vector3(Vector3& v):x(v.x),y(v.y),z(v.z){}
        Vector3(float fx,float fy,float fz):x(fx),y(fy),z(fz){}
        Vector3(float af[3]):x(af[0]),y(af[1]),z(af[2]){}
        Vector3(float xyz):x(xyz),y(xyz),z(xyz){}
        Vector3(__m128& v);

        //Operatoren

        operator __m128();

        inline Vector3& operator = (Vector3& v){
            x=v.x;
            y=v.y;
            z=v.z;
            return *this;
        }

        //Vektor mit Matrix

        Vector3 operator * (Matrix& m){
            __m128 result;
            result = _mm_mul_ps (_mm_replicate_x((__m128)(*this)),m(1));
            result = _mm_madd_ps(_mm_replicate_y((__m128)(*this)),m(2),result);
            result = _mm_madd_ps(_mm_replicate_z((__m128)(*this)),m(3),result);
            result = _mm_madd_ps(_mm_replicate_z((__m128)(*this)),m(4),result);
            return Vector3(result);
        };

        //Vektor mit Matrix

        Vector3 operator *= (Matrix& m);
    };
}
#endif

C-/C++-Quelltext

#ifndef __MATRIX_H
#define __MATRIX_H

#include <xmmintrin.h>
#include "Include.h"

namespace testit
{
    __declspec(align(16)) class Matrix
    {
    public:
        union{
            struct{
                float m11,m12,m13,m14;
                float m21,m22,m23,m24;
                float m31,m32,m33,m34;
                float m41,m42,m43,m44;
            };
            float m[4][4];
        };

        Matrix(){}
        Matrix(float nAll): m11(nAll),m12(nAll),m13(nAll),m14(nAll),
            m21(nAll),m22(nAll),m23(nAll),m24(nAll),
            m31(nAll),m32(nAll),m33(nAll),m34(nAll),
            m41(nAll),m42(nAll),m43(nAll),m44(nAll){}

        Matrix( float n11,float n12,float n13,float n14,
            float n21,float n22,float n23,float n24,
            float n31,float n32,float n33,float n34,
            float n41,float n42,float n43,float n44):   m11(n11),m12(n12),m13(n13),m14(n14),
            m21(n21),m22(n22),m23(n23),m24(n24),
            m31(n31),m32(n32),m33(n33),m34(n34),
            m41(n41),m42(n42),m43(n43),m44(n44){}
        Matrix(Matrix& m):  m11(m.m11),m12(m.m12),m13(m.m13),m14(m.m14),
            m21(m.m21),m22(m.m22),m23(m.m23),m24(m.m24),
            m31(m.m31),m32(m.m32),m33(m.m33),m34(m.m34),
            m41(m.m41),m42(m.m42),m43(m.m43),m44(m.m44){}

        Matrix(__m128& n1, __m128& n2, __m128& n3, __m128& n4);

        Matrix& operator = (Matrix& m);
        bool operator == (Matrix& m);
        inline __m128   operator ()(int i)
        {
            assert(i<5 && i>0);
            return _mm_load_ps(m[i-1]);
        };
        inline float&       operator ()(int i,int j)
        {
            assert(i>0 && i<5);
            assert(j>0 && j<5);
            return m[i-1][j-1];
        };


        //Statische Methoden


        inline static Matrix Identity(){
            return Matrix(  1.0f, 0.0f, 0.0f, 0.0f,
                0.0f, 1.0f, 0.0f, 0.0f,
                0.0f, 0.0f, 1.0f, 0.0f,
                0.0f, 0.0f, 0.0f, 1.0f);
        }

        inline static Matrix Translate(Vector3& v){
            Matrix mReturn;
            mReturn =(Identity());
            mReturn.m41 = v.x;
            mReturn.m42 = v.y;
            mReturn.m43 = v.z;
            return mReturn;
        }
    };
}

#endif

C-/C++-Quelltext

#ifndef __INCLUDE_H
#define __INCLUDE_H

#include "Vector.h"
#include "Matrix.h"

#endif

Quellcode

 error C2064: Ausdruck ergibt keine Funktion, die 1 Argumente übernimmt

C-/C++-Quelltext

result = _mm_mul_ps (_mm_replicate_x((__m128)(*this)),m(1));

Quellcode

========== Erstellen: 1 erfolgreich, Fehler bei 0, 0 aktuell, 0 übersprungen ==========