API tools faq
paste
Advertisement
Guest User

EGC - TEST 1

a guest
Mar 26th, 2019
63
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.14 KB | None | 0 0
raw download clone embed print report
  1. === VEC2.CPP ===
  2. vec2& vec2::operator =(const vec2 &srcVector){
  3.         x = srcVector.x;
  4.         y = srcVector.y;
  5.         return *this;
  6.     }
  7.  
  8.     vec2 vec2::operator +(const vec2& srcVector) const{
  9.         vec2 result;
  10.         result.x = x + srcVector.x;
  11.         result.y = y + srcVector.y;
  12.         return result;
  13.     }
  14.  
  15.     vec2& vec2::operator +=(const vec2& srcVector){
  16.         x+=srcVector.x;
  17.         y+=srcVector.y;
  18.         return *this;
  19.     }
  20.  
  21.     vec2 vec2::operator *(float scalarValue) const{
  22.         vec2 result;
  23.         result.x = x*scalarValue;
  24.         result.y = y*scalarValue;
  25.         return result;
  26.     }
  27.  
  28.     vec2 vec2::operator -(const vec2& srcVector) const{
  29.         vec2 result;
  30.         result.x=x-srcVector.x;
  31.         result.y =y-srcVector.y;
  32.         return result;
  33.     }
  34.  
  35.     vec2& vec2::operator -=(const vec2& srcVector){
  36.             x-=srcVector.x;
  37.             y-=srcVector.y;
  38.             return *this;
  39.     }
  40.  
  41.     vec2& vec2::operator -(){
  42.             x=-x;
  43.             y=-y;
  44.             return *this;
  45.     }
  46.  
  47.     float vec2::length() const{
  48.         return sqrt(x*x+y*y);
  49.     }
  50.  
  51.     vec2& vec2::normalize(){
  52.         float len = length();
  53.         x = x/len;
  54.         y = y/len;
  55.         return *this;
  56.     }
  57.  
  58.     float dotProduct(const vec2& v1, const vec2& v2){
  59.         float result;
  60.         result = v1.x*v2.x + v1.y*v2.y;
  61.         return result;
  62.     }
  63.  
  64. === VEC3.CPP ===
  65. vec3& vec3::operator =(const vec3 &srcVector){
  66.         x = srcVector.x;
  67.         y = srcVector.y;
  68.         z = srcVector.z;
  69.         return *this;
  70.     }
  71.  
  72.     vec3 vec3::operator +(const vec3& srcVector) const{
  73.         vec3 result;
  74.         result.x = x + srcVector.x;
  75.         result.y = y + srcVector.y;
  76.         result.z = z + srcVector.z;
  77.         return result;
  78.     }
  79.  
  80.     vec3& vec3::operator +=(const vec3& srcVector){
  81.         x += srcVector.x;
  82.         y += srcVector.y;
  83.         z += srcVector.z;
  84.         return *this;
  85.     }
  86.  
  87.     vec3 vec3::operator *(float scalarValue) const{
  88.         vec3 res;
  89.         res.x = x*scalarValue;
  90.         res.y = y*scalarValue;
  91.         res.z = z*scalarValue;
  92.         return res;
  93.     }
  94.  
  95.     vec3 vec3::operator -(const vec3& srcVector) const{
  96.         vec3 res;
  97.         res.x = x - srcVector.x;
  98.         res.y = y - srcVector.y;
  99.         res.z = z - srcVector.z;
  100.         return res;
  101.     }
  102.    
  103.     vec3& vec3::operator -=(const vec3& srcVector){
  104.         x-= srcVector.x;
  105.         y-= srcVector.y;
  106.         z-= srcVector.z;
  107.         return *this;
  108.     }
  109.  
  110.     vec3& vec3::operator -(){
  111.         x = -x;
  112.         y = -y;
  113.         z = -z;
  114.         return *this;
  115.     }
  116.  
  117.     float vec3::length() const{
  118.         return sqrt(x*x+y*y+z*z);
  119.     }
  120.  
  121.     vec3& vec3::normalize(){
  122.  
  123.         float len = this->length();
  124.        
  125.         x = x/len;
  126.         y = y/len;
  127.         z = z/len;
  128.         return *this;
  129.     }
  130.  
  131.     float dotProduct(const vec3& v1, const vec3& v2){
  132.         float res;
  133.         res = v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
  134.         return res;
  135.     }
  136.  
  137.     vec3 crossProduct(const vec3& v1, const vec3& v2){
  138.         return vec3(v1.y*v2.z - v1.z*v2.y,
  139.                       v1.z*v2.x - v1.x*v2.z,
  140.                       v1.x*v2.y - v1.y*v2.x);
  141.     }
  142.  
  143. === VEC4.CPP ===
  144. vec4& vec4::operator =(const vec4 &srcVector){
  145.         x = srcVector.x;
  146.         y = srcVector.y;
  147.         z = srcVector.z;
  148.         w = srcVector.w;
  149.         return *this;
  150.     }
  151.  
  152.     vec4 vec4::operator +(const vec4& srcVector) const{
  153.         vec4 result;
  154.         result.x = x+srcVector.x;
  155.         result.y = y+srcVector.y;
  156.         result.z = z+srcVector.z;
  157.         result.w = w+srcVector.w;
  158.         return result;
  159.        
  160.     }
  161.  
  162.     vec4& vec4::operator +=(const vec4& srcVector){
  163.         x+=srcVector.x;
  164.         y+=srcVector.y;
  165.         z+=srcVector.z;
  166.         w+=srcVector.w;
  167.         return *this;
  168.     }
  169.  
  170.     vec4 vec4::operator *(float scalarValue) const{
  171.         vec4 result;
  172.         result.x = x*scalarValue;
  173.         result.y = y*scalarValue;
  174.         result.z = z*scalarValue;
  175.         result.w = w*scalarValue;
  176.         return result;
  177.     }
  178.  
  179.     vec4 vec4::operator -(const vec4& srcVector) const{
  180.         vec4 result;
  181.         result.x = x-srcVector.x;
  182.         result.y = y-srcVector.y;
  183.         result.z = z-srcVector.z;
  184.         result.w = w-srcVector.w;
  185.         return result;
  186.        
  187.     }
  188.  
  189.     vec4& vec4::operator -=(const vec4& srcVector){
  190.         x-=srcVector.x;
  191.         y-=srcVector.y;
  192.         z-=srcVector.z;
  193.         w-=srcVector.w;
  194.         return *this;
  195.     }
  196.  
  197.     vec4& vec4::operator -(){
  198.         x = -x;
  199.         y = -y;
  200.         z = -z;
  201.         w =-w;
  202.         return *this;
  203.     }
  204.  
  205.     float vec4::length() const{
  206.         return sqrt(x*x+y*y+z*z+w*w);
  207.     }
  208.  
  209.     vec4& vec4::normalize(){
  210.  
  211.         float len = this->length();
  212.        
  213.         x = x/len;
  214.         y = y/len;
  215.         z = z/len;
  216.         w = w/len;
  217.         return *this;
  218.     }
  219.  
  220. === MAT3.CPP ===
  221. mat3& mat3::operator=(const mat3 &srcMatrix){
  222.         for(int i = 0; i < 9; i++)
  223.             matrixData[i] = srcMatrix.matrixData[i];
  224.         return *this;
  225.     }
  226.  
  227.     mat3 mat3::operator*(float scalarValue) const {
  228.         mat3 result;
  229.         for(int i = 0; i < 9; i++ )
  230.             result.matrixData[i] = matrixData[i] * scalarValue;
  231.         return result;
  232.     }
  233.  
  234.     mat3 mat3::operator*(const mat3 &srcMatrix) const {
  235.         mat3 result;
  236.         for(int i = 0; i < 3; i++)
  237.             for(int j = 0; j < 3; j++)
  238.             {
  239.                 result.at(i, j) = 0;
  240.                 for(int k = 0; k < 3; k++)
  241.                     result.at(i, j) += at(i, k) * srcMatrix.at(k, j);
  242.             }
  243.         return result;
  244.     }
  245.  
  246.     vec3 mat3::operator*(const vec3 &srcVector) const {
  247.         vec3 result;
  248.         result.x = srcVector.x * at(0, 0) + srcVector.y * at(0, 1) + srcVector.z * at(0, 2);
  249.         result.y = srcVector.x * at(1, 0) + srcVector.y * at(1, 1) + srcVector.z * at(1, 2);
  250.         result.z = srcVector.x * at(2, 0) + srcVector.y * at(2, 1) + srcVector.z * at(2, 2);
  251.         return result;
  252.     }
  253.  
  254.     mat3 mat3::operator+(const mat3 &srcMatrix) const {
  255.         mat3 result;
  256.         for(int i = 0; i < 9; i++ )
  257.             result.matrixData[i] = matrixData[i] + srcMatrix.matrixData[i];
  258.         return result;
  259.     }
  260.  
  261.  
  262.     float& mat3::at(int i, int j) {
  263.         return matrixData[i+3*j];
  264.     }
  265.  
  266.     const float mat3::at(int i, int j) const {
  267.         float result = matrixData[i+3*j];
  268.         return result;
  269.     }
  270.  
  271.     float mat3::determinant() const {
  272.         float result = at(0,0)*at(1,1)*at(2,2) + at(1,0)*at(2,1)*at(0,2) + at(0,1)*at(2,0)*at(1,2) - at(2,0)*at(1,1)*at(0,2) - at(0,0)*at(2,1)*at(1,2) - at(2,2)*at(0,1)*at(1,0);
  273.         return result;
  274.     }
  275.  
  276.     mat3 mat3::inverse() const {
  277.         float deter = this->determinant();
  278.         mat3 inversa;
  279.         for(int i = 0; i < 3; i++)
  280.         {
  281.             for(int j = 0; j < 3; j++)
  282.             {
  283.                 inversa.at(i,j) = ( at(((j+1)%3),((i+1)%3)) * at(((j+2)%3),((i+2)%3)) -
  284.                         at(((j+1)%3),((i+2)%3)) * at(((j+2)%3),((i+1)%3)) ) / deter;
  285.             }
  286.         }
  287.         return inversa;
  288.     }
  289.  
  290.     mat3 mat3::transpose() const {
  291.         mat3 result;
  292.         for(int i = 0; i < 3; i++)
  293.             for(int j = 0; j < 3; j++)
  294.                 result.at(i,j) = at(j, i);
  295.         return result;
  296.     }
  297.  
  298. === MAT4.CPP ===
  299. mat4& mat4::operator=(const mat4 &srcMatrix)
  300.     {
  301.         for(int i = 0; i < 16; i++)
  302.             this->matrixData[i] = srcMatrix.matrixData[i];
  303.         return *this;
  304.     }
  305.  
  306.     mat4 mat4::operator*(float scalarValue) const
  307.     {
  308.         mat4 result;
  309.         for(int i = 0; i < 16; i++ )
  310.             result.matrixData[i] = this->matrixData[i] * scalarValue;
  311.         return result;
  312.     }
  313.  
  314.     mat4 mat4::operator*(const mat4 &srcMatrix) const
  315.     {
  316.         mat4 result;
  317.         for(int i = 0; i < 4; i++)
  318.             for(int j = 0; j < 4; j++)
  319.             {
  320.                 result.at(i, j) = 0;
  321.                 for(int k = 0; k < 4; k++)
  322.                     result.at(i, j) += this->at(i, k) * srcMatrix.at(k, j);
  323.             }
  324.         return result;
  325.     }
  326.  
  327.     vec4 mat4::operator*(const vec4 &srcVector) const
  328.     {
  329.         vec4 result;
  330.         result.x = srcVector.x * at(0, 0) + srcVector.y * at(0, 1) + srcVector.z * at(0, 2) + srcVector.w * at(0,3);
  331.         result.y = srcVector.x * at(1, 0) + srcVector.y * at(1, 1) + srcVector.z * at(1, 2) + srcVector.w * at(1,3);
  332.         result.z = srcVector.x * at(2, 0) + srcVector.y * at(2, 1) + srcVector.z * at(2, 2) + srcVector.w * at(2,3);
  333.         result.w = srcVector.x * at(3, 0) + srcVector.y * at(3, 1) + srcVector.z * at(3, 2) + srcVector.w * at(3,3);
  334.         return result;
  335.     }
  336.  
  337.     mat4 mat4::operator+(const mat4 &srcMatrix) const
  338.     {
  339.         mat4 result;
  340.         for(int i = 0; i < 16; i++ )
  341.             result.matrixData[i] = this->matrixData[i] + srcMatrix.matrixData[i];
  342.         return result;
  343.     }
  344.  
  345.     //get element by (row, column)
  346.  
  347.     float& mat4::at(int i, int j)
  348.     {
  349.         return matrixData[i+4*j];
  350.     }
  351.  
  352.     const float mat4::at(int i, int j) const
  353.     {
  354.         float result = matrixData[i+4*j];
  355.         return result;
  356.     }
  357.  
  358.     float mat4::determinant() const
  359.     {
  360.         float result = at(0,0)*(at(1,1)*at(3,3)*at(2,2) + at(1,3)*at(2,1)*at(3,2) + at(3,1)*at(2,3)*at(1,2) - at(2,3)*at(1,1)*at(3,2) - at(3,3)*at(2,1)*at(1,2) - at(2,2)*at(3,1)*at(1,3)) -
  361.                        at(0,1)*(at(1,0)*at(3,3)*at(2,2) + at(1,3)*at(2,0)*at(3,2) + at(3,0)*at(2,3)*at(1,2) - at(2,3)*at(1,0)*at(3,2) - at(3,3)*at(2,0)*at(1,2) - at(2,2)*at(3,0)*at(1,3)) +
  362.                        at(0,2)*(at(1,0)*at(3,3)*at(2,1) + at(1,3)*at(2,0)*at(3,1) + at(3,0)*at(2,3)*at(1,1) - at(2,3)*at(1,0)*at(3,1) - at(3,3)*at(2,0)*at(1,1) - at(2,1)*at(3,0)*at(1,3)) -
  363.                        at(0,3)*(at(1,0)*at(3,2)*at(2,1) + at(1,2)*at(2,0)*at(3,1) + at(3,0)*at(2,2)*at(1,1) - at(2,2)*at(1,0)*at(3,1) - at(3,2)*at(2,0)*at(1,1) - at(2,1)*at(3,0)*at(1,2));
  364.         return result;
  365.     }
  366.  
  367.     mat4 mat4::inverse() const {
  368.         mat4 aux;
  369.  
  370.         for (int i = 0; i < 4; i++) {
  371.             for (int j = 0; j < 4; j++) {
  372.                 int iAux = 0;
  373.                 int jAux = 0;
  374.                 mat3 aux3;
  375.  
  376.                 for (int i1 = 0; i1 < 4; i1++) {
  377.                     if (i1 != i) {
  378.                         for (int j1 = 0; j1 < 4; j1++) {
  379.                             if (j1 != j) {
  380.                                 aux3.at(iAux, jAux) = (*this).at(i1, j1);
  381.  
  382.                                 jAux++;
  383.                                 if (jAux == 3) {
  384.                                     jAux = 0;
  385.                                     iAux++;
  386.                                 }
  387.                             }
  388.                         }
  389.                     }
  390.                 }
  391.  
  392.                 if ((i + j) % 2 == 0)
  393.                     aux.at(j, i) = aux3.determinant();
  394.                 else
  395.                     aux.at(j, i) = -aux3.determinant();
  396.             }
  397.         }
  398.  
  399.         return aux * (float)(1 / (*this).determinant());
  400.     }
  401.  
  402.  
  403.     mat4 mat4::transpose() const
  404.     {
  405.         mat4 result;
  406.         for(int i = 0; i < 4; i++)
  407.             for(int j = 0; j < 4; j++)
  408.                 result.at(i,j) = at(j, i);
  409.         return result;
  410.     }
  411.  
  412. === TRANSFORM.CPP ===
  413. //transformation matrices in 2D
  414.     mat3 translate(const vec2 translateArray) {
  415.         mat3 m;
  416.         m.at(0, 2) = translateArray.x;
  417.         m.at(1, 2) = translateArray.y;
  418.         return m;
  419.     }
  420.  
  421.     mat3 translate(float tx, float ty){
  422.         mat3 m;
  423.         m.at(0, 2) = tx;
  424.         m.at(1, 2) = ty;
  425.         return m;
  426.     }
  427.  
  428.     mat3 scale(const vec2 scaleArray){
  429.         mat3 m;
  430.         m.at(0,0) = scaleArray.x;
  431.         m.at(1,1) = scaleArray.y;
  432.         return m;
  433.     }
  434.  
  435.     mat3 scale(float sx, float sy){
  436.         mat3 m;
  437.         m.at(0,0) = sx;
  438.         m.at(1,1) = sy;
  439.         return m;
  440.     }
  441.  
  442.     mat3 rotate(float angle){
  443.         float alpha = (PI*angle)/180;
  444.         mat3 m;
  445.         m.at(0,0) = cos(alpha);
  446.         m.at(0,1) = sin(alpha)*(-1);
  447.         m.at(1,0) = sin(alpha);
  448.         m.at(1,1) = cos(alpha);
  449.         return m;
  450.     }
  451.  
  452.     //transformation matrices in 3D
  453.     mat4 translate(const vec3 translateArray){
  454.         mat4 m;
  455.         m.at(0, 3) = translateArray.x;
  456.         m.at(1, 3) = translateArray.y;
  457.         m.at(2, 3) = translateArray.z;
  458.         return m;
  459.     }
  460.  
  461.     mat4 translate(float tx, float ty, float tz){
  462.         mat4 m;
  463.         m.at(0, 3) = tx;
  464.         m.at(1, 3) = ty;
  465.         m.at(2, 3) = tz;
  466.         return m;
  467.     }
  468.  
  469.     mat4 scale(const vec3 scaleArray){
  470.         mat4 m;
  471.         m.at(0,0) = scaleArray.x;
  472.         m.at(1,1) = scaleArray.y;
  473.         m.at(2,2) = scaleArray.z;
  474.         return m;
  475.     }
  476.  
  477.     mat4 scale(float sx, float sy, float sz){
  478.         mat4 m;
  479.         m.at(0,0) = sx;
  480.         m.at(1,1) = sy;
  481.         m.at(2,2) = sz;
  482.         return m;
  483.     }
  484.  
  485.     mat4 rotateX(float angle){
  486.         mat4 m;
  487.         float alpha = (PI*angle)/180;
  488.         m.at(1,1) = cos(alpha);
  489.         m.at(1,2) = sin(alpha)*(-1);
  490.         m.at(2,1) = sin(alpha);
  491.         m.at(2,2) = cos(alpha);
  492.         return m;
  493.     }
  494.  
  495.     mat4 rotateY(float angle){
  496.         mat4 m;
  497.         float alpha = (PI*angle)/180;
  498.         m.at(0,0) = cos(alpha);
  499.         m.at(2,0) = sin(alpha)*(-1);
  500.         m.at(0,2) = sin(alpha);
  501.         m.at(2,2) = cos(alpha);
  502.         return m;
  503.     }
  504.  
  505.     mat4 rotateZ(float angle){
  506.         mat4 m;
  507.         float alpha = (PI*angle)/180;
  508.         m.at(0,0) = cos(alpha);
  509.         m.at(0,1) = sin(alpha)*(-1);
  510.         m.at(1,0) = sin(alpha);
  511.         m.at(1,1) = cos(alpha);
  512.         return m;
  513.     }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!