lunes, 22 de agosto de 2011

Math Engine : Capitulo 1. Sobrecarga de operadores

Capítulo perteneciente al math engine LordPakus

Hola a todos (disculpad por el parón, pero el niño me está "robando" algo más de tiempo del que me pensaba :D )

Bienvenidos al primer capitulo del Math Engine. En este capitulo no haremos mucho más que iniciar las bases del proyecto.

Conceptos fundamentales:
1. Todo el código se escribirá en un inicio en C/C++
2. Todo el código se intentará encapsular en clases (aunque en prinicipio no habrá gestores como en el game engine, usease el MathEngine será una colección de funcionalidades matematicas no un motor que correrá de fondo gestionandolo todo).
3. Todas las optimizaciones irán con ifdef (así se podrán hacer diferentes compilaciones optimizadas en función de la arquitectura en que se trabaje : tipo de ensamblador, tipo de procesador, etc...). Las optimizaciones mínimas que se tienen en cuenta ahora mismo son paralelización multicore y ensamblador vectorial SSE.
4. El código que gestione el usuario ha de ser mínimo , claro y sencillo.
5. Habrá 3 grandes bloques de trabajo: operaciones entre vectores, operaciones entre matrices y operaciones vector-matriz.
6. Las operaciones se irán implementado a medida que vosotros las vayais pidiendo así que si os interesa algún función en particular no dudeis en pedirla.


Dicha toda esta parrafada, expondremos el capitulo como tal.

Lo primero será crear el proyecto. Deberiais saber hacerlo pero si no teneis mucha memoria :D, podeis mirar como se creó el proyecto en el game engine (http://lordpakus.blogspot.com/2011/05/gameengine-capitulo-1.html).

Una vez tengais el proyecto creado cread los siguientes archivos y copiad el siguiente código. Vereis que no es más un código muy sencillo de operación entre vectores.

main.cpp:
/**************************************************************************************************/
//        Código creado por F.Bordas (LordPakus) como ejemplo de creación de un math engine
//        para el blog LordPakus (http://lordpakus.blogspot.com/).
//        Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/

/**************************************************************************************************/
// main.cpp : Main de nuestro MathEngine
/**************************************************************************************************/

//Include del Math engine
#include "LPMath.h"

//Delete console
//#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

#include <iostream>                //Usada para imprimir por consola

using namespace std;

int main (int argc, char* argv[])
{
    LPVector4 v1,v2;

    v1.Set(0.0f,1.0f,2.0f,3.0f);
    v2.Set(1.1f,1.2f,1.3f,1.4f);

    v1 += v2;

    cout << "Vector 1: ";
    v1.print();
    cout << "\n";

    cout << "Vector 2: ";
    v2.print();
}

LPMath.h
/**************************************************************************************************/
//        Código creado por F.Bordas (LordPakus) como ejemplo de creación de un math engine
//        para el blog LordPakus (http://lordpakus.blogspot.com/).
//        Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/

//Lista de todos los includes necesarios para el math engine.

#include "LPVector4.h"


LPVector4.h
/**************************************************************************************************/
//        Código creado por F.Bordas (LordPakus) como ejemplo de creación de un math engine
//        para el blog LordPakus (http://lordpakus.blogspot.com/).
//        Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/


/**************************************************************************************************/
// LPVector.h
/**************************************************************************************************/

#ifndef __LPVector4__
#define __LPVector4__

class LPVector4
{
public:
    void Set(float x, float y , float z , float t); //Funcion para inicializar un vector de 4 elementos
    void print();                                    //Función para imprimir el vector por la consola

    void operator +=(const LPVector4 v);            //Sobrecarga de operador +=
   

public:
    float xv,yv,zv,tv;
};

#endif



LPVector4.cp
/**************************************************************************************************/
//        Código creado por F.Bordas (LordPakus) como ejemplo de creación de un math engine
//        para el blog LordPakus (http://lordpakus.blogspot.com/).
//        Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/

#include "LPVector4.h"
#include <iostream>                //Usada para imprimir por consola

using namespace std;

void LPVector4::Set(float x, float y , float z , float t) //Funcion para inicializar un vector de 4 elementos
{
    xv = x;
    yv = y;
    zv = z;
    tv = t;
}

//Imprimimos el valor del vector
void LPVector4::print()
{
    cout << "x: " << xv << " y: " << yv << " z: " << zv << " t: " << tv;
}

//Sobrecarga operador +=
void LPVector4::operator +=(const LPVector4 v)
{
    xv += v.xv;
    yv += v.yv;
    zv += v.zv;
    tv += v.tv;
}





Para probar el ejecutable debereis hacerlo desde una consola para que os permita ver el resultado.




Por ahora lo único que os debe interesar es como se ha hecho la sobrecarga del operador += aplicado a los vectores ya que esta sobrecarga es de lo que más se usara en el MathEngine para hacer que el código quede limpio de cara al usuario.

Sin más, aqui os dejo, espero que os lo hayais pasado bien y hayais aprendido

Nos vemos

2 comentarios :

  1. Genial el tema.

    Una cosa queria preguntarte, e leido mucho codigo de varios juegos y engines, y e visto que usan en las cabeceras este tipo de definicion:
    //----------
    #ifndef __LPVector4__
    #define __LPVector4__

    #endif
    //----------

    Lo que no comprendo es el porque se sigue usando ese tipo ademas de ser mas lineas de codigo pudiendo usar el:

    #pragma once

    Que segun wikipedia dice que es conpactible con gcc

    Si alguien da una idea del porque, o porque se ve mas standar usar ifndef.


    Saludos.

    ResponderEliminar
  2. Buenas ,

    A mi forma de ver es lo mismo, solo depende de lo que tengas costumbre de usar.

    Siendo puristas, de la manera que lo he puesto se podria hacer una especie de log de compilación que nos dijera que se ha compilado y que no, pero vamos, no lo he visto usarse en la vida...

    A ver si alguien sabe un motivo más cientifico que yo tb tengo curiosidad de saberlo

    Nos vemos

    ResponderEliminar

Related Posts Plugin for WordPress, Blogger...