Lo de la democratización de la distribución de juegos me parece genial por parte de Microsoft, es más, es una gran oportunidad para todo Indie que quiera publicar su juego a un bajo coste (Coste de la subscripción al Creator Club). Además Microsoft solo va a velar por el contenido de dicho juego no por las mécanicas, esa parte se la dejarán a los jugadores. Lo malo.. quizá el espacio máximo que puede ocupar un juego. Al tratarse de XBLA no puede superar los 150MB.

XNA Creators Club http://creators.xna.com

Saludos!

Buenas de nuevo! voy a explicarme mejor. Yo tengo un motor 3D ya listo en el que puedo reproducir animaciones, etc. Entonces lo que quiero montar es un API de alto nivel para que luego alguien con ese API pueda montar el editor de cut scenes. Creo que esto ya aclara mi pregunta. Ya tengo mis ideas generales (línea de tiempo, acciones que se ejecutan en esa línea de tiempo, etc) pero me gustaría saber si alguien ya ha implementado algo parecido pues que las comparta :). Gracias por el Link ethernet pero creo para un Api de cutscenes no es suficiente con tener una timeline que va ejecutando comandos.

Saludos

 Buenas, estoy a punto de implementar un sistema para crear cut scenes y me gustaría saber si alguien conoce algún documento/s interesante/s sobre el tema, he estado googleando y no he encontrado nada de provecho. También me sería de ayuda si alguíen del foro ha implementado alguno pues que me contara sus ideas, etc. Yo más o menos tengo ya montada una idea general del asunto pero nunca está de más escuchar al resto. Muchas gracias.

Saludos

 Excelente trabajo chicos!!, He probado todos los tutoriales y me van todos excepto el 3 pues yo no tengo tarjeta model 3.0 :(
Un saludo en especial a b3rs3rk3r! hay que ver.. del Illusion3DEngine al Hadd 2.0 ya hay unos añitos eh? jeje que recuerdos!!
pues nada a seguir así!!. Suerte.

 Buenas, si no recuerdo mal, con el propio sdk de directx te viene un exportador de .x para 3dStudioMax.
¿Has probado con ese? saludos.

 Buenas, yo creo que ser ingeniero informático está muy bien y tiene muchas salidas, eso si, al principio toca tragar curtiendote en programación y demás, pero gracias a los conocimientos adquiridos en la carrera estás dotado para afrontar más o menos cualquier tipo de problema que te pueda surgir y es que eso es un ingeniero, un tipo que afronta y resuelve problemas, para ello se preparó durante 5 añitos :)
Y si un ingeniero en informática no sabe programar en su 4º año de carrera.. mal vamos, creo que ya ha tenido que pasar por varias asignaturas jodidillas al respecto (estructura de datos, algoritmía, etc). Y si hay mucha diferencia entre un tipo que se ha hecho un módulo en programación y un ingeniero, el del módulo sabe sobre el lenguaje/s X que aprendió en el módulo y quizás le hayan enseñado algo de metodología de la programación, pero el ingeniero tiene los conocimientos de la metodología de la programación así como de ingeniería del software. Así pues  el del módulo es un campeón del código pero lo tendrá más jodido a la hora de resolver el problema, mientras que el ingeniero aplicando las herramientas que aprendió en la carrera (UML por ejemplo para ver mucho más clara una aproximazión a la solución, etc) conseguirá plantear mucho mejor el problema y podrá decirle a uno de estos campeones del código que se implemente la solución que le transmite. Esto es un poco como lo veo yo. Saludos y Feliz Navidad!! :)

 Buenas, ¿Has probado a tener un constructor copia?, quizás te interesaría también tener un
operador de asignación. Saludos

 Buenas Marco!, a primera vista lo que me parece que está sucediendo es que lo mismo no se te pinta el trozo de cono que se vería a través del plano, porque primero estás dibujando el plano con alpha y luego el cono!. Si haces esto obviamente no se visualizará el cono pues cuando se hace la transparencia el cono no estaba pintado!. Mira a ver si es esto lo que te sucede. Un saludo

 Buenas, mientras que hacer un cambio de este tipo reporte beneficios al usuario no me parece tan mal, por ejemplo sin con ello consiguen aumentar el rendimiento, etc. Adelante, por qué no?, Saludos

Buenas, el problema que tenias es debido a que el polimorfismo solo funciona con punteros, si utilizas un contenedor de tipo... vector en vez de usar uno de tipo vector tendrás problemas al guardar en ese vector una clase derivada de a. Es por eso que en tu ejemplo al meter un objeto de tipo a1 en tu vector de tipo a, siempre te ejecutaba el ::draw de la clase padre en vez de la derivada. Tenez cuidado con este tipo de cosas. Saludos

Buenas... vete a la web del desarrollador tanto de Ati como de Nvidia, hay millones de ejemplos, papers, etc. Saludos

 Buenas, a ver si puedo ayudar... yo en el trabajo me curré un modelo de tráfico, esto es, cochecitos que van por una trayectoria determinada y se respetan entre si, a la vez que hacen caso de las señales de tráfico. Para que los cochecitos fueran por una determinada trayectoria hacia que siguieran una spline de tipo catmull-rom, usé este tipo de curvas debido a que son bastante sencillas de calcular y a mi entender
generan unas curvas más sueaves que las bezier. Voy a pegar por aquí el código de la clase que tengo para este tipo de clases, espero que os sirva de algo.

Código [Seleccionar] Expand


/***************************************************************************
* Módulo: Spline.h                                                         *
*                                                                   *
* Fichero: () Programa                        (X) Interfaz de Clase        *
*          () Implementación de Clase         () Otros                     *
*                                                                          *
* Autor: GSC                                  *
*                                                                          *
* Fecha: 13 de Enero de 2005                                               *
*                                      *
* Ultima modificación: 18 de Enero de 2005                                 *
*                                                                          *
* Descripción:                                                             *
*               Interfaz de la clase que implementa                        *
*               Splines de tipo Catmull-rom.                               *
*                                                                          *
***************************************************************************/

#ifndef SPLINE_H
#define SPLINE_H


//--------------------------------------------------------------------------
// Declaración de clases
//--------------------------------------------------------------------------

class CSpline
{
private:

 struct SplinePoint
 {
  float x, y, z;     // Coordenadas
  float tx, ty, tz;  // Tangente
 };

 struct SplineSegment
 {
  unsigned int uiIndexPoint1;  // Índice al primer punto del segmento
  unsigned int uiIndexPoint2;  // Índice al segundo punto del segmento
  float        fLength;        // Longitud del segmento
 };

 // Longitud total de la spline
 float m_fTotalLength;  

 // Puntos que componen la curva
 vector<SplinePoint> m_vCurve;
 
 // Segmentos de la curva
 vector<SplineSegment> m_vSegments;

 // VB que almacenará los puntos a pintar de la curva
 CDynamicVB<FVF_PosDiffuse> m_VB;

public:

 CSpline () : m_fTotalLength(0.0f) { }
 // Constructor

 void AddKey (float  x, float  y, float  z,
        float tx, float ty, float tz);
 // Añade un nuevo punto clave (punto + tangente) a la spline.

 void AddSegment (int iIndexPoint1, int iIndexPoint2, float fLength);
 // Añade un nuevo segmento a la spline

 float GetSegmentLength (unsigned int uiSegment) const { assert(uiSegment < m_vSegments.size());
                                return m_vSegments[uiSegment].fLength; }
 // Devuelve la longitud del segmento de la spline pasado por parámetro.

 unsigned int GetNumSplinePoints () const { return m_vCurve.size(); }
 // Devuelve el número de puntos clave que tiene la spline.

 unsigned int GetNumSplineSegments () const { return m_vSegments.size(); }
 // Devuelve el número de segmentos que tiene la spline.

 float GetSplineLength () const { return m_fTotalLength; }
 // Devuelve la longitud total de la spline.

 void CreateResources ();
 // Crea el VB que albergará los vértices que componen la spline.

 void ReleaseResources ();
 // Libera el VB que alberga los vértices que componen la spline.

 D3DXVECTOR3 Evaluate (float& rfDistance, unsigned int& ruiSegment);
 // Devuelve el punto en la spline dado la distancia dentro del segmento
 // y el segmento.

 void Render ();
 // Dibuja la spline.

 void Destroy ();
 // Elimina los recursos adquiridos al crear la spline.
};

#endif  // SPLINE_H


Como podeis ver, una spline se define por un conjuntos de puntos clave. Yo además conservo los segmentos
dados por dos puntos clave y una longitud. De donde saco todos estos datos? pues del 3DStudio Max. en Max el grafista creaba las trayectorias con las propias splines del Max y yo luego mediante un script de max script salvaba la información que necesitaba para luego poder recrear la curva en tiempo real. Bueno a continuación pego el .cpp

Código [Seleccionar] Expand


/***************************************************************************
* Módulo: Spline.cpp                                                       *
*                                                                   *
* Fichero: () Programa                        () Interfaz de Clase         *
*          (X) Implementación de Clase        () Otros                     *
*                                                                          *
* Autor: GSC                                  *
*                                                                          *
* Fecha: 13 de Enero de 2005                                               *
*                                      *
* Ultima modificación: 13 de Enero de 2005                                 *
*                                                                          *
* Descripción:                                                             *
*               Implementación de la clase que implementa                  *
*               Splines.                                                   *
*                                                                          *
***************************************************************************/

#include "../Precompile.h"  // Includes que usa todo el proyecto


//--------------------------------------------------------------------------
// Constantes
//--------------------------------------------------------------------------

const unsigned short BATCH = 200;
const unsigned int MAX_SPLINE_POINTS = 1000;


//--------------------------------------------------------------------------
// Implementación de los métodos públicos
//--------------------------------------------------------------------------

void CSpline::AddKey (float  x, float  y, float  z,
               float tx, float ty, float tz)
{
 SplinePoint Point;
 
 // Punto
 Point.x  =  x;
 Point.y  =  y;
 Point.z  =  z;

 // Tangente
 Point.tx = tx;
 Point.ty = ty;
 Point.tz = tz;

 // Guardamos la nueva clave
 m_vCurve.push_back(Point);
}


void CSpline::AddSegment (int iIndexPoint1, int iIndexPoint2, float fLength)
{
SplineSegment Segment;

// Longitud del segmento
Segment.fLength = fLength;

// Incrementamos la longitud total de la spline
m_fTotalLength += fLength;

// Guardamos los índices a los puntos que pertenece
// este segmento
Segment.uiIndexPoint1 = iIndexPoint1;
Segment.uiIndexPoint2 = iIndexPoint2;

// Guardamos el segmento
m_vSegments.push_back(Segment);
}


void CSpline::CreateResources ()
{
// Creamos el VB
m_VB.Create(CApplication::getDevice(), FVF_POSDIFFUSE, MAX_SPLINE_POINTS);
}


void CSpline::ReleaseResources ()
{
// Liberamos el VB
m_VB.Release();
}


D3DXVECTOR3 CSpline::Evaluate (float& rfDistance, unsigned int& ruiSegment)
{
// Si la distancia es mayor a la del segmento...
// pasamos al siguiente
if (rfDistance > m_vSegments[ruiSegment].fLength)
{
 ruiSegment = (ruiSegment + 1) % m_vSegments.size();
 rfDistance = 0.0f;
}

// Simplificamos indirección
SplineSegment* pCurrentSegment = &m_vSegments[ruiSegment];

// Distancia real en la spline
float fLength = rfDistance / pCurrentSegment->fLength;
 
 // Evaluamos el punto
float t2 = fLength * fLength;
float t3 = t2 * fLength;
   
float h1 =  2.0f * t3 - 3.0f * t2 + 1.0f;
float h2 = -2.0f * t3 + 3.0f * t2;
float h3 =  t3 - 2.0f * t2 + fLength;
float h4 =  t3 - t2;

// Conseguimos los puntos que componen el segmento donde
// estamos evaluando
SplinePoint* pPointOne = &m_vCurve[pCurrentSegment->uiIndexPoint1];
SplinePoint* pPointTwo = &m_vCurve[pCurrentSegment->uiIndexPoint2];

return D3DXVECTOR3(h1 * pPointOne->x + h2 * pPointTwo->x + h3 * pPointOne->tx + h4 * pPointTwo->tx,
          h1 * pPointOne->y + h2 * pPointTwo->y + h3 * pPointOne->ty + h4 * pPointTwo->ty,
          h1 * pPointOne->z + h2 * pPointTwo->z + h3 * pPointOne->tz + h4 * pPointTwo->tz);
}


void CSpline::Render ()
{
assert(m_vCurve.size() >= 2);

// Establecemos render states
SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
SetTextureStageState(0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);

// Ponemos matriz identidad...
D3DXMATRIX mIdentity;
D3DXMatrixIdentity(&mIdentity);
CApplication::getDevice()->SetTransform(D3DTS_WORLD, &mIdentity);

// Especificamos el tipo de vértice
CApplication::getDevice()->SetVertexShader(FVF_POSDIFFUSE);

// Colocamos los vértices
CApplication::getDevice()->SetStreamSource(0, m_VB.GetVertexBuffer(), sizeof(FVF_PosDiffuse));

// Bloqueamos el VB
unsigned int uiStartVertex;
unsigned int uiLock = BATCH;
FVF_PosDiffuse* pVertex = m_VB.Lock(uiLock, uiStartVertex);
assert(pVertex != NULL);

// Iteradores...
vector<SplinePoint>::iterator PointOne = m_vCurve.begin();
vector<SplinePoint>::iterator PointTwo = m_vCurve.begin() + 1;
unsigned short usPointsCount = 0;

do
{
 for (float t = 0.0f; t < 1.0f; t += 0.001f)
 {
  float t2 = t * t;
  float t3 = t2 * t;
   
  float h1 =  2.0f * t3 - 3.0f * t2 + 1.0f;
  float h2 = -2.0f * t3 + 3.0f * t2;
  float h3 =  t3 - 2.0f * t2 + t;
  float h4 =  t3 - t2;

  pVertex->vPos.x    = h1 * PointOne->x + h2 * PointTwo->x + h3 * PointOne->tx + h4 * PointTwo->tx;
  pVertex->vPos.y    = h1 * PointOne->y + h2 * PointTwo->y + h3 * PointOne->ty + h4 * PointTwo->ty;
  pVertex->vPos.z    = h1 * PointOne->z + h2 * PointTwo->z + h3 * PointOne->tz + h4 * PointTwo->tz;
  pVertex->dwDiffuse = D3DCOLOR_XRGB(255, 0, 0);
  pVertex++;

  // Un punto más
  usPointsCount++;

  // Miramos si hay que pintar...
  if (usPointsCount == BATCH)
  {
   // Desbloqueamos!
   m_VB.Unlock();

   // Pintamos
   CApplication::getDevice()->DrawPrimitive(D3DPT_POINTLIST, uiStartVertex, usPointsCount);

   // Volvemos a bloquear
   pVertex = m_VB.Lock(uiLock, uiStartVertex);
   assert(pVertex != NULL);

   // Contador a 0
   usPointsCount = 0;
  }
 }
 
 ++PointOne;
 ++PointTwo;
}
while (PointTwo != m_vCurve.end());

// Desbloqueo...
m_VB.Unlock();

// Pintamos si queda algún punto
if (usPointsCount)
{
 CApplication::getDevice()->DrawPrimitive(D3DPT_POINTLIST, uiStartVertex, usPointsCount);
}
}


void CSpline::Destroy ()
{
// Eliminamos recursos...
m_fTotalLength = 0.0f;
m_vCurve.clear();
m_vSegments.clear();
m_VB.Release();
}


A destacar el método Evaluate que es quien te devuelve el nuevo punto de la curva.
Los métodos relevantes al render... podeis obviarlos la spline se pinta punto por punto y
es una forma muy lenta de pintarla, simplemente era para unas pruebecillas... Bueno espero que
a alguien le sirva el code, saludos.

 Buenas, pues yo utilicé OPCODE para un simulador de grua torre que hice hace ya un tiempo en el curro. La verdad que es una lib de colisiones bastante maja. La inicialización es bastante sencilla. Luego por cada objeto que quieras que tenga info de colisiones pues creas otra estructura con los vértices e índices y que luego opcode gestiona. más cosas.. bueno luego necesitas una función de tipo callback que opcode necesita para chequear las colisiones entre los objetos. Te voy a poner por aquí algunos ejemplillos a ver si te sirven de ayuda. Yo utilicé la versión 1.2, creo que ya está la 1.3:

Código [Seleccionar] Expand


// Árbol de AABB para las colisiones
AABBTreeCollider m_TC;

// Opciones del AABB tree
m_TC.SetFirstContact(true);
m_TC.SetFullBoxBoxTest(true);
m_TC.SetFullPrimBoxTest(true);
m_TC.SetTemporalCoherence(true);

// Datos que necesita OPCODE para albergar
// la información de colisión de un objeto

Point  *m_pVertices;  // Vértices de la malla
udword *m_pIndices;   // Índices de la malla

OPCODECREATE oc;
oc.NbTris       = m_NumTris; // Número de triángulos de la malla (caras)
oc.NbVerts    = m_NumVerts;  // Número de vértices de la malla
oc.Tris           = m_pIndices;  // Ojo, tiene que contener los vértices de la malla
oc.Verts         = m_pVertices;  // Ojo, tiene que contener los triángulos de la malla
oc.Rules         = SPLIT_COMPLETE | SPLIT_SPLATTERPOINTS | SPLIT_GEOMCENTER;
oc.NoLeaf      = true;  // Sin hojas
oc.Quantized = true;  // Cuantizado

OPCODE_Model m_CollisionModel;  // Modelo de colisión de la malla

if (!m_CollisionModel.Build(oc))
{
 // Error al construir el modelo de colisión
 return E_FAIL;
}

// CALLBACK que necesita OPCODE para indexar en la geometría

void CCollisionList::_opcodeCallback (udword triangleIndex,
                 VertexPointers &triangle, udword userdata)
{
 CMesh  *Mesh     = reinterpret_cast<CMesh *>(userdata);
 udword *indices  = Mesh->GetIndexBuffer() + (triangleIndex * 3);
 Point  *vertices = Mesh->GetVertexBuffer();

 triangle.Vertex[0] = &vertices[indices[0]];
 triangle.Vertex[1] = &vertices[indices[1]];
 triangle.Vertex[2] = &vertices[indices[2]];
}


Bueno y ahora viene la parte de chequeo de colisiones... para ello necestias comparar dos modelos
de colisión. Esto es, pues dos objetos. En tu caso imagino que siempre tendrás un modelo de colisión fijo, la geometría que envuelve al jugador, etc. y los otros modelos variables, los muros, objetos, etc. Bueno aquí va, yo como utilizo Direct3D pues mis matrices están en mano izquierda, si utilizas otra api como opengl, imagino que tendrás que transponer las matrices. Bueno aquí va el código:

Código [Seleccionar] Expand



void CCollisionList::CreateCollisionList (list<int> *pIndexList)
{
 assert(pIndexList != NULL);

 // Limpiamos la lista..
 pIndexList->clear();

 list<CollisionNode>::iterator it;
 for (it = m_MeshList.begin(); it != m_MeshList.end(); ++it)
 {
   // Colocamos las callbacks
   m_TC.SetCallback0(_opcodeCallback, udword(m_pMesh));
   m_TC.SetCallback1(_opcodeCallback, udword(it->pMesh));

  // Calculamos la colisión
  m_TC.Collide(it->ColCache, reinterpret_cast<Matrix4x4 *>(m_pMesh->GetTransMatrix()),
                                 reinterpret_cast<Matrix4x4 *>(it->pMesh->GetTransMatrix()));

  // Si hay colisión... añadimos el índice de la malla que colisiona con la malla "master"
  if (m_TC.GetContactStatus())
  {
    pIndexList->push_back(it->index);
  }
 }
}


Bueno una cosa que olvidé, y es que cada nodo de mi lista de colisiones lleva una pequeña cache que se define así:

Código [Seleccionar] Expand

BVTCache ColCache;  // Cache de colisiones entre la malla "master" y la apuntada por el puntero
Esto lo hace Opcode para acelerar los cálculos. Bueno espero que te sirva de algo. La verdad que a mi me hubiera venido genial que alguien me explicara como iba la lib. Ya que la ayuda no era muy buena que digamos. Tuve que mirar código que utilizaba la lib. Bueno saludos.

ProD

 Bueno esta vez, he conseguido yo mismo resolver el problema...
se debia a una mala transformación de la cámara, ya está todo solucionado,
muchas gracias de todas formas.

 Buenas a todos de nuevo, parece que mi anterior prengunta de como capturar una pantalla en plan como lo hace el fraps no tuvo mucho éxito  :( bueno espero que en esta haya un poco más de acción. En fin os cuento. Tengo 3 clientes que renderizan una escena. Tengo 3 cámaras, una para cada cliente, cada cámara está configurada de forma que apunte a su respectivo canal, esto es, la cámara del cliente de la izquierda apunta como si miraramos 45º a la izquierda, la cámara del cliente del centro mira hacia delante y la cámara del cliente de la derecha mira 45º a la derecha. Muy bien, cómo consigo orientar las cámaras de este modo?, pues cojo la matriz de transformación del objeto que lleva la cámara, en este caso un coche y uso su posición y ejes para orientar correctamente las cámaras. El problema viene cuando este objeto, en mi caso el coche.. se sube por una acera, sube una cuesta, etc. Que Los clientes se descuadran, es decir, las cámaras no representan una imagen homogénea de lo que se está representando. Lo que quiero conseguir es una visualización como cuando vemos algo en multimonitor. Alguien se ha topado con este problema alguna vez?, alguna sugerencia... gracias a todos y un saludo.