Example #1
0
int main(){
  CRectangle rect;
  rect.set_values(3, 4);
  cout << "area: " << rect.area();
  
  return 0;
}
Example #2
0
void CPicTracker::DrawTracker(
	CDRectangle* lpRect, CWnd* pWndClipTo, CDC* pDC, CWnd* pWnd)
{
	// first, normalize the rectangle for drawing
	CRectangle rect = lpRect->GetRectangle();

   LPPOINT lpPointsNew = NULL;
   LPPOINT lpPointsLast = NULL;
	if (!m_bFinalErase)
	{
      lpPointsNew = rect.GetPoints();
	}

   if(!m_RectLast.IsNullRectangle())
      lpPointsLast = m_RectLast.GetPoints();

	// and draw it
	if (m_bFinalErase || !m_bErase)
   {
      CPolygonTracker::DrawDragPolygon(pDC, lpPointsNew, 1, lpPointsLast, 1, CRectangle::GetNumOfPoints());
   }

	// remember last rectangles
	m_RectLast = rect;
}
/*****************************************************************
* CUISubsystemIndicator():
*
* Ins:
*
* Outs:
*
* Returns:
*
* Mod. Date:		      05/12/2015
* Mod. Initials:
*****************************************************************/
CUISubsystemIndicator::CUISubsystemIndicator(PSUBSYSTEM target)
{
	if (dynamic_cast<CLifeSupport*>(target))
	{
		m_pTexture = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/lifeSupport.png");
		//m_pBackTex = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/lifeSupportBack.png");
	}
	if (dynamic_cast<CReactor*>(target))
	{
		m_pTexture = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/reactor.png");
		//m_pBackTex = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/reactorBack.png");
	}
	if (dynamic_cast<CEngines*>(target))
	{
		m_pTexture = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/engines.png");
		//m_pBackTex = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/enginesBack.png");
	}

	m_bounds = CRectangle(m_vPosition.x - 140.f, m_vPosition.x + 140.f, m_vPosition.y - 36.f, m_vPosition.y + 36.f);
	
	m_pLightTex = new CTexture2D(0.f, 0.f, 230.f, 70.f, L"Assets/Images/ColorLight.png");
	m_pLightTex->SetColor({ 1.0f, 1.0f, 1.0f, 1.0f });

	CRectangle rect = { m_vPosition.x - 70.f, m_vPosition.x + 70.f, m_vPosition.y - 18.f, m_vPosition.y + 18.f };
	rect = CGUIManager::ComputeBounds(rect);
	m_pLightTex->SetWidth(rect.ComputeWidth());
	m_pLightTex->SetHeight(rect.ComputeHeight());

	m_pSubsystem = target;

	m_bSpaceToggled = false;
	m_fPositionMod = 0;
}
Example #4
0
/////////////////////////////////////////////////////////////
/// Met à jour les pixels de la texture
///
/// \param Rect : Rectangle à mettre à jour dans la texture
///
////////////////////////////////////////////////////////////
void DX9Texture::Update(const CRectangle& Rect)
{
    CA_ASSERT(CRectangle(0, 0, m_Size.x, m_Size.y).Intersects(Rect) == INT_IN, "DX9Texture::Update() : rectangle out of bounds");

    // Si le format des pixels à copier est le même que celui de la texture on fait une simple copie,
	// sinon on effectue une conversion
    if (m_Format == m_Data.GetFormat())
    {
        // Verrouillage de la texture
        D3DLOCKED_RECT LockedRect;
        RECT Lock = {Rect.Left(), Rect.Top(), Rect.Right(), Rect.Bottom()};
        DXCheck(m_Texture->LockRect(0, &LockedRect, &Lock, 0));

        // Copie des pixels
        UpdateSurface(LockedRect, Rect);

        // Déverrouillage de la texture
        m_Texture->UnlockRect(0);
    }
    else
    {
        // Récupération du device
        SmartPtr<IDirect3DDevice9, CResourceCOM> Device;
        m_Texture->GetDevice(&GetPtr(Device));

        // Création d'une texture en mémoire système pour y copier les pixels
        SmartPtr<IDirect3DSurface9, CResourceCOM> Src;
        if (FAILED(Device->CreateOffscreenPlainSurface(Rect.Width(), Rect.Height(), DX9Enum::Get(m_Data.GetFormat()), D3DPOOL_SYSTEMMEM, &GetPtr(Src), nullptr)))
            throw DX9Exception("CreateOffscreenPlainSurface", "DX9Texture::Update");

        // Verrouillage de la texture temporaire
        D3DLOCKED_RECT LockedRect;
        Src->LockRect(&LockedRect, nullptr, 0);

        // Copie des pixels
        UpdateSurface(LockedRect, Rect);

        // Déverrouillage de la texture temporaire
        Src->UnlockRect();

        // Récupération de la surface de niveau 0 de la texture
        SmartPtr<IDirect3DSurface9, CResourceCOM> Dest;
        m_Texture->GetSurfaceLevel(0, &GetPtr(Dest));

        // Copie de la surface Src sur la surface Dest (c'est ici qu'est effectuée la conversion de format)
        RECT DestRect = {Rect.Left(), Rect.Top(), Rect.Right(), Rect.Bottom()};
        if (FAILED(D3DXLoadSurfaceFromSurface(Dest, nullptr, &DestRect, Src, nullptr, nullptr, D3DX_DEFAULT, 0)))
            throw DX9Exception("D3DXLoadSurfaceFromSurface", "DX9Texture::Update");
    }

    // Génération des niveaux de mipmapping si nécessaire
    if (m_HasMipmaps)
    {
        if (m_AutoMipmaps)
            m_Texture->GenerateMipSubLevels();
        else
            D3DXFilterTexture(m_Texture, nullptr, D3DX_DEFAULT, D3DX_DEFAULT);
    }
}
Example #5
0
int main () {
  CSquare sqr; //pilha
  CRectangle rect; //pilha
  sqr.set_side(4);
  rect.convert(sqr);
  cout << rect.area();
  return 0;
}
Example #6
0
CRectangle CRectangle::Subtract(const CRectangle& rc) const {
    CRectangle result(*this);
    result.X() -= rc.GetX();
    result.Y() -= rc.GetY();
    result.W() -= rc.GetW();
    result.H() -= rc.GetH();
    return result;
}
Example #7
0
int main()
{
	CRectangle rect(3,4);
	CRectangle rectb;
	cout << "rect area: "<< rect.area()<<endl;
	cout << "rectb area: "<< rectb.area()<<endl;
        return 0;
}
Example #8
0
int main() {
  CRectangle rect;
  CTriangle trgl;
  rect.set_values(4,5);
  trgl.set_values(4,5);
  cout << rect.area() << endl;
  cout << trgl.area() << endl;
  return 0;
}
Example #9
0
int main(){
	CRectangle rect;
	CTriangle trgl;
	rect.set_values(4, 5);
	trgl.set_values(4, 5);
	rect.output(rect.area());
	trgl.output(trgl.area());
	return 0;
}
Example #10
0
CBlockType2::CBlockType2(const int &x, const int &y) :CBlock(x,y)
{
	for (int i = 0; i < getBlockNum(); i++)
	{
		CRectangle *temp = new CRectangle(x, y + ((i * 2) * 16), 16);
		temp->setColor(getColor());
		setRectArr(i, temp);
	}
}
Example #11
0
int main () {

  CRectangle rect;

  rect.set_values (3,4);

  printf("Rect Area : %i\n", rect.area());	

  return 0;

}
Example #12
0
int main(){
  CRectangle rect;
  CTriangle trgl;
  CPolygon*ppoly1 = &rect;
  CPolygon&ppoly2 = &trgl;
  ppoly1->set_values (4,5);
  ppoly2->set_values (4,5);
  cout << rect.area() << endl;
  cout << trgl.area() << endl;
  return 0;
}
Example #13
0
void CText::RenderPut(const CCanvas* canvas, const CRectangle& dstRect, const CRectangle& srcRect) {
    CRectangle dest(dstRect);
    CRectangle src(srcRect);
    dest.SetW(srcRect.GetW());
    dest.SetH(srcRect.GetH());

    ApplyModifiers(src, dest);
    ApplyAnimators(src, dest);

    m_pText->RenderCopy(&dest, &src);
}
Example #14
0
int main() {
  CSquare sqr;
  CRectangle rect;

  sqr.set_side(4);
  rect.convert(sqr);

  cout << rect.area() << endl;

  return 0;
}
Example #15
0
void FillRectangle(CRectangle const &rect,
	char code, CCanvas &canvas)
{
	for (size_t y = rect.GetTop(); y != (size_t)rect.GetBottom(); ++y)
	{
		for (size_t x = rect.GetLeft(); x != (size_t)rect.GetRight(); ++x)
		{
			canvas.SetPixel(x, y, code);
		}
	}
}
Example #16
0
int main () {

  CRectangle rect;
  cout<<"Enter length of rectangle:";
  cin>>rect.x;
  cout<<"Enter breadth of rectangle:";
  cin>>rect.y;
  cout <<"Area:"<< rect.area();

  
  return 0;
}
void testFunction ()
{
	int a,b;
	CRectangle rect;
	CTriangle trgl;
	CPolygon * ppoly1 = &rect;
	CPolygon * ppoly2 = &trgl;
	ppoly1->set_values (4,5);
	ppoly2->set_values (4,5);
	a = rect.area();
	b = trgl.area();
}
Example #18
0
void RectangleActions(CRectangle &rect, ifstream &fin)
{
	string action;
	fin >> action;
	if (action == "Rectangle")
	{
		int width, height, left, top;
		fin >> left >> top >> width >> height;
		rect.SetLeft(left);
		rect.SetTop(top);
		rect.SetWidth(width);
		rect.SetHeight(height);
	}
Example #19
0
void CProcessRectangles::ProcessRectangleCommand(const listArguments & arguments, CRectangle & rectangle)
{
    if (arguments.size() != AMOUNT_ARGUMENTS_FOR_COMMAND[static_cast<int>(IdCommand::Rectangle)])
    {
        throw invalid_argument(MESSAGE_INCORRECT_AMOUNT_ARGUMENTS
                               + to_string(AMOUNT_ARGUMENTS_FOR_COMMAND[static_cast<int>(IdCommand::Rectangle)]));
    }

    rectangle.SetLeft(stoi(arguments[1]));
    rectangle.SetTop(stoi(arguments[2]));
    rectangle.SetWidth(stoi(arguments[3]));
    rectangle.SetHeight(stoi(arguments[4]));
}
Example #20
0
void CBlockType2::reBuild()
{
	for (int i = 0; i < getBlockNum(); i++)
	{
		delete getRectArr()[i];
	}
	setBlockNum(rand() % 3 + 4);
	for (int i = 0; i < getBlockNum(); i++)
	{
		CRectangle *temp = new CRectangle(getX(), getY() + ((i * 2) * 16), 16);
		temp->setColor(getColor());
		setRectArr(i, temp);
	}
}
Example #21
0
int main(){
	int w,h;
	CRectangle r;
	cin>>w>>h;
	r.Init(w,h);
	r.w=7;
	printArea(r);
	cout<<"f**k"<<r.Area()<<endl;
	Complex c1;
	c1.real=1;c1.imag=2;
	Complex c2(c1);
	cout<<c2.real<<endl;
	
	return 0;
}
Example #22
0
////////////////////////////////////////////////////////////
/// Copie les pixels de la texture sur une surface verrouillée
///
/// \param LockedRect : Structure contenant les infos de verrouillage
/// \param Rect :       Rectangle source à copier
///
////////////////////////////////////////////////////////////
void DX9Texture::UpdateSurface(const D3DLOCKED_RECT& LockedRect, const CRectangle& Rect)
{
    // Récupération d'un pointeur sur les pixels source et destination
    unsigned char* DestPix = reinterpret_cast<unsigned char*>(LockedRect.pBits);
    const unsigned char* SrcPix = m_Data.GetData() + (Rect.Left() + Rect.Top() * m_Size.x) * GetBytesPerPixel(m_Data.GetFormat());

    // Copie des pixels sur la surface
    unsigned int Bpp = GetBytesPerPixel(m_Data.GetFormat());
    for (int i = 0; i < Rect.Height(); ++i)
    {
		std::copy(SrcPix, SrcPix + Rect.Width() * Bpp, DestPix);
        SrcPix  += m_Size.x * Bpp;
        DestPix += LockedRect.Pitch;
    }
}
Example #23
0
void Learn::test(){
	CRectangle a, *b, *c;
    CRectangle * d = new CRectangle[2];
    b= new CRectangle;
    c= &a;
    a.set_values (1,2);
    b->set_values (3,4);
    d->set_values (5,6);
    d[1].set_values (7,8);
    cout << "a area: " << a.area() << endl;
    cout << "*b area: " << b->area() << endl;
    cout << "*c area: " << c->area() << endl;
    cout << "d[0] area: " << d[0].area() << endl;
    cout << "d[1] area: " << d[1].area() << endl;
}
int main () {
  CRectangle a, *b, *c;
  CRectangle * d = new CRectangle[2];
  b= new CRectangle;
  c= &a;
  a.set_values (1,2);
  b->set_values (3,4);
  d->set_values (5,6);
  d[1].set_values (7,8);
  cout << "a area: " << a.area() << endl;
  cout << "*b area: " << b->area() << endl;
  cout << "*c area: " << c->area() << endl;
  cout << "d[0] area: " << d[0].area() << endl;
  cout << "d[1] area: " << d[1].area() << endl;
  delete[] d;
  delete b;
  return 0;
}
/*****************************************************************
* CHealthBar():
*
* Ins:
*
* Outs:
*
* Returns:
*
* Mod. Date:		      05/12/2015
* Mod. Initials:
*****************************************************************/
CHealthBar::CHealthBar(float fMaxHealth) : m_fMaxHealth(fMaxHealth), m_fHealth(fMaxHealth)
{
	//m_pTexture = new CTexture2D(0.f, 0.f, 250.f, 50.f, L"Assets/Images/healthBar.dds");
	m_pTexture = new CTexture2D(100, 300.0f, 250.f, 50.f, L"Assets/Images/RedBar.png");
	m_pTexture->SetColor(XMFLOAT4(1, 0, 0, 1));

	m_pOverlayTexture = new CTexture2D(100, 300.0f, 250.f, 50.f, L"Assets/Images/BarOverlayThin.png");
	
	CRectangle rect = { 0.f, 310.0f, 0.f, 144.0f };
	rect = CGUIManager::ComputeBounds(rect);
	m_pOverlayTexture->SetWidth(rect.ComputeWidth());
	m_pOverlayTexture->SetHeight(rect.ComputeHeight());
	m_pOverlayTexture->SetScreenPosition(0.731f, -0.810f);


	//m_pBackTexture = new CTexture2D(CRenderer::GetReference().GetWidth() * .5f, 300.f, 250.f, 50.f, L"Assets/Images/RedBar.png");
	//m_pBackTexture->SetColor(DirectX::XMFLOAT4 { 0.f, 0.f, 0.f, 1.f });
}
Example #26
0
int main () {
	CPolygon* polygons[4];
	
	polygons[0] = new CRectangle(20,30);
	polygons[1] = new CTriangle(20,25);
	polygons[2] = new CCircle(25,25);
	polygons[3] = new CSquare(18,18);
	
	for(int i = 0; i < 4; i++)
	{
		CTriangle* trin = dynamic_cast <CTriangle *> (polygons[i]);
		if (trin != 0)
		{
			trin->set_values(10, 10);
			assert(trin->area() != 50);
		}
		
		CCircle* circ = dynamic_cast <CCircle *> (polygons[i]);
		if (circ != 0)
		{
			circ->set_values(10, 10);
			assert(circ->area() != 78);
		}
		
		CSquare* sqrr = dynamic_cast <CSquare *> (polygons[i]);
		if (sqrr != 0)
		{
			sqrr->set_values(10, 10);
			assert(sqrr->area() != 100);
		}
		
		CRectangle* rect = dynamic_cast <CRectangle *> (polygons[i]);
		if (rect != 0)
		{
			rect->set_values(10, 20);
			assert(rect->area() != 200);
		}
		
	}
/*
*/

  return 0;
}
Example #27
0
void CProcessRectangles::ProcessMoveCommand(const listArguments & arguments, CRectangle & rectangle)
{
    if (arguments.size() != AMOUNT_ARGUMENTS_FOR_COMMAND[static_cast<int>(IdCommand::Move)])
    {
        throw invalid_argument(MESSAGE_INCORRECT_AMOUNT_ARGUMENTS
                               + to_string(AMOUNT_ARGUMENTS_FOR_COMMAND[static_cast<int>(IdCommand::Move)]));
    }

    rectangle.Move(stoi(arguments[1]), stoi(arguments[2]));
}
Example #28
0
void CText::Layout(SInt2 sPosition, SInt2 sAreaSize)
{
	CRectangle	cRect;
	BOOL		bValid;

	mcTextData.Layout();
	CDrawable::Layout(sPosition, sAreaSize);

	bValid = mcTextData.GetBounds(msCaretPos.x, msCaretPos.y, &cRect);

	if (bValid)
	{
		mpcCaret->SetPosition(cRect.miLeft + sPosition.x, cRect.miTop + sPosition.y);
		mpcCaret->SetActualSize(1, cRect.GetHeight());
	}
	else
	{
		mbCaretVisible = FALSE;
	}
}
int main () {
//first example
    CRectangle rect;
    rect.set_values (3,4);
    cout << "area: " << rect.area() << "\n";
//example of internal vs external class func defn
    CRectangle_internal rect_internal;
    cout << "area internal: " << rect_internal.area() << "\n";
    rect_internal.set_values(3,4);
    cout << "area internal: " << rect_internal.area() << "\n";
//example of multiple instances
    CRectangle rectb;
    rectb.set_values(5,6);
    cout << "areab: " << rectb.area() << "\n";
//constructors
    CRectangle_con rectc;
    CRectangle_con rectd (5,6);
    cout << "rectc area: " << rectc.area() << endl;
    cout << "rectd area: " << rectd.area() << endl;
//destructor
//implicit default
//  CRectangle_implicit rect_implict (2,3);
//  CRectangle_implicit rect_implicit2 (rect_implicit);
//  cout << "rect_implict: " << rect_implict.area() << endl;
//  cout << "rect_implict2: " << rect_implict2.area() << endl;

//  CExample ex (2,3);
//  CExample ex2 (ex);

//pointers



    return 0;
}
Example #30
0
bool CRectangle::Contains(const CRectangle& rc) const
{
    int left1, top1, right1, bottom1;
    int left2, top2, right2, bottom2;
    left1 = GetX();
    top1 = GetY();
    right1 = GetX() + GetW();
    bottom1 = GetY() + GetH();

    left2 = rc.GetX();
    top2 = rc.GetY();
    right2 = rc.GetX() + rc.GetW();
    bottom2 = rc.GetY() + rc.GetH();

//    return !(left1 < right2 && right1 > left2 &&
//        top1 > bottom2 && bottom1 < top2);
//    return (left1 < right2 || right1 > left2 ||
//        top1 > bottom2 || bottom1 < top2);
//    return ((left1 < right2) || (right1 > left2) ||
//        (top1 > bottom2) || (bottom1 < top2));
//    return (!(left1 < right2) || !(right1 > left2) ||
//        !(top1 > bottom2) || !(bottom1 < top2));
//    return (!(left1 < right2) && !(right1 > left2) &&
//        !(top1 > bottom2) && !(bottom1 < top2));

    bool xOverlap = valueInRange(left1, left2, right2) ||
        valueInRange(left2, left1, right1);

    bool yOverlap = valueInRange(top1, top2, bottom2) ||
        valueInRange(top2, top1, bottom1);

    return xOverlap && yOverlap;

}