[HA SALIDO MI JUEGO PUBLICADO EN STEAM]

Hola de nuevo amigos de este estupendo foro. Bueno, después de tanto batallar con los requisitos y con las configuraciones, al fin el día de hoy 1 de Enero del 2019 HA SALIDO MI JUEGO PUBLICADO EN STEAM.

Esta es la página de mi tienda

Le agradecería mucho al que guste apoyarme comprando mi juego que tiene un costo de tan solo $58.00 pesos mexicanos.

Saludos.
;)

Hola de nuevo amigos. Les traigo el video avance de mi juego Indie que al fin terminé.

Lo pueden ver aquí https://www.youtube.com/watch?v=fKpshaGrIcs




También pueden descargar una DEMO (el enlace está en la descripción  ;))

Ojalá les agrade y opinen.

Saludos.
:)

Hola de nuevo amigos de esta estupenda web. Tengo una duda que ojalá me puedan resolver. Cuando un juego se lanza... ¿Qué se carga en la memoria RAM? Tengo entendido que en la memoria de video (VRAM) se carga toda la información gráfica como texturas, fondos, sprites, etc.

Pero entonces, ¿Qué es lo que se carga en la RAM?  ^_^'

Gracias.  :)

Hola de nuevos amigos de esta estupenda web. Me preguntaba si ustedes saben alguna o algunas técnicas para realizar este tipo de juegos. He leido algo sobre ello, pero casi siempre hacen alusión a juegos de tipo isométricos. Lo que en realidad busco es hacer juegos más acercados a esto:



o esto:



En donde los escenarios parecen estar en perspectiva 3D, pero los personajes parece que están limitados a una proyección 2D.

Ojalá me puedan ayudar.

Muchas gracias de antemano.
;)

Hola amigos de esta estupenda web. Si me permiten molestarlos de nuevo con una pregunta. Me gustaría saber si hay alguna librería de C/C++ que pueda leer el contenido de un archivo .zip al vuelo (imágenes, sonidos, etc.). Y que además acepte archivos .zip con contraseña.

Muchas gracias por sus respuestas.

Saludos.
;)

[OpenGL]

Hola amigos de esta estupenda web. Respetuosamente me gustaría mostrarles el juego en el que estoy trabajando. Este juego lo he hecho usando C++ y la que para mi es la mejor API gráfica del mercado. Desde luego hablo de OpenGL. El motor del juego lo he escrito enteramente también en C++ no muy avanzado. Dejando de lado la herencia y polimorfismo, para mantener lo más simple el uso de mi librería, a la hora de crear videojuegos.

Aquí está una captura de como va quedando el juego.



El juego es 95% hecho por mi; gráficos, programación, diseño y planeación. El otro 5% son los efectos de sonidos que he tenido que bajar de la web.

Características:

  -Uso de Frame Buffer Object para efecto de cámara bajo el agua.
  -Uso de Vertex Buffer Object para un modo de dibujado más eficiente.
  -Uso de "texturas" que no son potencia de 2, para un mejor uso de memoria. 
  -Implementación de pequeños FMV.s para la historia y explicación breve de objetivos en la misión, usando FFMPEG.
  -Motor de juego que fue programado para ser usado tanto en plataformas Windows como Linux.
  -Puede ser jugador por uno o dos jugadores simultáneos.
  -Auto alargado de la imágen para monitores tanto "cuadrados" (4:3) o más modernos (16:9)
  -60 cuadros por segundo.
  -Juego tipo "shooter" de avance lateral.

Requisitos mínimos

  -Windows XP, Vista o Windows 7.
  -Procesador Pentium III
  -256 mb de memoria RAM.
  -Tarjeta gráfica (preferentemente NVIDIA) de 128 mb de memoria.
  -OpenGL 1.5 para garantizar la compatibilidad del juego con pc's tanto nuevas como viejitas.

Ojalá les guste y opinen.

Nota: Espero que pronto pueda poner una demo jugable.

Saludos.
;)

[programa]

Hola queridos amigos de esta estupenda web. Pues eso, tengo la duda de cómo se pueden unir varios shaders a un mismo programa. Normalmente cuando un vertex shader y un fragment shader se unen a un programa; se hace algo como esto:

Código [Seleccionar] Expand

  vertex   = glCreateShader(GL_VERTEX_SHADER);
  fragment = glCreateShader(GL_FRAGMENT_SHADER);
  programa = glCreateProgram();

  char *vsFuente = LEE_SHADER(rutaVert);
  char *fsFuente = LEE_SHADER(rutaFrag);

  if(vsFuente == NULL)return GL_FALSE;
  if(fsFuente == NULL)return GL_FALSE;

  const char *vs = vsFuente;
  const char *fs = fsFuente;

  glShaderSource(vertex  ,1,&vs,NULL);
  glShaderSource(fragment,1,&fs,NULL);

  delete [] vsFuente;
  delete [] fsFuente;

  glCompileShader(vertex);
  glCompileShader(fragment);

  glAttachShader(programa,vertex);
  glAttachShader(programa,fragment);

  glLinkProgram(programa);

Bueno, pero si quiero unir otro par de shaders (vertex y fragment); en este caso a programa...   ¿Cómo debo hacerlo?

Muchas gracias por su ayuda.
;)

Hola amigos de esta estupenda web. De nuevo solicitanto su amable ayuda para entender este tema que me trae liado.

Bueno entiendo que el primer paso es guardar en un fbo una textura de profundidad; la cual se hace desde el punto de vista de la luz. Esto se realiza con gluLookAt.

Luego se renderiza desde la cámara como normalmente se hace, pero que ahí se compara la distancia que hay desde la fuente de luz hacia el fragmento, en este caso los objetos.

Si esa distancia en igual que la que hay en la depth texture, entonces no hay nada que se interponga entre la luz y el fragmento y por lo tanto no hay sombra. Pero si la distancia es mayor de la luz hacia el fragmento que de la luz hacia el z buffer entonces sí hay sombra.  Y se puede procesar en los shaders ¿cierto?

Bueno, pero lo que no entiendo ¿Cómo es que se hace la comparación de el z buffer y una textura (En este caso la textura en donde está guardado el z-buffer)? O ¿No es en sí una texura sino más bien los datos que contienen esa textura los que se evaluan?

Si alguien pudiera hacerme el favor de escribir un pequeño ejemplo usando glsl (usando peras y manzanas) porque de plano soy muy tonto y no lo entiendo.  :-\

He visto varios tutoriales pero, además de que están en inglés de plano no comprendo cómo funciona la cosa.

De antemano muchas gracias por su ayuda.
:)

Hola de nuevo amigos. Me preguntaba si ustedes son tan amables de decirme ¿Cómo debo ubicar las luces en mi escena? Tambien el tipo de luces. Sé que varía dependiendo del ambiente, si es cerrado o abierto. La verdad es que no tengo una idea clara del tipo de luces y el lugar en donde debo colocarlas, para lograr tener una escena agradable visualmente hablando.

Si pudieran darme algunos ejemplos para darme una mejor idea.

Agradezco de antemano su ayuda.

Saludos.
^_^

Hola amigos de esta estupenda web.  De nuevo molestándolos con dudas respecto a este tema. Ya he leido varios tutoriales (en inglés y bastante escuetos y otros demasiado técnicos). Y me gustaría saber si alguien que tenga experiencia con el Deferred Rendering en OpenGL me pueda ayudar.

Más o menos tengo la idea básica del G-buffer pero donde de plano no doy es con las luces.

Sé que mediante el uso de los FBO´s debo almacenar los datos del color (difuso), las normales, la posición del vértice y el z-buffer. Hasta ahí más o menos pero y las luces... ¿Cómo las proceso y las incorporo en mi fragment shader?.

Si alguien se pudiera tomar la molestia de escribir código de manera que lo pueda entender, le estaría muy agradecido.

De antemano muchas gracias.
;)

Hola queridos amigos. Me preguntaba si alguien sabe cómo usar los Vertex Buffer Object junto con GLSL (1.2). He buscado en la red y casi siempre encuentro ejemplos pero con GLSL 3.0 .

Ojalá alguien pueda ayudame.

Saludos y muchas gracias.
;)

Hola de nuevo amigos de esta estupenda web. Estoy haciendo mis primero pininos con C++ y tengo un problema que ojalá me puedan resolver.

Este es el código de mi cabecera.

Código [Seleccionar] Expand


#ifndef PRUEBA_H
#define PRUEBA_H

#include <iostream>
#include <cstring>

using namespace std;

class cadena{
  public:
   cadena();
   cadena(const char *c);
   cadena(int n);
   cadena(const cadena &Cad);
   ~cadena();
   void DevDir();
   void Asignar(const char *dest);
   char *Leer(char *c);
  private:
    char *cad;
    short valor;
    friend void tec(cadena obj);
};

#endif


Este el de mi archivo .cpp

Código [Seleccionar] Expand

#include "prueba.h"

cadena::cadena():cad(NULL),valor(128){}

cadena::cadena(const char *c){
  cad = new char[strlen(c)+1];
  strcpy(cad,c);
}

cadena::cadena(int n){
  cad = new char[n+1];
  cad[0] = 0;
}

cadena::cadena(const cadena &Cad){
  cad = new char[strlen(Cad.cad)+1];
  strcpy(cad,Cad.cad);
}

cadena::~cadena(){
  delete[] cad;
}

void cadena::DevDir(){
  cout << "dir valor: " << &cad << endl;
}

void cadena::Asignar(const char *dest){
  delete[] cad;
  cad = new char[strlen(dest)+1];
  strcpy(cad,dest);
}

char *cadena::Leer(char *c){
  strcpy(c,cad);
  return c;
}

void tec(cadena obj){
  cout << obj.valor << endl;
}


Y este el de main.

Código [Seleccionar] Expand

#include "prueba.h"

int main(){
    cadena Cadena1;

    tec(Cadena1);

    cin.get();
    return 0;
}


El problema es que lo compila bien, pero al ejecutarlo me manda un error como cuando hay una violación de acceso de memoria.

Uso Code::blocks y usando el debugger me indica que los errores están según en:

1. main, en la función tec(Cadena1).
2. en el archivo .cpp, en el constructor copia

El caso es que quitando la llamada a la función friend se quita el error, ya no hay errores.

Lo curioso es que incluso basta con solo llamar a la función tec(Cadena1) [aunque esté vacía] para que el error regrese. ¿Alguien me podría decir cuál es el error?

De antemano muchas gracias.
;)

Hola queridos amigos de esta estupenda web. Ojalá que me puedan ayudar con un problema que desde hace tiempo me tiene hecho  :shit: ( ^_^ ^_^)

Bien, comprendo lo de encerrar a los modelos en una caja o una esfera para saber si colisiona con algun otro del mismo tipo, con el fin de no usar muchos recursos al calcularlo.

Pero de plano lo que no acabo de entender es cómo realizo mis colisiones, de mi  personaje con la escena.

Ojalá me puedan ayudar.

Muchas gracias.
:)

Hola de nuevo amigos de esta estupenda web. Tengo una duda respecto al Frustum Culling. Entiendo que es una técnica para evitar dibujar todo aquello que está fuera del Frustum View de la cámara.

Bueno, pero mi pregunta es: He construido una escena 3D con muchos cuartos y cosas dentro de los cuartos... Aplicar el frustum culling a los objetos dentro de los cuartos no sería difícil pero... ¿Cómo aplico el frustum culling a los cuartos en sí?

He leído un poco sobre árboles BSP, octrees, etc. Lo malo es que no veo cómo aplicar eso, en el programa de modelado de mi escena 3D.

Hay un dicho que dice, "Divide y vencerás". Me pregunto si sería buena idea modelar los cuartos por separado y unirlos en mi escena 3D como si fuera uno solo. Creo que sería fácil aplicar el frustum culling de este modo. ¿Qué opinan?

Agradezco de antemano su ayuda.

Muchas gracias.
;)

Hola de nuevo amigos de esta estupenda web. Para no variar  ^_^', solicitando de nuevo su amable ayuda con este tema que desde hace un tiempo me da vueltas en la cabeza.

He leído a cerca de que usando cuaterniones es más sencillo trabajar con rotaciones. El problema es que no se como implementarlos usando lenguaje C y OpenGL.

Según entiendo, un cuaternión es una representación de la forma:

Código [Seleccionar] Expand

a + bi + cj + dk

en donde se tiene una parte real (a) y tres imaginarias (bi, cj, dk).

Bueno pero, ¿Cómo represento un cuaternión usando C? ¿Cómo lo implemento en OpenGL?

Ojalá alguien me pueda ayudar.

Muchas gracias.
:D

Hola de nuevo amigos de esta inmejorable web. De nuevo molestándolos con una duda, ¿Cuál es el significado de cada elemento en la matriz? Me explico, en todos lados aparece algo como esto:

a1  a5  a9    a13
a2  a6  a10  a14
a3  a7  a11  a15
a4  a8  a12  a16

a13, a14 y a15 establecen la posición del objeto es decir que a13 sería = X, a14 = Y a15 = Z ¿Correcto?

Pero ¿qué son a1, a2, a3, a5, a6, a7, a9, a10 y a11? ¿Qué significa cada uno ellos?, He leido que establecen la orientación del objeto (es decir hacia a donde miran) pero no entiendo del todo qué significan.

Ahora, todavía tengo más dudas al ver que para la escala de un objeto se usan a1, a6 y a11, algo así como  a1 = escX, a6 = escY y a11 = escZ. pero ¿Qué no eran de orientación?

Bueno ojalá me puedan ayudar.

Muchas gracias.
^_^'

Hola queridos amigos de esta estupenda Web. De nueva cuenta solicitando de su ayuda para resolver un problema. Uso OpenGL y tengo un cubo que quiero mover por la pantalla, quiero que cuando yo lo rote en alguno de sus ejes, este se mueva en la dirección a la que apunta. Algo como esto:



En este caso el cubo está siendo visto desde arriba. Lo muevo y luego quiero rotarlo. Quiero que ahora se mueva en la dirección en la que apunta.  Si lo vuelvo a rotar que se mueva en la nueva dirección.

Ojalá esté claro lo que quiero hacer.

Les agradezco de antemano.

Muchas gracias.
;)

Hola queridos amigos de esta estupenda web. Solicito su amable ayuda con un problema que tengo. Resulta que estoy probando con la técnica de la animación esqueletal, con el formato collada. Funciona bien pero el problema es el modo en que deben ser "unidos" los vértices a los huesos mediante la siguiente fórmula:

Vr += {[(v * BSM) * IBMi * JMi] * JW}

   i: Número de huesos que influencían a v.
   BSM: Bind-shape matrix
   IBMi: Inverse bind-pose del hueso i
   JMi:  matriz de tranformación de i
   JW: "Peso" que influencía un hueso i sobre un vértice v.

La cuestión es que como se darán cuenta, es necesario recorrer CADA UNO de los vértices que conforman el modelo para calcular la nueva posicion del vértice según se mueva el hueso. Esto significa que si el modelo está conformado por 10, 000 vértices el proceso será muy lento.  :grrr:

Aquí mi duda.

1.- ¿Existe otro método de "unir" los vértices a los huesos sin la necesidad de recorrer cada uno de los vértices?, no sé otra fórmula o algo por el estilo.

He logrado dibujar un modelo que tiene 2000 vértices a 60 cuadros por segundo, pero noto que se lleva gran parte de la capacidad del CPU. Por lo que incorporar otras cosas a la escena está difícil. Quiero destacar que he hecho la prueba en una pc con un procesador pentium III y una tarjeta NVIDIA GeForce 6200, No sé cómo funcionará en una máquina más nueva.

Me han comentado que lo mejor sería usar los vertex shaders (GLSL) para tener un rendimiento mucho mayor, sin embargo lo he dejado de lado, precisamente por si hay otro método que no requiera de la acelaración gŕafica de la GPU.

También tengo la duda si el "skinning" se hace así solo con Collada o también con otro tipo de archivos 3D que contengan animacion por huesos.

Les agradezco mucho sus respuestas.
;)