On Thu, 04 May 2006 21:43:44 -0500, Eric Fortier wrote:
Without seeing any actual code, the number of suggestions anyone can offer
is strongly limited.
Ok, here are a few examples (minus any setup code).
Normal (source copy) Blt loop:
for( int y=0 ; y<h ; ++y )
{
for( int x=0 ; x<w ; ++x )
{
/* Pixel function--> */
lpDest[x] = lpSrc[x];
/* <--Pixel function */
}
lpDest += nPitchY;
lpSrc += nSrcWidth;
}
Now a Blit with source color keying:
for( int y=0 ; y<h ; ++y )
{
for( int x=0 ; x<w ; ++x )
{
/* Pixel function--> */
if( ColorKey != lpSrc[x] )
{
lpDest[x] = lpSrc[x];
}
/* <--Pixel function */
}
lpDest += nPitchY;
lpSrc += nSrcWidth;
}
Now an Alpha blit:
for( int y=0 ; y<h ; ++y )
{
for( int x=0 ; x<w ; ++x )
{
/* Pixel function --> */ if( Alpha != 0 )
{
lpDest[x] = CALCULATE_ALPHA( src, dest );
}
/* <-- Pixel function */ }
lpDest += nPitchY;
lpSrc += nSrcWidth;
}
(this is all unoptimized code for better understanding what it does)
Now, you can combine alpha with color keying which leads to one more if() check
in the inner loop. I am asked to add at least two other draw mode (multiply &
invert) that also must combine with normal, color keying and alpha blending.
I've added /* Pixel function--> */ /* <--Pixel function */ markers to the
code to demarcate the parts of the three loops that are different. You
could write all three as
for( int y=0 ; y<h ; ++y )
{
for( int x=0 ; x<w ; ++x )
{
pixelFunction (lpDest[x], lpSource[x]);
}
lpDest += nPitchY;
lpSrc += nSrcWidth;
}
Then the question is, what type is pixelFunction? I did a bit of
experimentation and came up with something that both works and allows for
stateful functions like your alpha conversion function, which rely on
information specific to the function.
// BEGIN blitter.cpp
#include <iostream>
void passthrough (int &dest, const int &src) {
dest = src;
}
void invert (int &dest, const int &src) {
dest = ~src;
}
struct adder {
adder (int c):
constant (c)
{}
void operator () (int &dest, const int &src) {
dest = src + constant;
}
private:
const int constant;
};
template<typename Filter>
void arrayblit (int dest[], const int src[], std::size_t ints, Filter f) {
for (int i = 0; i < ints; ++i)
f(dest[i], src[i]);
}
int main () {
int src[] = {1, 2, 3, 4, 5};
int copied[5];
int flipped[5];
int added[5];
arrayblit (copied, src, 5, passthrough);
arrayblit (flipped, src, 5, invert);
arrayblit (added, src, 5, adder(2));
for (int i = 0; i < 5; ++i)
std::cout << src[i] << '\t'
<< copied[i] << '\t'
<< flipped[i] << '\t'
<< added[i] << std::endl;
}
// END blitter.cpp
With a bit of prodding I was able to get g++ to inline the first two pixel
functions into the template instantiations rather than invoking the pixel
function through a function pointer.
Break the BltFast function into independent functions that perform one
part of the blt process and have no flags at all. Then consider either
the Decorator[1] or the Template Method[2] pattern for controlling
which of or which group of individual functions are composed into the
final function.
I'd look into that but I can't view the pages you provided in either IE
or Firefox.
Weird. The c2 wiki contains the simplest HTML you'll probably find on the
internet at large. Any sign of an error message so I can at least let
them know what's wrong?
