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

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.

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

Estoy usando el Visual C++ Express para hacer un programa con ventanas de Windows, una de las cosas que hace es acceder a ficheros del disco. Sin embargo, no paro de obtener errores de de que el clase fstream no ha sido declarado (ya he comprobado que hice un #include <fstream>). ¿Alguien sabe que puede ser? ¿Alguien le ha pasado algo parecido? Desde luego, es muy frustrante.

 Llevo unos días peleandome con Direct3D y he decidido empezar aislar toda esa cacharrería en clases (me refiero a la inicialización y la posterior liberación de memoria). Me preguntaba si todo lo que se libera con el método Release, se puede poner en el destructor de la clase? O no, eso lo he de hacer manualmente?

 Suelo jugar en la facultad a juegos antiguos como Zak MacKraken,y etc que los sonidos se emiten por el PC speaker, quería saber si sabeis alguno manera de desactivarlo.

 Me podeis recomendar un buen tutorial de DirectX? Ya llevo bastante tiempo programando usando la librería Allegro  y ahora había pensado dejarla por DirectX.

 Hace poco pregunte en este link si comprarme un procesador de AMD o de Intel.
Finalmente me decanté por un AMD.
Sé que ya me estoy un poco pesado con tanto preguntar. Quería que me dierais vuestra opinión
sobre el equipo:
Procesador: AMD ATLHON X2 4200 460.40€
Placa base: dudo entre 2 la K8N-SLI S-939 de GYGABYTE(97.60€) o la ASUS A8N-E 939 (103.90€)
Disco duro: Serial ATA 80 gigas de maxtor 56.90€
RAM: 2 módulos de 512 MB DDR a 400 de Kingston 44.30€ cada una (compró dos para aprovechar el dual channel)
Grabadora DVD: LG de doble capa (41.90€)
Tarjeta gráfica: SVGA XFX GF 6200 TURBO CACHE 256 54.80€
Torre: con fuente de 450kW (siguiendo algunos consejos de los del foro)

Que os parece? Otra duda, es que no me entero mucho, lleva la placa base de GYGABYTE tarjeta de red o es que he leído mal?
Un saludo

 Estoy  deseando comprarme un ordenador nuevo y tengo una duda en cuanto al procesador que voy adquirir. Dudo entre un AMD 64 3000 o un Intel Pentium 4 a 3.0 Ghz, y no sé cual comprarme.
Pienso utilizar el ordenador para programar juegos y jugar. Además me interesa que dure, es decir, que no tenga dentro de poco tiempo cambiar el procesador para utilizar  aplicaciones.

 Hola, estaba buscando algunos sonidos tipo recreativos antiguos, tipo Pong, Asteroids, Space Invaders, Pac-Man, si alguien supiera una página.

 "Vuelos de fantasía" es un libro ya descatalogado. Su autor es Christopher Lampton, lo quería comprar y quería si alguien aquí del foro desea venderlo.

 Alguien alguna vez Out of this World (o tambien conocido como Another World)?
Pues hace poco estuve jugando, y me surgió una pregunta.
Son los gráficos de este juego (por cierto muy parecidos al de Flashback), 2D o 3D? Hay imagenes que me parecen muy complicadas para ser dibujadas en 2D (por ejemplo los vídeos). Me preguntada si los gráficos de este juego a lo mejor son diseñados en 3D, y luego se toman las imágenes renderizadas, como en el Donkey Kong de la SNES.
Aquí os dejo algunas imágenes de este fantástico juego:





Imágenes extraídas de:
http://www.cherryroms.com/snes_roms/2078/o..._of_this_world/
http://www.vgmuseum.com/end/scd/a/hota.htm