main(int ac,char *av[])
{
ImageData *img1,*img2;
Pixel rgb1,rgb2,rgb3;
int alpha;
int rr,gg,bb,r1;
int size;
int xx,yy,mx,my;
int i;
int res;
if(ac<5) return 4;
res=readBMPfile(av[1],&img1);
if(res<0) {
printf("画像(1)が読めません");
return;
}
res=readBMPfile(av[2],&img2);
if(res<0) {
printf("画像(2)が読めません");
return;
}
alpha=atoi(av[3]);
mx=img2->width;
my=img2->height;
if(mx>img1->width) mx=img1->width;
if(my>img1->height) my=img1->height;
for(yy=0;yy<my;yy++) {
for(xx=0;xx<mx;xx++) {
getPixel(img1,xx,yy,&rgb1);
getPixel(img2,xx,yy,&rgb2);
rgb3.r=blend(rgb1.r,rgb2.r,alpha);
rgb3.g=blend(rgb1.g,rgb2.g,alpha);
rgb3.b=blend(rgb1.b,rgb2.b,alpha);
setPixel(img1,xx,yy,&rgb3);
}
}
writeBMPfile(av[4],img1);
disposeImage(img1);
disposeImage(img2);
}
//------------------------------------------------------------------------
void pixel_map::blend(HDC h_dc, int x, int y, double scale) const
{
if(m_bmp == 0 || m_buf == 0) return;
unsigned width = unsigned(m_bmp->bmiHeader.biWidth * scale);
unsigned height = unsigned(m_bmp->bmiHeader.biHeight * scale);
RECT rect;
rect.left = x;
rect.top = y;
rect.right = x + width;
rect.bottom = y + height;
blend(h_dc, &rect);
}
void LLDrawPoolGrass::render(S32 pass)
{
LLGLDisable blend(GL_BLEND);
{
LLFastTimer t(FTM_RENDER_GRASS);
LLGLEnable test(GL_ALPHA_TEST);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
}
void Layer::renderCompositeLinear() {
int trans;
for(int pix = 0; pix < STRIP_PIXEL_COUNT; pix++) {
effectPixel(effect)(meta, &scratch[0], pix, STRIP_PIXEL_COUNT);
// calculate trans btwn 1-256 so we can do a shift devide
transitionPixel(transititionIdx)(tmeta, &trans, pix, STRIP_PIXEL_COUNT);
target[pix] = blend(target[pix], scratch[0], trans);
}
}
void LLDrawPoolGlow::render(S32 pass)
{
S32 mode = gViewerWindow->getMaskMode();
LLFastTimer t(FTM_RENDER_GLOW);
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.flush();
/// Get rid of z-fighting with non-glow pass.
LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1.0f, -1.0f);
gGL.setSceneBlendType(LLRender::BT_ADD);
U32 shader_level = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
if (shader_level > 0 && fullbright_shader)
{
fullbright_shader->bind();
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
if (shader_level > 1)
{
pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
}
else
{
renderTexture(LLRenderPass::PASS_GLOW, getVertexDataMask());
}
if(mode == MASK_MODE_RIGHT)
{
gGL.setColorMask(false,true,true,false);
}
if(mode == MASK_MODE_LEFT)
{
gGL.setColorMask(true,false,false,false);
}
if(mode == MASK_MODE_NONE)
{
gGL.setColorMask(true, false);
}
gGL.setSceneBlendType(LLRender::BT_ALPHA);
if (shader_level > 0 && fullbright_shader)
{
fullbright_shader->unbind();
}
}
Color Color::blendWithWhite() const
{
// If the color contains alpha already, we leave it alone.
if (hasAlpha())
return *this;
Color newColor;
for (int alpha = cStartAlpha; alpha <= cEndAlpha; alpha += cAlphaIncrement) {
// We have a solid color. Convert to an equivalent color that looks the same when blended with white
// at the current alpha. Try using less transparency if the numbers end up being negative.
int r = blend(red(), alpha);
int g = blend(green(), alpha);
int b = blend(blue(), alpha);
newColor = Color(r, g, b, alpha);
if (r >= 0 && g >= 0 && b >= 0)
break;
}
return newColor;
}
static void assRender(VSFrameRef *dst, VSFrameRef *alpha, const VSAPI *vsapi,
ASS_Image *img)
{
uint8_t *planes[4];
int strides[4], p;
for(p = 0; p < 4; p++) {
VSFrameRef *fr = p == 3 ? alpha : dst;
planes[p] = vsapi->getWritePtr(fr, p % 3);
strides[p] = vsapi->getStride(fr, p % 3);
memset(planes[p], 0, strides[p] * vsapi->getFrameHeight(fr, p % 3));
}
while(img) {
uint8_t *dstp, *alphap, *sp, color[4], outa;
int x, y, k;
if(img->w == 0 || img->h == 0) {
img = img->next;
continue;
}
color[0] = _r(img->color);
color[1] = _g(img->color);
color[2] = _b(img->color);
color[3] = _a(img->color);
for(p = 0; p < 4; p++) {
dstp = planes[p] + (strides[p] * img->dst_y) + img->dst_x;
alphap = planes[3] + (strides[3] * img->dst_y) + img->dst_x;
sp = img->bitmap;
for(y = 0; y < img->h; y++) {
for(x = 0; x < img->w; x++) {
k = (sp[x] * color[3] + 255) >> 8;
outa = (k * 255 + (alphap[x] * (255 - k)) + 255) >> 8;
if(p == 3)
dstp[x] = outa;
else if(outa != 0)
dstp[x] = blend(k, color[p], alphap[x], dstp[x], outa);
}
dstp += strides[p];
alphap += strides[3];
sp += img->stride;
}
}
img = img->next;
}
}
void
x_drawable_rep::clear (SI x1, SI y1, SI x2, SI y2) {
x1= max (x1, cx1-ox); y1= max (y1, cy1-oy);
x2= min (x2, cx2-ox); y2= min (y2, cy2-oy);
// outer_round (x1, y1, x2, y2); might still be needed somewhere
decode (x1, y1);
decode (x2, y2);
if ((x1>=x2) || (y1<=y2)) return;
XSetForeground (dpy, gc, CONVERT (cur_bg));
XFillRectangle (dpy, win, gc, x1, y2, x2-x1, y1-y2);
XSetForeground (dpy, gc, CONVERT (blend (cur_fg, cur_bg)));
}
void LDVector3Test::blendTest()
{
LDVector3 vector1;
LDVector3 vector2;
LDVector3 actual;
LDVector3 expected;
//ld_float delta = 0.00001f;
ld_float t1;
ld_float t2;
// Input : vector1{x = 0.0, y = 0.0, z = 0.0}
// vector2{x = 0.0, y = 0.0, z = 0.0}, t1 = 0.0, t2 = 0.0 (ゼロベクトル)
vector1.zero();
vector2.zero();
t1 = 0.0f;
t2 = 0.0f;
expected.zero();
actual = blend( vector1, vector2, t1, t2 );
QCOMPARE( expected.x, actual.x );
QCOMPARE( expected.y, actual.y );
QCOMPARE( expected.z, actual.z );
// Input : vector1{x = 1.0, y = 2.0, z = 3.0}
// vector2{x = 4.0, y = 5.0, z = 6.0}, t1 = 1.0, t2 = 2.0 (任意の値)
vector1.x = 1.0f;
vector1.y = 2.0f;
vector1.z = 3.0f;
vector2.x = 4.0f;
vector2.y = 5.0f;
vector2.z = 6.0f;
t1 = 1.0f;
t2 = 2.0f;
expected.x = vector1.x * t1 + vector2.x * t2;
expected.y = vector1.y * t1 + vector2.y * t2;
expected.z = vector1.z * t1 + vector2.z * t2;
actual = blend( vector1, vector2, t1, t2 );
QCOMPARE( expected.x, actual.x );
QCOMPARE( expected.y, actual.y );
QCOMPARE( expected.z, actual.z );
}
void Point::blend_comp(float u, float v, float alpha, float ea, float eb)
{
this->x = cos(v)*cos(u)*blend(alpha) + aux_c(v, ea) * aux_c(u, eb) * (1-blend(alpha));
this->y = cos(v)*sin(u)*blend(alpha) + aux_c(v, ea) * aux_s(u, eb) * (1-blend(alpha));
this->z = sin(v)*blend(alpha) + aux_s(v, ea) * (1-blend(alpha));
}
void InterpolationEffect::addInterpolationsFromKeyframes(CSSPropertyID property, Element* element, const ComputedStyle* baseStyle, Keyframe::PropertySpecificKeyframe& keyframeA, Keyframe::PropertySpecificKeyframe& keyframeB, double applyFrom, double applyTo)
{
RefPtrWillBeRawPtr<Interpolation> interpolation = keyframeA.maybeCreateInterpolation(property, keyframeB, element, baseStyle);
if (interpolation) {
addInterpolation(interpolation, &keyframeA.easing(), keyframeA.offset(), keyframeB.offset(), applyFrom, applyTo);
} else {
RefPtrWillBeRawPtr<Interpolation> interpolationA = keyframeA.maybeCreateInterpolation(property, keyframeA, element, baseStyle);
RefPtrWillBeRawPtr<Interpolation> interpolationB = keyframeB.maybeCreateInterpolation(property, keyframeB, element, baseStyle);
ASSERT(interpolationA);
ASSERT(interpolationB);
Vector<TimingFunction::PartitionRegion> regions = Vector<TimingFunction::PartitionRegion>();
keyframeA.easing().partition(regions);
size_t regionIndex = 0;
for (const auto& region : regions) {
double regionStart = blend(keyframeA.offset(), keyframeB.offset(), region.start);
double regionEnd = blend(keyframeA.offset(), keyframeB.offset(), region.end);
double regionApplyFrom = regionIndex == 0 ? applyFrom : regionStart;
double regionApplyTo = regionIndex == regions.size() - 1 ? applyTo : regionEnd;
if (region.half == TimingFunction::RangeHalf::Lower) {
interpolation = interpolationA;
} else if (region.half == TimingFunction::RangeHalf::Upper) {
interpolation = interpolationB;
} else {
ASSERT_NOT_REACHED();
continue;
}
addInterpolation(interpolation.release(),
&keyframeA.easing(), regionStart, regionEnd, regionApplyFrom, regionApplyTo);
regionIndex++;
}
}
}
void LLDrawPoolWLSky::renderStars(void) const
{
LLGLSPipelineSkyBox gls_sky;
LLGLEnable blend(GL_BLEND);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
// *NOTE: have to have bound the cloud noise texture already since register
// combiners blending below requires something to be bound
// and we might as well only bind once.
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
gPipeline.disableLights();
// *NOTE: we divide by two here and GL_ALPHA_SCALE by two below to avoid
// clamping and allow the star_alpha param to brighten the stars.
bool error;
LLColor4 star_alpha(LLColor4::black);
star_alpha.mV[3] = LLWLParamManager::getInstance()->mCurParams.getFloat("star_brightness", error) / 2.f;
llassert_always(!error);
gGL.getTexUnit(0)->bind(gSky.mVOSkyp->getBloomTex());
gGL.pushMatrix();
gGL.rotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
// gl_FragColor.rgb = gl_Color.rgb;
// gl_FragColor.a = gl_Color.a * star_alpha.a;
if (LLGLSLShader::sNoFixedFunction)
{
gCustomAlphaProgram.bind();
gCustomAlphaProgram.uniform1f("custom_alpha", star_alpha.mV[3]);
}
else
{
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_VERT_COLOR);
gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT_X2, LLTexUnit::TBS_CONST_ALPHA, LLTexUnit::TBS_TEX_ALPHA);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, star_alpha.mV);
}
gSky.mVOWLSkyp->drawStars();
gGL.popMatrix();
if (LLGLSLShader::sNoFixedFunction)
{
gCustomAlphaProgram.unbind();
}
else
{
// and disable the combiner states
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
}
}
void BSpline::computePoint(BSPoint *control, BSPoint *output, double v)
{
double temp;
// initialize the variables that will hold our outputted point
output->x=0;
output->y=0;
for (size_t k = 0; k <= n_control_points; k++)
{
temp = blend(k, n_degree, v);
output->x += (control[k]).x * temp;
output->y += (control[k]).y * temp;
}
}
double BSpline::blend(int k, int t, double v)
{
double value;
if (t == 0)
((v >= knots[k]) && (v<knots[k+1]))? value = 1 : value = 0;
else{
if((knots[k+t] == knots[k]) && (knots[k+t+1] == knots[k+1])) value = 0;
else if(knots[k+t] == knots[k]) value = (knots[k+t+1] -v )/(knots[k+t+1] -knots[k+1])*blend(k+1,t -1 ,v );
else if(knots[k+t+1] == knots[k+1]) value = (v - knots[k])/(knots[k+t] - knots[k]) * blend(k,t-1, v);
else value = (v - knots[k])/(knots[k+t] - knots[k]) * blend(k,t-1, v) + (knots[k+t+1] -v )/(knots[k+t+1] -knots[k+1])*blend(k+1,t -1 ,v );
}
return value;
}
void Layer::mapFloorToLinear() {
int f,l;
CRGB pixel;
for(l = 0; l < STRIP_PIXEL_COUNT; l++) {
f = floorMap(l);
pixel = scratch[f];
if (f < FLOOR_PIXEL_COUNT-1) {
pixel = blend(pixel, scratch[f+1], ORIENTATION_INTERPOLATION);
}
target[l] = pixel;
}
}
PassRefPtrWillBeRawPtr<AnimatableValue> AnimatableLength::interpolateTo(const AnimatableValue* value, double fraction) const
{
const AnimatableLength* length = toAnimatableLength(value);
CSSPrimitiveValue::LengthUnitType type = commonUnitType(length);
if (!isCalc(type))
return AnimatableLength::create(blend(m_lengthValue, length->m_lengthValue, fraction), type);
// FIXME(crbug.com/168840): Support for viewport units in calc needs to be added before we can blend them with other units.
if (isViewportUnit() || length->isViewportUnit())
return defaultInterpolateTo(this, value, fraction);
return AnimatableLength::create(scale(1 - fraction).get(), length->scale(fraction).get());
}
void RenderState::resumeFromFunctorInvoke() {
glViewport(0, 0, mViewportWidth, mViewportHeight);
glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
debugOverdraw(false, false);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
scissor().invalidate();
blend().invalidate();
mCaches->textureState().activateTexture(0);
mCaches->textureState().resetBoundTextures();
}
void VisitCircle(const AirspaceCircle &airspace) {
RasterPoint screen_center = projection.GeoToScreen(airspace.GetCenter());
unsigned screen_radius = projection.GeoToScreenDistance(airspace.GetRadius());
if (!warning_manager.IsAcked(airspace) && SetupInterior(airspace)) {
GLEnable blend(GL_BLEND);
canvas.DrawCircle(screen_center.x, screen_center.y, screen_radius);
}
// draw outline
if (SetupOutline(airspace))
canvas.DrawCircle(screen_center.x, screen_center.y, screen_radius);
}
void
ThermalAssistantWindow::PaintPoints(Canvas &canvas) const
{
#ifdef ENABLE_OPENGL
GLBlend blend(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#elif defined(USE_GDI)
canvas.SetMixMask();
#endif /* GDI */
canvas.Select(look.polygon_brush);
canvas.Select(look.polygon_pen);
canvas.DrawPolygon(lift_points, 36);
}
void LLDrawPoolSimple::render(S32 pass)
{
LLGLDisable blend(GL_BLEND);
LLGLState alpha_test(GL_ALPHA_TEST, gPipeline.canUseWindLightShadersOnObjects());
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
{ //render simple
LLFastTimer t(LLFastTimer::FTM_RENDER_SIMPLE);
gPipeline.enableLightsDynamic();
renderTexture(LLRenderPass::PASS_SIMPLE, getVertexDataMask());
}
{
LLFastTimer t(LLFastTimer::FTM_RENDER_GRASS);
LLGLEnable test(GL_ALPHA_TEST);
LLGLEnable blend(GL_BLEND);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
{ //render fullbright
if (mVertexShaderLevel > 0)
{
fullbright_shader->bind();
fullbright_shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
}
else
{
gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
}
LLFastTimer t(LLFastTimer::FTM_RENDER_FULLBRIGHT);
U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD | LLVertexBuffer::MAP_COLOR;
renderTexture(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask);
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
void LLDrawPoolWLSky::renderSkyHaze(F32 camHeightLocal) const
{
if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
{
LLGLDisable blend(GL_BLEND);
sky_shader->bind();
/// Render the skydome
renderDome(camHeightLocal, sky_shader);
sky_shader->unbind();
}
}
float SVGPathBlender::blendAnimatedDimensonalFloat(float from, float to, FloatBlendMode blendMode)
{
if (m_addTypesCount) {
ASSERT(m_fromMode == m_toMode);
return from + to * m_addTypesCount;
}
if (m_fromMode == m_toMode)
return blend(from, to, m_progress);
float fromValue = blendMode == BlendHorizontal ? m_fromCurrentPoint.x() : m_fromCurrentPoint.y();
float toValue = blendMode == BlendHorizontal ? m_toCurrentPoint.x() : m_toCurrentPoint.y();
// Transform toY to the coordinate mode of fromY
float animValue = blend(from, m_fromMode == AbsoluteCoordinates ? to + toValue : to - toValue, m_progress);
if (m_isInFirstHalfOfAnimation)
return animValue;
// Transform the animated point to the coordinate mode, needed for the current progress.
float currentValue = blend(fromValue, toValue, m_progress);
return m_toMode == AbsoluteCoordinates ? animValue + currentValue : animValue - currentValue;
}
void VisitPolygon(const AirspacePolygon &airspace) {
if (!PreparePolygon(airspace.GetPoints()))
return;
if (!warning_manager.IsAcked(airspace) && SetupInterior(airspace)) {
// fill interior without overpainting any previous outlines
GLEnable blend(GL_BLEND);
DrawPrepared();
}
// draw outline
if (SetupOutline(airspace))
DrawPrepared();
}
void Visit(const AirspaceCircle& airspace) {
RasterPoint screen_center = projection.GeoToScreen(airspace.GetCenter());
unsigned screen_radius = projection.GeoToScreenDistance(airspace.GetRadius());
{
GLEnable blend(GL_BLEND);
setup_interior(airspace);
canvas.circle(screen_center.x, screen_center.y, screen_radius);
}
// draw outline
setup_outline(airspace);
canvas.circle(screen_center.x, screen_center.y, screen_radius);
}
JSBool facInt(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
uint32_t tog=0;
diaElemUInteger blend(&tog,QT_TR_NOOP("Uinteger"),0,255);
diaElem *elems[]={&blend };
if(diaFactoryRun(QT_TR_NOOP("Test uinteger"),1,elems))
{
*rval = BOOLEAN_TO_JSVAL(1);
printf("Value : %u\n",tog);
}else
*rval = BOOLEAN_TO_JSVAL(0);
return JS_TRUE;
}
void doCell(PIXEL *cellBuffer, const PIXEL &cellColor, const PIXEL &bgColor,
int x0, int y0, int x1, int y1) {
// Apply the mask to the cell. 0 pixels are bgColored, GRAY::maxChannelValue
// ones are cellColored.
PIXEL *pix, *line = cellBuffer, *lineEnd;
GRAY *grPix, *grLine = m_mask->pixels(y0) + x0, *grLineEnd;
int x, y, grWrap = m_mask->getWrap(), lx = x1 - x0;
for (y = y0; y < y1; ++y, line += this->m_wrap, grLine += grWrap) {
lineEnd = line + lx;
grLineEnd = grLine + lx;
for (x = x0, pix = line, grPix = grLine; x < x1; ++x, ++pix, ++grPix)
*pix = blend(bgColor, cellColor,
grPix->value / (double)GRAY::maxChannelValue);
}
}
void BackgroundLayer::draw(Mat& colorMap, Mat& heightMap, LayerStyle& style, bool simple)
{
if (simple)
return;
Mat fg_c = Mat::zeros(colorMap.rows, colorMap.cols, CV_64FC3);
Mat fg_a = Mat::zeros(colorMap.rows, colorMap.cols, CV_64FC3);
Mat fg_h = Mat::zeros(colorMap.rows, colorMap.cols, CV_64FC3);
fg_a.setTo(1);
tileTexture(style.texImage, fg_h);
fg_h.copyTo(fg_c);
blend(colorMap, heightMap, fg_c, fg_a, fg_h, style.opacity);
}
float SVGPathBlender::BlendState::blendAnimatedDimensonalFloat(float from, float to, FloatBlendMode blendMode)
{
if (m_addTypesCount) {
ASSERT(m_typesAreEqual);
return from + to * m_addTypesCount;
}
if (m_typesAreEqual)
return blend(from, to, m_progress);
float fromValue = blendMode == BlendHorizontal ? m_fromCurrentPoint.x() : m_fromCurrentPoint.y();
float toValue = blendMode == BlendHorizontal ? m_toCurrentPoint.x() : m_toCurrentPoint.y();
// Transform toY to the coordinate mode of fromY
float animValue = blend(from, m_fromIsAbsolute ? to + toValue : to - toValue, m_progress);
// If we're in the first half of the animation, we should use the type of the from segment.
if (m_isInFirstHalfOfAnimation)
return animValue;
// Transform the animated point to the coordinate mode, needed for the current progress.
float currentValue = blend(fromValue, toValue, m_progress);
return !m_fromIsAbsolute ? animValue + currentValue : animValue - currentValue;
}
void drawDeviceIcon(BVRef device, pixmap_t *buffer, position_t p)
{
int devicetype;
if( diskIsCDROM(device) )
devicetype = iDeviceCDROM; // Use CDROM icon
else
{
switch (device->part_type)
{
case kPartitionTypeHFS:
// TODO: add apple raid icon choices
devicetype = iDeviceHFS; // Use HFS icon
break;
case kPartitionTypeHPFS:
devicetype = iDeviceNTFS; // Use HPFS / NTFS icon
break;
case kPartitionTypeFAT16:
devicetype = iDeviceFAT16; // Use FAT16 icon
break;
case kPartitionTypeFAT32:
devicetype = iDeviceFAT32; // Use FAT32 icon
break;
case kPartitionTypeEXT3:
devicetype = iDeviceEXT3; // Use EXT2/3 icon
break;
default:
devicetype = iDeviceGeneric; // Use Generic icon
break;
}
}
// draw icon
blend( images[devicetype].image, buffer, centeredAt( images[devicetype].image, p ));
p.y += (images[iSelection].image->height / 2) + font_console.chars[0]->height;
// draw volume label
drawStrCenteredAt( device->label, &font_small, buffer, p);
}
void motion(
int x, int y, Time t,
unsigned int kb_mask
) {
static uint8_t old_alpha = 255;
alpha = (255*x/width);
if (alpha != old_alpha) {
uint32_t t1, t2;
t1 = getTime();
switch (function) {
case 0:
printf("%s", function_name[function]);
blend();
break;
case 1:
printf("%s", function_name[function]);
SSE4_blend();
break;
case 2:
printf("%s", function_name[function]);
SSE42_blend();
break;
case 3:
printf("%s", function_name[function]);
swar_64bit_blend();
break;
case 4:
printf("%s", function_name[function]);
blend_sse_1();
break;
case 5:
printf("%s", function_name[function]);
blend_sse_2();
break;
default:
return;
}
t2 = getTime();
printf(" = %d us\n", t2-t1);
Xscr_redraw();
old_alpha = alpha;
frequency[function].n += 1;
frequency[function].sum += (t2 - t1);
}
}
