Пример #1
0
void cPrimitives::DrawQuad( const eeQuad2f& q, const eeColorA& Color1, const eeColorA& Color2, const eeColorA& Color3, const eeColorA& Color4, const eeFloat& OffsetX, const eeFloat& OffsetY ) {
	sBR->SetTexture( NULL );
	sBR->SetBlendMode( mBlendMode );

	switch( mFillMode ) {
		case DRAW_LINE:
		{
			sBR->SetLineWidth( mLineWidth );

			sBR->LineLoopBegin();
			sBR->LineLoopSetColorFree( Color1, Color2 );
			sBR->BatchLineLoop( OffsetX + q[0].x, OffsetY + q[0].y, OffsetX + q[1].x, OffsetY + q[1].y );
			sBR->LineLoopSetColorFree( Color2, Color3 );
			sBR->BatchLineLoop( OffsetX + q[2].x, OffsetY + q[2].y, OffsetX + q[3].x, OffsetY + q[3].y );
			break;
		}
		case DRAW_FILL:
		{
			sBR->QuadsBegin();
			sBR->QuadsSetColorFree( Color1, Color2, Color3, Color4 );
			sBR->BatchQuadFree( OffsetX + q[0].x, OffsetY + q[0].y, OffsetX + q[1].x, OffsetY + q[1].y, OffsetX + q[2].x, OffsetY + q[2].y, OffsetX + q[3].x, OffsetY + q[3].y );
			break;
		}
	}

	DrawBatch();
}
Пример #2
0
void DrawRect(float x, float y, float w, float h, color c, GLuint texture) {
  float scale = gameState.scale;

  x = x * scale / gameState.screenWidth * 2.0f - 1.0f;
  y = y * scale / gameState.screenHeight * 2.0f - 1.0f;
  w = w * scale / gameState.screenWidth * 2.0f;
  h = h * scale / gameState.screenHeight * 2.0f;

  float vVertices[] = {
    x, y, 0.0f,
    x, y + h, 0.0f,
    x + w, y, 0.0f,
    x + w, y + h, 0.0f,
    x, y + h, 0.0f,
    x + w, y, 0.0f
  };
  float vColors[] = {
    c.r, c.g, c.b, c.a,
    c.r, c.g, c.b, c.a,
    c.r, c.g, c.b, c.a,
    c.r, c.g, c.b, c.a,
    c.r, c.g, c.b, c.a,
    c.r, c.g, c.b, c.a
  };
  float vTexCoords[] = {
    0.0f,  1.0f,
    0.0f,  0.0f,
    1.0f,  1.0f,
    1.0f,  0.0f,
    0.0f,  0.0f,
    1.0f,  1.0f
  };

  DrawBatch(vVertices, vColors, vTexCoords, 6, texture);
}
Пример #3
0
void cPrimitives::DrawPolygon( const eePolygon2f& p ) {
	sBR->SetTexture( NULL );
	sBR->SetBlendMode( mBlendMode );

	switch( mFillMode ) {
		case DRAW_LINE:
		{
			sBR->SetLineWidth( mLineWidth );

			sBR->LineLoopBegin();
			sBR->LineLoopSetColor( mColor );

			for ( Uint32 i = 0; i < p.Size(); i += 2 )
				sBR->BatchLineLoop( p.X() + p[i].x, p.Y() + p[i].y, p.X() + p[i+1].x, p.Y() + p[i+1].y );

			break;
		}
		case DRAW_FILL:
		{
			sBR->PolygonSetColor( mColor );
			sBR->BatchPolygon( p );
			break;
		}
	}

	DrawBatch();
}
Пример #4
0
void cPrimitives::DrawTriangle( const eeTriangle2f& t, const eeColorA& Color1, const eeColorA& Color2, const eeColorA& Color3 ) {
	sBR->SetTexture( NULL );
	sBR->SetBlendMode( mBlendMode );

	switch( mFillMode ) {
		case DRAW_LINE:
		{
			sBR->SetLineWidth( mLineWidth );

			sBR->LineLoopBegin();

			sBR->LineLoopSetColorFree( Color1, Color2 );
			sBR->BatchLineLoop( t.V[0].x, t.V[0].y, t.V[1].x, t.V[1].y );
			sBR->LineLoopSetColorFree( Color2, Color3 );
			sBR->BatchLineLoop( t.V[1].x, t.V[1].y, t.V[2].x, t.V[2].y );
			break;
		}
		default:
		case DRAW_FILL:
		{
			sBR->TrianglesBegin();

			sBR->TrianglesSetColorFree( Color1, Color2, Color3 );
			sBR->BatchTriangle( t.V[0].x, t.V[0].y, t.V[1].x, t.V[1].y, t.V[2].x, t.V[2].y );

			break;
		}
	}

	DrawBatch();
}
Пример #5
0
 void OpenGL::UpdateScissorState(bool enabled)
 {
    DrawBatch();
    _enableScissoring = enabled;
    _rasterizerDesc.ScissorEnable = _enableScissoring;
    ID3D11RasterizerState* rasterizerState;
    _device->CreateRasterizerState(&_rasterizerDesc, &rasterizerState);
    _context->RSSetState(rasterizerState);
 }
Пример #6
0
void CRenderer::End()
{
	DrawBatch();

	IwGxFlush(); 

	IwGxSwapBuffers(); 
	
	ClearMtlCache();
}
Пример #7
0
void DX11SpriteBatch::EndBatch(ID3D11DeviceContext* dc)
{
	assert(mInitialized);

	u32 viewportCount = 1;
	D3D11_VIEWPORT vp;
	dc->RSGetViewports(&viewportCount, &vp);

	mScreenWidth  = vp.Width;
	mScreenHeight = vp.Height;

	u32 stride = sizeof(MeshData::SpriteVertex);
	u32 offset = 0;
	dc->IASetInputLayout(mInputLayout);
	dc->IASetIndexBuffer(mIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
	dc->IASetVertexBuffers(0, 1, &mVertexBuffer, &stride, &offset);
	dc->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

	DX11Effects::SpriteFX->SetSpriteMap(mBatchTexSRV);

	ID3DX11EffectPass* pass = DX11Effects::SpriteFX->SpriteTech->GetPassByIndex(0);
	pass->Apply(0, dc);

	u32 spritesToDraw = (u32)mSpriteList.size();
	u32 startIndex = 0;

	while( spritesToDraw > 0 )
	{
		if( spritesToDraw <= BatchSize )
		{
			DrawBatch(dc, startIndex, spritesToDraw);
			spritesToDraw = 0;
		}
		else
		{
			DrawBatch(dc, startIndex, BatchSize);
			startIndex += BatchSize;
			spritesToDraw -= BatchSize;
		}
	}

	RJE_SAFE_RELEASE(mBatchTexSRV);
}
Пример #8
0
void cPrimitives::DrawLine( const eeLine2f& line ) {
	sBR->SetLineWidth( mLineWidth );

	sBR->SetTexture( NULL );
	sBR->LinesBegin();
	sBR->LinesSetColor( mColor );

	sBR->BatchLine( line.V[0].x, line.V[0].y, line.V[1].x, line.V[1].y );

	DrawBatch();
}
Пример #9
0
void cPrimitives::DrawPoint( const eeVector2f& p, const eeFloat& pointSize ) {
	sBR->SetPointSize( pointSize );

	sBR->SetTexture( NULL );
	sBR->PointsBegin();
	sBR->PointSetColor( mColor );

	sBR->BatchPoint( p.x, p.y );

	DrawBatch();
}
Пример #10
0
void DxSprite::EndBatch( )
{
    assert( Initialized );

    GetDX11Context()->VSSetShader(VS, 0, 0);
    GetDX11Context()->PSSetShader(PS, 0, 0);

    UINT stride = sizeof(SpriteVertex);
    UINT offset = 0;

    GetDX11Context()->IASetInputLayout(InputLayout );
    GetDX11Context()->IASetIndexBuffer(IB, DXGI_FORMAT_R16_UINT, 0);
    GetDX11Context()->IASetVertexBuffers(0, 1, &VB, &stride, &offset);
    GetDX11Context()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    GetDX11Context()->PSSetShaderResources(0, 1, &BatchTexSRV);

    UINT spritesToDraw = SpriteList.size();
    UINT startIndex = 0;

    while(spritesToDraw > 0)
    {
        if(spritesToDraw <= 512)
        {
            DrawBatch(startIndex, spritesToDraw);
            spritesToDraw = 0;
        }
        else
        {
            DrawBatch(startIndex, 512);
            startIndex += 512;
            spritesToDraw -= 512;
        }
    }

    BatchTexSRV->Release();
}
Пример #11
0
void CRenderer::Draw( IwGxPrimType type, const CIwSVec2 * vertex, const CIwSVec2 * uv, const uint16* indexStream, const CIwColour * colour, int32 vertexCount, CIwMaterial * mat )
{
	if ( mat == NULL )
	{
		mat = mDefaultMaterial;
	}
	if (( GetVBSize() + vertexCount >= RENDER_MAX_BUFF_SIZE 
		|| (mat != mCurrMtl) 
		|| (GetBufferType() != type)
		|| (uv == NULL && GetUVBSize() != 0) 
		|| (indexStream == NULL && GetIBSize() != 0)
		|| (colour == NULL && GetCBSize() != 0)
		))
	{
		DrawBatch();
	}

	if ( (uint32)vertexCount >= RENDER_MAX_BUFF_SIZE )
	{
		CIwSVec2 * _v = IW_GX_ALLOC(CIwSVec2, vertexCount);
		CIwSVec2 * _uv = IW_GX_ALLOC(CIwSVec2, vertexCount);
		CIwColour * _c = IW_GX_ALLOC(CIwColour, vertexCount);

		uint16 * _is = NULL;
		if (indexStream != NULL )
		{
			_is = IW_GX_ALLOC(uint16, vertexCount);
			memcpy(_is, indexStream, vertexCount*sizeof(uint16));
		}
		memcpy(&_v[0], &vertex[0], vertexCount*sizeof(CIwSVec2));
		memcpy(&_uv[0], &uv[0], vertexCount*sizeof(CIwSVec2));
		memcpy(&_c[0], &colour[0], vertexCount*sizeof(CIwColour));

		CameraTransform( &_v[0], vertexCount);
		DrawDirect(type, _v, _uv, _is, _c, vertexCount, mat);
	}
	else
	{
		mCurrMtl  = mat;
		SetBufferType(type);
		AddBuffer(type, vertex, uv, indexStream, colour, vertexCount);
		CameraTransform( &mVB[GetVBSize() - vertexCount], vertexCount);
	}	
}
Пример #12
0
void cPrimitives::DrawRectangle( const eeRectf& R, const eeColorA& TopLeft, const eeColorA& BottomLeft, const eeColorA& BottomRight, const eeColorA& TopRight, const eeFloat& Angle, const eeVector2f& Scale ) {
	sBR->SetTexture( NULL );
	sBR->SetBlendMode( mBlendMode );

	switch( mFillMode ) {
		case DRAW_FILL:
		{
			sBR->QuadsBegin();
			sBR->QuadsSetColorFree( TopLeft, BottomLeft, BottomRight, TopRight );

			eeSizef size = const_cast<eeRectf*>(&R)->Size();

			sBR->BatchQuadEx( R.Left, R.Top, size.Width(), size.Height(), Angle, Scale );
			break;
		}
		case DRAW_LINE:
		{
			sBR->SetLineWidth( mLineWidth );

			sBR->LineLoopBegin();
			sBR->LineLoopSetColorFree( TopLeft, BottomLeft );

			if ( Scale != 1.0f || Angle != 0.0f ) {
				eeQuad2f Q( R );
				eeSizef size = const_cast<eeRectf*>(&R)->Size();

				Q.Scale( Scale );
				Q.Rotate( Angle, eeVector2f( R.Left + size.Width() * 0.5f, R.Top + size.Height() * 0.5f ) );

				sBR->BatchLineLoop( Q[0].x, Q[0].y, Q[1].x, Q[1].y );
				sBR->LineLoopSetColorFree( BottomRight, TopRight );
				sBR->BatchLineLoop( Q[2].x, Q[2].y, Q[3].x, Q[3].y );
			} else {
				sBR->BatchLineLoop( R.Left, R.Top, R.Left, R.Bottom );
				sBR->LineLoopSetColorFree( BottomRight, TopRight );
				sBR->BatchLineLoop( R.Right, R.Bottom, R.Right, R.Top );
			}

			break;
		}
	}

	DrawBatch();
}
Пример #13
0
void cPrimitives::DrawCircle( const eeVector2f& p, const eeFloat& radius, Uint32 points ) {
	if ( 0 == points ) {
		// Optimized circle rendering
		static const GLfloat circleVAR[] = {
			 0.0000f,  1.0000f,
			 0.2588f,  0.9659f,
			 0.5000f,  0.8660f,
			 0.7071f,  0.7071f,
			 0.8660f,  0.5000f,
			 0.9659f,  0.2588f,
			 1.0000f,  0.0000f,
			 0.9659f, -0.2588f,
			 0.8660f, -0.5000f,
			 0.7071f, -0.7071f,
			 0.5000f, -0.8660f,
			 0.2588f, -0.9659f,
			 0.0000f, -1.0000f,
			-0.2588f, -0.9659f,
			-0.5000f, -0.8660f,
			-0.7071f, -0.7071f,
			-0.8660f, -0.5000f,
			-0.9659f, -0.2588f,
			-1.0000f, -0.0000f,
			-0.9659f,  0.2588f,
			-0.8660f,  0.5000f,
			-0.7071f,  0.7071f,
			-0.5000f,  0.8660f,
			-0.2588f,  0.9659f,
			 0.0000f,  1.0000f,
			 0.0f, 0.0f, // For an extra line to see the rotation.
		};
		static const int circleVAR_count = sizeof(circleVAR)/sizeof(GLfloat)/2;

		GLi->Disable( GL_TEXTURE_2D );

		GLi->DisableClientState( GL_TEXTURE_COORD_ARRAY );

		GLi->PushMatrix();

		GLi->Translatef( p.x, p.y, 0.0f );

		GLi->Scalef( radius, radius, 1.0f);

		GLi->VertexPointer( 2, GL_FLOAT, 0, circleVAR, circleVAR_count * sizeof(float) * 2 );

		std::vector<eeColorA> colors( circleVAR_count - 1 ,mColor );

		GLi->ColorPointer( 4, GL_UNSIGNED_BYTE, 0, &colors[0], circleVAR_count * 4 );

		switch( mFillMode ) {
			case DRAW_LINE:
			{
				GLi->DrawArrays( GL_LINE_LOOP, 0, circleVAR_count - 1 );
				break;
			}
			case DRAW_FILL:
			{
				GLi->DrawArrays( GL_TRIANGLE_FAN, 0, circleVAR_count - 1 );
				break;
			}
		}

		GLi->PopMatrix();

		GLi->Enable( GL_TEXTURE_2D );

		GLi->EnableClientState( GL_TEXTURE_COORD_ARRAY );

		return;
	}

	if(points < 6) points = 6;
	eeFloat angle_shift =  360 / static_cast<eeFloat>(points);

	sBR->SetTexture( NULL );

	switch( mFillMode ) {
		case DRAW_LINE:
		{
			sBR->SetLineWidth( mLineWidth );
			sBR->LineLoopBegin();
			sBR->LineLoopSetColor( mColor );

			for( eeFloat i = 0; i < 360; i+= ( angle_shift + angle_shift ) )
				sBR->BatchLineLoop( p.x + radius * Math::sinAng(i), p.y + radius * Math::cosAng(i), p.x + radius * Math::sinAng( i + angle_shift ), p.y + radius * Math::cosAng( i + angle_shift ) );

			break;
		}
		case DRAW_FILL:
		{
			sBR->TriangleFanBegin();
			sBR->TriangleFanSetColor( mColor );

			for( eeFloat i = 0; i < 360; i+= ( angle_shift + angle_shift + angle_shift ) )
				sBR->BatchTriangleFan( p.x + radius * Math::sinAng(i), p.y + radius * Math::cosAng(i), p.x + radius * Math::sinAng( i + angle_shift ), p.y + radius * Math::cosAng( i + angle_shift ), p.x + radius * Math::sinAng( i + angle_shift + angle_shift ), p.y + radius * Math::cosAng( i + angle_shift + angle_shift ) );

			break;
		}
	}

	DrawBatch();
}
Пример #14
0
   void OpenGL::Draw(const std::vector<OpenGLVertex>& vertices)
   {
      if (_loadingComplete == false)
      {
         return;
      }

      if (_vertexBuffer == NULL)
      {
         D3D11_BUFFER_DESC bd;
         ZeroMemory(&bd, sizeof(bd));
         bd.Usage = D3D11_USAGE_DYNAMIC;
         bd.ByteWidth = _maxVertices * sizeof(OpenGLVertex);
         bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
         bd.CPUAccessFlags = D3D11_CPU_ACCESS_FLAG::D3D11_CPU_ACCESS_WRITE;
         bd.MiscFlags = 0;
         bd.StructureByteStride = 0;
         D3D11_SUBRESOURCE_DATA initData;
         ZeroMemory(&initData, sizeof(initData));
         auto hr = _device->CreateBuffer(&bd, NULL, &_vertexBuffer);
      }

      if (_firstDrawInFrame)
      {
         _context->IASetInputLayout(_inputLayout);
         _context->VSSetShader(_vertexShader, nullptr, 0);
         _context->VSSetConstantBuffers(0, 1, &_constantBuffer);

         _firstDrawInFrame = false;
         _context->UpdateSubresource(_constantBuffer, 0, NULL, &_constantBufferData, 0, 0);
         UINT stride = sizeof(OpenGLVertex);
         UINT offset = 0;
         _context->IASetVertexBuffers(0, 1, &_vertexBuffer, &stride, &offset);
         _context->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
      }

      // Check if a texture state has changed
      if (_currentTextureId != _batchCurrentTextureId ||
         _enableTexture2D != _batchEnableTexture2D)
      {
         DrawBatch();
         _batchCurrentTextureId = _currentTextureId;
         _batchEnableTexture2D = _enableTexture2D;
      }

      auto matrix4x4 = _matrices.top();
      auto viewMatrix = DirectX::XMLoadFloat4x4(matrix4x4);
      int count = vertices.size();
      for (int i = 0; i < count; i++)
      {
         OpenGLVertex vertex = vertices[i];

         DirectX::XMVECTOR v = DirectX::XMVectorSet(vertex.x, vertex.y, vertex.z, 1.f);
         DirectX::XMVECTOR tv = DirectX::XMVector4Transform(v, viewMatrix);

         vertex.x = DirectX::XMVectorGetX( tv );
         vertex.y = DirectX::XMVectorGetY( tv );
         vertex.z = DirectX::XMVectorGetZ( tv );

         _batchVertices[_currentBatchVertex++] = vertex;
      }
   }
Пример #15
0
void cPrimitives::ForceDraw( const bool& force ) {
	mForceDraw = force;

	if ( force )
		DrawBatch();
}
Пример #16
0
////////////////////////////////////////////////////////////////
//
// CMaterialLine3DBatcher::Flush
//
// Draw all pending lines
//
////////////////////////////////////////////////////////////////
void CMaterialLine3DBatcher::Flush(void)
{
    if (m_LineList.empty())
        return;

    // Get scene matrices
    D3DXMATRIX matWorld;
    D3DXMatrixIdentity(&matWorld);
    const D3DXMATRIX& matView = g_pDeviceState->TransformState.VIEW;
    const D3DXMATRIX& matProjection = g_pDeviceState->TransformState.PROJECTION;

    // Pre-calc camera position
    D3DXMATRIX matViewInv;
    D3DXMatrixInverse(&matViewInv, NULL, &matView);
    const CVector vecCameraPos(matViewInv._41, matViewInv._42, matViewInv._43);

    // Set transforms
    m_pDevice->SetTransform(D3DTS_WORLD, &matWorld);
    m_pDevice->SetTransform(D3DTS_VIEW, &matView);
    m_pDevice->SetTransform(D3DTS_PROJECTION, &matProjection);

    // Set render states
    if (g_pDeviceState->AdapterState.bRequiresClipping)
        m_pDevice->SetRenderState(D3DRS_CLIPPING, TRUE);
    m_pDevice->SetRenderState(D3DRS_ZENABLE, m_bPreGUI ? D3DZB_TRUE : D3DZB_FALSE);
    m_pDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
    m_pDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
    m_pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    m_pDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
    m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    m_pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    m_pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
    m_pDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
    m_pDevice->SetRenderState(D3DRS_ALPHAREF, 0x01);
    m_pDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);
    m_pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    m_pDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
    m_pDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
    m_pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    m_pDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    m_pDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
    m_pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    m_pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
    m_pDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
    m_pDevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

    m_CurrentTextureAddress = (ETextureAddress)0;

    //
    // Sort by distance
    //

    const float fMaxDrawDistance = CCore::GetSingleton().GetMultiplayer()->GetFarClipDistance();
    const float fSmallLineTolerance = 20;
    const float fMaxDrawDistanceIncTol = fMaxDrawDistance + fSmallLineTolerance;

    const float fMaxDrawDistanceSq = fMaxDrawDistance * fMaxDrawDistance;
    const float fMaxDrawDistanceIncTolSq = fMaxDrawDistanceIncTol * fMaxDrawDistanceIncTol;
    const float fSmallLineToleranceSq = fSmallLineTolerance * fSmallLineTolerance;

    const uint        uiNumLines = m_LineList.size();
    std::vector<uint> indexList;
    indexList.resize(uiNumLines);
    uint* pIndices = &indexList[0];
    uint  uiNumIndicies = 0;

    // Calculate distances
    for (uint i = 0; i < uiNumLines; i++)
    {
        SMaterialLine3DItem& item = m_LineList[i];
        item.fDistSq = (item.vecAvgPosition - vecCameraPos).LengthSquared();
        if (item.fDistSq > fMaxDrawDistanceIncTolSq)
        {
            // Check if line bounding sphere is visible

            float fRadiusSq = (item.vecTo - item.vecFrom).LengthSquared();
            if (fRadiusSq < fSmallLineToleranceSq)
                continue;

            float fSphereDist = std::max(0.f, (item.vecAvgPosition - vecCameraPos).Length() - sqrt(fRadiusSq));
            float fSphereDistSq = fSphereDist * fSphereDist;
            if (fSphereDistSq > fMaxDrawDistanceSq)
                continue;
        }
        // Add the index for this line to the draw list
        pIndices[uiNumIndicies++] = i;
    }

    if (uiNumIndicies > 0)
    {
        indexList.resize(uiNumIndicies);

        // Sort index list by distance
        ms_pLines = &m_LineList[0];
        std::sort(indexList.begin(), indexList.end(), [](const uint a, const uint b) { return ms_pLines[a].fDistSq > ms_pLines[b].fDistSq; });

        pIndices = &indexList[0];

        // Draw index list, batching by material
        uint uiBatchFirstIndex = 0;
        for (uint i = 0; i < uiNumIndicies; i++)
        {
            const SMaterialLine3DItem& item = ms_pLines[pIndices[i]];

            // Flush batch if this is the last index, or the next one uses a different material
            if ((i == uiNumIndicies - 1) || item.pMaterial != ms_pLines[pIndices[i + 1]].pMaterial)
            {
                uint* pBatchIndices = &pIndices[uiBatchFirstIndex];
                uint  uiNumBatchLines = i - uiBatchFirstIndex + 1;

                DrawBatch(vecCameraPos, pBatchIndices, uiNumBatchLines, item.pMaterial);

                uiBatchFirstIndex = i + 1;
            }
        }
    }

    // Clean up
    for (uint i = 0; i < uiNumLines; i++)
        m_LineList[i].pMaterial->Release();

    ListClearAndReserve(m_LineList);

    if (g_pDeviceState->AdapterState.bRequiresClipping)
        m_pDevice->SetRenderState(D3DRS_CLIPPING, FALSE);
}
Пример #17
0
void CRenderer::Flush()
{
	DrawBatch();
}
Пример #18
0
 void OpenGL::EndFrame()
 {
    // Ensure that everything has been drawn before ending the frame.
    DrawBatch();
 }
Пример #19
0
void cPrimitives::DrawRoundedRectangle( const eeRectf& R, const eeColorA& TopLeft, const eeColorA& BottomLeft, const eeColorA& BottomRight, const eeColorA& TopRight, const eeFloat& Angle, const eeVector2f& Scale, const eeUint& Corners ) {
	sBR->SetTexture( NULL );
	sBR->SetBlendMode( mBlendMode );

	eeUint i;
	eeSizef size		= const_cast<eeRectf*>( &R )->Size();
	eeFloat xscalediff	= size.Width()	* Scale.x - size.Width();
	eeFloat yscalediff	= size.Height()	* Scale.y - size.Height();
	eeVector2f Center( R.Left + size.Width() * 0.5f + xscalediff, R.Top + size.Height() * 0.5f + yscalediff );
	eePolygon2f Poly	= eePolygon2f::CreateRoundedRectangle( R.Left - xscalediff, R.Top - yscalediff, size.Width() + xscalediff, size.Height() + yscalediff, Corners );
	eeVector2f poly;

	Poly.Rotate( Angle, Center );

	switch( mFillMode ) {
		case DRAW_FILL:
		{
			if ( TopLeft == BottomLeft && BottomLeft == BottomRight && BottomRight == TopRight ) {
				sBR->PolygonSetColor( TopLeft );

				sBR->BatchPolygon( Poly );
			} else {
				for ( i = 0; i < Poly.Size(); i++ ) {
					poly = Poly[i];

					if ( poly.x <= Center.x && poly.y <= Center.y )
						sBR->PolygonSetColor( TopLeft );
					else if ( poly.x <= Center.x && poly.y >= Center.y )
						sBR->PolygonSetColor( BottomLeft );
					else if ( poly.x > Center.x && poly.y > Center.y )
						sBR->PolygonSetColor( BottomRight );
					else if ( poly.x > Center.x && poly.y < Center.y )
						sBR->PolygonSetColor( TopRight );
					else
						sBR->PolygonSetColor( TopLeft );

					sBR->BatchPolygonByPoint( Poly[i] );
				}
			}

			break;
		}
		case DRAW_LINE:
		{
			sBR->SetLineWidth( mLineWidth );

			sBR->LineLoopBegin();
			sBR->LineLoopSetColor( TopLeft );

			if ( TopLeft == BottomLeft && BottomLeft == BottomRight && BottomRight == TopRight ) {
				for ( i = 0; i < Poly.Size(); i+=2 ) {
					sBR->BatchLineLoop( Poly[i], Poly[i+1] );
				}
			} else {
				for ( eeUint i = 0; i < Poly.Size(); i++ ) {
					poly = Poly[i];

					if ( poly.x <= Center.x && poly.y <= Center.y )
						sBR->LineLoopSetColor( TopLeft );
					else if ( poly.x < Center.x && poly.y > Center.y )
						sBR->LineLoopSetColor( BottomLeft );
					else if ( poly.x > Center.x && poly.y > Center.y )
						sBR->LineLoopSetColor( BottomRight );
					else if ( poly.x > Center.x && poly.y < Center.y )
						sBR->LineLoopSetColor( TopRight );
					else
						sBR->LineLoopSetColor( TopLeft );

					sBR->BatchLineLoop( Poly[i] );
				}
			}

			break;
		}
	}

	DrawBatch();
}