/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkContext3D.cxx

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

#include "vtkContext3D.h"
#include "vtkContextDevice3D.h"
#include "vtkTransform.h"

#include "vtkObjectFactory.h"

#include <cassert>

vtkStandardNewMacro(vtkContext3D);

void vtkContext3D::PrintSelf(ostream& os, vtkIndent indent)
{
  Superclass::PrintSelf(os, indent);
  os << indent << "Context Device: ";
  if (this->Device)
  {
    os << endl;
    this->Device->PrintSelf(os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }
}

bool vtkContext3D::Begin(vtkContextDevice3D* device)
{
  if (this->Device == device)
  {
    return true;
  }
  this->Device = device;
  return true;
}

vtkContextDevice3D* vtkContext3D::GetDevice()
{
  return this->Device;
}

bool vtkContext3D::End()
{
  if (this->Device)
  {
    this->Device = nullptr;
  }
  return true;
}

void vtkContext3D::DrawLine(const vtkVector3f& start, const vtkVector3f& end)
{
  assert(this->Device);
  vtkVector3f line[2] = { start, end };
  this->Device->DrawPoly(line[0].GetData(), 2);
}

void vtkContext3D::DrawPoly(const float* points, int n)
{
  assert(this->Device);
  this->Device->DrawPoly(points, n);
}

void vtkContext3D::DrawPoint(const vtkVector3f& point)
{
  assert(this->Device);
  this->Device->DrawPoints(point.GetData(), 1);
}

void vtkContext3D::DrawPoints(const float* points, int n)
{
  assert(this->Device);
  this->Device->DrawPoints(points, n);
}

void vtkContext3D::DrawPoints(const float* points, int n, unsigned char* colors, int nc_comps)
{
  assert(this->Device);
  this->Device->DrawPoints(points, n, colors, nc_comps);
}

void vtkContext3D::DrawTriangleMesh(const float* mesh, int n, const unsigned char* colors, int nc)
{
  assert(this->Device);
  this->Device->DrawTriangleMesh(mesh, n, colors, nc);
}

void vtkContext3D::ApplyPen(vtkPen* pen)
{
  assert(this->Device);
  this->Device->ApplyPen(pen);
}

void vtkContext3D::ApplyBrush(vtkBrush* brush)
{
  assert(this->Device);
  this->Device->ApplyBrush(brush);
}

void vtkContext3D::SetTransform(vtkTransform* transform)
{
  if (transform)
  {
    this->Device->SetMatrix(transform->GetMatrix());
  }
}

vtkTransform* vtkContext3D::GetTransform()
{
  if (this->Device && this->Transform)
  {
    this->Device->GetMatrix(this->Transform->GetMatrix());
    return this->Transform;
  }
  return nullptr;
}

void vtkContext3D::AppendTransform(vtkTransform* transform)
{
  if (transform)
  {
    this->Device->MultiplyMatrix(transform->GetMatrix());
  }
}

void vtkContext3D::PushMatrix()
{
  this->Device->PushMatrix();
}

void vtkContext3D::PopMatrix()
{
  this->Device->PopMatrix();
}

void vtkContext3D::EnableClippingPlane(int i, double* planeEquation)
{
  assert(this->Device);
  this->Device->EnableClippingPlane(i, planeEquation);
}

void vtkContext3D::DisableClippingPlane(int i)
{
  assert(this->Device);
  this->Device->DisableClippingPlane(i);
}

vtkContext3D::vtkContext3D() = default;

vtkContext3D::~vtkContext3D() = default;
