Es un poco offtopic, pero bueno, se sabe algo de lo que se comenta de la desaparición de títulos y sustitución por títulos proprios de la universidad?

No entiendo el porque lo que he dicho es incorrecto. Igual me he expresado de forma inadecuada.
Lo que pretendía decir era exactamente la ley de los grandes números de Jakob Bernouilli que esta considerada como uno de los teoremas fundamentales de la teoría de probabilidad.

Saludos

Creo que el título es autoexplicativo, estoy haciendo una función que calcule x^n para n entero (la utilizaré muchas veces, por lo que necesito que sea rápida). La primera solución que me vino a la cabeza fue supongo que la típica de

Código [Seleccionar] Expand


total=1;
while(n--!=0)
 total*=x;


Pero, me he dado cuenta de que si quisiera calcular x^4 en vez de realizar 3 productos, podría reducirlo a 2, podría calcular x^2 y luego multiplicar ese valor por el mismo. Así, para cualquier n que sea potencia de 2. También, por ejemplo para calcular x^7,  no necesito hacer 6 productos, podemos hacer y=x*x, z=y*y, total=z/x.
¿Alguien conoce algun algoritmo para evaluar x^n con el menor número de productos posibles?
Saludos

_Grey muy buen enlace, creo que viene a explicar lo que pretendía decir

Es imposible predecir lo que va suceder en un experimento concreto, pero si realizamos un número de experimentos suficientemente grande los números tenderán a aparecer el mismo número de veces.  Es decir, sea un dado y el experimento lanzarlo y ver el número que ha salido. Si lo lanzamos, una vez es imposible predecir lo  que saldrá, pero supongamos que hacemos 6 millones de lanzamientos, la esperanza matemática nos hace pensar que cada número habrá salido aproximadamente un millón de veces.

Si te soy sincero no estoy muy interesado en el tema de la Bonoloto y no sé exactamente como funciona, lo que sé sobre ella es lo que acabo de consultar en Google. Si me he enterado bien, consiste en un bombo con bolas númerdas del nº 1 al 49. De ahí se extraen 6 bolas. Si he entendido bien no depende del orden en que se saquen las bolas.
Si el juego es así, hagamos cálculos:
P(de que salga una combinación concreta, como 4 7 11 12 25 28)=casos favorables/casos posibles=1/nº combinatorio(49 sobre 6)=1/13 983 816.
No sé cual es el tiempo entre sorteos, supongamos que son a diario, y dijistes que se llevan ejecutando desde el 1988, 19 años (contando aquel y este), entonces tenemos aproximadamente (sin contar bisiestos) 365*19=6935 sorteos.
Ahora calculemos la P(de que no salgan dos numeros iguales en 6935 sorteos)=(13983816-1)*(13983816-2)*(13983816-3)...(13983816-6935)/(13983816^6935)
Realizando estos calculos en el ordenaodor, calculé el logaritmo neperiano  de la expresión de forma aproximada obtengo -0.33, y calculando su exponencial tenemos que la probabilidad de forma aproximada de que no salgan dos números iguales es de 0.71. Es una probabilidad elevada por lo que era de esperarse que no salieran dos números iguales en todo este tiempo. Podría haber sucedido que hubieran salido, el azar es caprichoso.

No te desanimes, hasta los mas grandes matematicos se han equivocado, Leibniz lo hizo (creía que sumar 11 tirando dos dados era igual de probable que sumar 12). Los grandes pierden batallas pero no la guerra

Saludos

Imaginate que en un sorteo sale el:

4 13 24 28 39 46

Al dia siguiente alguien se va a poner a empezar a jugar en esto de la loteria y se le ocurre el mismo numero anterior: 4 13 24 28 39 46 .
(Por poder si, si nos ponemos...) pero realmente es muy dificil que de las millones de combinaciones que se pueden obtener salgan 2 dias y consecutivos los mismos numeros, con lo que esa persona habra malgastado ese dinero.

Cosa que si hubiera sabido que la combinacion anterior fue esa, no habria puesto la misma y hubiera tenido mas opciones de acertar la serie de numeros ¿no? pocas mas pero....

No entiendo por que al suceder un suceso su probabilidad se reduce.
Si te he entendido bien lo que has dicho, de forma análoga, al tirar un dado y sacar un 6, cuando volviera a tirarlo la probabilidad de sacarlo sería menor (algo que de hecho no es cierto).

La probabilidad que es menor es que lance dos veces un dado y las dos veces salga un 6 (P(x)=1/36). Pero una vez ha ocurrido un suceso, es decir he sacado un 6, la probabilidad de sacar otro 6 es P(x)=1/6.

Zupervaca, ¿me permites hacerte algunas preguntas? Es que estoy haciendo tambien un juego estilo Arkanoid.
¿Como has tratado el tema de la colisión con los ladrillos? ¿Bounding box? Es que yo lo he tratado de esa forma y en cada ciclo verifico si la bola colisiona con todos los ladrillos, pero me parece un método lento.

Sí, la verdad, es que no se me ocurrió otra cosa al llamar la variable itineradora, por eso le puse "juan", mi nombre, porque se me vino a la cabeza.

Voy a probar de mientras eso.

¿Que tal el nombre de i?  :shock:

Estoy hablando de mas o menos cuando tenia 8-12 años y no existia internet y ni siquiera tenia dinero para comprar los libros y aprender, asi que la unica manera de aprender las cosas que tuve fue el prueba/fallo/soluciona o codigo de juegos en las revistas, fijo que muchos de por aqui se sentiran identificados de esta manera.

Creo que yo soy el que he empezado más pronto. A los dos años de edad ya era capaz de programar el VHS para grabar.  :)   :)

Muchas gracias senior wapo, ya me tira perfecto.

Estoy iniciandome con DirectX. Estoy haciendo un clon del Arkanoid, y la verdad es que el código que tengo hasta ahora es muy lento. Alguien puede decirme el motivo?

App.h

Código [Seleccionar] Expand


#pragma once

#include "Wind.h"
#include "Engine.h"
#include "HTime.h"
#include "Keyboard.h"
#include "Pad.h"

class App
{
public:
App(void);
bool Init(HINSTANCE hInst,char * Name,char *Title,int x,int y,int width,int height,bool Windowed);
void Run(void);
void Release(void);
~App(void);
private:
Graphic engine;
Wind window;
HTime timer;
Keyboard keyboard;
Pad pad;
Sprite border;
};


App.cpp

Código [Seleccionar] Expand


#include "App.h"

App::App(void): engine(),window(),timer(),keyboard(), pad(), border()
{
}

App::~App(void)
{
Release();
}

bool App::Init(HINSTANCE hInst,char * Name,char *Title,int x,int y,
  int width,int height,bool Windowed)
{
bool b;
b=window.Init(hInst,Name,Title,x,y,width,height,((Windowed)?(FOR_WINDOWED):(FOR_FULLSCREEN)));
if(!b) return false;
b=engine.Init(window.hWnd(),Windowed,width,height,((Windowed)?(GWINDOW):(GFULL)));
if(!b) Release();
window.Show();
if(FAILED(keyboard.Init(hInst,window.hWnd())))
{
Release();
return false;
}
pad.Prepare();
border.Load("images\\border.tga");
border((float)Sprite::SizeX/2,(float)Sprite::SizeY-150-25);
return b;
}

void App::Release(void)
{
keyboard.Release();
border.Release();
pad.Release();
engine.Release();
}

void App::Run(void)
{
float delta=timer.Elapsed();
keyboard.Update();
if(keyboard.IsPressed(DIK_ESCAPE)) PostQuitMessage(0);
if(keyboard.IsPressed(DIK_LEFT))   pad.MoveLeft(delta);
if(keyboard.IsPressed(DIK_RIGHT))  pad.MoveRight(delta);

engine.Clear(D3DCOLOR_XRGB(0,0,0));
engine.Prepare();
pad.Draw();
border.Draw();
engine.Render();
}


Engine.h

Código [Seleccionar] Expand


//Necesita d3d9.lib d3dx9.lib
#include <d3d9.h>
#include <d3dx9.h>

class Sprite;
class Graphic;

#include "Graphic.h"
#include "Sprite.h"


Graphic.h

Código [Seleccionar] Expand


#pragma once


#define GFULL   D3DFMT_A8R8G8B8
#define GWINDOW D3DFMT_UNKNOWN

class Graphic
{
friend class Sprite;
public:
Graphic(void);
bool Init(HWND hWnd,bool Windowed,int sizeX,int sizeY,D3DFORMAT Format=D3DFMT_UNKNOWN);
void Release(void);
void Clear(D3DCOLOR Color)
{
pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET,Color, 1.0f, 0 );
}
void Render(void)
{
pd3dSprite->End();
pd3dDevice->EndScene();
pd3dDevice->Present(NULL,NULL,NULL,NULL);
}
D3DFORMAT Format(void) const
{
return format;
}
void Prepare(void)
{
pd3dDevice->BeginScene();
pd3dSprite->Begin(0);
}
~Graphic(void);
private:
LPDIRECT3D9 pD3D;
LPDIRECT3DDEVICE9 pd3dDevice;
LPDIRECT3DSURFACE9 backbuffer;
LPD3DXSPRITE pd3dSprite;
D3DFORMAT format;
int SizeX,SizeY;
};



Graphic.cpp

Código [Seleccionar] Expand


#include "Engine.h"

Graphic::Graphic(void)
{
pD3D=NULL;
pd3dDevice=NULL;
backbuffer=NULL;
pd3dSprite=NULL;
SizeX=SizeY=0;
ZeroMemory(&format,sizeof(D3DFORMAT));
}

Graphic::~Graphic(void)
{
Release();
}

void Graphic::Release(void)
{
if(pD3D)
{
if(pd3dDevice)
{
if(pd3dSprite)
{
pd3dSprite->Release();
pd3dSprite=NULL;
}
pd3dDevice->Release();
pd3dDevice=NULL;
}
pD3D->Release();
pD3D=NULL;
}
}

bool Graphic::Init(HWND hWnd,bool Windowed,int sizeX,int sizeY,D3DFORMAT Format)
{
HRESULT hr;
D3DPRESENT_PARAMETERS d3dpp;

pD3D=Direct3DCreate9(D3D_SDK_VERSION);
if(!pD3D) return false;

ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = Windowed;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
format=((Windowed)?(D3DFMT_UNKNOWN):(Format));
d3dpp.BackBufferFormat = Format;
d3dpp.BackBufferCount = 1;
d3dpp.BackBufferHeight = sizeY;
d3dpp.BackBufferWidth = sizeX;
d3dpp.hDeviceWindow = hWnd;
SizeX=sizeX;
SizeY=sizeY;
hr = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_REF,hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,&d3dpp,&pd3dDevice);
if(FAILED(hr))
{
Release();
return false;
}
hr = D3DXCreateSprite(pd3dDevice, &pd3dSprite);
if(FAILED(hr))
{
Release();
return false;
}
Sprite::engine=this;
Sprite::SizeX=sizeX;
Sprite::SizeY=sizeY;
return true;
}


HTime.h

Código [Seleccionar] Expand


#pragma once
#include <windows.h>

class HTime
{
public:
HTime(void);
void Wait(float ms);
float Elapsed(void);
~HTime(void);
private:
LARGE_INTEGER timerFrequency;
LARGE_INTEGER last;
LARGE_INTEGER now;
};


HTime.cpp

Código [Seleccionar] Expand


#include "HTime.h"

HTime::HTime(void)
{
QueryPerformanceFrequency(&timerFrequency);
QueryPerformanceCounter(&last);
}

HTime::~HTime(void)
{
}

void HTime::Wait(float ms)
{
LARGE_INTEGER start,moment;
float elap;
QueryPerformanceCounter(&start);
do
{
QueryPerformanceCounter(&moment);
elap=float(moment.QuadPart-start.QuadPart)/(timerFrequency.QuadPart);
}while(elap<ms);
}

float HTime::Elapsed()
{
QueryPerformanceCounter(&now);
return (float)(now.QuadPart-last.QuadPart)/(timerFrequency.QuadPart);
}


Keyboard.h

Código [Seleccionar] Expand


#pragma once

//Needs dinput8.lib
#define DIRECTINPUT_VERSION 0x0800 //Se pone para eliminar el Warning (le digo que quiero usar DINPUT 8)
#include <dinput.h>

#define KEYDOWN(name, key) (name[key] & 0x80)
const int KEYS = 256;

class Keyboard
{
public:
Keyboard();
Keyboard(HINSTANCE hInst,HWND hWnd){Init(hInst,hWnd);};
HRESULT Init(HINSTANCE hInst,HWND hWnd);
void Update() {lpDIDevice->GetDeviceState(sizeof(buffer),(LPVOID)&buffer);}
bool IsPressed(int key)
{
if(KEYDOWN(buffer,key))
return TRUE;
else return FALSE;
};
void Release();
~Keyboard(){Release();};
private:
LPDIRECTINPUT8  lpDI;
LPDIRECTINPUTDEVICE8  lpDIDevice;
char buffer[KEYS];

};


Keyboard.cpp

Código [Seleccionar] Expand


#include "Keyboard.h"

Keyboard::Keyboard()
{
lpDI=NULL;
lpDIDevice=NULL;
}
HRESULT Keyboard::Init(HINSTANCE hInst,HWND hWnd)
{
HRESULT hr=DirectInput8Create(hInst, DIRECTINPUT_VERSION,IID_IDirectInput8, (void**)&lpDI, NULL);
if(FAILED(hr))
return hr;
hr=lpDI->CreateDevice(GUID_SysKeyboard, &lpDIDevice, NULL);
if(FAILED(hr))
return hr;
hr=lpDIDevice->SetDataFormat(&c_dfDIKeyboard);
if(FAILED(hr))
return hr;
hr=lpDIDevice->SetCooperativeLevel(hWnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if(FAILED(hr))
return hr;
hr=lpDIDevice->Acquire();
return hr;
}

void Keyboard::Release()
{
   if(lpDI)
   {
       if(lpDIDevice)
       {
           lpDIDevice->Unacquire();
           lpDIDevice->Release();
           lpDIDevice = NULL;
       }
       lpDI->Release();
       lpDI = NULL;
   }
}


Main.h

Código [Seleccionar] Expand


#include "App.h"


Main.cpp

Código [Seleccionar] Expand


#include "Main.h"

INT WINAPI WinMain(HINSTANCE hInst,HINSTANCE,LPSTR,INT )
{
MSG msg;
App app;

if(!app.Init(hInst,"Arkanoid","Arkanoid",20,20,640,480,true))
return -1;

msg.message=WM_NULL;
while(WM_QUIT!= msg.message)
{
if(PeekMessage(&msg,NULL,0U,0U,PM_REMOVE))
{
DispatchMessage(&msg);
}
else app.Run();
}
app.Release();
return 0;
}


Sprite.h

Código [Seleccionar] Expand


#pragma once

class Sprite
{
friend class Graphic;
public:
Sprite(void);
bool Load(const char * File);
void Release(void);
~Sprite(void);
float  X(void)  {return x;};
float  Y(void)  {return y;};
void operator() (float x,float y)
{
this->x=x;
this->y=y;
}
int  Height(void)  {return height;};
int  Width (void)  {return width;};
void Draw(void)
{
engine->pd3dSprite->Draw(texture,NULL,&D3DXVECTOR3((float)(twidth/2),float(theight/2),0.0f),&D3DXVECTOR3(x,y,0.0f),0xFFFFFFFF);
}

static int SizeX,SizeY;
protected:
RECT rect;
float x,y;
int width;
int height;
LPDIRECT3DTEXTURE9 texture;
int theight, twidth;
static Graphic *engine;
};


Sprite.cpp

Código [Seleccionar] Expand


#include "Engine.h"

int Sprite::SizeX=0;
int Sprite::SizeY=0;
Graphic * Sprite::engine =NULL;

Sprite::Sprite(void)
{
texture=NULL;
rect.bottom=0;
rect.left=0;
rect.right=0;
rect.top=0;
x=y=0;
width=height=0;
twidth=theight=0;
}

Sprite::~Sprite(void)
{
Release();
}

bool Sprite::Load(const char *File)
{
HRESULT hr;
D3DXIMAGE_INFO imageInfo;
D3DSURFACE_DESC surfaceInfo;

hr = D3DXCreateTextureFromFileEx(Sprite::engine->pd3dDevice,File,D3DX_DEFAULT,
D3DX_DEFAULT,D3DX_DEFAULT,0 ,D3DFMT_UNKNOWN,
D3DPOOL_DEFAULT,D3DX_DEFAULT,D3DX_DEFAULT,0,
&imageInfo,NULL,&texture);
if(FAILED(hr))
return false;
if(FAILED(texture->GetLevelDesc(0,&surfaceInfo)))
return false;

width=imageInfo.Width;
height=imageInfo.Height;
theight=surfaceInfo.Height;
twidth=surfaceInfo.Width;
//ARREGLAR EN UN FUTURO
rect.top=0;
rect.left=0;
rect.right=twidth;
rect.bottom=theight;
//
return true;
}

void Sprite::Release()
{
if(texture)
{
texture->Release();
texture=NULL;
}
}


Wind.h

Código [Seleccionar] Expand


#pragma once
#include <windows.h>
#include <string>

#define FOR_FULLSCREEN WS_EX_TOPMOST | WS_POPUP | WS_VISIBLE
#define FOR_WINDOWED   WS_OVERLAPPEDWINDOW

class Wind
{
public:
Wind(void);
bool Init(HINSTANCE hInst,const char * Name,const char * Title,int x, int y, int width,int height,DWORD dwStyle=WS_OVERLAPPEDWINDOW);
void Show(void) const;
~Wind(void);
static LRESULT CALLBACK MsgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam);
int Width(void) const
{
return m_width;
}
int Height(void) const
{
return m_height;
}
HWND hWnd(void) const
{
return m_hWnd;
}
private:
WNDCLASSEX m_wc;
HWND m_hWnd;
int m_width;
int m_height;
std::string m_Name;
};


Wind.cpp

Código [Seleccionar] Expand


#include "Wind.h"

Wind::Wind(void)
{

}

bool Wind::Init(HINSTANCE hInst,const char * Name,const char *Title,int x, int y, int width,int height,DWORD dwStyle)
{
ZeroMemory(&m_wc, sizeof(WNDCLASSEX));
m_wc.cbSize = sizeof( WNDCLASSEX );
m_wc.style  = CS_HREDRAW | CS_VREDRAW;
m_wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
m_wc.lpfnWndProc = (WNDPROC)Wind::MsgProc;
m_wc.lpszClassName = Name;
m_wc.hInstance=hInst;
RegisterClassEx(&m_wc);
m_hWnd=CreateWindow(Name,Title,dwStyle,x,y, width, height,
GetDesktopWindow(), NULL, hInst, NULL);
if(m_hWnd)
{
m_Name=Name;
m_height=height;
m_width=width;
return true;
}
else return false;
}

void Wind::Show(void) const
{
ShowWindow(m_hWnd, SW_SHOWDEFAULT );
UpdateWindow(m_hWnd);
}

LRESULT CALLBACK Wind::MsgProc(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
switch(msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_SETCURSOR:
       SetCursor(NULL);
       return TRUE;
case WM_ERASEBKGND:
return TRUE;
}
return DefWindowProc( hWnd, msg, wparam, lparam);
}

Wind::~Wind()
{
UnregisterClass( m_Name.c_str() , m_wc.hInstance );
}


Pad.h

Código [Seleccionar] Expand


#pragma once
#include "Engine.h"

class Pad:public Sprite
{
public:
Pad(void);
void MoveRight(float elapsed);
void MoveLeft (float elapsed);
void Prepare(void)
{
Load("images\\pad.tga");
x=float(Sprite::SizeX)/2.0f;
y=float(Sprite::SizeY-20);
}
~Pad(void);
private:
int lives;
};


Pad.cpp

Código [Seleccionar] Expand


#include "Pad.h"

const float Speed=1.0f;
Pad::Pad(void):Sprite()
{
lives=3;
}

Pad::~Pad(void)
{
}

void Pad::MoveLeft(float elapsed)
{
x-=(elapsed)*Speed;
}

void Pad::MoveRight(float elapsed)
{
x+=(elapsed)*Speed;
}


Conoceis páginas donde haya tutoriales sobre 2D(DX9). Googleando he encontrado páginas como 32 bits, toymaker..., pero por lo general usan algunas funciones que ya no estan en la versión de febrero.
Con los libros sucede algo parecido, la mayoría que he encontrado son sobre Dx8, y los q son sobre dx9 apenas tratan el 2d y se centran en el 3d.

Ya me funciona, gracias a todos.

Antes nada, decir que gracias por todos que os habeis interesado en contestarme. Siento no haber contestado antes, pero es que ayer estaba de examenes. No me imaginaba que el tema del color keying diera tanto que hablar.
He hecho una serie de cambios en el código, antes trabajaba con Offscreen Plain Surfaces, y segun he leído en los mensajes he de trabajar con Textures, también segun lo que he leído, he de trabajar con el D3DXSPRITE.
Respecto a mi código, quizás es un poco raro (y se podrían mejorar muchas cosas supongo, tengo la manía de hacer la implementación de algunos métodos dentro del fichero *.h para que sean inline). Se tratan de dos clases una llamada Graphic y otra llamada Sprite. La primera se encarga de inicializar D3D, el Device, y D3DXSPRITE (en un método llamado Init). Esta es friend de Sprite, y cuando termina el método Init pone el valor del miembro engine (static) de Sprite a this (he hecho para no tener que pasar el device siempre como parametro). En cuanto a la clase sprite, esta se encargaría de cargar una imagen del disco duro y ponerla en pantalla, siendo el color transparente por ejemplo el rosa chillón (algo que tal vez se cambia a un color por parametro).
Aqui esta el  código:

Graphic.h

Código [Seleccionar] Expand


#pragma once


#define GFULL   D3DFMT_X8R8G8B8
#define GWINDOW D3DFMT_UNKNOWN

class Graphic
{
friend class Sprite;
public:
Graphic(void);
bool Init(HWND hWnd,bool Windowed,int sizeX,int sizeY,D3DFORMAT Format=D3DFMT_UNKNOWN);
void Release(void);
void Clear(D3DCOLOR Color)
{
pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET,Color, 1.0f, 0 );
}
void Render(void)
{
HRESULT hr;
pd3dSprite->End();
pd3dDevice->EndScene();
//if(backbuffer)
//{
// backbuffer->Release();
// backbuffer=NULL;
//}
hr=pd3dDevice->Present(NULL,NULL,NULL,NULL);
if(FAILED(hr)) ::OutputDebugString("ERROR: Present");
}
D3DFORMAT Format(void) const
{
return format;
}
void Prepare(void)
{
HRESULT hr;

//hr=pd3dDevice->GetBackBuffer(0,0,D3DBACKBUFFER_TYPE_MONO,&backbuffer);

hr = pd3dDevice->BeginScene();
if(FAILED(hr)) ::OutputDebugString("ERROR: Begin Scene");
pd3dSprite->Begin(D3DXSPRITE_ALPHABLEND);
}
~Graphic(void);
private:
LPDIRECT3D9 pD3D;
LPDIRECT3DDEVICE9 pd3dDevice;
LPDIRECT3DSURFACE9 backbuffer;
LPD3DXSPRITE pd3dSprite;
D3DFORMAT format;
int SizeX,SizeY;
};


Graphic.cpp

Código [Seleccionar] Expand


#include "Engine.h"

Graphic::Graphic(void)
{
pD3D=NULL;
pd3dDevice=NULL;
backbuffer=NULL;
pd3dSprite=NULL;
SizeX=SizeY=0;
ZeroMemory(&format,sizeof(D3DFORMAT));
}

Graphic::~Graphic(void)
{
Release();
}

void Graphic::Release(void)
{
if(pD3D)
{
if(pd3dDevice)
{
if(pd3dSprite)
{
pd3dSprite->Release();
pd3dSprite=NULL;
}
pd3dDevice->Release();
pd3dDevice=NULL;
}
pD3D->Release();
pD3D=NULL;
}
}

bool Graphic::Init(HWND hWnd,bool Windowed,int sizeX,int sizeY,D3DFORMAT Format)
{
HRESULT hr;
D3DPRESENT_PARAMETERS d3dpp;

pD3D=Direct3DCreate9(D3D_SDK_VERSION);
if(!pD3D) return false;

ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = Windowed;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
format=((Windowed)?(D3DFMT_UNKNOWN):(Format));
d3dpp.BackBufferFormat = Format;
d3dpp.BackBufferCount = 1;
d3dpp.BackBufferHeight = sizeY;
d3dpp.BackBufferWidth = sizeX;
d3dpp.hDeviceWindow = hWnd;
SizeX=sizeX;
SizeY=sizeY;
hr = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_REF,hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dpp,&pd3dDevice);
if(FAILED(hr))
{
Release();
return false;
}
hr = D3DXCreateSprite(pd3dDevice, &pd3dSprite);
if(FAILED(hr))
{
Release();
return false;
}
Sprite::engine=this;
Sprite::SizeX=sizeX;
Sprite::SizeY=sizeY;
return true;
}



Sprite.h

Código [Seleccionar] Expand


#pragma once

class Sprite
{
friend class Graphic;
public:
Sprite(void);
bool Load(const char * File);
void Release(void);
~Sprite(void);
void X(int nx)
{
x=nx;
};
int  X(void)  {return x;};
void Y(int ny)
{
y=ny;
};
int  Y(void)  {return y;};
int  Height(void)  {return height;};
int  Width (void)  {return width;};
void Draw(void)
{
//if(engine->backbuffer)
//{
engine->pd3dSprite->Draw(texture,&rect,&D3DXVECTOR3(width/2,height/2,0),&D3DXVECTOR3(x,y,0.0f),0xFFFFFFFF);
//}
}
static int SizeX,SizeY;
protected:
RECT rect;
int x,y;
int width;
int height;
LPDIRECT3DTEXTURE9 texture;
static Graphic *engine;
};


Sprite.cpp

Código [Seleccionar] Expand


#include "Engine.h"

int Sprite::SizeX=0;
int Sprite::SizeY=0;
Graphic * Sprite::engine =NULL;

Sprite::Sprite(void)
{
texture=NULL;
rect.bottom=0;
rect.left=0;
rect.right=0;
rect.top=0;
x=y=0;
width=height=0;
}

Sprite::~Sprite(void)
{
Release();
}

bool Sprite::Load(const char *File)
{
HRESULT hr;
D3DXIMAGE_INFO imageInfo;
hr = D3DXCreateTextureFromFileEx(Sprite::engine->pd3dDevice,File,D3DX_DEFAULT,
D3DX_DEFAULT,D3DX_DEFAULT,D3DUSAGE_RENDERTARGET ,D3DFMT_UNKNOWN,
D3DPOOL_DEFAULT,D3DX_DEFAULT,D3DX_DEFAULT,D3DCOLOR_XRGB(255,0,0),
&imageInfo,NULL,&texture);
if(FAILED(hr))
return false;
rect.top=0;
rect.left=0;
rect.right=imageInfo.Width;
rect.bottom=imageInfo.Height;
width=imageInfo.Width;
height=imageInfo.Height;

return true;
}

void Sprite::Release()
{
if(texture)
{
texture->Release();
texture=NULL;
}
}


Engine.h

Código [Seleccionar] Expand


#include <d3d9.h>
#include <d3dx9.h>

class Sprite;
class Graphic;

#include "Graphic.h"
#include "Sprite.h"


Zupervaca, gracias por contestar. ¿Me permites hacer unas preguntas más?
El código no me funciona (algo habre hecho mal). Estoy trabajando en 2D y con surfaces, para que funcione, he  usar textures? O bien, es por el método en que dibujo las surfaces en pantalla, las dibujo usando StretchRect sobre el  backSurface?
Saludos,
y gracias por la atención

Estoy aprendiendo directX 9, y  quería saber si sabeis como puedo decirle que cuando pinte un surface no pinte un color (es decir como el color transparente de un gif). Lo máximo que he conseguido hasta ahora es que cuando cargo una imagen de un fichero, un color elegido pasa a ser negro, pero nada más.
Saludos