HRESULT D2DRenderer::Draw(HDC hdc)
{
    HRESULT hr = DrawInternal();

    // If D2D returns D2DERR_RECREATE_TARGET, the client should recreate
    // the render target and try rendering the entire frame again.
    if (hr == D2DERR_RECREATE_TARGET)
    {
        FreeDeviceDependentResources();
        hr = DrawInternal();
    }

    return hr;
}
void
AirspaceLabelRenderer::Draw(Canvas &canvas,
#ifndef ENABLE_OPENGL
                            Canvas &stencil_canvas,
#endif
                            const WindowProjection &projection,
                            const MoreData &basic, const DerivedInfo &calculated,
                            const AirspaceComputerSettings &computer_settings,
                            const AirspaceRendererSettings &settings)
{
  if (airspaces == nullptr || airspaces->IsEmpty())
    return;

  AirspaceWarningCopy awc;
  if (warning_manager != nullptr)
    awc.Visit(*warning_manager);

  const AircraftState aircraft = ToAircraftState(basic, calculated);
  const AirspaceMapVisible visible(computer_settings, settings,
                                   aircraft, awc);

  DrawInternal(canvas,
#ifndef ENABLE_OPENGL
               stencil_canvas,
#endif
               projection, settings, awc, visible, computer_settings.warnings);
}
Beispiel #3
0
void ImageBase::Draw(HDC hdc, RECT& rc, bool clip)
{
	HRGN hrgn = NULL;
	if (clip) {
		hrgn = CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
		SelectClipRgn(hdc, hrgn);
	}

	SIZE iSize;
	GetSize(iSize);

	const int sizeX = rc.right - rc.left;
	const int sizeY = rc.bottom - rc.top;

	const int x = rc.left + (sizeX > iSize.cx || clip ? (sizeX - iSize.cx) / 2 : 0);
	const int y = rc.top + (sizeY > iSize.cy || clip ? (sizeY - iSize.cy) / 2 : 0);

	const int scaleX = sizeX > iSize.cx || clip ? iSize.cx : sizeX;
	const int scaleY = sizeY > iSize.cy || clip ? iSize.cy : sizeY;

	DrawInternal(hdc, x, y, scaleX, scaleY);

	if (clip) {
		SelectClipRgn(hdc, NULL);
		DeleteObject(hrgn);
	}
}
Beispiel #4
0
	void RenderingContext::Draw( const std::shared_ptr<IMesh>& mesh )
	{
		if ( mesh == nullptr )
		{
			return;
		}

		RenderingDevice* pDevice = RenderingDevice::GetInstance();
		Assert( pDevice );
		Assert( m_inputAssembler );
		Assert( m_vertexShader );
		Assert( m_rasterizer );
		Assert( m_pixelShader );
		Assert( m_outputMerger );

		// Set a constant buffer for WVP transform.
		ConstantBuffer& cbuffer = GetSharedConstantBuffer();
		const Matrix4& w = cbuffer.GetMatrix4( ConstantBuffer::WorldMatrix );
		Matrix4 wv = w * pDevice->GetViewMatrix();
		Matrix4 wvp = wv * pDevice->GetProjectionMatrix();
		cbuffer.SetMatrix4( ConstantBuffer::WVPMatrix, wvp );

		// Draw primitives here.
		if ( mesh->GetPrimitiveType() == PrimitiveType::Undefined )
		{
			if ( const IrregularMesh* pMesh = dynamic_cast< const IrregularMesh* >( mesh.get() ) )
			{
				for ( size_t face = 0; face < pMesh->NumFaces(); ++face )
				{
					const unsigned char* color = pMesh->GetFaceColor( face );
					cbuffer.SetVector4( ConstantBuffer::DiffuseColor, Vector4( static_cast<byte>( color[0] / 255.0f ), 
																				static_cast<byte>( color[1] / 255.0f ), 
																				static_cast<byte>( color[2] / 255.0f ), 
																				static_cast<byte>( color[3] / 255.0f ) ) );

					m_inputAssembler->SetFaceIndex( face );
					SetCullMode( CullMode::None );
					DrawInternal( mesh, GetPrimitiveTypeFromNumberOfVertices( pMesh->NumVerticesInFace( face ) ) );
				}
			}
		}
		else
		{
			SetCullMode( CullMode::CCW );
			DrawInternal( mesh );
		}
	}
Beispiel #5
0
void CMeshOES2::Draw(CPrimList *pLists, int nLists)
{
    if (!(ShaderUtil()->OnDrawMesh(this, pLists, nLists)))
    {
        MarkAsDrawn();
        return;
    }
    DrawInternal(pLists, nLists);
}
Beispiel #6
0
void Critter::Draw() const {
  ofPushMatrix();
  ofTranslate(position);
  ofRotate(ofRadToDeg(orientation));
  ofPushStyle();
  if (food > 0) {
    ofEnableAlphaBlending();
    ofColor interior = interior_cell_color().getLerped(wall_cell_color(), (radius() - 10) / 10.0);
    ofSetColor(interior, 255 * food);
    ofFill();
    ofSetLineWidth(0);
    DrawInternal();
    ofDisableAlphaBlending();
  }
  ofColor membrane = membrane_color();
  membrane.setSaturation(255 * (1 - age * age * age));
  ofSetColor(membrane / (21.0 / radius()));
  ofNoFill();
  ofSetLineWidth(area * kLineWidthScaleFactor);
  DrawInternal();
  ofPopStyle();
  ofPopMatrix();
}
Beispiel #7
0
void
AirspaceRenderer::Draw(Canvas &canvas,
#ifndef ENABLE_OPENGL
                       Canvas &stencil_canvas,
#endif
                       const WindowProjection &projection,
                       const AirspaceRendererSettings &settings,
                       const AirspaceWarningCopy &awc,
                       const AirspacePredicate &visible)
{
  if (airspaces == nullptr || airspaces->IsEmpty())
    return;

  DrawInternal(canvas,
#ifndef ENABLE_OPENGL
               stencil_canvas,
#endif
               projection, settings, awc, visible);

  intersections = awc.GetLocations();
}
Beispiel #8
0
void CMeshOES2::Draw(int nFirstIndex, int nIndexCount)
{
    if (!(ShaderUtil()->OnDrawMesh(this, nFirstIndex, nIndexCount)))
    {
        MarkAsDrawn();
        return;
    }

    CPrimList primList;
    if (!nIndexCount || (nFirstIndex == -1))
    {
        primList.m_FirstIndex = 0;
        primList.m_NumIndices = m_NumIndices;
    }
    else
    {
        primList.m_FirstIndex = nFirstIndex;
        primList.m_NumIndices = nIndexCount;
    }
    DrawInternal(&primList, 1);
}
Beispiel #9
0
//------------------------------------------------------------------------------
void TreeDrawer::Draw ()
{
    NodeIterator <Node> n (t->GetRoot());
    Node *q = n.begin();
    while (q)
    {
    	if (q->IsLeaf ())
        {
        	DrawLeaf (q);
        }
        else
        {
			DrawInternal (q);
        }

        q = n.next();
    }
    if (rooted)
    {
    	DrawRoot ();
    }
}
Beispiel #10
0
RasterImage::Draw(gfxContext* aContext,
                  const IntSize& aSize,
                  const ImageRegion& aRegion,
                  uint32_t aWhichFrame,
                  SamplingFilter aSamplingFilter,
                  const Maybe<SVGImageContext>& /*aSVGContext - ignored*/,
                  uint32_t aFlags)
{
  if (aWhichFrame > FRAME_MAX_VALUE) {
    return DrawResult::BAD_ARGS;
  }

  if (mError) {
    return DrawResult::BAD_IMAGE;
  }

  // Illegal -- you can't draw with non-default decode flags.
  // (Disabling colorspace conversion might make sense to allow, but
  // we don't currently.)
  if (ToSurfaceFlags(aFlags) != DefaultSurfaceFlags()) {
    return DrawResult::BAD_ARGS;
  }

  if (!aContext) {
    return DrawResult::BAD_ARGS;
  }

  if (IsUnlocked() && mProgressTracker) {
    mProgressTracker->OnUnlockedDraw();
  }

  // If we're not using SamplingFilter::GOOD, we shouldn't high-quality scale or
  // downscale during decode.
  uint32_t flags = aSamplingFilter == SamplingFilter::GOOD
                 ? aFlags
                 : aFlags & ~FLAG_HIGH_QUALITY_SCALING;

  DrawableSurface surface =
    LookupFrame(aSize, flags, ToPlaybackType(aWhichFrame));
  if (!surface) {
    // Getting the frame (above) touches the image and kicks off decoding.
    if (mDrawStartTime.IsNull()) {
      mDrawStartTime = TimeStamp::Now();
    }
    return DrawResult::NOT_READY;
  }

  bool shouldRecordTelemetry = !mDrawStartTime.IsNull() &&
                               surface->IsFinished();

  auto result = DrawInternal(Move(surface), aContext, aSize,
                             aRegion, aSamplingFilter, flags);

  if (shouldRecordTelemetry) {
      TimeDuration drawLatency = TimeStamp::Now() - mDrawStartTime;
      Telemetry::Accumulate(Telemetry::IMAGE_DECODE_ON_DRAW_LATENCY,
                            int32_t(drawLatency.ToMicroseconds()));
      mDrawStartTime = TimeStamp();
  }

  return result;
}
void MLIFont::Draw(const string &s, Vector2 position, Color color, RectangleWH clipRect, double scale)
{
    DrawInternal(s, position, color, scale, clipRect);
}
void MLIFont::Draw(const string &s, Vector2 position, Color color, RectangleWH clipRect)
{
    DrawInternal(s, position, color, 1.0, clipRect);
}
void MLIFont::Draw(const string &s, Vector2 position, Color color, double scale)
{
    DrawInternal(s, position, color, scale, RectangleWH(0, 0, -1, -1));
}
void MLIFont::Draw(const string &s, Vector2 position, Color color)
{
    DrawInternal(s, position, color, 1.0, RectangleWH(0, 0, -1, -1));
}