Capa de abstracción para hiper3d.

[erkosone]

Cuelgo esto aquí por que voy a empezar con ello y no se hasta donde seré capaz de llegar.. pego lo que iba a poner en recursos.. haber que tal se me da XD..

Buenas, cuelgo este post para ir comentando sobre lo que ando haciendo.
En principio son una colección de funciones para facilitar muchas de las tareas habituales de programación en 3d mas comunes, normalmente se suele usar un motor de renderizado 3d que ayuda a cargar objetos y manipular tamaños y angulos, pero casi siempre hay que currarse a mano estas funciones, así que en gemix no iba a ser menos, por ahora tenemos la lib hiper3d que renderiza en windows, así que todo lo demás hay que hacerlo a mano, cuando tenga algo minimamente presentable lo cuelgo.
Por cierto, gracias de nuevo a hiperbou por la lib

Los objetivos por ahora alcanzables son estos:
- setOrientation( id );
- getDist3d( id );
- getDist3d( id, id );
- advance3d( float distancia_ );
- collison3d( id, id );
- setCameraOrientation( id );
- setCameraFollow( id, mode ); -> en mode especificar primera persona, tercera persona, aerea, desactivar seguimiento..

Seguro que me voy a encontrar con mil trabas para hacerlo.. pero cuando se me mete algo en el coco..
Aunque mas que un set de funciones lo que quiero conseguir es un nivel de abstracción bastante mayor para usar la librería como se usan los Sprites en Div, todo relacionado con el id del objeto.
Incomming..

Por supuesto si alguien tiene ya experiencia anterior en todo esto lo animo a que haga mas cosas o las mismas pero mejores
Haber que me sale.. la idea es que quede como la EGUI, completamente transparente para el programador.

[CicTec]

Hola erkos,

Y si las programas en C, construyendo otro modulo temporal y cuando todo funciona se integran en la hiper3D, no seria mejor ?

[erkosone]

Si, primero voy a hacerlo directamente por scripting en gemix, cuando todo funcione perfectamente lo pasaré a C, por que ahora mismo en Gemix me aclaro al 100% y en C++ le tengo miedo a los problemas que me puedan salir al acceder a objetos que no he programado yo, cuando vea que todo está correcto si quieres hasta puedes añadirselo a la original para que tenga mas features.

[erkosone]

Vaya.. ya tengo los primeros contratiempos, no puedo meter un dato typedef en el bloque de variables LOCAL.. y las variables public van con ID global.. esto tiene mala pinta.

[erkosone]

Pues es un poco complicado hacer un advance XD.. con lo facil que sería en radianes como toda la vida.. pero esta lib está portada al sistema Div, en grados y escalados * 1000 para los angulos.
Para hacer cualquier cosa es complicadisimo traducirlo XD.. me estoy volviendo loco, cada día odio con mas fuerza a Div y su absurdo sistema trigonometrico.

[GINO]

Pasar de grados a radianes y viceversa es esencial:
radianes = grados * PI / 180000
grados = radianes * 180000 / PI
Nota que sería 180º pero ahí ya está escalado para funcionar con ángulos DIV.

[erkosone]

Siempre me pierdo en las conversiones por que las funciones de la lib van como en div pero hay que hacer una conversión a radianes antes de sacar los valores de advanceX y advanceY y una vez teniendolos volver a grados, es la leche XD..

GINO te invito a que lo trastes también, haber si nos sale un control de cámara normalito XD.. con eso para empezar será la leche, por que las colisiones son lo mas sencillo por radios.

[SimulatorOne]

yo te animo a que creas nuevas funciones de calculo 3D
por que esta lib actualmente la veo limitada en muchas cosas.(ademas que trabaja por soft y es muy lenta)

yo tengo experiencia en programación 3D... pero solo a nivel basic(lo mas sencillo) con DrakBasic (que tiempos 2005-2006 xDD)
y si es mi segundo programa de edicion de "juegos" que compro de verdad. 50€ me costo.

y si todo programación en modo OPP sin procesos, solo funciones, la verdad que me tiraba la vida solo para hacer algo muy sencillo, en cuando en leguaje div lo hago en un momento en 2D

si quieres te puedo chivarte la API del DarkBAsic, solo como referencia a las futuras funciones 3D.

Y si leyendo tu primer post, esa primera lista de funciones seria lo mas bascio. Si, es muy parecido con DarkBasic.

y las colisiones???? por vectoriales, polígonos, cubica, esférica... que tienes pensado en las colisiones.


Puedo depir algunas sugerencias:
->Creacion de modelos 3d con primitivas formas: NEW_OBJECT
=Cubo 3D y cuadrado plano 2D, estas ya estan actualmente
>Cilindro 3D
>Esfera pelota 3D
>Circulo/redonda 2D
>Cono 3D
>triangulo plano 2D

-> Manipulación de textura:
>parecido a SET_OBJECT_TEXTUREWRAP, pero que tamaños size_x size_y float. permite cambiar el tamaño de la textura.
>SET_OBJECT_TEXTURE... pero que sea animado, es decir partiendo de un GRAPH en memoria, se pueda cambiar dinamicamente.
>Habilitacion y Dehabilitacion de Transparencias/Canal Alpha en las texturas (supongo que esto solo funciona en modo 32bits)
>Se puedan aplicar efectos FXMODE en las texturas.


de momento lo dejo asi estas sugerencias...
de todas formas, son sugerencias futuras para tomar nota,
Erkos no son para ti solo estas sugerencias, es para el team que creo el modulo 3D, o si Cictec o GINO puede echarle mano a esta lib.


La verdad que se puede aprovechar esta lib 3D, para simular un modo8, pero tiene algunas mejoras con respeto al modo8: coordenadas,tamaños floats, se pueden cargar modelos 3D m2d y se pueden añadir cubos... en fin.
el modo8 de div2... solo funciona por AREAS cuadradas, sprites 2D. u_u

y bueno pixelado como la PS1 o la NDS.
al menos la N64 tiene un filtro de suavizado en las texturas.

[erkosone]

Hola Simulatorone, esta librería no está limitada por que le falte todo esto, falta otra librería que la complemente como "motor 3d" que sería la que incluye todo lo que estamos hablando, la TinyGL en C++ es todavía mas rudimentaria que la hiper3D, esta por lo menos renderiza modelos md2 y permite rotar ya nativa XD.. en c eso se hace también a pelo o en su defecto con una función que te haces tu que aplica rotación a cava vertice.. un lío curioso XD..

Las colisiones las voy a hacer por ahora solo por esferas por que es muy sencillo, ya cuando consiga mover bien la cámara las hago en un momento, pero si quieres te adelanto la formula por si estás trasteando.. es muy simple solo tienes que hacer esto:

Dando por supuesto que las cordenadas centrales de un objeto están almacenadas en variables simples como:
Objeto A:
float x_;
float y_;
float z_;

Objeto B:
float x_;
float y_;
float z_;

Y teniendo en cuenta que en el momento de crear un objeto nuevo hay que darle un valor añadido de 'radio de colisión' que estará almacenado en esta variable:
float radius_;

Se hace esto para calcular si los objetos están solapandose uno con el otro:
Paso A, calcular la distancia 3d entre los 2 objetos, como estamos hablando de sus centros.. pues calculamos la distancia entre los dos 'puntos' o 'vectores' de la siguiente manera:
Distancia3d = sqrt( ( B.x_ - A.x_ )*( B.x_ - A.x_ ) + ( B.y_ - A.y_ )*( B.y_ - A.y_ ) + ( B.z_ - A.z_ )*( B.z_ - A.z_ ) )
Colisión = si (A.radius_ + B.radius_) es mayor o igual a Distancia3D se ha producido colisión, si es menor no se ha colisionado.

Como ves las colisiones "por esferas" son un chiste XD.. lo chungo es que estoy traduciendo esto a Gemix pero tío.. entre que una cosa está en grados y otra en radianes yo me hago la picha un lío y no se por donde tirar.. tengo algunas nociones.. pero no demasiada soltura.. y tengo que hacerlo muy despacio y pensando muy bien cada operación por que en gemix con esta librería cambia todo XD..

El código de una cámara simple en opengl usando glut es este:

Source Code (C++) [ Download ] [ Hide ]

Source Code (C++) [ Download ] [ Show ]

• #include "camera.h"
• #include "math.h"
• #include <iostream>
• #include "windows.h"
• SF3dVector F3dVector ( GLfloat x, GLfloat y, GLfloat z )
• {
•         SF3dVector tmp;
•         tmp.x = x;
•         tmp.y = y;
•         tmp.z = z;
•         return tmp;
• }
• SF3dVector AddF3dVectors (SF3dVector* u, SF3dVector* v)
• {
•         SF3dVector result;
•         result.x = u->x + v->x;
•         result.y = u->y + v->y;
•         result.z = u->z + v->z;
•         return result;
• }
• void AddF3dVectorToVector ( SF3dVector * Dst, SF3dVector * V2)
• {
•         Dst->x += V2->x;
•         Dst->y += V2->y;
•         Dst->z += V2->z;
• }
•  
•  
• /***************************************************************************************/
•  
• CCamera::CCamera()
• {
•         //Init with standard OGL values:
•         Position = F3dVector (  0.0,
•                                                         0.0,
•                                                         0.0);
•         ViewDir = F3dVector(    0.0,
•                                                         0.0,
•                                                         -1.0);
•         ViewDirChanged = false;
•         //Only to be sure:
•         RotatedX = RotatedY = RotatedZ = 0.0;
• }
•  
• void CCamera::GetViewDir( void )
• {
•         SF3dVector Step1, Step2;
•         //Rotate around Y-axis:
•         Step1.x = cos( (RotatedY + 90.0) * PIdiv180);
•         Step1.z = -sin( (RotatedY + 90.0) * PIdiv180);
•         //Rotate around X-axis:
•         double cosX = cos (RotatedX * PIdiv180);
•         Step2.x = Step1.x * cosX;
•         Step2.z = Step1.z * cosX;
•         Step2.y = sin(RotatedX * PIdiv180);
•         //Rotation around Z-axis not yet implemented, so:
•         ViewDir = Step2;
• }
• void CCamera::Move (SF3dVector Direction)
• {
•         AddF3dVectorToVector(&Position, &Direction );
• }
•  
• void CCamera::RotateY (GLfloat Angle)
• {
•         RotatedY += Angle;
•         ViewDirChanged = true;
• }
•  
• void CCamera::RotateX (GLfloat Angle)
• {
•         RotatedX += Angle;
•         ViewDirChanged = true;
• }
•  
• void CCamera::Render( void )
• {
•         glRotatef(-RotatedX , 1.0, 0.0, 0.0);
•         glRotatef(-RotatedY , 0.0, 1.0, 0.0);
•         glRotatef(-RotatedZ , 0.0, 0.0, 1.0);
•         glTranslatef( -Position.x, -Position.y, -Position.z );
• }
•  
• void CCamera::MoveForwards( GLfloat Distance )
• {
•         if (ViewDirChanged) GetViewDir();
•         SF3dVector MoveVector;
•         MoveVector.x = ViewDir.x * -Distance;
•         MoveVector.y = ViewDir.y * -Distance;
•         MoveVector.z = ViewDir.z * -Distance;
•         AddF3dVectorToVector(&Position, &MoveVector );
• }
•  
• void CCamera::StrafeRight ( GLfloat Distance )
• {
•         if (ViewDirChanged) GetViewDir();
•         SF3dVector MoveVector;
•         MoveVector.z = -ViewDir.x * -Distance;
•         MoveVector.y = 0.0;
•         MoveVector.x = ViewDir.z * -Distance;
•         AddF3dVectorToVector(&Position, &MoveVector );
• }

como ves no es nada de código.. pero tela para traducirlo XD.. no por que sea difícil, si no por que hay que tenerlo todo muy claro, si te ves con ganas te animo a que lo intentes también, te cuelgo un proyecto minimo en C++ con opengl que funciona, es una escena hecha a lineas con 4 for´s y el objeto cámara que funciona perfectamente, solo hay que traducir esto a nuestro 'niño'

[erkosone]

Por cierto, la oop de darkbasic es bastante lamentable XD.. yo también lo compré después de div2, está chulo pero yo que se.. ahora mismo se me hace muy extraño programar de esa manera a mi también, la verdad es que es un sistema bastante come cocos.. no vale la pena programar en eso