Echadle Un Vistazo Al Primer Tutorial

[Haddd]

 

Código [Seleccionar] Expand


#region Using directives

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.Direct3D;
using Microsoft.DirectX.DirectInput;

using HadddEngine;
using HadddEngine.Video;
using HadddEngine.Core;
using HadddEngine.Maths;
using HadddEngine.Scene;
using HadddEngine.Scene.MD5;
using HadddEngine.Physics;
using HadddEngine.Particles;
using HadddEngine.Sound;
using HadddEngine.Tools;

#endregion

namespace Tutorial
{
/// <summary>
/// Este ejemplo nos enseñará a crear un objeto, asignarle un material
/// y añadir una luz omni.
/// Al no indicar cámara, el motor utilia una cámara de primera persona por defecto
/// que se maneja con las teclas WASD y el ratón.
/// </summary>
public class HTutorial :HMain
{

 #region Constructores

 public HTutorial()
 {
 }

 #endregion

 #region Init

 /// <summary>
 /// Este método se llama por el motor una vez que se ha creado el device
 /// </summary>
 /// <param name="form">Formulario que se utiliza como ventana</param>
 /// <returns>true si todo ha ido bien</returns>
 public override bool InitGame(Form form)
 {
  // Creamos los objetos de fuentes y texturas...
  Haddd.AfterCreateDevice();

  // Cargamos texturas, escenas, shaders...por defecto
  Haddd.LoadCreateInHouse();

  #region Objetos

  // Creamos un HMesh que es el objeto que contiene la información de los
  // vértices e índices
  // En este caso, un cubo, de 3 metros de ancho, alto y profundo

  // Importante recordar que en Haddd, la unidad de medida es el METRO

  HMesh cubeMesh = HMesh.CreateCube(3, 3, 3);

  // Un HMeshObject es un objeto que tiene la información de las mallas
  // y los materiales. Es el elemento que utilizaremos para renderizar
  // las mallas

  // Creamos un nuevo HMeshObject en la escena. Indicamos que no queremos
  // crear el objeto mesh, puesto que lo acabamos de crear.

  HMeshObject cube = Haddd.Scene.MeshObjects.Create("room",false);

  // Ahora asociamos el mesh con el meshobject

  cube.Mesh = cubeMesh;

  #endregion

  #region Material

  // Creamos un array de materiales de 1 elemento.
  // Es necesario un array porque los meshes pueden tener subsets
  // es decir, información para más de 1 material.

  HMaterial[] material = new HMaterial[1];

  material[0] = new HMaterial();

  // Un material está formado por capas, para poder realizar efectos multicapa
  // En este ejemplo sólo utilizaremos una capa.

  // Creamos la capa
  HMaterialLayer layer = new HMaterialLayer();

  // Lo añadimos al material
  material[0].AddLayer(layer);

  // Asignamos la textura diffuse. El motor detecta si la textura no existe
  // y la carga. Si existe, simplemente la referencia.
  // No se debe indicar el tipo de archivo( .tga,.jpg,.bmp...) El motor buscará
  // los diferentes tipos hasta encontrar la textura.

  // Para buscar las texturas, el motor entrará en el directorio base/textures
  // y recursivamente lo recorrerá hasta encontrar la que busco
  // De esta forma se pueden crear subcarpetas para ordenar las texturas
  // sin tener que modificar el motor

  layer.DiffuseMap.Texture = Haddd.Video.Textures.Create2D("acolchadoDif", true);

  // Asignamos a nuestros HMeshObject el materal que acabamos de crear
  cube.Material = material;

  #endregion

  #region Luz

  // Creo una luz omnidireccional

  HOmniLight light = (HOmniLight)Haddd.Scene.Lights.Create("light", HLightType.Omni);

  // Asigno su posición
  light.Position = new Vector3(0, 0, -2f);

  // La intensidad
  light.Multiplier = 1f;

  // La atenuación
  light.AttenuationType = HLightAttenuationType.DualRadius;
 
  // La distancia a la que empieza a atenuarse
  light.FarAttenuationStart = 1f;
 
  // La distancia a la que se atenua completamente
  light.FarAttenuationEnd = 2f;
 
  // El color
  light.Color = HColor.Yellow;

  // Si afecta al diffuse del material
  light.AffectDiffuse = true;

  // Si afecta al specular del material
  light.AffectSpecular = true;

  // Por ahora, que no genere sombras
  light.CastShadows = false;

  // Ponemos la luz ambiente
  Haddd.Scene.Lights.Ambient = new HColor(0.4f, 0.4f, 0.4f);

  #endregion

  // Una vez que todo está preparado, iniciamos el motor
  Haddd.Begin();

  // Creamos la clase input para gestionar el teclado y el ratón
  Haddd.CreateInput();

  return true;
 }

 #endregion

 #region Action

 /// <summary>
 /// Este método se llama en cada fotograma y es donde debemos
 /// indicar los eventos de teclado y la acción del juego
 /// </summary>
 /// <returns>true=continuamos; false=salir de la aplicación</returns>
 public override bool Action()
 {
  // ¿Salimos de la aplicación?
  if (Haddd.Input.Keyboard.KeyPressed(Key.Escape)) return false;

  // Si pulsa la G activamos / desactivamos los gizmos
  // La diferencia entre KeyTouch y KeyPressed es que KeyTouch sólo devuelve
  // true cuando la tecla se presiona por primera vez, y no siempre que está presionada
  // como es el caso de KeyPressed

  // KeyTouch actuaría como un teclado normal, devolviendo true sólo 1 vez por
  // cada pulsación de tecla

  if(Haddd.Input.Keyboard.KeyTouch(Key.G))
   Haddd.Scene.ShowGizmos=!Haddd.Scene.ShowGizmos;

  // Todo correcto, continuamos
  return true;
 }

 #endregion

 #region Render

 /// <summary>
 /// Este es el método de renderización
 /// </summary>
 public override void Render()
 {
  // Preparamos la escena para que empiece el render
  Haddd.Scene.Begin();

  {

   // Renderizamos todos los elementos de la escena
   Haddd.Scene.Render();

   // Realizamos la postproducción
   Haddd.Scene.ProcessPostProduction();

   // Renderizamos diversas cosas de la escena (gizmos, Axes, Names...)
   Haddd.Scene.RenderMiscellaneous();

   // Obtenemos acceso a la 1ª fuente. El motor por defecto crea una fuente
   HFont fuente = Haddd.Video.Fonts[0];

   // Iniciamos la renderización de las fuentes
   Haddd.Video.Fonts.Begin();

   // Escribimos texto en la primera línea, posición x=0, color amarillo
   fuente.RenderLine(Haddd.Version + ". Press ESC to exit. Press G to Show/Hide Gizmos", 0, HColor.Yellow);

   // Escribimos texto en la segunda línea, posición x=0, color amarillo
   fuente.RenderLine(Haddd.Video.Render.Stats.Fps + " FPS", 0, HColor.White);

   // Finalizamos la renderización de las fuentes
   Haddd.Video.Fonts.End();
   
  }

  // Terminamos la escena

  Haddd.Scene.End();

 }

 #endregion
}
}


[Gambus]

 Muy bien comentado el código... lo que no me queda claro es como planteais el tema de control de excepciones y si el motor deja algún tipo de traza para ver tiempos de ejecución, mensajes de inicialización, mensajes 'warning',... errores
Pero bueno, me imagino que esto será para tutoriales más avanzados  B)

[Kaneda]

 uufff, uffff , que ganitas tengo de poder usar el motor. solo un par de cuestiones mas basicas:

¿Como se instala las sdk de directx y el ensamblado correspondiente en Visual Studio ??
¿¿Y el ensamblado del motor??

(esto podrias hacer un mini-mini esquema dibujado de las partes del motor que vayas usando : Ejemplo. una HmeshObject tiene una Mesh (o varias, no se) , y cada Mesh tiene un array de Material o como va la estructura de un material. Por experiencia en la enseñanza , se que las ilustraciones son mas rapidas y claras de aprender) (o de como es la estructura de una luz y para que sirve cada miembro ;) )

Ah, oye como curiosidad, he visto que el motor tiene un namespace llamado physics ¿ habeis integrado newtown o otro dentro del motor? ( jajaja magnifico,  si es que no voy a dormir hasta que publiqueis el motor jaja)

Bueno, conclusion . Magnifico trabajo, como todo lo que habeis hecho hasta ahora, se que la documentacion y los ejemplos son siempre lo mas aburrido de hacer, pero os animo a que continueis con las mismas ganas, y cuanto mas hagais mejor para todos  :P  

[Haddd]

 Habrá un doc explicando como instalrlo todo desde 0. Tranquilos sobre eso... ;)

Por supuesto habrá documentación sobre las clases, pero no en el tutorial, claro ... ;)

Newton está integrado en el motor.... (uoh)   Ya verás lo fácil que es en el tutorial de física...

 Como tutorial de bienvenida estaría bien uno a color con sus diagramas, sus fotitos, su código, fotos del escritorio con las ventanas de trabajo y editores, ... y esos pequeños detalles ilustrados y coloreados que tanto agradan ver cuando empiezas con algo.

No digo un manual completo, que sería mucho curro ahora, si no un pequeño archivo en formato pdf, con la forma de comenzar, trabajar, etc.  con muchas imágenes, unos comentarios entre medias, y el tutorial que has puesto.

Pa impresionar y eso  ;).

[masaniz]

 Haddd, seguid así que os está quedando estupendo, y sobre la documentación, vereis como una vez que saqueis una versión preliminar, la gente se empieza a animar y os envia docs hechos por ellos mismos y ejemplos sobre el propio motor ayudando en lo posible a apliar la información sobre el motor, sino, fijaos en Irrlicht así les ocurrió.


Os felicito por la magnífica labor desarrollada.

PD.: A ver si cuando saqueis una release, yo mismo me animo y hago alguna cosilla.  :D  

[BeRSeRKeR]

No digo un manual completo, que sería mucho curro ahora, si no un pequeño archivo en formato pdf, con la forma de comenzar, trabajar, etc.  con muchas imágenes, unos comentarios entre medias, y el tutorial que has puesto.

¡Qué casualidad, justo lo que le dije anoche a Haddd! :lol:

[AgeR]

 Una cosilla, cuando creáis la luz, por qué no lo hacéis mediante un método al que le pasáis todos los parámetros? En este caso porque sólo hay una luz, pero meter así 10 o 12 luces me parece un poco basto. Igual ya tenéis un método y usáis esta forma por ser un tutorial, no sé.  :P  

[Hastur]

 Me encanta, muy bien explicado y sencillo, que ganas que tengo de hincarle el diente :P

Por cierto, la beta del Visual C# dejara de funcionar cuando saquen la version final? O podremos continuar con esta beta?

[BeRSeRKeR]

 

Una cosilla, cuando creáis la luz, por qué no lo hacéis mediante un método al que le pasáis todos los parámetros? En este caso porque sólo hay una luz, pero meter así 10 o 12 luces me parece un poco basto. Igual ya tenéis un método y usáis esta forma por ser un tutorial, no sé.  :P

Bueno, está claro que pasar todos los parametros de la luz al constructor sería una barbaridad ya que son unas 15 propiedades. En todo caso sería cuestión de pasar una estructura con los parámetros (como se hace con las partículas) pero igualmente tienes que rellenar esa estructura previamente. A no ser que esas luces tengan los mismos parámetros, claro. En ese caso sí estaría bien que compartieran la estructura, pero para eso se clona la luz y a correr.

De todas formas no tiene excesiva importancia ya que tanto luces, como materiales, partículas, etc, normalmente se cargarán desde archivos por lo que no es demasiado inconveniente.

Saludos.

[Kaneda]

 Hola soy yo de nuevo,  :P , el que no para de hacer preguntas sobre el motor ( es que no tengo paciencia)

Trasteando por la red,he encontrado unos elementos GUI de directx ( CDXUTDialog, CDXUTButton,etc) para hacer las pantallas iniciales con Menus-botones de "un jugador", multijugador","opciones",etc, aunque no son exactamente de directx, creo que es de una libreria de utilidades o algo asi , Hay un ejemplo en :

msdn.microsoft.com/library/en-us/directx9_c/ directx/graphics/TutorialsAndSamples/Samples/CustomUI.asp

Mi pregunta es ¿ Funcionarian estas GUI con el motor ? no estoy muy seguro porque bueno, como ya os he dicho parece ser de otra libreria que no es exactamente de directx (puede que este equivocado)

He pensado que si estas librerias funcionasen os quitariais de un plumazo la GUI del motor no?
Incluso aunque funcionasen ¿ Pensais que es una alternativa aceptable? ¿ Prefeririais hacerlo de otra forma?

[BeRSeRKeR]

 El sistema de GUI que mencionas viene con el SDK de DX, pero como dices no está "dentro" de DX. Más bien está insertado en el framework que es el que se utiliza para crear los ejemplos.

Por otra parte, me imagino que se podría insertar ese sistema en el motor, cuán follonero no sé cómo sería. Pero lo que no sé es si al final nos decantaríamos por ese sistema o por uno personalizado. Lo que está claro es que una vez que el código del motor esté fuera, cada uno podrá implementar lo que quiera.

Saludos.