[SOLVED] Unhandled exception!!!

Hi everybody,

First of all I have to say that I am new using OgreNewt.

I have successfully compiled and linked OgreNewt and setup my program to be able to use it.

But, following the OgreNewt wiki:

http://www.ogre3d.org/wiki/index.php/Ne ... e_Dynamics

I do not why my program crashes when it starts the physics engine.

I have created the following method:

void CreatePhysicBody(OgreNewt::World* mWorld)
{
// BOX BODY
// standard 1x1x1 cube.
Vector3 size = Ogre::Vector3( 1, 1, 1 );
SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
Entity* ent = mSceneMgr->createEntity("box_body", "box.mesh" );
node->attachObject( ent );
node->setScale( size );

// rigid body.
OgreNewt::Collision* col = new OgreNewt::CollisionPrimitives::Box( mWorld, size );
OgreNewt::Body* bod = new OgreNewt::Body( mWorld, col );
bod->attachToNode( node );

// initial position
bod->setPositionOrientation( Ogre::Vector3(0,3,-2),Ogre::Quaternion::IDENTITY );
delete col;

int mass = 10.0;
Vector3 inertia = OgreNewt::MomentOfInertia::CalcBoxSolid( mass, size );
bod->setMassMatrix( mass, inertia );
bod->setStandardForceCallback();
}

When the program runs that method it crashes. I have debugged the program and it says:

Unhandled exception at 0x0042b3f2 in test.exe: 0xC0000005: Access violation reading location 0x00000000.

It crashes in the line:

m_col = NewtonCreateBox( m_world->getNewtonWorld(), (float)size.x, (float)size.y, (float)size.z, &matrix[0] );

from the OgreNewt_CollisionPrimitives.cpp

Could anyone tell me what is the problem, please?

Thanks

Can you put the code part when you call this function?

I have a similar but more complex structure to create objects. I don't finish it at all (specially in terms of animations) but perhaps you can use it. It`s in spanish but is easy to understand, just do this translations:

obtener = get
eliminar = destroy
tamanio = size
cuerpo = body
crear = create
sombra = shadow
número = number
velocidad = speed/velocity


int numero_entidades = 0; // número de entidades cargadas actualmente


class clase_objeto_nivel
{

private: // variables y funciones privadas

Entity* entidad;
SceneNode* nodo;
string nombre_nodo;
Collision* colision;
Body* cuerpo;
Real masa;
Vector3 tamanio;
Vector3 inercia;
Vector3 posicion;
bool activar_colisiones;
AnimationState* animacion;
Real velocidad_animacion;
int numero_entidad;


public: // variables y funciones públicas

void incrementar_numero_entidades() // incrementa el número de entidades actual
{
numero_entidades++;
}

void resetear_numero_entidades() // resetea el número de entidades actual
{
numero_entidades = 0;
}

void decrementar_numero_entidades(int cantidad) // decrementa el número de entidades actual la cantidad solicitada
{
numero_entidades = numero_entidades + cantidad;
}

void crear_entidad(String mesh) // crea una entidad nueva e incrementa el número de éstas
{
entidad = manager->createEntity(mesh + StringConverter::toString(numero_entidades), mesh );
incrementar_numero_entidades();
aboveWaterEnts.push_back(entidad);
}


Entity* obtener_entidad(void) // devuelve la entidad que contiene el objeto
{
return entidad;
}

void eliminar_entidad() // elimina la entidad que contiene el objeto
{
manager->destroyEntity(entidad);
}


void crear_nodo (Vector3 tam)
{
nodo = manager->getRootSceneNode()->createChildSceneNode();
nodo->attachObject(entidad);
nodo->setScale(tam);
}

void crear_nodo(Vector3 tam, Quaternion orient) // crea un nodo nuevo asociado a la entidad
{
nodo = manager->getRootSceneNode()->createChildSceneNode();
nodo->attachObject(entidad);
nodo->setScale(tam);
nodo->setOrientation(orient);
}

SceneNode* obtener_nodo() // devuelve el nodo contenido en el objeto
{
return nodo;
}

void eliminar_nodo() // elimina el nodo contenido en el objeto
{
nodo->detachAllObjects();
manager->destroySceneNode(nodo->getName());
}

void definir_posicion_nodo(Vector3 pos) // define la posición del nodo contenido en el objeto
{
nodo->setPosition(pos);

}

Vector3 obtener_posicion_nodo() // devuelve la posición del nodo
{
return nodo->getPosition();
}

void definir_orientacion_nodo(Quaternion orient) // define la orientación del nodo
{
nodo->setOrientation(orient);
}


Quaternion obtener_orientacion_nodo() //devuelve la posición del nodo
{
return nodo->getOrientation();
}

void crear_colision(int tipo_objeto, Vector3 tam, Real mas) // crea una colisión para el objeto
{
switch(tipo_objeto)
{
case 0: colision = new OgreNewt::CollisionPrimitives::TreeCollision( mundo, nodo, false );
break;
case 1: colision = new OgreNewt::CollisionPrimitives::Box( mundo, tam );
break;
case 2: colision = new OgreNewt::CollisionPrimitives::Ellipsoid( mundo, tam );
break;
case 3: colision = new OgreNewt::CollisionPrimitives::ConvexHull( mundo, nodo, nodo->getOrientation(), nodo->getPosition() );
break;
}
}


Collision* obtener_colision() // devuelve la colisión del objeto (por defecto no puede devolver nada porque se elimina tras crear el cuerpo)
{
return colision;
}


void eliminar_colision() // elimina la colisión del objeto (por defecto)
{
delete colision;
}


void crear_cuerpo(int tipo_objeto, Vector3 tam, Real mas) // crea el cuerpo del objeto
{
cuerpo = new OgreNewt::Body( mundo, colision );
cuerpo ->attachToNode( nodo);
cuerpo ->setPositionOrientation( obtener_posicion_nodo(), Ogre::Quaternion::IDENTITY );

switch(tipo_objeto)
{
case 1: inercia = OgreNewt::MomentOfInertia::CalcBoxSolid( mas, tam );
cuerpo->setMassMatrix( mas, inercia);
cuerpo->setStandardForceCallback();
break;

case 2: inercia = OgreNewt::MomentOfInertia::CalcEllipsoidSolid( mas, tam );
cuerpo->setMassMatrix( mas, inercia);
cuerpo->setStandardForceCallback();
break;

case 3: inercia = OgreNewt::MomentOfInertia::CalcEllipsoidSolid( mas, tam );
cuerpo->setMassMatrix( mas, inercia);
cuerpo->setStandardForceCallback();
break;
}
}


Body* obtener_cuerpo() // devuelve el cuerpo del objeto
{
return cuerpo;
}

Vector3 obtener_posicion_cuerpo() // devuelve la posición del cuerpo del objeto
{
Quaternion orient;
Vector3 pos;

cuerpo->getPositionOrientation(pos, orient);

return pos;
}

Quaternion obtener_orientacion_cuerpo() // devuelve la orientación del cuerpo del objeto
{
Quaternion orient;
Vector3 pos;

cuerpo->getPositionOrientation(pos, orient);

return orient;
}


void definir_posicion_cuerpo(Vector3 pos) // define la posición del cuerpo del objeto
{
Quaternion orient;
Vector3 pos_vieja;

cuerpo->setPositionOrientation(pos, orient);
}


void definir_orientacion_cuerpo(Quaternion orient) // define la orientacion del cuerpo del objeto
{
Quaternion orient_vieja;
Vector3 pos;

cuerpo->setPositionOrientation(pos, orient);
}


void definir_posicion_orientacion_cuerpo(Vector3 pos, Quaternion orient) // define la posición y la orientación del cuerpo del objeto, ambas a la vez
{
cuerpo->setPositionOrientation (pos, orient);
}




void eliminar_cuerpo() // eliminar el cuerpo del objeto
{
delete cuerpo;
}

void activar_sombras(bool sombras) // activar las sombras del objeto (para desactivar las sombras sobre el propio objeto hay que hacerlo sobre el material)
{
entidad->setCastShadows(sombras);
}


void anadir_animacion(string nombre, bool activa, bool loop) // añadir animación al objeto (FALTA PERFECCIONARLO PARA AÑADIR MÁS DE UNA)
{
animacion = entidad->getAnimationState(nombre);
animacion ->setEnabled(activa);
animacion ->setLoop(loop);
}

void animar (Real velocidad) // animar el objeto
{
animacion->addTime(velocidad);
}



////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// CREAR EL OBJETO (varios tipos)
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////

// objeto sin colisiones, ni animaciones -> eligiendo orientacion

void crear_objeto(String mesh, bool sombras, Vector3 tamanio, Vector3 posicion, Quaternion orientacion)
{
crear_entidad(mesh);
crear_nodo(tamanio, orientacion);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
}


// objeto sin colisiones, ni animaciones -> sin elegir orientacion

void crear_objeto(String mesh, bool sombras, Vector3 tamanio, Vector3 posicion)
{
crear_entidad(mesh);
crear_nodo(tamanio);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
}


// objeto con animaciones pero sin colisiones -> eligiendo orientacion

void crear_objeto(string mesh, bool sombras, Vector3 tamanio, Vector3 posicion, Quaternion orientacion, string nombre_animacion, bool animacion_activa, bool loop)
{
crear_entidad(mesh);
crear_nodo(tamanio, orientacion);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
anadir_animacion(nombre_animacion, animacion_activa, loop);
}

// objeto con animaciones pero sin colisiones -> sin elegir orientacion

void crear_objeto(string mesh, bool sombras, Vector3 tamanio, Vector3 posicion, string nombre_animacion, bool animacion_activa, bool loop)
{
crear_entidad(mesh);
crear_nodo(tamanio);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
anadir_animacion(nombre_animacion, animacion_activa, loop);
}

// objeto con colisiones pero sin animaciones -> eligiendo orientacion

void crear_objeto(string mesh, bool sombras, Vector3 tamanio, Vector3 posicion, Quaternion orientacion, int tipo_colision, Real masa)
{
crear_entidad(mesh);
crear_nodo(tamanio, orientacion);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
crear_colision(tipo_colision, tamanio, masa);
crear_cuerpo(tipo_colision, tamanio, masa);
eliminar_colision();
}


// objeto con colisiones pero sin animaciones -> sin elegir orientacion

void crear_objeto(string mesh, bool sombras, Vector3 tamanio, Vector3 posicion, int tipo_colision, Real masa)
{
crear_entidad(mesh);
crear_nodo(tamanio);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
crear_colision(tipo_colision, tamanio, masa);
crear_cuerpo(tipo_colision, tamanio, masa);
eliminar_colision();
}

// objeto con colisiones y animaciones -> eligiendo orientacion

void crear_objeto(string mesh, bool sombras, Vector3 tamanio, Vector3 posicion, Quaternion orientacion, int tipo_colision, Real masa, string nombre_animacion, bool animacion_activa, bool loop)
{
crear_entidad(mesh);
crear_nodo(tamanio, orientacion);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
crear_colision(tipo_colision, tamanio, masa);
crear_cuerpo(tipo_colision, tamanio, masa);
eliminar_colision();
anadir_animacion(nombre_animacion, animacion_activa, loop);

}

// objeto con colisiones y animaciones -> sin elegir orientacion

void crear_objeto(string mesh, bool sombras, Vector3 tamanio, Vector3 posicion, int tipo_colision, Real masa, string nombre_animacion, bool animacion_activa, bool loop)
{
crear_entidad(mesh);
crear_nodo(tamanio);
definir_posicion_nodo(posicion);
activar_sombras(sombras);
crear_colision(tipo_colision, tamanio, masa);
crear_cuerpo(tipo_colision, tamanio, masa);
eliminar_colision();
anadir_animacion(nombre_animacion, animacion_activa, loop);

}





void eliminar_objeto() // Eliminar el objeto
{
eliminar_nodo();
eliminar_entidad();
eliminar_cuerpo();

}




};

I have solved the problem it was a noob mistake! . I am a bit sleepy...

Are you spanish?

Yes, I'm Spanish (you can notice it by loooking at my strange english xDD)

Where are you from?

I am from Spain too