Actualmente para un additive blending hago lo siguiente:


pD3dDevice7->SetRenderState( D3DRENDERSTATE_ALPHABLENDENABLE , TRUE );

pD3dDevice7->SetRenderState( D3DRENDERSTATE_SRCBLEND , D3DBLEND_SRCALPHA);
pD3dDevice7->SetRenderState( D3DRENDERSTATE_DESTBLEND , D3DBLEND_ONE);


Cómo podría hacer un subtractive blending?? por la naturaleza de la operación, la cual incluye una suma, parece que es imposible.

Hay alguna manera sencilla de hacer subtractive blending?? cuando digo sencilla me refiero a poco más que jugar con el render state, es un código de hace algún tiempo que usa DirectX7.

Utilizo el ChangeDisplaySettings() para pasar a fullscreen y salir de él, pero una vez de cada muchas me encuentro que al regresar al escritorio los iconos han cambiado de lugar. He buscado por san Google, y parece que es algo más o menos común, pero curiosamente no encuentro por ningún lugar la forma correcta de llamar a ChangeDisplaySettings() para que no haga tal fechoría.

Puede alguien decirme por qué ocurre y como evitarlo?!?!?

Para entrar en fullscreen hago esto:

Código [Seleccionar] Expand

// Pone la ventana a pantalla completa segun GDI
bool Window::SetFullScreenGDI(int x,int y,ColorMode cm,int hz){ // GDI

bool creada;
DEVMODE ModoPantalla;

// Si no esta creada, la crea
if(!GetProperty(CREATE)){
Create(true);
creada=true;
} else creada=false;

// Pone pantalla completa
ModoPantalla.dmSize = sizeof(DEVMODE); // Tamaño de la estructura
ModoPantalla.dmBitsPerPel = (cm==COLOR8INDEX)?8:(cm==COLOR16RGB)?16:(cm==COLOR16XRGB)?16:(cm==COLOR24RGB)?24:(cm==COLOR32XRGB)?32:(cm==COLOR32ARGB)?32:0;// Profundidad de color
ModoPantalla.dmPelsWidth = x; // Ancho
ModoPantalla.dmPelsHeight = y; // Alto
ModoPantalla.dmDisplayFrequency = hz; // Refresco
ModoPantalla.dmFields = DM_PELSWIDTH | // VALORES A USAR DE LA ESTRUCTURA
DM_PELSHEIGHT |
DM_BITSPERPEL |
DM_DISPLAYFREQUENCY;

// Pone pantalla completa
if(ChangeDisplaySettings(&ModoPantalla,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL){
// No pudo poner pantalla completa
if(creada) // Se creo en la funcion, la destruye
Destroy();
logMsg("( ~ %d ) ( %s ) Window::SetFullScreen(int x,int y,ColorMode cm,int hz) : fallo el ChangeDisplaySettings() con %dx%dx%s %dHz.",
__LINE__,__FILE__,x,y, (cm==COLOR8INDEX)?"8":(cm==COLOR16RGB)?"16RGB":(cm==COLOR16XRGB)?"16XRGB":(cm==COLOR24RGB)?"24":(cm==COLOR32XRGB)?"32XRGB":(cm==COLOR32XRGB)?"32ARGB":"?(solo son validos COLOR8INDEX,COLOR16RGB,COLOR24RGB,COLOR32XRGB)", hz);
return false;
}

// Guarda valor de Stickykeys
m_skOriginal.cbSize= sizeof (STICKYKEYS);
m_skOriginal.dwFlags = 0;
SystemParametersInfo(SPI_GETSTICKYKEYS,sizeof (STICKYKEYS),&m_skOriginal,0);
// Desactiva Stickykeys
STICKYKEYS stickyOff = m_skOriginal;
stickyOff.dwFlags &=SKF_STICKYKEYSON;
SystemParametersInfo(SPI_SETSTICKYKEYS,sizeof (STICKYKEYS),&stickyOff,0);

// Fuerza estilo WS_POPUP, necesario para ventana a pantalla completa
m_bFullScreen=true;
SetWindowLong(m_hWnd,GWL_STYLE,WS_POPUP);
m_nXFullScreen=x;
m_nYFullScreen=y;
m_cmFullScreen=cm;
m_nHZ=hz;
SetWindowPos(m_hWnd,HWND_TOPMOST/*HWND_TOP*/,0,0,x,y,SWP_SHOWWINDOW); // Se asegura que sea la visible

return true;
}


He puesto también el codigo del Stikykeys y demás por si tiene algo que ver... todo y que lo dudo.

Y para salir de fullscreen hago esto otro:

Código [Seleccionar] Expand

// Sale de pantalla completa segun GDI
void Window::FullScreenExitGDI(){

if(!m_bFullScreen) return;

// sale de fullscreen
ChangeDisplaySettings(NULL,0);

// Desactiva flag m_bFullScreen(para que funcionen SetSize() y SetPosition())
m_bFullScreen=false;

// Restaura la ventana normalmente
if(GetProperty(CREATE)){
// Restaura estilo,posicion y tamaño de ventana
SetWindowLong(m_hWnd,GWL_STYLE,GetStyleWindow(m_wtWindowType));
SetWindowPos(m_hWnd,HWND_NOTOPMOST,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW); // Se asegura que sea la visible
SetPosition(m_uX,m_uY);
SetSize(m_uWidth,m_uHeight);
}

// Restaura valor de stickykeys
SystemParametersInfo(SPI_SETSTICKYKEYS,sizeof (STICKYKEYS),&m_skOriginal,0);

}


Gracias.

He encontrado este mini juego atraves del blog de th2bears.com(y este desde www.gameproducer.net).

Y antes de que pase desapercibido os dejo el link, que tiene su puntito, un juego experimento sobre fisicas.

Saludos.

Espero que no se haya posteado ya...

 Estoy usando ChangeDisplaySettings() para poner mi aplicación en pantalla completa, en un principio funciona bien, pero e detectado algunos problemas;

1º- Cuando pongo a pantalla completa se ve la barra de tareas durante un segundo aprox. y si el usuario es hábil puede situarse encima y clickar, haciendo perder el foco a la aplicación que entra en fullscreen.

2º- cuando  salgo de pantalla completa, las ventanas pueden haber cambiado de posición y de tamaño.

no se no se- Al salir de fullscreen, parece que el sistema tarda algo en reaccionar, sacar la barra de tareas si me coloco encima cuando esta oculta, por ejemplo, si bien este ultimo punto puede ser normal...

Alguien sabe como solucionar los 2 primeros puntos por lo menos!? Estoy en Win32Api "pelao".

Gracias,saludos.

 Tengo algunas dudas sobre el diseño de mi mini librería personal, que quisiera compartir;

Tengo la clase Image que no es mas que eso, un objeto que representa una imagen y tiene las adecuadas funciones para tratar con ella, pero como podrían existir varias referencias a esta clase y nadie quiere que los objetos mueran y quedarse con su puntero, he creado una clase que Image usa de clase base que se dedica a contar las referencias que hay y eliminar el objeto cuando estas se agotan, y he puesto el destructor como private, la verdad muy feo, solo se puede crear dinámicamente, y eliminar con la función que decrementa la cuenta de referencias si esta es 0, esto os parece aceptable?! juraría que no, y que seria mejor usar una interface en lugar de un objeto con... ¡comportamiento de interface!, pero quisiera conocer mas opiniones.

Si bien la primera cuestión, parece obvia, me plantea una segunda. Debería dejar solo interfaces!? ( de cara al programador, claro, todos sabemos que detrás de estas habrá objetos reales ), o es comprensible el uso de interfaces y objetos!? ya e explicado que la clase Image puede estar referenciada con punteros desde otros sitios y el valor de contar las referencias,pero otros objetos no lo necesitan y seria mas fácil trabajar con un objeto, que se destruye por cuenta propia al final de la función y no necesita de llamadas especiales..... pero uso objetos e interfaces de forma que no se si es la mejor,
por ejemplo;

Tengo objetos de Keyboard, GamePad y Mouse.... y todos heredan la interfaz IGamePadControl, con lo que use lo que use el usuario, siempre te podrás comunicas con esa interfaz. Me parece un punto positivo, pero, no se podría decir que uso clases e interfaces de forma arbitrarea!??!

Con lo que me planteo otra vez ... seria mejor dejarlo todo como interfaces, me parece mas difícil de usar la librería con todo como interfaces, pero no se si en realidad complico la vida al programador usando objetos por un lado e interfaces por otra.

Mi idea es dejarlo como esta, pero pasando a interface el objeto Image y el Sprite, y el de Animation, y el Actor(que trabajaría con Animation) dejarlo como clase. Se ve ??? Dejar interfaces para recursos(que cuentan referencias) y para abstraer hardware(como IGamePadControl, sin contar referencias), y Objetos para cosas fisicas que no son recursos(El objeto Keyboard para el teclado, o incluso el Window para las ventanas del sistema).

Lamento la parrafada, tengo decidido esto ultimo que he dicho casi al 100%, pero quisiera conocer otras opiniones, usáis solo interfaces de cara al programador que use la librería??, interfaces y clases!??! solo clases y que vigile el programador si tiene punteros a ellos cuando elimina objetos!??! como lo hacen otras librerías!? he estado viendo la web de PTK, todos los objetos se crean de forma dinámica, son todo interfaces!?y otras librerías!?

Saludos y gracias.

 Estoy intentando acceder al HBITMAP de una ventana, para ello cojo el HDC de la ventana con GetDC(), despues cojo el HBITMAP con GetCurrentObject(), pero al usar GetObject() para acceder a los datos de este, los datos son incorrectos, es mas la funcion retorna un 0.

He probado a acceder a HBITMAP's de otros HDC's (que no son ventanas), y todo funciona bien.

Alguien sabe que puedo estar haciendo mal?! quiza no se pueda acceder al HBITMAP de un HDC de una ventana?

Gracias, y saludos.

 Quería documentar un proyecto y alguna vez os he oído hablar de programas que pueden hacer esto por nosotros basándose en comentarios con determinados "Tag's".
Que "documentadores" automáticos usáis ??? En principio me interesa uno que trabaje con fuentes en c/c++ y funcione en Windows, pero si conocéis alguno que además trate Java y funciones en Linux, seria interesante.

Alguna recomendación?!Gracias.

Saludos.

 Os parecera increible que haya alguien que no conozca aun correctamente la GPL... pero la cosa es que estaba leyendo los foros de gp32spain, y hay un post hacerca de estas cuestiones. Y me a venudi la tipica duda tonta de quien no toca el mundillo del open source y demas....

La licencia GPL, te obliga a liberar TODO el codigo de tu proyecto, y solo las librerias GPL usadas con los cambios que hayas realizado????
Ya que estamos, la LGPL es lo mismo nop!?
es solo una duda, nada mas.

Gracias y saludos.

 Hacerca de la version express del VC2005 que es gratis, cuando te registras, alguien me podria decir hasta que punto husmean en tu ordenador cuando te registras y recolectan informacion... ??? y a riesgo de parecer iterativo, se puede usar para programas comerciales... de darse el caso claro,, nop?!

Gracias, y saludos.

 Cuando e intentado editar una cosilla de un msg reciente me encuentro con que en la caja de texto aparece mi mensaje..... y el HTML del resto de la pagina (!?).

Pues nada mas que un aviso del problema.

Saludos.

[EDIT] Curiosamente en este no, sera por el uso del

??

 Holas, como ha todos les a pasado desde el anuncio del concurso también estoy tocando algo de J2ME, y esta tarde después de haber practicado algunas cosillas y recordando las limitaciones al tratar objetos Image, me dio por probar de aplicar el efecto fuego que todos habéis de haber visto alguna vez en alguna demo, además el otro dio ley algo de el en un librito de esos....

Me a parecido interesante para que se veo como es la programación en J2ME, y de paso me gustaría saber la opinión de los expertos en J2ME, sobre puntos concretos que no se si se podrían mejorar.

Bien, pasemos al código:

fire.java; este es el objeto MIDlet con el que se arranca la aplicacion.

Código [Seleccionar] Expand


import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class fire extends MIDlet{
   public fire(){}

   public void startApp(){

       // Objeto genera efecto fuego
       FireCanvas fuego=new FireCanvas();

       // Canvas de fuego controlara el display
       Display.getDisplay(this).setCurrent(fuego);
   }

   public void pauseApp(){}

   public void destroyApp(boolean boo){
   }
}

FireCanvas.java; este es el objeto Canvas que genera el efecto del fuego

Código [Seleccionar] Expand


import java.util.*;
import javax.microedition.lcdui.*;

// Clase FireCanvas
public class FireCanvas extends Canvas implements Runnable {

   Image ImageColors[];    // Imagenes con los colores
   int buffer1[][];    // Buffer con fuego
   int buffer2[][];    // Buffer de apoño para calculos de fuego
   int flameSize;        // Alto ancho del pixel del fuego
   int width,height;    // Alto ancho de los bufferes buffer1 y buffer2
   int extincion;        // Velocidad a la que el fuego se extingue
   Random rand=new Random();    // Objeto de numeros aleatorios
   private Thread     t;        // Hilo de esta clase

   Image ImageSecundario;        // Backbuffer
   Graphics GraphicsSecundario;    // Backbuffer

   // Constructor de la clase Game
   public FireCanvas(){
       // Descubre dispositivo sobre el que trabajara
       System.out.println("Ancho:"+getWidth());
       System.out.println("Alto:"+getHeight());
       System.out.println("doubleBuffer:"+isDoubleBuffered());

       // Prepara backbuffer si es necesario
       ImageSecundario=null;
       GraphicsSecundario=null;
       if(!isDoubleBuffered()){
           ImageSecundario=Image.createImage(getWidth(),getHeight());
           GraphicsSecundario=ImageSecundario.getGraphics();
       }

       // Velocidad de extincion de fuego
       extincion=1;

       // Tamaños de los bueffer's, y del pixel del fuego
       flameSize=3;
       width=getWidth()/flameSize;
       height=getHeight()/flameSize;

       // Crea imagenes de color
       System.out.println("Creando imagenes de color");
       ImageColors= new Image[256];
       for(int i=0;i<256;i++){
           ImageColors[i]=Image.createImage(flameSize*width,flameSize);
           Graphics g=ImageColors[i].getGraphics();
           g.setColor(i,i/2,i/2);
           g.fillRect(0,0,flameSize,flameSize);
       }

       // Limpia buffer's
       buffer1=new int[height][width];
       buffer2=new int[height][width];
       System.out.println("limpia buffer");
       for(int y=0;y<height;y++)
           for(int x=0;x<width;x++){
               buffer1[y][x]=0;
               buffer2[y][x]=0;
           }

       // inicia hilo de ejecucion de la clase
       t= new Thread(this);
       t.start();
   }

   // Bucle(e hilo) donde se ejecuta el efecto
   public void run(){
       while(true){
           fireStep();        // Hace avanzar el efecto
           repaint();        // Llama a repintar
           serviceRepaints();    // Espera termine repintado (?)
       }
   }

   // Pinta pantalla
   public void paint(Graphics g){

       // Coge backbuffer si necesario
       Graphics gReal=g;
       if(GraphicsSecundario!=null) g=GraphicsSecundario;

       // Pinta buffer en pantalla
       for(int y=0;y<height;y++)
           for(int x=0;x<width;x++){
               int color=buffer1[y][x];
               g.drawImage(ImageColors[color],x*flameSize,y*flameSize,0);
           }

       // Pasa del backbuffer a buffer principal si es necesario
       if(GraphicsSecundario!=null) gReal.drawImage(ImageSecundario,0,0,0);

       System.out.println("Dibujado");
   }

   // Avanza efecto fuego
   private void fireStep(){
       // Emborrona
       for(int y=1;y<height;y++)
           for(int x=0;x<width;x++){
               // Hace la media de los valores del entorno
               int xless1=x==0?x:x-1;
               int yless1=y==0?y:y-1;
               int xmore1=x==width-1?x:x+1;
               int ymore1=y==height-1?y:y+1;
               int media=buffer1[yless1][x]+buffer1[ymore1][x]+
                   buffer1[y][xless1]+buffer1[y][xmore1];
               media/=4;
               media-=extincion;
               if(media<0) media=0;
               // Guarda en segundo buffer, una linea mas arriba
               buffer2[y-1][x]=media;
           }

       // Pasa de segundo buffer al primero
       for(int y=0;y<height-1;y++)
           for(int x=0;x<width;x++){
               buffer1[y][x]=buffer2[y][x];
           }

       // Rellena ultima linea con nuevos valores
       for(int x=0;x<width;x++){
           // Se asegura que no tenga signo, y redondea a 255, (el >>>1 es para quitar el

signo, nop?? lo e visto de una web... y me hace eso mismo)
           buffer1[height-1][x]=((rand.nextInt()>>>1)%200)+55;
       }
   }
}

Bien, este es el código, supongo que todos sabrían hacer un proyecto para KToolBar del Wireles toolkit de SUN.
Hay algunas cosas que reconozco que no se si es la mejor forma; Por ejemplo en el método run(), en lugar de usar un t.sleep(??) llamo al serviceRepaints(), por pruebas que hice el otro día, parece que el pintado de pantalla se hace en otro hilo y puedes llamar a repaint() antes de que termine, pero el serviceRepaints(), debería forzar ese pintado antes de continuar, pero en las pruebas que hice parece ir igual. Lo hago correctamente o no??
Por otro lado, no tengo nada para controlar la salida, en un principio no me hace falta, pero debería hacerlo por algún motivo?? cual??

Y ahora pasemos al código. Para pintar en pantalla pixel a pixel uso objetos Image, si, es mas rápido que un fillRect(). Trabajar a nivel de pixel es muy lento, así que se puede controlar el tamaño de los pixels del fuego, con un flameSize=3, tira bastante bien, con extinción se controla cuanto tarda en extinguirse el fuego, mas valor dura menos. La paleta se crea de forma muy simple, pero da muy buen resultado para lo que es.
El tema de las optimizaciones, use una referencia para controlar cual array escribe y cual lee en cada momento para eliminar los dos for's que pasan de un buffer a otro en fireStep(), pero se hace mas complicado de leer, y la mejora de rendimiento no existe, si va lento es por las llamadas a drawImage(), que se reducen ampliando el flameSize. Probé alguna cosa estrambótica, pero nada, parece que no correrá mas.

En fin si alguien quiere fuego para su móvil, ya puede ponérselo.

Saludos.

[Edit]
Ayadida imagen.

En la linea:
buffer1[height-1]

• =((rand.nextInt()>>>1)%200)+55;
  Se puede "homogeneizar el fuego que sale;
  buffer1[height-1]
• =((rand.nextInt()>>>1)%255);
  de esta ultima forma es menos "plano".

 Pues eso, Que en las noticias de stratos pone:

[ J | 06/10/05 ] Beta de Mexus Sand Battles
El equipo de desarrollo Studios Tortuga ha terminado la primera beta del juego Mexus Sand Battles. La beta de este juego de acción por equipos multiplayer comprende por ahora sólamente un escenario de prueba, y tres armas : rifle de asalto, pistola y granada. Este juego ya ha sido enviado al certamen de videojuegos de Art Futura 2005. Noticia enviada por Antonio Ávila Membrives.

Lo he estado probando, aun tiene algunos errores y esta incompleto, pero me e quedado con unas ganas de darme con alguien .... que pa que!

Si pasa algunos de los responsable que cuente cuando puede uno entrar en el server "oficial" para encontrar gente.

Saludos.

PD: Pide el .Net FrameWork, sera C#!?!??!

 Para obtener el plano de un poligono se saca la normal de este y luego se resuelve "d".

Pero resulta que me parece que la forma de sacar d, puede variar, lo encuentro basicamente asi:

d=dot(n,p);
d=-dot(n,p);

n es la normal, p un punto en el plano y dot() la funcion de dot product. La segunda la suelo encontrar en temas de OpenGL (mano derecha), y la primera en sistemas que parece ser que tiran de mano izquierda.

Estoy en un error y solo una es valida?? por que el resultado para calcular colisiones puede cambiar del todo, y si es asi, cual es valida??? o se usan segun el sistema de coordenadas!??!?

(nooo)  (nooo) (asco) En fin esta es una de esas cosas tan entretenidas como los vectores fila y los vectores columnas y su mania de hacer las cosas del reves el uno del otro.... y yo que no los sigo.....

Gracias, y saludos.  

["In 64-bit mode, the default addresssize is 64 bits and new features, such as register extensions,are supported for system and application software."]

 Aprovecho ahora que se pone de moda hablar de los 64bits y sus beneficios para sacar un tema, que tenia resuelto desde jovenzuelo pero que con el avance de la informática y su extensión a todo el mundo parece que se a embrutecido un poco.

La cosa es tan simple como que son los bits de CPU, antes querían decir algo técnico, pero con el marketing y demás parece que es un logo, marca, o metafísica existencial...

Esto lo digo por que e encontrado en foros respuestas de todo tipo, y cuando digo de todo tipo, es literal, y además de gente que decía ser entendida, ingenieros y demás.

Bien he puesto una encuesta con las opciones mas habituales, a ver si así aclaramos algo, o vuelvo a estar seguro como lo estaba antes.

En este pdf en la pagina 21 se puede leer : "In 64-bit mode, the default address
size is 64 bits and new features, such as register extensions,
are supported for system and application software."

Siempre había pensado que era el ancho de bus de datos. Por lo menos de joven con cierta seguridad, recuerdo la CPU de mi MSX, un Z80, un procesador de 8bits, con 8 lineas en su bus de datos, 16 en su bus de direcciones y registros de 8bits y de 16 bits, algunos de ellos como el SP, imposibles de dividir en 2 de 8bits.

Es algo ridículo una encuesta sobre algo que no admite discusión, es un dato técnico, pero quería saber si todos pensamos lo mismo que es, o también vamos a la "babala".

Creo que finalmente el avance informático los ha convertido en "modos" de trabajo de una CPU, convirtiendo el termino en algo un poco abstracto y confuso.

PD.: Es mi primera encuesta, espero configurarla bien... :P

 Como veo que muchos andan ya probando el VS2005Beta y me quede con las ganas de aplicar ciertas optimizaciones con las que no puedo tratar actualmente, me decidí a descargar el Visual C++ 2005 Beta, pero me lo han cambiado demasiado desde mi VC++6.0.

La cuestión es que cargo un proyecto de VC++6.0, me dice que tiene que hacerle ciertas cosas para cargar el proyecto, a lo que le digo "pos falen", pero a la hora de compilar me sale conque no puede encontrar el include "windows.h".... raro raro... en los directorios donde se instalo VS2005Beta, no esta, así que puse el directorio donde se encuentra con el VC++6.0 (:mellow: mal hecho...), después no me encontraba la winmm.lib y actué igual, poniendo el directorio del antiguo (:mellow: mal hecho... otra vez), después de eso los errores son innumerables sobre funciones a las que no se puede enlazar desde los .obj que crea el compilador, seguro que por que no debí linkar a un .lib de una versión antigua.

Después de esto, como cargo un proyecto de VC++6.0?? donde esta mi añorado windows.h, y el winmm.lib!?
Alguien con experiencia?? gracias.

Saludos.

 Garantizan que funciona.

 Estoy usando los mensajes de windows para controlar el desplazamiento del raton (WM_MOUSEMOVE, y los de pulsaciones de botonts).

Pero con estos lo que realmente consigo es obtener la posicion del cursor en pantalla, se puede obtener el "desplazamiento" de este en lugar de su posicion en ventana como lo tengo ahora?? con win32API nada de DirectX.

gracias.

Saludos.

 Hace unos dias encontre esta noticia en Gamedev.net, quiza a algunos interese Diner Dash ha vendido mas de 50000 copias, realmente mas de lo que pensaba que se podia vender en ese mercado.

Quiza el truco este en que se apoya en otras grandes web's, de hecho en google con "Diner Dash" lo ultimo que saldra es un link a gameplan.

PD: Mi ingles es nulo (si no inexistente) y la noticia podria decir todo lo contrario.... espero que no :ph34r:  

 Estoy con una clase que me empaqueta todo lo que es una imagen "en si" tratando esta de forma interna el tema de los HDC, mascaras y demas.

La cuestion es que tengo algunas funciones para copiar fragmentos de imagen, normal, con zoom, incluso rotacion, con y sin mascara. Para eso utilizo la funcion PlgBlt con la que puedes hacer todo esto, el problema es que e añadido la posibilidad de invertir la imagen; hacer un efecto espejo en Y o X, pero me encuentro que si bien lo hace correctamente con el el color de la imagen y utilizo su mascara para agregar trasparencias me encuentro con que la aplicacion de la mascara falla, como si se invirtiera solo el bitmap de color. En el caso de la rotacion parece funcionar bien pero cuando el giro es de 180º la mascara se aplica "normal" como si solo girara la parte de color.

Esto es normal ??? se trata de algun bug?? La funcion PlgBlt() me retorna 1, osea que va bien, pero GetDeviceCaps(XXX,RC_BITBLT) un 0, no la puedo usar?? entonces por que funciona normalmente bien??

Tengo la posibilidad de hacerlo por soft, pero claro, pretendia pasar por el GDI siempre que fuera posible, alguien me ilustra?!

Garcias.

[EDIT]
Me olvidaba de algo , la funcion de copia con mascara es esta;

Código [Seleccionar] Expand

// copia un fragmento de imagen de otro objeto Image
// Objeto Image del que copiar, (x,y) a donde se copia
// (x,y) de donde se copia (width,heght) cuanto se copia
bool Image::CopyColorKey(int xd,int yd,const Image &In,int x,int y,int width,int height,
     int xc,int yc,bool flipx,bool flipy){

// Si imagen bloqueada retorna false, y no continua
if(m_bImageBlock) return false;

// Coordenadas segun el centro de la imagen
xd-=xc;
yd-=yc;

// Corrige coordenadas si invierte la imagen en X o Y
if(flipx) xd--;
if(flipy) yd--;

//int ret=BitBlt(m_hDC,xd,yd,width,height,In.m_hDC,x,y,SRCINVERT);

// int ret=BitBlt(m_hDC,xd,yd,width,height,In.m_hDCMask,x,y,SRCAND);
// ret+=BitBlt(m_hDC,xd,yd,width,height,In.m_hDC,x,y,SRCPAINT);
// Rota una de las esquinas del paralelograma
POINT points[3];

//xd=flipx?xd-1:xd;
//yd=flipy?yd-1:yd;

points[0].x = flipx?xd+width:xd;
points[0].y = flipy?yd+height:yd;

// Rota otra de las esquinas del paralelograma
points[1].x = flipx?xd:xd+width;
points[1].y = flipy?yd+height:yd;

// Rota la esquina restante del paralelograma
points[2].x = flipx?xd+width:xd;
points[2].y = flipy?yd:yd+height;

// Copia la imagen en el DC de la ventana
int ret=PlgBlt(m_hDC,points,In.m_hDC,x,y,width,height,In.m_hBMMask,x,y);

return ret?true:false;
}


 Me he pasado por gamedev.net y e visto que tienen una noticia que parece interesante sobre las patentes y microsoft. Mi ingles es MUY escaso, pero parece ser que no es precisamente una mala noticia.

link