23/2/2013 19:16

Wave Engine ya está disponible

Este jueves por fin lanzamos WaveEngine (waveengine.net) tras más de dos años de desarrollo. Creo que es un proyecto muy interesante para desarrolladores C# por lo que os animo a todos a probarlo y darnos feedback para continuar mejorándolo. A continuación para motivaros a probarlo os voy a contar rápidamente algunas API highlights del proyecto, las cuales desde mi punto de vista son bastantes atractivas e interesantes para desarrollados en C#. WaveEngine ha sido diseñado bajo los principios de Component...
Publicado por Javier | con no comments
13/12/2012 19:39

Entrevista para la Newsletter de Visual Studio

Javier Cantón lleva vinculado a Microsoft los últimos 10 años. Reconocido MVP experto en tecnologías como DirectX y XNA centradas en el desarrollo de Videojuegos y tratamiento de imágenes, ha centrado parte de su trabajo y carrera profesional en el mundo del desarrollo vinculándose con las últimas tecnologías del entretenimiento. Licenciado en Ingeniería Informática y especializado en el tratamiento y procesamiento de imágenes...
Publicado por Javier | 1 comment(s)
15/7/2012 22:59

Memoria compartida entre C# struct

  Problemática: Imaginemos que estamos desarrollando un graphics ó physics engine en C#, el cual queremos que sea multiplataformas por lo que luego lo usaremos contra diferentes APIs como XNA, OpenTK y SharpDX. Trabajaremos con nuestras propias estructuras para Matrix4x4 ó Vector3 por ejemplo y luego las tendremos que traducir a las structs concretas de cada API.   La struct para Vector3 de nuestro motor puede ser tan simple como: public struct Vector {     public float X;...
Publicado por Javier | con no comments
Archivado en: ,,,,
9/11/2011 21:14

WP7 Problemas de rendimiento con Struct (II / II)

Realicemos un pequeño benchmark para poder evaluar cual es la pérdida de rendimiento obtenido, el cual se producirá por: CPU: Tiempo empleado en gestionar las llamadas (realizar las copias de las estructuras) Para el test vamos a crear un proyecto para Windows Phone 7.1 con Visual Studio, y luego lo analizaremos con el profiler de WP7 corriendo directamente en un dispositivo real. La demo será muy simple, colocaremos un bucle en el método Draw que es donde más...
Publicado por Javier | 4 comment(s)
Archivado en: ,,
9/11/2011 21:11

WP7 Problemas de rendimiento con Struct (I / II)

Recientemente he pasado bastantes horas optimizando código para Windows Phone 7, y una de las primeras cosas que hay que tener en mente es que el CLR(Common Language Runtime) de WP7 no es el de Windows. Incluso en la última versión (Mango) en la que han hecho grandes mejoras, como por ejemplo que ahora el GC (Garbage Collector) ofrece un rendimiento más decente con 2 generaciones, o como al aprovechamiento de las instrucciones SIMD. Otro factor a tener en cuenta para todos esos desarrolladores que...
Publicado por Javier | 1 comment(s)
Archivado en: ,,
16/9/2011 19:27

Wave Engine

Buenas, Hoy es un gran día para volver a escribir en el Blog, tras casi un año trabajando en Plain Concepts donde he conocido a gente muy grande y de la que he aprendido mucho, hoy hacemos público un vídeo en el que se puede ver Bye Bye Brain App-ocalypse corriendo sobre Wave Engine en el que hemos estado trabajando durante tantos meses, el cual permite desarrollar juegos de forma productiva para múltiples plataformas. A pesar de que aún no nos dejan desvelar...
Publicado por Javier | 1 comment(s)
Archivado en: ,,,,,
12/3/2011 10:46

Occlusion Culling (IV de IV)

************************************************************************************************ - Back-face culling - Frustum Culling - Occlusion Culling - Optimizaciones para el Occlusion Culling ************************************************************************************************ En el post anterior explicamos los principios básicos del occlusión culling, y este último post lo dedicaremos a la implementación de dicha técnica de forma eficiente.  Recordemos rápidamente en que consistía...
Publicado por Javier | 2 comment(s)
27/2/2011 20:08

Occlusion Culling (III de IV)

************************************************************************************************ - Back-face culling - Frustum Culling - Occlusion Culling - Optimizaciones para el Occlusion Culling ************************************************************************************************ Por fin toca escribir sobre la técnica que puso nombre a esta serie de artículos XD, Occlusión Culling también es una técnica que podemos incluir dentro de los algoritmos de visibilidad, esta técnica intenta...
Publicado por Javier | 5 comment(s)
13/2/2011 20:31

Occlusion Culling (II de IV)

************************************************************************************************ - Back-face culling - Frustum Culling - Occlusion Culling - Optimizaciones para el Occlusion Culling ************************************************************************************************ Frustum Culling : Es otra de las técnicas de visibilidad más usadas ya que es muy simple de implementar, consiste en no enviar a la tarjeta gráfica aquellos objetos que queden fuera del volumen de render de...
Publicado por Javier | 1 comment(s)
6/2/2011 19:25

Occlusion Culling (I de IV)

************************************************************************************************ - Back-face culling - Frustum Culling - Occlusion Culling - Optimizaciones para el Occlusion Culling ************************************************************************************************ Hacía tiempo que no escribía y me alegra que el regreso sea con un tema tan interesante como el Occlusion Culling. Esta técnica podríamos clasificarla dentro de las técnicas de visibilidad para mejorar el rendimiento...
Publicado por Javier | con no comments
11/8/2010 20:10

Simular el acelerómetro de Windows Phone 7

Con la llegada de XNA 4.0 y el soporte para los nuevos teléfonos la API nos da acceso a una parte muy usada para el desarrollo de juegos en los teléfonos, el acelerómetro, el problema es que al no tener aún los dispositivos físicos (ya que saldrán en Septiembre-Octubre) y que el emulador que se ha proporcionado para Visual Studio 2010 tampoco nos permite emularlo, muchos desarrolladores nos encontramos limitados a la hora de crear proyectos que usen el acelerómetro...
Publicado por Javier | 4 comment(s)
Archivado en: ,,
6/5/2010 9:17

Evento XNA 4.0 & Windows Phone 7

Actualmente me encuentro colaborando con personas de Microsoft como Isabel Gomez Miragaya en las presentaciones de Windows Phone 7 en España. El 28 de Mayo estaremos en Barcelona en un evento sobre Windows Phone 7 pero que lo centraremos en el desarrollo de videojuegos con XNA 4.0, dejo aquí más información: Windows Phone 7 Developer Hub: Desarrolla juegos para Windows Phone 7 con XNA 28 de Mayo, Hotel Barcelo Sants, Barcelona Durante este evento descubriréis la...
Publicado por Javier | 1 comment(s)
Archivado en: ,,,
1/4/2010 1:20

XNA Graphics Pipeline

Si queremos extraerle el máximo partido gráfico a XNA usando HLSL es importante conocer el pipeline gráfico usado por este framework: Cada uno de estos “módulos” cumplen un papel especial hasta conseguir pintar un objeto en pantalla, ya sea un modelo 3D ó una imagen 2D (la cual es pintada sobre un quad “anclado” a la pantalla). Veamos que se hace en cada uno de estos “módulos”: Vertex Data: Contiene un buffer de vértices sin transformar indexado o no indexado, es posible indicar mediante VertexDeclaration...
Publicado por Javier | 7 comment(s)
Archivado en: ,,,
11/3/2010 9:30

HLSL, Un poco de historia

HLSL (High Level Shader Language) es el lenguaje desarrollado por Microsoft con el que podemos programar efectos gráficos mediante DirectX para que sean ejecutados por la GPU (Graphics Processor Unit) situada en nuestras actuales tarjetas gráficas, con el se pueden aplicar efectos gráficos tan impresionantes como: Pero como se ha llegado hasta todo esto que hoy conocemos y nos es tan común, pues todo empezó en 1995 con la salida de la primera tarjeta aceleradora...
Publicado por Javier | 5 comment(s)
4/3/2010 20:23

Alpha blending en XNA (IV de IV)

Vayamos ahora a por el último bloque de instrucciones presentado en el primer post:   GraphicsDevice.RenderState.AlphaBlendEnable = false ; GraphicsDevice.RenderState.BlendFunction = BlendFunction.Add; GraphicsDevice.RenderState.BlendFactor = new Color(255, 255, 255, 255); GraphicsDevice.RenderState.SourceBlend = Blend.One; GraphicsDevice.RenderState.DestinationBlend = Blend.Zero;   GraphicsDevice.RenderState.SeparateAlphaBlendEnabled = false ; GraphicsDevice.RenderState.AlphaBlendOperation...
Publicado por Javier | 7 comment(s)
Archivado en: ,,
25/2/2010 8:16

Alpha blending en XNA (III de IV)

Recordemos que al principio del todo presentamos un gran conjunto de parámetros que están relacionados con el Alpha dentro de la API de XNA: GraphicsDevice.RenderState.AlphaBlendEnable = false ; GraphicsDevice.RenderState.BlendFunction = BlendFunction.Add; GraphicsDevice.RenderState.BlendFactor = new Color(255, 255, 255, 255); GraphicsDevice.RenderState.SourceBlend = Blend.One; GraphicsDevice.RenderState.DestinationBlend = Blend.Zero;   GraphicsDevice.RenderState.SeparateAlphaBlendEnabled =...
Publicado por Javier | con no comments
Archivado en: ,,,,,
18/2/2010 23:03

Alpha blending en XNA (II de IV)

Recordemos la formula general usada para las transparecias: (Source * SourceBlend) (blendFunction) (Destination * DestinationBlend)   En los dos ejemplos anteriores usamos como BlendFunction la operación suma que suele ser la más común, pero se pueden usar otras, la lista completa es: Add     result = (Source * SourceBlend) + (Destination * DestinationBlend) Max      result = max( (Source * SourceBlend), (Destination * DestinationBlend) Min    ...
Publicado por Javier | con no comments
Archivado en: ,,,
14/2/2010 14:37

Alpha blending en XNA (I de IV)

Alpha blending es la técnica con la cual podemos trabajar con transparencias tanto en 2D como en 3D, nos centraremos en pintar un plano con una textura y veremos diferentes formas de aplicar esta técnica. Para el primer ejemplo usaremos una textura de vidriera: la cual nos gustaría aplicar a un plano en 3D y que se viese translucido. Si simplemente la textura el resultado sería algo como: Aquí entran en juego todos los parámetros con los que podemos trabajar, estos los podemos dividir en 3 grupos...
Publicado por Javier | 1 comment(s)
Archivado en: ,,,
24/1/2010 18:51

Problemas con el ZBuffer en XNA

El zbuffer es el algoritmo que se utiliza a la hora de dibujar los objetos en pantalla para decidir que objetos están delante de otros, recibe este nombre ya que se realiza un test de las coordenadas z de los objetos para comparar la profundidad a la que se encuentran en el mundo 3D. Esto a muchos matemáticos o físicos les puede resultar extraño ya que están acostumbrados a que en sus sistema de referencia la z es el vector que apunta hacia arriba, en los gráficos 3D el eje z es el que “entra hacia...
Publicado por Javier | 6 comment(s)
Archivado en: ,,
10/1/2010 19:21

Shaders en XNA

Hace unas semanas Jesús Bosch me lió para dar un webcast online (si Jesús fue así ahora no lo niegues XD), y la idea principal es que iba a ser un webcast orientado a desarrolladores de XNA por lo que todos tendrían ya unos ciertos conocimientos previos sobre esta tecnología. La charla entonces la centré en una introducción al mundo de los shaders y a como poder hacer uso de ellos dentro de XNA, los shaders para que el que no sepa de que estoy hablando son mini programas que se escriben para ser...
Publicado por Javier | 1 comment(s)
Archivado en: ,,
Más artículos Página siguiente >