/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#include "OdaCommon.h"

#include "SrTriangleRenderer.h"

namespace TriangleRendering
{
  OdSrTriangleRendererData::TriangleVertex::TriangleVertex() : x(0), y(0), u(0.0f), v(0.0f), w(1.0f) {}

  OdSrTriangleRendererData::TriangleVertex::TriangleVertex(OdInt32 _x, OdInt32 _y, float _u, float _v, float _w)
      : x(_x), y(_y), u(_u), v(_v), w(_w) {}

  OdSrTriangleRendererData::TriangleVertex::TriangleVertex(OdInt32 _x, OdInt32 _y, const OdGePoint3d& pt)
      : x(_x), y(_y), u((float)pt.x), v((float)pt.y), w((float)pt.z) {}

  OdSrTriangleRendererData::RenderSettings OdSrTriangleRendererData::RenderSettings::Wrapped(OdUInt8 _alpha)
  {
    RenderSettings settings;
    settings.wrapTexture = true;
    settings.alpha = _alpha;
    return settings;
  }

  OdSrTriangleRendererData::RenderSettings OdSrTriangleRendererData::RenderSettings::FastRender(bool _wrap, OdUInt8 _alpha)
  {
    RenderSettings settings;
    settings.wrapTexture = _wrap;
    settings.alpha = _alpha;
    settings.qualityMode = RenderQuality::Low;
    return settings;
  }

  OdSrTriangleRendererData::DepthBuffer::DepthBuffer(OdUInt32 w, OdUInt32 h, OdUInt8* sl, OdUInt32 len)
      : width(w), height(h), scanLines(sl), scanLineLength(len) {}

  OdSrTriangleRendererData::ClipRegion::ClipRegion(const OdGsDCRect& rect)
      : clipRect(rect) {}
  void OdSrTriangleRendererData::ClipRegion::resetMask()
  {
    clipMask = nullptr;
  }

  // =========== RendererData Implementation ===========

  OdSrTriangleRendererData::OdSrTriangleRendererData(const OdSrZClipper::ZClipPlanes& zClipPlanes)
      : m_ZClipPlanes(zClipPlanes)
  {
    setRenderSettings(true, false, 255);
  }
  OdSrTriangleRendererData& OdSrTriangleRendererData::setFrameBuffer(OdUInt32 width, OdUInt32 height, OdUInt8* scanLines, OdUInt32 scanLineLength)
  {
    m_frameBuffer = FrameBuffer();
    m_frameBuffer.setData(scanLines, scanLineLength, width, height);
    m_frameBuffer.setFormat(TextureFormat::BPP24, TextureFormat::BGR, nullptr, TextureFormat::TransparencyMode::None);
    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::setFrameFormat(TextureFormat::BitsPerPixel bpp,
                                                                     TextureFormat::ColorOrder order,
                                                                     ODCOLORREF* pColorPalette,
                                                                     TextureFormat::TransparencyMode transparency)
  {
    m_frameBuffer.setFormat(bpp, order, pColorPalette, transparency);
    return *this;
  }
  OdSrTriangleRendererData& OdSrTriangleRendererData::setTextureBuffer(OdUInt32 width, OdUInt32 height, OdUInt8* scanLines, OdUInt32 scanLineLength)
  {
    m_textureBuffer = TextureBuffer();
    m_textureBuffer.setData(scanLines, scanLineLength, width, height);
    return *this;
  }
  OdSrTriangleRendererData& OdSrTriangleRendererData::setTextureFormat(TextureFormat::BitsPerPixel bpp,
                                                                       TextureFormat::ColorOrder order,
                                                                       ODCOLORREF* pColorPalette,
                                                                       TextureFormat::TransparencyMode transparency)
  {
    m_textureBuffer.setFormat(bpp, order, pColorPalette, transparency);
    return *this;
  }
  OdSrTriangleRendererData& OdSrTriangleRendererData::setTextureParams(const OdSrTextureParams& params)
  {
    TextureFormat::BitsPerPixel bpp = (TextureFormat::BitsPerPixel)params.rasterBitDepth;
    TextureFormat::ColorOrder order = params.bRasterRGB ? TextureFormat::ColorOrder::RGB : TextureFormat::ColorOrder::BGR;
    m_pRasterPalette = params.pRasterPalette;

    TextureFormat::TransparencyMode transparency;

    if (params.bRasterTransparency)
      transparency = TextureFormat::TransparencyMode::None;
    else
      transparency = params.raster32TranspMode == OdSrTextureParams::RasterImage32TransparencyType::kRI32TTDef ? TextureFormat::TransparencyMode::Default
                     : params.raster32TranspMode == OdSrTextureParams::RasterImage32TransparencyType::kRI32TT1 ? TextureFormat::TransparencyMode::OneBit
                     : params.raster32TranspMode == OdSrTextureParams::RasterImage32TransparencyType::kRI32TT8 ? TextureFormat::TransparencyMode::EightBit
                                                                                                               : TextureFormat::TransparencyMode::None;
    m_textureBuffer.setFormat(bpp, order, params.pRasterPalette, transparency);
    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::resetTextureBuffer()
  {
    m_textureBuffer.reset();
    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::setColorBuffer(const ODCOLORREF* pColors, OdUInt32 colorsLength)
  {
    ODA_ASSERT(colorsLength <= 3);

    m_externalColorBuffer = pColors; // Just point to external data
    m_colorBufferLength = colorsLength;
    m_useExternalBuffer = true;

    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::applyFadingToColorBuffer(const ODCOLORREF* pColors,
                                                                               OdUInt32 colorsLength,
                                                                               ODCOLORREF fadeColor,
                                                                               OdUInt8 fadingValue)
  {
    ODA_ASSERT(colorsLength <= 3);

    // Copy and apply fading to a local buffer
    for (OdUInt32 i = 0; i < colorsLength; ++i)
    {
      ODCOLORREF originalColor = pColors[i];
      m_triangleColorBuffer[i] = (ODGETALPHA(originalColor) << 24) |
                                 ::OdMergeRGBAlpha(fadeColor, originalColor & 0x00FFFFFF, fadingValue);
    }

    m_colorBufferLength = colorsLength;
    m_useExternalBuffer = false;

    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::setDepthBuffer(OdUInt32 width, OdUInt32 height, OdUInt8* scanLines, OdUInt32 scanLineLength)
  {
    m_depthBuffer = DepthBuffer(width, height, scanLines, scanLineLength);
    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::setTextureTransform(const OdSrTextureTransform& transform)
  {
    m_textureTransform = transform;
    return *this;
  }
  OdSrTriangleRendererData& OdSrTriangleRendererData::setPixelFormat(const OdGiRasterImage::PixelFormatInfo& pixelFormat)
  {
    m_pixelFormat = pixelFormat;
    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::setRasterPalette(OdUInt32* palette)
  {
    m_pRasterPalette = palette;
    return *this;
  }

  OdSrTriangleRendererData& OdSrTriangleRendererData::setRenderSettings(bool wrap, bool noTransform, OdUInt8 alpha)
  {
    OdSrTriangleRendererData::RenderSettings settings;
    settings.wrapTexture = wrap;
    settings.skipTransform = noTransform;
    settings.alpha = alpha;
    return *this;
  }

  OdSrTriangleRendererData::FrameBuffer& OdSrTriangleRendererData::frameBuffer()
  {
    return m_frameBuffer;
  }

  const OdSrTriangleRendererData::FrameBuffer& OdSrTriangleRendererData::frameBuffer() const
  {
    return m_frameBuffer;
  }

  const OdSrTriangleRendererData::TextureBuffer& OdSrTriangleRendererData::textureBuffer() const
  {
    return m_textureBuffer;
  }

  //should be changed from renderer
  const OdSrTriangleRendererData::DepthBuffer& OdSrTriangleRendererData::depthBuffer() const
  {
    return m_depthBuffer;
  }

  const ODCOLORREF* OdSrTriangleRendererData::triangleColorBuffer(OdUInt32& colorBufferLength) const
  {
    colorBufferLength = m_colorBufferLength;
    return m_useExternalBuffer ? m_externalColorBuffer : m_triangleColorBuffer;
  }

  OdSrTriangleRendererData::ClipRegion& OdSrTriangleRendererData::clipRegion()
  {
    return m_clipRegion;
  }
  const OdSrTriangleRendererData::ClipRegion& OdSrTriangleRendererData::clipRegion() const
  {
    return m_clipRegion;
  }

  const OdSrZClipper::ZClipPlanes& OdSrTriangleRendererData::zClipPlanes() const
  {
    return m_ZClipPlanes;
  }

  const OdSrTextureTransform& OdSrTriangleRendererData::textureTransform() const
  {
    return m_textureTransform;
  }

  const OdGiRasterImage::PixelFormatInfo& OdSrTriangleRendererData::pixelFormat() const
  {
    return m_pixelFormat;
  }

  const OdSrTriangleRendererData::RenderSettings& OdSrTriangleRendererData::renderSettings() const
  {
    return m_renderSettings;
  }

  ODCOLORREF* OdSrTriangleRendererData::rasterPalette() const
  {
    return m_pRasterPalette;
  }
};