Question

我在空闲时间做了很多游戏编程，目前正在开发游戏引擎库。在此之前，我已经制作了直接在应用程序中构建的自定义游戏引擎，然而，为了进一步挑战我的逻辑技能，我决定制作一个我可以用于任何我写的游戏的引擎，有点像一个插件。

在此之前，我一直在使用BufferedImage拉动纹理，使用getRBG将像素[]拉出来并手工在背景int []上写入（x，Y）位置的纹理int []数组可渲染的居住地。然后，当所有内容都写入master int []时，我会使用master int []创建一个新的BufferedImage并使用setRGB，并使用BufferStrategy和它的Graphic来绘制BufferedImage的imageImage。我喜欢这种方法，因为我觉得我可以完全控制渲染事物的方式，但我认为它不是很有效。

以下是我用来写入master int []

的方式

public void draw(Render render, int x, int y, float alphaMul){
    for(int i=0; i<render.Width; i++){
        int xPix = i + x;
        if(Width - 1<xPix || xPix<0)continue;
        for(int j=0; j<render.Height; j++){
            int yPix = j + y;
            if(Height - 1<yPix || yPix<0)continue;

            int srcARGB = render.Pixels[i + j * render.Width];
            int dstARGB = Pixels[xPix + yPix * Width];

            int srcAlpha = (int)((0xFF & (srcARGB >> 24))*alphaMul);
            int srcRed = 0xFF & (srcARGB >> 16);
            int srcGreen = 0xFF & (srcARGB >> 8);
            int srcBlue = 0xFF & (srcARGB);

            int dstAlpha = 0xFF & (dstARGB >> 24);
            int dstRed = 0xFF & (dstARGB >> 16);
            int dstGreen = 0xFF & (dstARGB >> 8);
            int dstBlue = 0xFF & (dstARGB);

            float srcAlphaF = srcAlpha/255.0f;
            float dstAlphaF = dstAlpha/255.0f;


            int outAlpha = (int)((srcAlphaF + (dstAlphaF)*(1 - (srcAlphaF)))*255);

            int outRed = (int)(srcRed*srcAlphaF) + (int)(dstRed * (1 - srcAlphaF));
            int outGreen = (int)(srcGreen*srcAlphaF) + (int)(dstGreen * (1 - srcAlphaF));
            int outBlue = (int)(srcBlue*srcAlphaF) + (int)(dstBlue * (1 - srcAlphaF));

            int outARGB = (outAlpha<<24)|(outRed << 16) | (outGreen << 8) | (outBlue);

            Pixels[xPix + yPix * Width] = outARGB;
        }
    }
}

我最近发现它可能更快，使用drawImage我可以循环遍历所有Renderables并使用它们各自的（X，Y）位置将它们绘制为BufferedImages。但是，我不知道如何使用alphaBlending。所以我的问题是，我将如何获得我想要的结果？并且它比以前的方法更有资源和时间吗？

由于 -Craig

使用Graphics使用AlphaBlending Java绘制BufferedImage

0 个答案: