Kinect Basics: Background Subtracction (clipping)

El tratamiento o procesamiento digital de imágenes (TDI o PDI) es una de las etapas fundamentales de un sistema de visión artificial. De forma superficial el TDI o PDI puede definirse como un conjunto de procedimientos que realizan sobre una imagen para su almacenamiento, trasmisión o tratamiento, este tipo de sistemas están enfocados principalmente a la restauración o mejora de imágenes, por lo tanto la entrada para un sistema de este tipo o naturaleza es una imagen de dimensiones definidas(la imagen del kinect) y por ende la salida luego del tratamiento y procesamiento será una imagen con las mismas dimensiones que la de entrada o información(datos) de interés. Sin embargo las entradas y salidas del sistema varían dependiendo del dominio del problema.

El TDI es un proceso que requiere tanto del uso de hardware y software especializado para tal fin. A continuación se describen en términos generales las etapas fundamentales del procesamiento de imágenes.

1) la adquisición de la imagen, para ello es necesario un sensor de imágenes (analógica o digital), capaz de digitalizar la señal de entrada, como por ejemplo una cámara de video, una cámara fotográfica monocroma o a color, un escáner o un Kinect y de producir una imagen para su procesamiento por lo menos cada 1/30 de segundo. Sensible a un segmento del espectro electromagnético (como las bandas de rayos x, ultravioleta, visible o infrarrojo).

2) pre-procesamiento, en esta etapa se busca mejorar la calidad de las imágenes, captadas o capturadas por el sensor, a través de diferentes técnicas de mejoramiento y procesamiento de imágenes, como por ejemplo la atenuación o eliminación total del ruido, mejora del brillo o del contraste de la misma entre otras, se busca aumentar las posibilidades de éxitos y disminuir el margen de error en las etapas posteriores, por lo tanto esta es quizás una de las etapas más importantes dentro del proceso general.

Luego del pre-procesamiento de la imagen, la siguiente etapa y quizás la más importante dentro de un sistema de procesamiento de imágenes debido a su impacto es 3) la segmentación, consiste en dividir la imagen de entrada en sus componentes, es uno de los procesos más complejos, lo que se espera como resultado en esta etapa son los pixeles en brutos que constituyen bien sea una región de interés o los puntos que definen un contorno.

4)la descripción, también denominada selección de rasgos, consiste en extraer o identificar información de interés y que puede llegar a ser útil para el reconocimiento e interpretación de los objetos en las imágenes de entrada

Finalmente la última etapa dentro del procesamiento digital de imágenes es 5) el reconocimiento e interpretación, en la cual a partir de la información recolectada en los procesos anteriores y teniendo en cuenta como punto de comparación si es el caso las imágenes que se tienen como base de datos (6) base de conocimiento), implica asignar significado a un conjunto de objetos reconocidos para posteriormente identificar correspondencias entre estos. De este grupo de objetos saldrá el resultado.

 

Clipping: Es una técnica de segmentación de objetos que consiste en usando la información de profundidad  de los pixeles recolectada por el sensor (kinect)  tomar de cada frame de video los objetos mas cercanos a este(el player) . a continuación el código fuente de como lograrlo usando el SDK de kinect, opencv en C++:

 

#include "stdafx.h"
#include <Windows.h>
#include <NuiApi.h>
#include <opencv2/opencv.hpp>


int _tmain(int argc, _TCHAR* argv[])
{
	cv::setUseOptimized( true );


	INuiSensor* pSensor;
	HRESULT hResult = S_OK;
	hResult = NuiCreateSensorByIndex( 0, &pSensor );
	if( FAILED( hResult ) ){
		std::cerr << "Error : NuiCreateSensorByIndex" << std::endl;
		return -1;
	}

	hResult = pSensor->NuiInitialize( NUI_INITIALIZE_FLAG_USES_COLOR | NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX );
	if( FAILED( hResult ) ){
		std::cerr << "Error : NuiInitialize" << std::endl;
		return -1;
	}

	
	HANDLE hColorEvent = INVALID_HANDLE_VALUE;
	HANDLE hColorHandle = INVALID_HANDLE_VALUE;
	hColorEvent = CreateEvent( nullptr, true, false, nullptr );
	hResult = pSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, hColorEvent, &hColorHandle );
	if( FAILED( hResult ) ){
		std::cerr << "Error : NuiImageStreamOpen( COLOR )" << std::endl;
		return -1;
	}


	HANDLE hDepthPlayerEvent = INVALID_HANDLE_VALUE;
	HANDLE hDepthPlayerHandle = INVALID_HANDLE_VALUE;
	hDepthPlayerEvent = CreateEvent( nullptr, true, false, nullptr );
	hResult = pSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, NUI_IMAGE_RESOLUTION_640x480, 0, 2, hDepthPlayerEvent, &hDepthPlayerHandle );
	if( FAILED( hResult ) ){
		std::cerr << "Error : NuiImageStreamOpen( DEPTH&PLAYER )" << std::endl;
		return -1;
	}

	HANDLE hEvents[2] = { hColorEvent, hDepthPlayerEvent };

	cv::namedWindow( "Mask" );
	cv::namedWindow( "Clip" );

	
	int iterationErode = 2;
	int iterationDilate = 2;
	cv::createTrackbar( "erode", "Mask", &iterationErode, 10 );
	cv::createTrackbar( "dilate", "Mask", &iterationDilate, 10 );

	while( 1 ){
	
		ResetEvent( hColorEvent );
		ResetEvent( hDepthPlayerEvent );
		WaitForMultipleObjects( ARRAYSIZE( hEvents ), hEvents, true, INFINITE );

		
		NUI_IMAGE_FRAME pColorImageFrame = { 0 };
		hResult = pSensor->NuiImageStreamGetNextFrame( hColorHandle, 0, &pColorImageFrame );
		if( FAILED( hResult ) ){
			std::cerr << "Error : NuiImageStreamGetNextFrame( COLOR )" << std::endl;
			return -1;
		}

	
		NUI_IMAGE_FRAME pDepthPlayerImageFrame = { 0 };
		hResult = pSensor->NuiImageStreamGetNextFrame( hDepthPlayerHandle, 0, &pDepthPlayerImageFrame );
		if( FAILED( hResult ) ){
			std::cerr << "Error : NuiImageStreamGetNextFrame( DEPTH&PLAYER )" << std::endl;
			return -1;
		}

	
		INuiFrameTexture* pColorFrameTexture = pColorImageFrame.pFrameTexture;
		NUI_LOCKED_RECT sColorLockedRect;
		pColorFrameTexture->LockRect( 0, &sColorLockedRect, nullptr, 0 );

		
		INuiFrameTexture* pDepthPlayerFrameTexture = pDepthPlayerImageFrame.pFrameTexture;
		NUI_LOCKED_RECT sDepthPlayerLockedRect;
		pDepthPlayerFrameTexture->LockRect( 0, &sDepthPlayerLockedRect, nullptr, 0 );

		
		cv::Mat colorMat( 480, 640, CV_8UC4, reinterpret_cast<uchar*>( sColorLockedRect.pBits ) );
		LONG registX = 0;
		LONG registY = 0;
		ushort* pBuffer = reinterpret_cast<ushort*>( sDepthPlayerLockedRect.pBits );
		cv::Mat maskMat = cv::Mat::zeros( 480, 640, CV_8UC1 );
		for( int y = 0; y < 480; y++ ){
			for( int x = 0; x < 640; x++ ){
				pSensor->NuiImageGetColorPixelCoordinatesFromDepthPixelAtResolution( NUI_IMAGE_RESOLUTION_640x480, NUI_IMAGE_RESOLUTION_640x480, nullptr, x, y, *pBuffer, &registX, &registY );
				if( ( registX >= 0 ) && ( registX < 640 ) && ( registY >= 0 ) && ( registY < 480 ) ){
					if( ( *pBuffer & 0x7 ) != 0 ){
						maskMat.at<uchar>( registY, registX ) = 0xff; // 255
					}
				}
				pBuffer++;
			}
		}

		
		// Mathematical Morphology - opening
		cv::erode( maskMat, maskMat, cv::Mat(), cv::Point( -1, -1 ), iterationErode );
		cv::dilate( maskMat, maskMat, cv::Mat(), cv::Point( -1, -1 ), iterationDilate );

		// Mathematical Morphology - cpening
		cv::dilate( maskMat, maskMat, cv::Mat(), cv::Point( -1, -1 ), iterationDilate );
		cv::erode( maskMat, maskMat, cv::Mat(), cv::Point( -1, -1 ), iterationErode );
		
		cv::Mat clipMat = cv::Mat::zeros( 480, 640, CV_8UC4 );
		colorMat.copyTo( clipMat, maskMat );

		cv::imshow( "Mask", maskMat );
		cv::imshow( "Clip", clipMat );

	
		pColorFrameTexture->UnlockRect( 0 );
		pDepthPlayerFrameTexture->UnlockRect( 0 );
		pSensor->NuiImageStreamReleaseFrame( hColorHandle, &pColorImageFrame );
		pSensor->NuiImageStreamReleaseFrame( hDepthPlayerHandle, &pDepthPlayerImageFrame );

	
		if( cv::waitKey( 30 ) == VK_ESCAPE ){
			break;
		}
	}


	pSensor->NuiShutdown();
	CloseHandle( hColorEvent );
	CloseHandle( hDepthPlayerEvent );
	CloseHandle( hColorHandle );
	CloseHandle( hDepthPlayerHandle );

	cv::destroyAllWindows();

	return 0;
}

 

El link de descarga: https://github.com/haruiz/Kinect_Blog

El resultado:

image

image

 

Espero les sea de utilidad para sus proyectos.

 

saludos

Anuncio publicitario

Mi Primer Proyecto en cocos2d-x para Windows Phone 8

en el anterior post (Introducción al desarrollo de videojuegos en cocos2d-x) vimos como crear un proyecto en cocos2d, vamos hablar un poco acerca de la estructura del mismo y después  a analizar un poco como es el flujo de ejecución de nuestra aplicación.

Estructura de carpeta:

image

  • Folder Assets: aquí debes adicionar todos los recursos multimedia que tu videojuego use.
  • Floder Classes: Todas las clases de tu proyecto cocos2d, escenas, capas. la clase AppDelegate es la mas importante, en el siguiente bloque se explicara el porque.

Flujo de ejecución:

g1

 

1. se ejecuta nuestra aplicación (el entry point de la misma): ver(http://developer.nokia.com/community/wiki/C++_support_from_Windows_Phone_8)

“To launch an application, Windows phone need an «entry point» it may consume. To perform it, your «entry point» will be developed with C++/CX and C++ main function is replaced by a C++/CX version:”

   1: [Platform::MTAThread]

   2: int main(Platform::Array<Platform::String^>^)

   3: {

   4:     auto factory= ref new myFactory();

   5:     CoreApplication::Run(direct3DApplicationSource);

   6:     return 0;

   7: }

el cual en nuestro proyecto demo1 esta dentro del archivo demo1.cpp

   1: [Platform::MTAThread]

   2: int main(Platform::Array<Platform::String^>^)

   3: {    

   4:     auto direct3DApplicationSource = ref new Direct3DApplicationSource();

   5:     CoreApplication::Run(direct3DApplicationSource);

   6:     return 0;

   7: }

Nuestra aplicación cocos2d  no deja de ser una aplicación Direct3d,es por esto que la clase Direct3DApplicationSource implementa la interface IFrameworkViewSource. ver (http://developer.nokia.com/community/wiki/C++_support_from_Windows_Phone_8)

Platform::MTAThread : metadata about application multi-thread apartment. myFactory(): implements IFrameworkViewSource. This class is a factory use to instantiate a Iframeworkview.”

   1: ref class myFactory sealed : Windows::ApplicationModel::Core::IFrameworkViewSource

   2: {

   3: public:

   4:     virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView()

   5:     {

   6:          return ref new myView();

   7:     };

   8: };

 

es la clase Direct3DApplicationSource(dentro del archivo demo.h)  que como lo mencione anteriormente, implementa la interfaz  IFrameworkViewSource ,  es la que se encarga de proveer el espacio(cargar la vista) en el que nuestro videojuego se ejecutara, por lo tanto la vista demo1, que representa ese espacio, implementa la interfaz IFrameworkView, como se muestra a continuación (archivo demo.h).

   1:  

   2: ref class demo1 sealed : public Windows::ApplicationModel::Core::IFrameworkView

   3: {

   4: public:

   5:     demo1();

   6:     

   7:     // IFrameworkView Methods.

   8:     virtual void Initialize(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView);

   9:     virtual void SetWindow(Windows::UI::Core::CoreWindow^ window);

  10:     virtual void Load(Platform::String^ entryPoint);

  11:     virtual void Run();

  12:     virtual void Uninitialize();

  13:  

  14: protected:

  15:     // Event Handlers.

  16:     void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args);

  17:     void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ args);

  18:     void OnResuming(Platform::Object^ sender, Platform::Object^ args);

  19:     void OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args);

  20:     void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args);

  21:     void OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);

  22:     void OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);

  23:     void OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);

  24:     void OnBackButtonPressed(Platform::Object^ sender, Windows::Phone::UI::Input::BackPressedEventArgs^ args);

  25:  

  26: private:

  27:  

  28:     // The AppDelegate for the Cocos2D app

  29:     AppDelegate app;

  30: };

 

es al función createView la que se encarga de crear ese espacio(crear la vista):

   1: IFrameworkView^ Direct3DApplicationSource::CreateView()

   2: {

   3:     return ref new demo1();

   4: }

al crearse la vista demo1, el método run es ejecutado y la aplicación cocos2d es cargada(AppDelegate):

   1: void demo1::Run()

   2: {    

   3:     CCApplication::sharedApplication()->run();

   4: }

AppDelegate En esta clase que hereda de cocos2d::CCApplication, ocurre todo.

 

   1:  

   2: #include "cocos2d.h"

   3:  

   4: /**

   5: @brief    The cocos2d Application.

   6: 

   7: The reason for implement as private inheritance is to hide some interface call by CCDirector.

   8: */

   9: class  AppDelegate : private cocos2d::CCApplication

  10: {

  11: public:

  12:     AppDelegate();

  13:     virtual ~AppDelegate();

  14:  

  15:     /**

  16:     @brief    Implement CCDirector and CCScene init code here.

  17:     @return true    Initialize success, app continue.

  18:     @return false   Initialize failed, app terminate.

  19:     */

  20:     virtual bool applicationDidFinishLaunching();

  21:  

  22:     /**

  23:     @brief  The function be called when the application enter background

  24:     @param  the pointer of the application

  25:     */

  26:     virtual void applicationDidEnterBackground();

  27:  

  28:     /**

  29:     @brief  The function be called when the application enter foreground

  30:     @param  the pointer of the application

  31:     */

  32:     virtual void applicationWillEnterForeground();

  33: };

  34:  

  35: #endif // _APP_DELEGATE_H_

  36:  

 

Justo en el metodo  AppDelegate::applicationDidFinishLaunching() dentro del archivo AppDelegate.cpp es donde se crea y se carga nuestra escena (CCScene).

   1:  

   2: bool AppDelegate::applicationDidFinishLaunching() {

   3:     // initialize director

   4:     CCDirector* pDirector = CCDirector::sharedDirector();

   5:     CCEGLView* pEGLView = CCEGLView::sharedOpenGLView();

   6:  

   7:     pDirector->setOpenGLView(pEGLView);

   8:     

   9:     // turn on display FPS

  10:     pDirector->setDisplayStats(true);

  11:  

  12:     // set FPS. the default value is 1.0/60 if you don't call this

  13:     pDirector->setAnimationInterval(1.0 / 60);

  14:  

  15:     // create a scene. it's an autorelease object

  16:     CCScene *pScene = HelloWorld::scene();

  17:  

  18:     // run

  19:     pDirector->runWithScene(pScene);

  20:  

  21:     return true;

  22: }

 

Finalmente Nuestra escena, HelloworldScene, se cargan las capas, los Sprites y los demas elementos de nuestro Juego. archivo HelloWorldScene.cpp.

   1: #include "HelloWorldScene.h"

   2:  

   3: USING_NS_CC;

   4:  

   5:  

   6:  

   7: CCScene* HelloWorld::scene()

   8: {

   9:     // 'scene' is an autorelease object

  10:     CCScene *scene = CCScene::create();

  11:     

  12:     // 'layer' is an autorelease object

  13:     HelloWorld *layer = HelloWorld::create();

  14:  

  15:     // add layer as a child to scene

  16:     scene->addChild(layer);    

  17:     // return the scene

  18:     CCLayerGradient* layer1 = CCLayerGradient::create(ccc4(255,0,0,255),ccc4(255,0,255,255));

  19:  

  20:     //CCLayerGradient* layer1 = CCLayerGradient::create();

  21:  

  22:     layer1->setContentSize(CCSizeMake(800, 800));

  23:  

  24:     layer1->setPosition(ccp(0, 0));

  25:  

  26:     scene->addChild(layer1);

  27:  

  28:     

  29:     CCParticleSystemQuad* m_emitter = new CCParticleSystemQuad();

  30:  

  31:     m_emitter = CCParticleSun::create();

  32:  

  33:  

  34:     m_emitter->setEmitterMode(kCCParticleModeGravity);

  35:  

  36:     m_emitter->setGravity(CCPoint(0, -90));

  37:  

  38:     //m_emitter->setDuration(20);

  39:     

  40:  

  41:     layer1->addChild(m_emitter);

  42:     

  43:     m_emitter->setPosition(ccp(100, 100));    

  44:  

  45:     //gravity mode|

  46:     

  47:  

  48:     return scene;

  49: }

  50:  

  51: // on "init" you need to initialize your instance

  52: bool HelloWorld::init()

  53: {

  54:     //////////////////////////////

  55:     // 1. super init first

  56:     if ( !CCLayer::init() )

  57:     {

  58:         return false;

  59:     }

  60:     

  61:     CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();

  62:     CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();

  63:     //create main loop

  64:     this->schedule(schedule_selector(HelloWorld::update));

  65:     return true;

  66: }

  67:  

  68:  

  69:  

  70: void HelloWorld::update(float dt) {

  71:     //the main loop

  72: }

  73:  

  74: void HelloWorld::menuCloseCallback(CCObject* pSender)

  75: {

  76:  

  77: #if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT) || (CC_TARGET_PLATFORM == CC_PLATFORM_WP8)

  78:     CCMessageBox("You pressed the close button. Windows Store Apps do not implement a close button.","Alert");

  79: #else

  80:     CCDirector::sharedDirector()->end();

  81: #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)

  82:     exit(0);

  83: #endif

  84: #endif

  85: }

Fundamentos de cocos2d-x

 

antes de entrar en materia, es decir antes de entrar técnicamente a hablar de lo que es el desarrollo de videojuegos para Windows Phone 8 en cocos2d-x, es necesario entender su funcionamiento.

cocos2d2

Los Nodos / contenedores: son los componentes principales de un juego desarrollado usando cocos2d, en cocos2d-x todos los objetos son nodos, que pueden a su vez contener otros nodos, estos están organizados jerárquicamente  por lo tanto, cualquier cambio que se realice sobre un nodo afectara los hijos del mismo.conceptualmente se pueden organizar de la siguiente forma:

  • CCScene: puede contener uno o mas objetos CCLayer, suelen usarse para construir las pantallas de nuestro videojuego, por ejemplo un objeto CCSene, para el menú, otro para el primer nivel, otro para la pantalla de configuración etc.. cada objeto CCScene es independiente. programáticamente podemos aplicar efectos de transición entre las escenas.
  • CCLayer: puede contener uno o mas objetos de tipo CCSPrite, los objetos CCLayer nos permiten organizar el contenido de cada pantalla en capas,  por ejemplo para la pantalla del menú, un objeto CCLayer podría ser el fondo y otro el Menú como tal,los objetos CCLayer son capaces de escuchar y atender las entradas del usuario (eventos), por ejemplo el touch , accelerometer and gyroscope).
  • CCSprite: es quizás en mi opinión la clase mas importante, contienen las imágenes que serán adicionadas a nuestras Capas.
  • CCNode: de esta clase heredan todas las clase anteriormente mencionadas y otras que no dejan de ser importantes como por ejemplo CCMotionStreak, CCParallaxNode , y puede ser usada para la construcción de nodos propios.

El Objeto CCDirector

este objeto es el encargado de gestionar o administrar las escenas(CCScene) en nuestro videojuego además nos permite configurar por ejemplo el tamaño de la pantalla, el frame rate, la escala etc. existen otras clases muy útiles como por ejemplo, CCParticles, para el manejo de  sistemas de partículas,  muy sofisticados por cierto, CCActions para el manejo de animaciones por ejemplo, o nodos especializados para cosas como barras de progreso, efectos especiales, tile maps etc.

 

cocos2d

Sistema de coordenadas
 
en el desarrollo de videojuegos, existen 3 tipos de sistemas de coordenadas diferentes, basados en los 2 que ya conocemos, que se muestran en la siguiente figura:
 
left-right-handed-cartesian
 
UI Coordinate System:
  • el origen  (x=0, y=0) esta en la esquina superior izquierda.
    el eje x empieza al lado izquierdo de la pantalla y el valor  incrementa hacia la derecha. la coordenada Y empieza en la parte  superior de la pantalla y aumenta hacia abajo de la misma.

ui-coordinate-system

Direct3D Coordinate System

DirectX usa Left-handed Cartesian Coordinate.

OpenGL and Cocos2d Coordinate System

Cocos2d-x/-html5/-iphone usa el mismo sistema de coordenadas que usa OpenGL, “Right-handed Cartesian Coordinate System”.

el origen  (x=0, y=0) esta en la esquina inferior izquierda.
el eje x empieza al lado izquierdo de la pantalla y el valor  incrementa hacia la derecha. la coordenada Y empieza en la parte  inferior de la pantalla y aumenta hacia arriba de la misma.

 

DeviceScreen

Introducción al desarrollo de videojuegos para Windows Phone 8 usando cocos2d-x

Hola que tal a todos, este es el primer tutorial de la serie de tutoriales de introducción al desarrollo de videojuegos para Windows Phone 8  usando cocos2d-x que estaré publicando en los próximos días, espero que les sea de gran utilidad.

Cocos2CoordinateRelease

¿Qué es coco2D-x?

para los amantes del desarrollo de videojuegos cocos2d es un framework de desarrollo de videojuegos 2d, concebido en un principio específicamente para el desarrollo de videojuegos para iPhone, sin embargo debido al éxito que ha tenido en los últimos años (empresas como zynga, Atari  e incluso konami lo usan) hoy en día este popular framework permite desarrollar videojuegos casi que para cualquier plataforma. Actualmente existen 3 implementaciones de cocos2d, la primera cocos2d (basado en Pyglet escrito en python) específicamente para el desarrollo de videojuegos para iPhone , cocos2d-x para el desarrollo de  videojuegos multiplataforma(SO, escrito en c++  y OpenGl Es 1.1 /2.0) y Cocos2d-html5 (escrito en JavaScript) para el desarrollo de videojuegos usando html5, una de las características quizás la mas importante es que solo codificando nuestro videojuego una sola vez  estará disponible para las diferentes plataformas soportadas.

cocos2d-x-architecture

en este primer tutorial, explicare como instalar y crear un nuevo proyecto usando cocos2d-x.

  1. Crear un nuevo proyecto en cocos2d-x
  • primero descargue la versión mas recientes de cocos2d-x, directamente de la pagina (http://www.cocos2d-x.org/download), en internet se suelen encontrar muchas plantillas de proyectos, ya configuradas y lista para usar en visualstudio, sin embargo en este tutorial explicaré paso a paso como es el proceso de creación de un nuevo proyecto desde cero.
  • luego al terminar la descarga ,descomprima el contenido del archivo  .rar , en la carpeta que usted desee. como se muestra en la imagen a continuación.
  • dentro de la estructura de capetas ubique el siguiente archivo “..\cocos2d-x-2.2.2\tools\project-creator\create_project.py”
  • para el siguiente paso, que tiene que ver con la ejecución del archivo anteriormente mencionado, que nos permitirá crear nuestro nuevo proyecto,   es necesario instalar la versión de python 2.7, con algunas versiones mayores, suelen haber conflictos.
  • la instalación de python, consiste en seguir el asistente, teniendo en cuenta la ruta de instalación de este.
  • al finalizar la instalación de python, abra una nueva ventana de línea comando (cmd/línea de comandos), y ejecute el archivo teniendo en cuenta los parámetros que se le deben pasar. Note que es necesario a través del comando cd, ubicarse en la carpeta en donde esta el archivo create_project.py.

//esta primera línea solo se debe ejecutar si el path de instalación de python no esta registrada en las variables de entorno.

…\cocos2d-x-2.2.2\tools\project-creator>set Path=C:\Python27

…\cocos2d-x-2.2.2\tools\project-creator>python create_project.py -project demo1  -package com.sinapsis.demo1    –language    cpp

image

  • luego de que el comando haya sido ejecutado satisfactoriamente, vaya a la carpeta de instalación de cocos2d-x y valide si dentro de la carpeta projects el folder demo2 se creo.

Untitled

  • finalmente abra la carpeta proj.wp8.

Nota: si desea elimine el archivo HelloCpp.sdf y renombre el archivo HelloCpp.suo

Untitled2

  • abra la solución (demo.sln) en visualstudio 2013, y ejecute el proyecto, es posible que al cargar la solución le aparezca la siguiente advertencia, haga clic en ok .

image

  • finalmente ejecute el proyecto

Untitled3

 

hasta la próxima, espero les sea de utilidad.

Xna

Windows 8 delivers the opportunity for you to create engaging games that reach the broadest audience, and run across a wide range of devices. In this session, learn the essentials of the new Windows 8 game development and application environment, including the Windows Runtime, CoreWindow, DirectX 11.1, Process Lifetime Management, asynchronous execution, and C++/Cx. We will also demonstrate Visual Studio capabilities for debugging 3-D applications, managing code and basic content types like shaders, textures, and meshes in both design-time and run-time formats. Each key step will be illustrated with code from a Windows 8 SDK sample app such as MarbleMaze or Simple3DGame.