Más que la falta de tiempo, yo siempre he pensado que en el mundo amateur el verdadero problema es la imposibilidad de preveer el tiempo que se va a poder dedicar al proyecto (más allá de unos días/semanas). En un entorno laboral se parte de que se trabajan X horas al día, y a la hora de hacer una planificación el error viene de no ser capaces de estimar la duración de las tareas.

En un desarrollo amateur, además, no somos capaces de estimar cuántas horas al día vamos a dedicar dentro de un par de semanas, y mucho menos de estimar cuántas van a dedicar los demás. Esto es debido a que el tiempo libre, por mucho interés que tengamos en el proyecto, está condicionado por factores sobre los que no siempre se tiene control, y que en muchos casos no son predecibles.

Así que, aunque una planificación siempre es deseable, a la hora de cumplirla lo que ocurre es que tareas estimadas para una semana se demoran un mes, y tareas estimadas para un mes se hacen en una semana. Aunque la planificación sigue siendo importante para analizar el progreso del desarrollo, y para marcar objetivos, en un grupo amateur se suele (y se debe) ser más flexible.

Aun así, si que creo que hay herramientas para reducir el efecto de esto. Partiendo de la idea de que no se puede controlar cuánto tiempo se dedica, la idea es más bien aumentar la productividad durante el tiempo disponible, priorizar las tareas, intentar dedicar varias horas en un sólo día que pocos minutos cada día, intentar eliminar todas las dependencias posibles entre tareas, etc...

Si usas una libreria 2D como SDL no suele ser una buena idea el rotar o escalar sprites, porque las operaciones hay que hacerlas a nivel de software y es bastante lento (al igual que el alpha blending).

Como te han dicho, una solución es preparar ya los sprites rotados de antemano y solo tener que dibujarlos. Pero si realmente te interesa escalar y rotar en tiempo real, quizas deberías mirar el pasar a OpenGL (o Direct3D) que si soportan todas estas operaciones a nivel de hardware.

Tu mismo :lol:. Un saludo

                                Por la imagen, yo diria que Hadd y Repoker tienen razón, y se trata realmente de un problema de clipping. Sin embargo, y espero que algún "experto" responda a esto, ¿es ese sistema se chequeo correcto?
Me refiero a que pueden darse casos en los que el frustum intersecta con el cubo sin que ninguno de los puntos del cubo esté dentro del frustum. En ese caso ese algoritmo fallaría, cuando realmente si se está produciendo una intersección.

Otro sistema para reducir ese fallo que conozco es el siguiente:
Si no hay ningún vértice del cubo en el interior del frustum, aun asi puede haber interseccion, asi que comprobamos si TODOS los vértices del cubo están detrás de alguno de los planos que forman el frustum. Si es así, ya estamos seguros de que el cubo nunca intersecta con el frustum.

Esto no lo he probado en la práctica, así que no sé si es demasiado lento (supongo que sí, que los expertos opinen), pero aquí lo tienes por si te ayuda:

Código [Seleccionar] Expand



BOOL cFrustum::CheckCube(float fCenterX, float fCenterY, float fCenterZ, float fSize){



char i=0;



//Tabla de resultados

BOOL bResults[6][8];



//Comprueba cada vertice con cada plano

for (i=0; i<6; i++){



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX - fSize, fCenterY - fSize,

  fCenterZ - fSize)) < 0.0f){

  bResults[i][0] = FALSE;

 }else{

  bResults[i][0] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX + fSize, fCenterY - fSize,

  fCenterZ - fSize)) < 0.0f){

  bResults[i][1] = FALSE;

 }else{

  bResults[i][1] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX - fSize, fCenterY + fSize,

  fCenterZ - fSize)) < 0.0f){

  bResults[i][2] = FALSE;

 }else{

  bResults[i][2] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX + fSize, fCenterY + fSize,

  fCenterZ - fSize)) < 0.0f){

  bResults[i][3] = FALSE;

 }else{

  bResults[i][3] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX - fSize, fCenterY - fSize,

  fCenterZ + fSize)) < 0.0f){

  bResults[i][4] = FALSE;

 }else{

  bResults[i][4] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX + fSize, fCenterY - fSize,

  fCenterZ + fSize)) < 0.0f){

  bResults[i][5] = FALSE;

 }else{

  bResults[i][5] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX - fSize, fCenterY + fSize,

  fCenterZ + fSize)) < 0.0f){

  bResults[i][6] = FALSE;

 }else{

  bResults[i][6] = TRUE;

 }



 if(D3DXPlaneDotCoord(&d_Plane[i], &D3DXVECTOR3(fCenterX + fSize, fCenterY + fSize,

  fCenterZ + fSize)) < 0.0f){

  bResults[i][7] = FALSE;

 }else{

  bResults[i][7] = TRUE;

 }



}





//Si un vertice esta delante de todos los planos, el cubo intersecta con el frustum

for (i=0; i<8; i++){

 if ((bResults[0][i] == TRUE)&&(bResults[1][i] == TRUE)&&(bResults[2][i] == TRUE)&&

  (bResults[3][i] == TRUE)&&(bResults[4][i] == TRUE)&&(bResults[5][i] == TRUE))

  return TRUE;

}



//Si no hay ningun vertice dentro del frustum, aun asi el cubo puede intersectar. Para

//descartarlo, comprobamos si todos los vertices estan DETRAS de un plano. En caso

//afirmativo, el cubo no intersecta. Este metodo no es fiable al 100%, pero los resultados

//son validos en la mayoria de ocasiones

for(i=0; i<6; i++){

 if ((bResults[i][0] == FALSE) && (bResults[i][1] == FALSE) && (bResults[i][2] == FALSE) &&

  (bResults[i][3] == FALSE) && (bResults[i][4] == FALSE) && (bResults[i][5] == FALSE) &&

  (bResults[i][6] == FALSE) && (bResults[i][7] == FALSE))

  return FALSE;

}



return TRUE;

}



También estoy pensando si sería suficiente con hacer la última comprobación en la mayoría de los casos, aumentando así la velocidad y sin necesidad de esa tabla de resultados. Espero vuestras opiniones.                                

                                Hola, creo que a lo que te refieres es algun metodo para obtener la formula "general" de un plano (A, B, C y D) a partir de la normal y un punto, espero que esto te sirva de ayuda:

Como han dicho, A, B y C son los valores X, Y y Z de la normal, por lo que lo unico que tenemos que hallar es D. Sabiendo un punto que pertenece al plano, podemos sustituir en la formula general:

Ax + By + Cz + D = 0

Si A, B, y C son la normal, y x, y, z las coordenadas del punto, datos que conocemos, la ecuacion queda asi:

Nx*Px + Ny*Py + Nz*Pz + D = 0

(N se refiere a la normal, y P al punto)

Ahora solo tenemos que despejar D de la ecuacion, y puedes usar los 4 coeficientes que usabas en tus calculos.

Espero haberte ayudado. Un saludo.