spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void Bitmap::blt_image(const ubyte* src_data,
                            int src_xstart, int src_ystart, uint src_width,
                            uint src_bytepp,
                            uint src_bitmapwidth,uint src_bitmapheight,

                            ubyte* dst_data,
                            int dst_xstart, int dst_ystart,uint dst_width,
                            uint dst_bytepp,
                            uint dst_bitmapwidth,uint dst_bitmapheight,

                            uint width, uint height,
                            bool blend, uint8 alpha)
{
    if(blend && alpha < 1)
        return;
    if(!src_data || !dst_data)
        return;

    //outside of Bitmap
    if(src_xstart > static_cast<int>(src_bitmapwidth) || src_ystart > static_cast<int>(src_bitmapheight))
        return;
    if(dst_xstart > static_cast<int>(dst_bitmapwidth) || dst_ystart > static_cast<int>(dst_bitmapheight))
        return;

    //limit to the smallest width/height
    uint dstartx = std::max<int>(dst_xstart, 0);
    uint dstarty  = std::max<int>(dst_ystart, 0);
    uint dendx = std::min<int>(dst_xstart+width,dst_bitmapwidth);
    uint dendy = std::min<int>(dst_ystart+height,dst_bitmapheight);

    uint sstartx = std::max<int>(src_xstart, 0);
    uint sstarty = std::max<int>(src_ystart, 0);
    uint sendx = std::min<int>(src_xstart+width,src_bitmapwidth);
    uint sendy = std::min<int>(src_ystart+height,src_bitmapheight);

    //start is greater than end
    if(sstarty > sendy || dstarty > dendy)
        return;

    //Alpha Blending
    //((srccolor * alpha) + (dstalpha * (256-alpha)) / 255 (src/dst/alpha value range: 0-255)
    //((srccolor * alpha) + (dstalpha * (257-alpha)) / 256 (src/dst/alpha value range: 1-256)

    //x >> 8 = x / 256
    //=>  (((srccolor+1) * (alpha+1)) + ((dstalpha+1) * (257 - (alpha+1))) >> 8 = 1..256
    //=> ((((srccolor+1) * (alpha+1)) + ((dstalpha+1) * (257 - (alpha+1))) >> 8) - 1 = 0..255

    //dst/src width and height
    uint dxw = dendx-dstartx;
    uint sxw = sendx-sstartx;
    uint dyh = dendy-dstarty;
    uint syh = sendy-sstarty;

    //width/height of copy feld
    uint copyw = std::min(dxw,sxw);
    uint copyh = std::min(dyh,syh);

    //start coord.
    uint dx = dstartx;
    uint sx = sstartx;
    uint dy = dstarty;
    uint sy = sstarty;

    //to reckon with integer
    int intAlpha = static_cast<int>(alpha);

    //copy as RGB/RGBA
    size_t bpp = std::min(src_bytepp,dst_bytepp);

    //not blendeffect and have same bytepp
    if(!blend && src_bytepp == dst_bytepp){
        while(copyh-- > 0){
            //Source Pixel index
            size_t spi = (sstartx + sy * src_width)*src_bytepp;
            //Destination Pixel index
            size_t dpi = (dstartx + dy * dst_width)*dst_bytepp;

            //copy the whole width
            memcpy(dst_data+dpi,src_data+spi,copyw*dst_bytepp*sizeof(ubyte));

            dy++;
            sy++;
        }
    }else if(src_bytepp == dst_bytepp){ //have same bytepp
        while(copyh-- > 0){
            //Source Pixel index
            size_t spi = (sstartx + sy * src_width)*src_bytepp;
            //Destination Pixel index
            size_t dpi = (dstartx + dy * dst_width)*dst_bytepp;

            ubyte *dest = dst_data+dpi;
            ubyte const *src = src_data+spi;

            //copy the whole width with alphablending
            size_t len = copyw*dst_bytepp*sizeof(ubyte);
            while (len-- > 0){
                //value range is over 255 (convert to int)
                int sa = static_cast<int>(*src)+1;
                int da = static_cast<int>(*dest)+1;

                //alpha blending color
                int32 color = (sa * intAlpha) + (da * (257-intAlpha));
                color = (color >> 8) - 1;

                *dest = static_cast<ubyte>(color);

                dest++;
                src++;
            }

            dy++;
            sy++;
        }
    }else{
        uint resetcopyw = copyw; //copy of copyw

        while(copyh-- > 0){
            copyw = resetcopyw;
            while(copyw-- > 0){
                //Source Pixel index
                size_t spi = (sx + sy * src_width)*src_bytepp;
                //Destination Pixel index
                size_t dpi = (dx + dy * dst_width)*dst_bytepp;

                ubyte *dest = dst_data+dpi;
                ubyte const *src = src_data+spi;

                if(src_bytepp == 3){ //is RGB (without alpha)
                    size_t len = src_bytepp;

                    //without alphablending
                    while(len-- > 0){
                        *dest++ = *src++;
                    }
                }else{
                    //copy as RGB/RGBA
                    size_t len = bpp;
                    while(len-- > 0){
                        //value range is over 255 (convert to int)
                        int sa = static_cast<int>(*src)+1;
                        int da = static_cast<int>(*dest)+1;

                        //alpha blending color
                        int32 color = (sa * intAlpha) + (da * (257-intAlpha));
                        color = (color >> 8) - 1;
                        *dest = static_cast<uint8>(color);

                        dest++;
                        src++;
                    }
                }
                sx++;
                dx++;
            }
            sy++;
            dy++;
        }
    }
}

C-/C++-Quelltext

blt_image(src_data,
          0,0,512,
          4,
          473,332,

          dst_data,
          0,0,1024,
          4,
          488,536,

          200,300,
          true,196);