void CDDomWidgetA::MakeColor( D3DCOLOR& d3dcolor, DOMINATING_TEAM team )
{
	if( m_ToBeDominated != DTEAM_NONE )
	{
		switch( team )
		{
		case DTEAM_A: d3dcolor = D3DCOLOR_ARGB( 0xFF, GetAlpha(), 0x00, 0x00 ); break;
		case DTEAM_B: d3dcolor = D3DCOLOR_ARGB( 0xFF, 0x00, 0x00, GetAlpha() ); break;
			default:
				{
					d3dcolor = 0xDAD5DBBA;  
				}break;
		}
	}
	else
	{
		switch( team )
		{
			case DTEAM_A: d3dcolor = 0xFFE01B1B; break;
			case DTEAM_B: d3dcolor = 0xFF3C47DE; break;
			default:
				{
					d3dcolor = 0xDAD5DBBA;  
				}break;
		}
	}
}

void CASW_VGUI_Computer_Splash::SetHidden(bool bHidden)
{
	if (bHidden && GetAlpha() > 0)
	{
		vgui::GetAnimationController()->RunAnimationCommand(this, "Alpha", 0, 0, 0.7f, vgui::AnimationController::INTERPOLATOR_LINEAR);
	}
	else if (!bHidden && GetAlpha() <= 0)
	{
		vgui::GetAnimationController()->RunAnimationCommand(this, "Alpha", 255, 0, 0.7f, vgui::AnimationController::INTERPOLATOR_LINEAR);
	}
}

void GuiInfomsg::Update(GuiTrigger * t)
{
	if(GetAlpha() == 0){
		return;
	}

	if(difftime(time(NULL), timer) >= 2.0f){
		SetAlpha(GetAlpha()-10);
		if(GetAlpha() < 0){ SetAlpha(0); }
	}

}

/* ================================================================
   コピー。
   ソース画像が透明色を持っていない場合はmemory-to-memoryコピー
   そうでない場合は1pixelづつコピー
================================================================ */
void VnImage::Copy(const VnImage& img, const VnRect& srcRect, int dx, int dy)
{
  // 範囲内のチェック
  VnRect src_rect(0, 0, img.Width(), img.Height());
  src_rect &= srcRect;
  
  VnRect dst_rect(0, 0, Width(), Height());
  dst_rect &= VnRect(dx, dy, src_rect.width, src_rect.height);

  if (GetAlpha(img.mTransColor) == 0xff) {
    // 不透明画像をコピー
    for(int y = 0; y < dst_rect.height; ++y) {
      memcpy(GetPixelBuf(dst_rect.x, dst_rect.y + y), img.GetPixelBuf(src_rect.x, src_rect.y + y), dst_rect.width * 4);
    }
  } else {
    const u_int32_t trans_color = ToMachineColor(img.mTransColor & 0xffffff00);

    // 透明色を考慮したコピー
    for(int y = 0; y < dst_rect.height; ++y) {
      const u_int32_t* src = img.GetPixelBuf(src_rect.x, src_rect.y + y);
      u_int32_t* dst       = GetPixelBuf(dst_rect.x, dst_rect.y + y);
      for(int x = 0; x < dst_rect.width; ++x, ++dst, ++src) {
        // ソースが透明色でない場合に書き込む
        // リトルエンディアン限定(:TODO:)
        if (trans_color != (*src & 0x00ffffff)) {
          *dst = *src;
        }
      }
    }
  } // end of if (GetAlpha ...)

//   cerr << "VnImage::Copy " << t.GetPassed() << "(s)" << endl;

}

void WINAPI duListBox::DrawObject(HDC hDC)
{
	duRect rcListBox;
	Plugin_GetRect(this, &rcListBox);
	rcListBox.OffsetRect(-rcListBox.left, -rcListBox.top);

	duStyleGroup *pStyleGroup = (duStyleGroup *)GetResObj(GetStyle(), DU_RES_STYLEGROUP);
	if (pStyleGroup)
		pStyleGroup->Draw(hDC, &rcListBox, GetState(), GetText(), GetAlpha());
	

	pStyleGroup = (duStyleGroup *)GetResObj(m_szItemStyle, DU_RES_STYLEGROUP);
	if (pStyleGroup == NULL)
		return;

	duRect rcItem;
	rcItem.SetRectEmpty();
	rcItem.right = rcListBox.Width();
	rcItem.OffsetRect(0, -m_nYOffset);
	
	ListBoxItem *pItem = NULL;
	int i;
	int nItemCount = GetItemCount();
	for (i = 0;i < nItemCount; i++)
	{
		pItem = m_vtItem[i];
		rcItem.top = rcItem.bottom;
		rcItem.bottom = rcItem.top + m_nItemHeight;
		DrawItem(pItem, hDC, pStyleGroup, rcItem);
	}
}

void WINAPI duOutlookBar::DrawObject(HDC hDC)
{
	duRect rect;
	GetRect(&rect);
	rect.OffsetRect(-rect.left, -rect.top);

	duStyleGroup *pStyleGroup = (duStyleGroup *)GetResObj(GetStyle(), DU_RES_STYLEGROUP);
	if (pStyleGroup)
		pStyleGroup->Draw(hDC, &rect, DU_STATE_ALL, GetText(), GetAlpha());

	duStyleGroup *pItemStyleGroup = (duStyleGroup *)GetResObj(m_szItemStyle, DU_RES_STYLEGROUP);
	if (pItemStyleGroup == NULL)
		return ;

	int i;
	OutlookBarItem *pOutlookBarItem = NULL;
	int nItemCount = GetItemCount();
	duRect rectItem = rect;
	rectItem.bottom = rectItem.top + m_nItemHeight;

	for (i = 0;i < nItemCount; i++)
	{
		pOutlookBarItem = m_vtItems[i];
		pItemStyleGroup->Draw(hDC, &rectItem, pOutlookBarItem->iState, pOutlookBarItem->strText.c_str(), GetAlpha());

		if (pOutlookBarItem->fSelected)
		{
			rectItem.top = rect.bottom - (nItemCount - i - 1) * m_nItemHeight;
			rectItem.bottom = rectItem.top + m_nItemHeight;
		}
		else
			rectItem.OffsetRect(0, m_nItemHeight);
	}
}

 void Color::ToFloat(float Dest[]) const
 {
     Dest[0] = GetRed()   / 255.0f;
     Dest[1] = GetGreen() / 255.0f;
     Dest[2] = GetBlue()  / 255.0f;
     Dest[3] = GetAlpha() / 255.0f;
 }

static int MBAnalyzeBestIntra16Mode(VP8EncIterator* const it) {
  const int max_mode =
      (it->enc_->method_ >= FAST_ANALYSIS_METHOD) ? MAX_INTRA16_MODE
                                                  : NUM_PRED_MODES;
  int mode;
  int best_alpha = DEFAULT_ALPHA;
  int best_mode = 0;

  VP8MakeLuma16Preds(it);
  for (mode = 0; mode < max_mode; ++mode) {
    VP8Histogram histo = { { 0 } };
    int alpha;

    VP8CollectHistogram(it->yuv_in_ + Y_OFF,
                        it->yuv_p_ + VP8I16ModeOffsets[mode],
                        0, 16, &histo);
    alpha = GetAlpha(&histo);
    if (IS_BETTER_ALPHA(alpha, best_alpha)) {
      best_alpha = alpha;
      best_mode = mode;
    }
  }
  VP8SetIntra16Mode(it, best_mode);
  return best_alpha;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMessageDialog::PaintBackground( void )
{
	int wide, tall;
	GetSize( wide, tall );

	if ( !( m_nType & MD_SIMPLEFRAME ) )
	{
		int nAlpha = GetAlpha();

		m_clrNotSimpleBG[3] = nAlpha;
		m_clrNotSimpleBGBlack[3] = nAlpha;

		DrawBox( 0, 0, wide, tall, m_clrNotSimpleBGBlack, 1.0f );	
		DrawBox( 0, 0, wide, tall - m_FooterTall, m_clrNotSimpleBG, 1.0f );	

		return;
	}

	Color col = GetBgColor();
	DrawBox( 0, 0, wide, tall, col, 1.0f );

	// offset the inset by title
	int titleX, titleY, titleWide, titleTall;
	m_pTitle->GetBounds( titleX, titleY, titleWide, titleTall );	
	int y = titleY + titleTall;

	// draw an inset
	Color darkColor;
	darkColor.SetColor( 0.70f * (float)col.r(), 0.70f * (float)col.g(), 0.70f * (float)col.b(), col.a() );
	vgui::surface()->DrawSetColor( darkColor );
	vgui::surface()->DrawFilledRect( 8, y, wide - 8, tall - 8 );
}

void GuiCross::Draw()
{
	GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
	GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
	GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
	GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);

	f32 x1 = GetLeft();
	f32 x2 = x1 + width;
	f32 y1 = GetTop();
	f32 y2 = y1 + height;
	
	int alpha = GetAlpha();
	
	GX_Begin(GX_LINES, GX_VTXFMT0, 4);
	GX_Position3f32(x1, y1, 0.0f);
	GX_Color4u8(color.r, color.g, color.b, alpha);
	GX_Position3f32(x2, y2, 0.0f);
	GX_Color4u8(color.r, color.g, color.b, alpha);
	GX_Position3f32(x2, y1, 0.0f);
	GX_Color4u8(color.r, color.g, color.b, alpha);
	GX_Position3f32(x1, y2, 0.0f);
	GX_Color4u8(color.r, color.g, color.b, alpha);
	GX_End();
	GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
}

/**
 *  Additional stuff we need to do before drawing (in this case: update the map)
 */
void IngameMinimap::BeforeDrawing()
{
    // Ab welcher Knotenanzahl (Teil der Gesamtknotenanzahl) die Textur komplett neu erstellt werden soll
    static const unsigned MAX_NODES_UPDATE_DENOMINATOR = 2; // (2 = 1/2, 3 = 1/3 usw.)

    if(!nodesToUpdate.empty())
    {
        // Komplette Textur neu erzeugen, weil es zu viele Knoten sind?
        if(nodesToUpdate.size() >= map_width * map_height / MAX_NODES_UPDATE_DENOMINATOR)
        {
            // Ja, alles neu erzeugen
            UpdateAll();
            for(MapPoint p(0, 0); p.y < map_height; p.y++)
                for(p.x = 0; p.x < map_width; p.x++)
                    nodes_updated[GetMMIdx(p)] = false;
        } else
        {
            // Entsprechende Pixel updaten
            for(std::vector<MapPoint>::iterator it = nodesToUpdate.begin(); it != nodesToUpdate.end(); ++it)
            {
                for(unsigned t = 0; t < 2; ++t)
                {
                    unsigned color = CalcPixelColor(*it, t);
                    map.tex_setPixel((it->x * 2 + t + (it->y & 1)) % (map_width * 2), it->y, GetRed(color), GetGreen(color),
                        GetBlue(color), GetAlpha(color));
                }
                nodes_updated[GetMMIdx(*it)] = false;
            }
        }

        this->nodesToUpdate.clear();
    }
}

/**
 *
 *  @author OLiver
 */
void Minimap::CreateMapTexture(const void *param)
{
	map.DeleteTexture();

	if(!param)
		return;

	/// Buffer für die Daten erzeugen
	unsigned char *buffer = new unsigned char[map_width * 2 * map_height * 4];

	for(MapCoord y = 0;y<map_height;++y)
	{
		for(MapCoord x = 0;x<map_width;++x)
		{
			// Die 2. Terraindreiecke durchgehen
			for(unsigned t = 0;t<2;++t)
			{
				unsigned color = CalcPixelColor(param,x,y,t);

				unsigned pos  = y*map_width*4*2+(x*4*2+t*4+(y&1)*4)%(map_width*4*2);
				buffer[pos+2] = GetRed(color);
				buffer[pos+1] = GetGreen(color);
				buffer[pos]   = GetBlue(color);
				buffer[pos+3] = GetAlpha(color);
			}
		}
	}

	map.setFilter(GL_LINEAR);
	map.create(map_width*2, map_height, buffer, map_width*2, map_height,
				libsiedler2::FORMAT_RGBA, LOADER.GetPaletteN("pal5"));

	delete [] buffer;
}

//-----------------------------------------------------------------------------
// Sets the color + transparency
//-----------------------------------------------------------------------------
void CBaseShader::SetColorState( int colorVar, bool setAlpha )
{
	Assert( !IsSnapshotting() );
	if ( !s_ppParams )
		return;

	// Use tint instead of color if it was specified...
	IMaterialVar* pColorVar = (colorVar != -1) ? s_ppParams[colorVar] : 0;

	float color[4] = { 1.0, 1.0, 1.0, 1.0 };
	if (pColorVar)
	{
		if (pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
		{
			pColorVar->GetVecValue( color, 3 );
		}
		else
		{
			color[0] = color[1] = color[2] = pColorVar->GetFloatValue();
		}

		// Clamp...
		color[0] = clamp( color[0], 0.0f, 1.0f );
		color[1] = clamp( color[1], 0.0f, 1.0f );
		color[2] = clamp( color[2], 0.0f, 1.0f );
	}

	color[3] = setAlpha ? GetAlpha() : 1.0f;
	s_pShaderAPI->Color4fv( color );	
}

void duSplitter::DrawObject(HDC hDC)
{
	duRect rectSplitter;
	Plugin_GetRect(this, &rectSplitter);
	rectSplitter.OffsetRect(-rectSplitter.left, -rectSplitter.top);

	DrawByStyle(this, GetStyle(), hDC, &rectSplitter, GetState(), GetText(), GetAlpha());
}

void CASW_VGUI_Computer_Container::OnThink()
{
	BaseClass::OnThink();

	float fDeathCamInterp = ASWGameRules()->GetMarineDeathCamInterp();

	if ( fDeathCamInterp > 0.0f && GetAlpha() >= 255 )
	{
		SetAlpha( 254 );
		vgui::GetAnimationController()->RunAnimationCommand(this, "Alpha", 0, 0, 0.5f, vgui::AnimationController::INTERPOLATOR_LINEAR);
	}
	else if ( fDeathCamInterp <= 0.0f && GetAlpha() <= 0 )
	{
		SetAlpha( 1 );
		vgui::GetAnimationController()->RunAnimationCommand(this, "Alpha", 255, 0, 0.5f, vgui::AnimationController::INTERPOLATOR_LINEAR);
	}
}

    Color Color::Modulate(const Color& c) const
    {
        uint8 R = static_cast<uint8>(GetRed()   * c.GetRed()   / 255);
        uint8 G = static_cast<uint8>(GetGreen() * c.GetGreen() / 255);
        uint8 B = static_cast<uint8>(GetBlue()  * c.GetBlue()  / 255);
        uint8 A = static_cast<uint8>(GetAlpha() * c.GetAlpha() / 255);

        return Color(R, G, B, A);
    }

sf::Color rbColor::ToSFML( VALUE aColor )
{
    aColor = rbColor::ToRuby( aColor );
    sf::Uint8 r = NUM2CHR( GetRed( aColor ) );
    sf::Uint8 g = NUM2CHR( GetGreen( aColor ) );
    sf::Uint8 b = NUM2CHR( GetBlue( aColor ) );
	sf::Uint8 a = NUM2CHR( GetAlpha( aColor ) );
    return sf::Color( r, g, b, a );
}

void SkeletonSprite::Render() const {
	// TAREA: Implementar la especificacion del enunciado
	Renderer::Instance().SetBlendMode( GetBlendMode() );
	Renderer::Instance().SetColor( GetRed(), GetGreen(), GetBlue(), GetAlpha() );
	glPushMatrix();
	glTranslated( GetX(), GetY(), 0 );
	root->Render();
	glPopMatrix();
}

/**
 *  Zeichnet die Textur.
 *
 *  @author FloSoft
 */
void glArchivItem_Bitmap::Draw(short dst_x, short dst_y, short dst_w, short dst_h, short src_x, short src_y, short src_w, short src_h, const unsigned int color, const unsigned int unused)
{
    if(texture == 0)
        GenerateTexture();
    if(texture == 0)
        return;

    if(src_w == 0)
        src_w = width_;
    if(src_h == 0)
        src_h = height_;
    if(dst_w == 0)
        dst_w = src_w;
    if(dst_h == 0)
        dst_h = src_h;

    VIDEODRIVER.BindTexture(texture);

    assert(getBobType() != libsiedler2::BOBTYPE_BITMAP_PLAYER);

    struct GL_T2F_C4UB_V3F_Struct
    {
        GLfloat tx, ty;
        GLubyte r, g, b, a;
        GLfloat x, y, z;
    };

    GL_T2F_C4UB_V3F_Struct tmp[4];

    int x = -nx_ + dst_x;
    int y = -ny_ + dst_y;

    tmp[0].x = tmp[1].x = GLfloat(x);
    tmp[2].x = tmp[3].x = GLfloat(x + dst_w);

    tmp[0].y = tmp[3].y = GLfloat(y);
    tmp[1].y = tmp[2].y = GLfloat(y + dst_h);

    tmp[0].z = tmp[1].z = tmp[2].z = tmp[3].z = 0.0f;

    tmp[0].tx = tmp[1].tx = (GLfloat)src_x / tex_width_;
    tmp[2].tx = tmp[3].tx = (GLfloat)(src_x + src_w) / tex_width_;

    tmp[0].ty = tmp[3].ty = (GLfloat)src_y / tex_height_;
    tmp[1].ty = tmp[2].ty = (GLfloat)(src_y + src_h) / tex_height_;

    tmp[0].r = tmp[1].r = tmp[2].r = tmp[3].r = GetRed(color);
    tmp[0].g = tmp[1].g = tmp[2].g = tmp[3].g = GetGreen(color);
    tmp[0].b = tmp[1].b = tmp[2].b = tmp[3].b = GetBlue(color);
    tmp[0].a = tmp[1].a = tmp[2].a = tmp[3].a = GetAlpha(color);

    glInterleavedArrays(GL_T2F_C4UB_V3F, 0, tmp);
    glDrawArrays(GL_QUADS, 0, 4);

    return;
}

static int MBAnalyzeBestIntra4Mode(VP8EncIterator* const it,
                                   int best_alpha) {
  uint8_t modes[16];
  const int max_mode =
      (it->enc_->method_ >= FAST_ANALYSIS_METHOD) ? MAX_INTRA4_MODE
                                                  : NUM_BMODES;
  int i4_alpha;
  VP8Histogram total_histo = { { 0 } };
  int cur_histo = 0;

  VP8IteratorStartI4(it);
  do {
    int mode;
    int best_mode_alpha = DEFAULT_ALPHA;
    VP8Histogram histos[2];
    const uint8_t* const src = it->yuv_in_ + Y_OFF + VP8Scan[it->i4_];

    VP8MakeIntra4Preds(it);
    for (mode = 0; mode < max_mode; ++mode) {
      int alpha;

      memset(&histos[cur_histo], 0, sizeof(histos[cur_histo]));
      VP8CollectHistogram(src, it->yuv_p_ + VP8I4ModeOffsets[mode],
                          0, 1, &histos[cur_histo]);
      alpha = GetAlpha(&histos[cur_histo]);
      if (IS_BETTER_ALPHA(alpha, best_mode_alpha)) {
        best_mode_alpha = alpha;
        modes[it->i4_] = mode;
        cur_histo ^= 1;   // keep track of best histo so far.
      }
    }
    // accumulate best histogram
    MergeHistograms(&histos[cur_histo ^ 1], &total_histo);
    // Note: we reuse the original samples for predictors
  } while (VP8IteratorRotateI4(it, it->yuv_in_ + Y_OFF));

  i4_alpha = GetAlpha(&total_histo);
  if (IS_BETTER_ALPHA(i4_alpha, best_alpha)) {
    VP8SetIntra4Mode(it, modes);
    best_alpha = i4_alpha;
  }
  return best_alpha;
}