Infinite Lines and the Axes

// Axes.h

#pragma once

#include "DirectXBase.h"

// This class represents a graph's axes as two perpendicular lines

class Axes {

     ID2D1SolidColorBrush* m_solidBrush; // Brush to draw with

     float m_lineThickness; // Thickness in pixels

     float m_opacity;      // Opacity, 0.0f is invisible 1.0f is solid

     D2D1::ColorF m_color;  // The color of the lines

public:

     // Public constructor

     Axes(D2D1::ColorF col, float thickness, float opacity);

     // Create the solid brush to draw with

     void CreateDeviceDependentResources

          (Microsoft::WRL::ComPtr<ID2D1DeviceContext> context);

     // The render method needs to know the panning and scaling

     void Render(Microsoft::WRL::ComPtr<ID2D1DeviceContext> context,

          float panX, float panY, float scaleX, float scaleY);

};

// Axes.cpp

#include "pch.h"

#include "Axes.h"

using namespace D2D1;

using namespace DirectX;

Axes::Axes(D2D1::ColorF col, float thickness = 3.0f, float opacity = 1.0f): m_color(0)

{

// Save these settings to member variables so

// they can create the brush later:

this->m_color = col;

this->m_lineThickness = thickness;

this->m_opacity = opacity;

}

void Axes::CreateDeviceDependentResources(

Microsoft::WRL::ComPtr<ID2D1DeviceContext> context){

// Create the solid color brush

DX::ThrowIfFailed(context->CreateSolidColorBrush(

     m_color, D2D1::BrushProperties(m_opacity), &m_solidBrush));

}

void Axes::Render(Microsoft::WRL::ComPtr<ID2D1DeviceContext> context, float panX, float panY, float scaleX, float scaleY) {

// Draw infinite vertical line with 0.0f as the x-coordinate

context->DrawLine(

     D2D1::Point2F(

          0.0f,   // Horizontal axis

          (-context->GetSize().height - panY) / scaleY // Top of the screen

          ),

     D2D1::Point2F(

          0.0f,   // Horizontal axis

          (-panY) / scaleY // Bottom of the screen

          ),

     m_solidBrush,

     m_lineThickness/scaleX);

// Draw infinite horizontal line with 0.0f as the y-coordinate

context->DrawLine(

     D2D1::Point2F(

          -(panX)/scaleX,  // Left side of screen

          0.0f     // Vertical axis

          ),

     D2D1::Point2F(

          (context->GetSize().width - panX)/scaleX, // Right side of screen

          0.0f     // Vertical axis

          ),

     m_solidBrush,

     m_lineThickness/scaleY);

}

//

// Additional headers for graph objects here

//

#include "GradientBackground.h"

#include "ScatterPlot.h"

#include "Axes.h"

private:

     // Global pan value for moving the chart with the mouse

     Windows::Foundation::Point m_pan;

     // Background

     GradientBackground *m_gradientBackground;

     // Axes

     Axes* m_axes;

     // Data

     ScatterPlot* m_scatterPlot;

GraphRenderer::GraphRenderer() {

// Create the gradient background:

D2D1_COLOR_F colors[] = {

     D2D1::ColorF(ColorF::PaleGoldenrod), D2D1::ColorF(ColorF::PaleTurquoise),

     D2D1::ColorF(0.7f, 0.7f, 1.0f, 1.0f) };

float stops[] = { 0.0f, 0.5f, 1.0f };

m_gradientBackground = new GradientBackground(colors, stops, 3);

// Create the scatter plot:

const int count = 25;

float* x = new float[count];

float* y = new float[count];

// Create random points to plot, these

// would usually be read from some data source:

for(int i = 0; i < count; i++) {

     x[i] = (float)((rand() % 2000) - 1000);

     y[i] = (float)((rand() % 1000) - 500);

     }

m_scatterPlot = new ScatterPlot(x, y, 10.0f, D2D1::ColorF::Chocolate, NodeShape::Circle, count);

delete[] x;

delete[] y;

// Create the Axes

m_axes = new Axes(D2D1::ColorF::Black, 5.0f, 0.75f);

}

void GraphRenderer::CreateDeviceResources() {

DirectXBase::CreateDeviceResources();

// Create the brush for the scatter plot:

m_scatterPlot->CreateDeviceDependentResources(m_d2dContext);

// Create the brush for the Axes

m_axes->CreateDeviceDependentResources(m_d2dContext);

}

void GraphRenderer::Render() {

m_d2dContext->BeginDraw();

// Clear to some color other than blank

m_d2dContext->Clear(D2D1::ColorF(ColorF::CornflowerBlue));

// Reset the transform matrix so our background does not pan

m_d2dContext->SetTransform(m_orientationTransform2D);

// Draw the background

m_gradientBackground->Render(m_d2dContext);

// The scale matrix inverts the y-axis

Matrix3x2F scale = Matrix3x2F::Scale(1.0f, -1.0f, D2D1::Point2F(0.0f, 0.0f));

// The pans added to the screen height so origin is at lower left

Matrix3x2F panMatrix = Matrix3x2F::Translation

     (m_pan.X, m_pan.Y + m_d2dContext->GetSize().height);

// Apply the scale and the pan

m_d2dContext->SetTransform(scale*panMatrix*m_orientationTransform2D);

// Draw the axes

m_axes->Render(m_d2dContext, m_pan.X, m_pan.Y, 1.0f, -1.0f);

//

// Draw objects here

//

m_scatterPlot->Render(m_d2dContext);

// Ignore D2DERR_RECREATE_TARGET error

HRESULT hr = m_d2dContext->EndDraw();

if (hr != D2DERR_RECREATE_TARGET) DX::ThrowIfFailed(hr);

}