/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2024, 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-2024 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 "DbStdAfx.h"
#include "DbVisualizeRTRenderSettings.h"

const int OdDbVisualizeRTRenderSettings::lastKnownVersion = 1;
ODRX_DXF_DEFINE_MEMBERS(OdDbVisualizeRTRenderSettings, OdDbRenderSettings, DBOBJECT_CONSTR, OdDb::vAC24, OdDb::kMRelease0,
                        OdDbProxyEntity::kAllAllowedBits, ExVisualizeRTRenderSettings, VisualizeRT | Description: ODA SDK Run-time Extension Example)

OdDbVisualizeRTRenderSettings::OdDbVisualizeRTRenderSettings()
{}
OdDbVisualizeRTRenderSettings::~OdDbVisualizeRTRenderSettings()
{}

int OdDbVisualizeRTRenderSettings::getVersion()
{
  return lastKnownVersion;
}

void OdDbVisualizeRTRenderSettings::setRendererType(OdGiVisualizeRTRenderSettingsTraits::RendererType renderType)
{
  assertWriteEnabled();
  m_rtData.setRendererType(renderType);
}
OdGiVisualizeRTRenderSettingsTraits::RendererType OdDbVisualizeRTRenderSettings::rendererType() const
{
  assertReadEnabled();
  return m_rtData.rendererType();
}

void OdDbVisualizeRTRenderSettings::setRenderQuality(OdGiVisualizeRTRenderSettingsTraits::QualityLevel renderQual)
{
  assertWriteEnabled();
  m_rtData.setRenderQuality(renderQual);
}
OdGiVisualizeRTRenderSettingsTraits::QualityLevel OdDbVisualizeRTRenderSettings::renderQuality() const
{
  assertReadEnabled();
  return m_rtData.renderQuality();
}

void OdDbVisualizeRTRenderSettings::setDefaultShader(OdGiVisualizeRTRenderSettingsTraits::DefaultShader shader)
{
  assertWriteEnabled();
  m_rtData.setDefaultShader(shader);
}
OdGiVisualizeRTRenderSettingsTraits::DefaultShader OdDbVisualizeRTRenderSettings::defaultShader() const
{
  assertReadEnabled();
  return m_rtData.defaultShader();
}

void OdDbVisualizeRTRenderSettings::setTextureQuality(OdGiVisualizeRTRenderSettingsTraits::TextureQuality texQlty)
{
  assertWriteEnabled();
  m_rtData.setTextureQuality(texQlty);
}
OdGiVisualizeRTRenderSettingsTraits::TextureQuality OdDbVisualizeRTRenderSettings::textureQuality() const
{
  assertReadEnabled();
  return m_rtData.textureQuality();
}

void OdDbVisualizeRTRenderSettings::setPixelSamples(OdInt32 nX, OdInt32 nY)
{
  if (nX < 1 || nY < 1 || nX > 16 || nY > 16)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setPixelSamples(nX, nY);
}
void OdDbVisualizeRTRenderSettings::pixelSamples(OdInt32 &nX, OdInt32 &nY) const
{
  assertReadEnabled();
  m_rtData.pixelSamples(nX, nY);
}

void OdDbVisualizeRTRenderSettings::setMaxBounces(OdUInt32 nBounces)
{
  if (nBounces < 1 || nBounces > 32000)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMaxBounces(nBounces);
}
OdUInt32 OdDbVisualizeRTRenderSettings::maxBounces() const
{
  assertReadEnabled();
  return m_rtData.maxBounces();
}

void OdDbVisualizeRTRenderSettings::setMaxSelfReflections(OdUInt32 nRels)
{
  if (nRels < 1 || nRels > 32000)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMaxSelfReflections(nRels);
}
OdUInt32 OdDbVisualizeRTRenderSettings::maxSelfReflections() const
{
  assertReadEnabled();
  return m_rtData.maxSelfReflections();
}

void OdDbVisualizeRTRenderSettings::setMaxSelfRefractions(OdUInt32 nRefs)
{
  if (nRefs < 1 || nRefs > 32000)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMaxSelfRefractions(nRefs);
}
OdUInt32 OdDbVisualizeRTRenderSettings::maxSelfRefractions() const
{
  assertReadEnabled();
  return m_rtData.maxSelfRefractions();
}

void OdDbVisualizeRTRenderSettings::setGeometryAccelerator(OdGiVisualizeRTRenderSettingsTraits::AcceleratorType treeType,
                                                           OdGiVisualizeRTRenderSettingsTraits::SplitMethod splitMode,
                                                           OdUInt32 nMaxLeafPrims, OdUInt32 nNodeDepth, bool bSort)
{
  if (nMaxLeafPrims < 1 || nMaxLeafPrims > 32000 || nNodeDepth < 1 || nNodeDepth > 256)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGeometryAccelerator(treeType, splitMode, nMaxLeafPrims, nNodeDepth, bSort);
}
void OdDbVisualizeRTRenderSettings::geometryAccelerator(OdGiVisualizeRTRenderSettingsTraits::AcceleratorType &treeType,
                                                        OdGiVisualizeRTRenderSettingsTraits::SplitMethod &splitMode,
                                                        OdUInt32 &nMaxLeafPrims, OdUInt32 &nNodeDepth, bool &bSort) const
{
  assertReadEnabled();
  m_rtData.geometryAccelerator(treeType, splitMode, nMaxLeafPrims, nNodeDepth, bSort);
}

void OdDbVisualizeRTRenderSettings::setPrimitiveAccelerator(OdGiVisualizeRTRenderSettingsTraits::AcceleratorType treeType,
                                                            OdGiVisualizeRTRenderSettingsTraits::SplitMethod splitMode,
                                                            OdUInt32 nMaxLeafPrims, OdUInt32 nNodeDepth, bool bSort)
{
  if (nMaxLeafPrims < 1 || nMaxLeafPrims > 32000 || nNodeDepth < 1 || nNodeDepth > 256)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setPrimitiveAccelerator(treeType, splitMode, nMaxLeafPrims, nNodeDepth, bSort);
}
void OdDbVisualizeRTRenderSettings::primitiveAccelerator(OdGiVisualizeRTRenderSettingsTraits::AcceleratorType &treeType,
                                                         OdGiVisualizeRTRenderSettingsTraits::SplitMethod &splitMode,
                                                         OdUInt32 &nMaxLeafPrims, OdUInt32 &nNodeDepth, bool &bSort) const
{
  assertReadEnabled();
  m_rtData.primitiveAccelerator(treeType, splitMode, nMaxLeafPrims, nNodeDepth, bSort);
}

void OdDbVisualizeRTRenderSettings::setToleranceOverride(bool bOverride, float fTol, double dTol)
{
  if (fTol <= 0.0f || dTol <= 0.0)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setToleranceOverride(bOverride, fTol, dTol);
}
bool OdDbVisualizeRTRenderSettings::toleranceOverride(float &fTol, double &dTol) const
{
  assertReadEnabled();
  return m_rtData.toleranceOverride(fTol, dTol);
}

void OdDbVisualizeRTRenderSettings::setMinEnergy(float fEnergy)
{
  if (fEnergy < 0.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMinEnergy(fEnergy);

}
float OdDbVisualizeRTRenderSettings::minEnergy() const
{
  assertReadEnabled();
  return m_rtData.minEnergy();
}

void OdDbVisualizeRTRenderSettings::setLinePrimitivesEnabled(bool bEnable, float fWidth)
{
  if (fWidth <= 0.0f || fWidth > 64.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setLinePrimitivesEnabled(bEnable, fWidth);
}
bool OdDbVisualizeRTRenderSettings::linePrimitivesEnabled(float &fWidth) const
{
  assertReadEnabled();
  return m_rtData.linePrimitivesEnabled(fWidth);
}

void OdDbVisualizeRTRenderSettings::setMaxCPUThreads(OdUInt32 nThreads)
{
  if (nThreads > 256)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMaxCPUThreads(nThreads);
}
OdUInt32 OdDbVisualizeRTRenderSettings::maxCPUThreads() const
{
  assertReadEnabled();
  return m_rtData.maxCPUThreads();
}

void OdDbVisualizeRTRenderSettings::setTileSize(OdUInt32 nWidth, OdUInt32 nHeight)
{
  if (nWidth < 1 || nWidth > 16000 || nHeight < 1 || nHeight > 16000)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setTileSize(nWidth, nHeight);
}
void OdDbVisualizeRTRenderSettings::tileSize(OdUInt32 &nWidth, OdUInt32 &nHeight) const
{
  assertReadEnabled();
  return m_rtData.tileSize(nWidth, nHeight);
}

void OdDbVisualizeRTRenderSettings::setTileOrder(OdGiMrTileOrder order)
{
  assertWriteEnabled();
  m_rtData.setTileOrder(order);
}
OdGiMrTileOrder OdDbVisualizeRTRenderSettings::tileOrder() const
{
  assertReadEnabled();
  return m_rtData.tileOrder();
}

void OdDbVisualizeRTRenderSettings::setMaxGPUBufferSubdivisions(OdUInt32 nSubdivs)
{
  if (nSubdivs < 1 || nSubdivs > 4)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMaxGPUBufferSubdivisions(nSubdivs);
}
OdUInt32 OdDbVisualizeRTRenderSettings::maxGPUBufferSubdivisions() const
{
  assertReadEnabled();
  return m_rtData.maxGPUBufferSubdivisions();
}

void OdDbVisualizeRTRenderSettings::setMinGPUBufferSubdivisionSize(OdUInt32 nWidth, OdUInt32 nHeight)
{
  if (nWidth < 1 || nWidth > 16000 || nHeight < 1 || nHeight > 16000)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMinGPUBufferSubdivisionSize(nWidth, nHeight);
}
void OdDbVisualizeRTRenderSettings::minGPUBufferSubdivisionSize(OdUInt32 &nWidth, OdUInt32 &nHeight) const
{
  assertReadEnabled();
  m_rtData.minGPUBufferSubdivisionSize(nWidth, nHeight);
}

void OdDbVisualizeRTRenderSettings::setGPUBufferScalePercents(OdUInt32 nPercs)
{
  if (nPercs < 1 || nPercs > 16000)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGPUBufferScalePercents(nPercs);
}
OdUInt32 OdDbVisualizeRTRenderSettings::gpuBufferScalePercents() const
{
  assertReadEnabled();
  return m_rtData.gpuBufferScalePercents();
}

void OdDbVisualizeRTRenderSettings::setGPUWorkGroupSize(OdUInt32 nThreads)
{
  if (nThreads < 1 || nThreads > 2048)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGPUWorkGroupSize(nThreads);
}
OdUInt32 OdDbVisualizeRTRenderSettings::gpuWorkGroupSize() const
{
  assertReadEnabled();
  return m_rtData.gpuWorkGroupSize();
}

void OdDbVisualizeRTRenderSettings::setGPUTiledRendering(bool bEnable)
{
  assertWriteEnabled();
  m_rtData.setGPUTiledRendering(bEnable);
}
bool OdDbVisualizeRTRenderSettings::gpuTiledRendering() const
{
  assertReadEnabled();
  return m_rtData.gpuTiledRendering();
}

void OdDbVisualizeRTRenderSettings::setGPUForceShadowMapsInsideReflections(bool bEnable)
{
  assertWriteEnabled();
  m_rtData.setGPUForceShadowMapsInsideReflections(bEnable);
}
bool OdDbVisualizeRTRenderSettings::gpuForceShadowMapsInsideReflections() const
{
  assertReadEnabled();
  return m_rtData.gpuForceShadowMapsInsideReflections();
}

void OdDbVisualizeRTRenderSettings::setPartialRenderComponents(OdUInt32 nComponents)
{
  if (GETBIT(nComponents, ~OdGiVisualizeRTRenderSettingsTraits::kAllRenderComponents))
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setPartialRenderComponents(nComponents);
}
OdUInt32 OdDbVisualizeRTRenderSettings::partialRenderComponents() const
{
  assertReadEnabled();
  return m_rtData.partialRenderComponents();
}

void OdDbVisualizeRTRenderSettings::setMinimalReflectionCutoff(float refCutoff)
{
  if (refCutoff < 0.0f || refCutoff > 1.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMinimalReflectionCutoff(refCutoff);
}
float OdDbVisualizeRTRenderSettings::minimalReflectionCutoff() const
{
  assertReadEnabled();
  return m_rtData.minimalReflectionCutoff();
}

void OdDbVisualizeRTRenderSettings::setMinimalRefractionCutoff(float refCutoff)
{
  if (refCutoff < 1.0f || refCutoff > 4.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMinimalRefractionCutoff(refCutoff);
}
float OdDbVisualizeRTRenderSettings::minimalRefractionCutoff() const
{
  assertReadEnabled();
  return m_rtData.minimalRefractionCutoff();
}

void OdDbVisualizeRTRenderSettings::setMinimalLightingCutoff(float lightCutoff)
{
  if (lightCutoff < 0.0f || lightCutoff > 1.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setMinimalLightingCutoff(lightCutoff);
}
float OdDbVisualizeRTRenderSettings::minimalLightingCutoff() const
{
  assertReadEnabled();
  return m_rtData.minimalLightingCutoff();
}

void OdDbVisualizeRTRenderSettings::setShadowTypeOverride(OdGiVisualizeRTRenderSettingsTraits::ShadowTypeOverride shadowType)
{
  assertWriteEnabled();
  m_rtData.setShadowTypeOverride(shadowType);
}
OdGiVisualizeRTRenderSettingsTraits::ShadowTypeOverride OdDbVisualizeRTRenderSettings::shadowTypeOverride() const
{
  assertReadEnabled();
  return m_rtData.shadowTypeOverride();
}

void OdDbVisualizeRTRenderSettings::setGlobalIlluminationEnabled(bool bSet)
{
  assertWriteEnabled();
  m_rtData.setGlobalIlluminationEnabled(bSet);
}
bool OdDbVisualizeRTRenderSettings::globalIlluminationEnabled() const
{
  assertReadEnabled();
  return m_rtData.globalIlluminationEnabled();
}

void OdDbVisualizeRTRenderSettings::setGlobalIlluminationSamples(OdInt32 nX, OdInt32 nY)
{
  if (nX < 1 || nY < 1 || nX > 16 || nY > 16)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGlobalIlluminationSamples(nX, nY);
}
void OdDbVisualizeRTRenderSettings::globalIlluminationSamples(OdInt32 &nX, OdInt32 &nY) const
{
  assertReadEnabled();
  m_rtData.globalIlluminationSamples(nX, nY);
}

void OdDbVisualizeRTRenderSettings::setGlobalIlluminationRadius(float fRad)
{
  if (fRad <= 0.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGlobalIlluminationRadius(fRad);
}
float OdDbVisualizeRTRenderSettings::globalIlluminationRadius() const
{
  assertReadEnabled();
  return m_rtData.globalIlluminationRadius();
}

void OdDbVisualizeRTRenderSettings::setGlobalIlluminationAutoRadiusEnabled(bool bSet)
{
  assertWriteEnabled();
  m_rtData.setGlobalIlluminationAutoRadiusEnabled(bSet);
}
bool OdDbVisualizeRTRenderSettings::globalIlluminationAutoRadiusEnabled() const
{
  assertReadEnabled();
  return m_rtData.globalIlluminationAutoRadiusEnabled();
}

void OdDbVisualizeRTRenderSettings::setGlobalIlluminationAutoRadiusPercents(float fPerc)
{
  if (fPerc <= 0.0f || fPerc > 2.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGlobalIlluminationAutoRadiusPercents(fPerc);
}
float OdDbVisualizeRTRenderSettings::globalIlluminationAutoRadiusPercents() const
{
  assertReadEnabled();
  return m_rtData.globalIlluminationAutoRadiusPercents();
}

void OdDbVisualizeRTRenderSettings::setGlobalIlluminationOcclusionCoefficient(float fCoef)
{
  if (fCoef < 0.0f || fCoef > 1.0f)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setGlobalIlluminationOcclusionCoefficient(fCoef);
}
float OdDbVisualizeRTRenderSettings::globalIlluminationOcclusionCoefficient() const
{
  assertReadEnabled();
  return m_rtData.globalIlluminationOcclusionCoefficient();
}

void OdDbVisualizeRTRenderSettings::setRoughnessSamples(OdInt32 nX, OdInt32 nY)
{
  if (nX < 1 || nY < 1 || nX > 16 || nY > 16)
    throw OdError(eOutOfRange);
  assertWriteEnabled();
  m_rtData.setRoughnessSamples(nX, nY);
}
void OdDbVisualizeRTRenderSettings::roughnessSamples(OdInt32 &nX, OdInt32 &nY) const
{
  assertReadEnabled();
  m_rtData.roughnessSamples(nX, nY);
}

class OdDbVisualizeRTRenderSettingsIO
{
  protected:
    OdGiVisualizeRTRenderSettingsTraitsData &m_rtData;
  protected:
    virtual bool rdBool() = 0;
    virtual OdInt16 rdInt16() = 0;
    virtual OdInt32 rdInt32() = 0;
    virtual double rdDouble() = 0;
    virtual void wrBool(bool bVal) = 0;
    virtual void wrInt16(OdInt16 iVal) = 0;
    virtual void wrInt32(OdInt32 iVal) = 0;
    virtual void wrDouble(double dVal) = 0;
  public:
    OdDbVisualizeRTRenderSettingsIO(const OdGiVisualizeRTRenderSettingsTraitsData &rtData)
      : m_rtData(const_cast<OdGiVisualizeRTRenderSettingsTraitsData&>(rtData)) { }

    void inFields()
    {
      m_rtData.setRendererType((OdGiVisualizeRTRenderSettingsTraits::RendererType)rdInt16());
      m_rtData.setRenderQuality((OdGiVisualizeRTRenderSettingsTraits::QualityLevel)rdInt16());
      m_rtData.setDefaultShader((OdGiVisualizeRTRenderSettingsTraits::DefaultShader)rdInt16());
      m_rtData.setTextureQuality((OdGiVisualizeRTRenderSettingsTraits::TextureQuality)rdInt16());
      OdInt32 nX = rdInt32();
      m_rtData.setPixelSamples(nX, rdInt32());
      m_rtData.setMaxBounces((OdUInt32)rdInt32());
      m_rtData.setMaxSelfReflections((OdUInt32)rdInt32());
      m_rtData.setMaxSelfRefractions((OdUInt32)rdInt32());
      { const OdUInt16 treeType = (OdUInt16)rdInt16();
        const OdUInt16 splitMode = (OdUInt16)rdInt16();
        const OdUInt32 maxLeafPrims = (OdUInt32)rdInt32();
        const OdUInt32 nodeDepth = (OdUInt32)rdInt32();
        m_rtData.setGeometryAccelerator((OdGiVisualizeRTRenderSettingsTraits::AcceleratorType)treeType,
                                        (OdGiVisualizeRTRenderSettingsTraits::SplitMethod)splitMode,
                                        maxLeafPrims, nodeDepth, rdBool());
      }
      { const OdUInt16 treeType = (OdUInt16)rdInt16();
        const OdUInt16 splitMode = (OdUInt16)rdInt16();
        const OdUInt32 maxLeafPrims = (OdUInt32)rdInt32();
        const OdUInt32 nodeDepth = (OdUInt32)rdInt32();
        m_rtData.setPrimitiveAccelerator((OdGiVisualizeRTRenderSettingsTraits::AcceleratorType)treeType,
                                         (OdGiVisualizeRTRenderSettingsTraits::SplitMethod)splitMode,
                                         maxLeafPrims, nodeDepth, rdBool());
      }
      { const bool bVal = rdBool();
        const float fTol = (float)rdDouble();
        m_rtData.setToleranceOverride(bVal, fTol, rdDouble());
      }
      m_rtData.setMinEnergy((float)rdDouble());
      { const bool bVal = rdBool();
        m_rtData.setLinePrimitivesEnabled(bVal, (float)rdDouble());
      }
      m_rtData.setMaxCPUThreads((OdUInt32)rdInt32());
      nX = rdInt32();
      m_rtData.setTileSize((OdUInt32)nX, (OdUInt32)rdInt32());
      m_rtData.setTileOrder((OdGiMrTileOrder)rdInt16());
      m_rtData.setMaxGPUBufferSubdivisions((OdUInt32)rdInt32());
      nX = rdInt32();
      m_rtData.setMinGPUBufferSubdivisionSize((OdUInt32)nX, (OdUInt32)rdInt32());
      m_rtData.setGPUBufferScalePercents((OdUInt32)rdInt32());
      m_rtData.setGPUWorkGroupSize((OdUInt32)rdInt32());
      m_rtData.setGPUTiledRendering(rdBool());
      m_rtData.setGPUForceShadowMapsInsideReflections(rdBool());
      m_rtData.setPartialRenderComponents((OdUInt32)rdInt32());
      m_rtData.setMinimalReflectionCutoff((float)rdDouble());
      m_rtData.setMinimalRefractionCutoff((float)rdDouble());
      m_rtData.setMinimalLightingCutoff((float)rdDouble());
      m_rtData.setShadowTypeOverride((OdGiVisualizeRTRenderSettingsTraits::ShadowTypeOverride)rdInt16());
      m_rtData.setGlobalIlluminationEnabled(rdBool());
      nX = rdInt32();
      m_rtData.setGlobalIlluminationSamples(nX, rdInt32());
      m_rtData.setGlobalIlluminationRadius((float)rdDouble());
      m_rtData.setGlobalIlluminationAutoRadiusEnabled(rdBool());
      m_rtData.setGlobalIlluminationAutoRadiusPercents((float)rdDouble());
      m_rtData.setGlobalIlluminationOcclusionCoefficient((float)rdDouble());
      nX = rdInt32();
      m_rtData.setRoughnessSamples(nX, rdInt32());
    }
    void outFields()
    { OdInt32 nX, nY; OdUInt32 nWidth, nHeight; float fVal;
      wrInt16((OdInt16)m_rtData.rendererType());
      wrInt16((OdInt16)m_rtData.renderQuality());
      wrInt16((OdInt16)m_rtData.defaultShader());
      wrInt16((OdInt16)m_rtData.textureQuality());
      m_rtData.pixelSamples(nX, nY);
      wrInt32(nX); wrInt32(nY);
      wrInt32((OdInt32)m_rtData.maxBounces());
      wrInt32((OdInt32)m_rtData.maxSelfReflections());
      wrInt32((OdInt32)m_rtData.maxSelfRefractions());
      { OdGiVisualizeRTRenderSettingsTraits::AcceleratorType treeType;
        OdGiVisualizeRTRenderSettingsTraits::SplitMethod splitMode;
        OdUInt32 maxLeafPrims, nodeDepth; bool bVal;
        m_rtData.geometryAccelerator(treeType, splitMode, maxLeafPrims, nodeDepth, bVal);
        wrInt16((OdInt16)treeType); wrInt16((OdInt16)splitMode);
        wrInt32((OdInt32)maxLeafPrims); wrInt32((OdInt32)nodeDepth);
        wrBool(bVal);
      }
      { OdGiVisualizeRTRenderSettingsTraits::AcceleratorType treeType;
        OdGiVisualizeRTRenderSettingsTraits::SplitMethod splitMode;
        OdUInt32 maxLeafPrims, nodeDepth; bool bVal;
        m_rtData.primitiveAccelerator(treeType, splitMode, maxLeafPrims, nodeDepth, bVal);
        wrInt16((OdInt16)treeType); wrInt16((OdInt16)splitMode);
        wrInt32((OdInt32)maxLeafPrims); wrInt32((OdInt32)nodeDepth);
        wrBool(bVal);
      }
      { float fTol; double dTol;
        wrBool(m_rtData.toleranceOverride(fTol, dTol));
        wrDouble(fTol); wrDouble(dTol);
      }
      wrDouble(m_rtData.minEnergy());
      wrBool(m_rtData.linePrimitivesEnabled(fVal));
      wrDouble(fVal);
      wrInt32(m_rtData.maxCPUThreads());
      m_rtData.tileSize(nWidth, nHeight);
      wrInt32((OdInt32)nWidth); wrInt32((OdInt32)nHeight);
      wrInt16((OdInt16)m_rtData.tileOrder());
      wrInt32((OdInt32)m_rtData.maxGPUBufferSubdivisions());
      m_rtData.minGPUBufferSubdivisionSize(nWidth, nHeight);
      wrInt32((OdInt32)nWidth); wrInt32((OdInt32)nHeight);
      wrInt32((OdInt32)m_rtData.gpuBufferScalePercents());
      wrInt32((OdInt32)m_rtData.gpuWorkGroupSize());
      wrBool(m_rtData.gpuTiledRendering());
      wrBool(m_rtData.gpuForceShadowMapsInsideReflections());
      wrInt32((OdInt32)m_rtData.partialRenderComponents());
      wrDouble(m_rtData.minimalReflectionCutoff());
      wrDouble(m_rtData.minimalRefractionCutoff());
      wrDouble(m_rtData.minimalLightingCutoff());
      wrInt16((OdInt16)m_rtData.shadowTypeOverride());
      wrBool(m_rtData.globalIlluminationEnabled());
      m_rtData.globalIlluminationSamples(nX, nY);
      wrInt32(nX); wrInt32(nY);
      wrDouble(m_rtData.globalIlluminationRadius());
      wrBool(m_rtData.globalIlluminationAutoRadiusEnabled());
      wrDouble(m_rtData.globalIlluminationAutoRadiusPercents());
      wrDouble(m_rtData.globalIlluminationOcclusionCoefficient());
      m_rtData.roughnessSamples(nX, nY);
      wrInt32(nX); wrInt32(nY);
    }
};

class OdDbVisualizeRTRenderSettingsIO_dwg : public OdDbVisualizeRTRenderSettingsIO
{
  protected:
    OdDbDwgFiler *m_pFiler;
  protected:
    virtual bool rdBool() { return m_pFiler->rdBool(); }
    virtual OdInt16 rdInt16() { return m_pFiler->rdInt16(); }
    virtual OdInt32 rdInt32() { return m_pFiler->rdInt32(); }
    virtual double rdDouble() { return m_pFiler->rdDouble(); }
    virtual void wrBool(bool bVal) { m_pFiler->wrBool(bVal); }
    virtual void wrInt16(OdInt16 iVal) { m_pFiler->wrInt16(iVal); }
    virtual void wrInt32(OdInt32 iVal) { m_pFiler->wrInt32(iVal); }
    virtual void wrDouble(double dVal) { m_pFiler->wrDouble(dVal); }
  public:
    OdDbVisualizeRTRenderSettingsIO_dwg(OdDbDwgFiler *pFiler, const OdGiVisualizeRTRenderSettingsTraitsData &rtData)
      : OdDbVisualizeRTRenderSettingsIO(rtData), m_pFiler(pFiler) { }
};

class OdDbVisualizeRTRenderSettingsIO_dxf : public OdDbVisualizeRTRenderSettingsIO
{
  protected:
    OdDbDxfFiler *m_pFiler;
  protected:
    virtual bool rdBool() { return (m_pFiler->nextRb(), m_pFiler->rdBool()); }
    virtual OdInt16 rdInt16() { return (m_pFiler->nextRb(), m_pFiler->rdInt16()); }
    virtual OdInt32 rdInt32() { return (m_pFiler->nextRb(), m_pFiler->rdInt32()); }
    virtual double rdDouble() { return (m_pFiler->nextRb(), m_pFiler->rdDouble()); }
    virtual void wrBool(bool bVal) { m_pFiler->wrBool(290, bVal); }
    virtual void wrInt16(OdInt16 iVal) { m_pFiler->wrInt16(70, iVal); }
    virtual void wrInt32(OdInt32 iVal) { m_pFiler->wrInt32(90, iVal); }
    virtual void wrDouble(double dVal) { m_pFiler->wrDouble(40, dVal); }
  public:
    OdDbVisualizeRTRenderSettingsIO_dxf(OdDbDxfFiler *pFiler, const OdGiVisualizeRTRenderSettingsTraitsData &rtData)
      : OdDbVisualizeRTRenderSettingsIO(rtData), m_pFiler(pFiler) { }
};

OdResult OdDbVisualizeRTRenderSettings::dwgInFields(OdDbDwgFiler *pFiler)
{
  OdResult res = OdDbRenderSettings::dwgInFields(pFiler);
  if (res != eOk)
    return res;
  const int nVersion = pFiler->rdInt16();
  if (nVersion > getVersion())
    return eMakeMeProxy;
  OdDbVisualizeRTRenderSettingsIO_dwg(pFiler, m_rtData).inFields();
  return eOk;
}
void OdDbVisualizeRTRenderSettings::dwgOutFields(OdDbDwgFiler *pFiler) const
{
  OdDbRenderSettings::dwgOutFields(pFiler);
  pFiler->wrInt16((OdInt16)getVersion());
  OdDbVisualizeRTRenderSettingsIO_dwg(pFiler, m_rtData).outFields();
}

OdResult OdDbVisualizeRTRenderSettings::dxfInFields(OdDbDxfFiler *pFiler)
{
  OdResult res = OdDbRenderSettings::dxfInFields(pFiler);
  if (res != eOk)
    return res;
  if (!pFiler->atSubclassData(desc()->name()))
    return eBadDxfSequence;
  const int nVersion = pFiler->nextRb()->getInt16();
  if (nVersion > getVersion())
    return eMakeMeProxy;
  OdDbVisualizeRTRenderSettingsIO_dxf(pFiler, m_rtData).inFields();
  return eOk;
}
void OdDbVisualizeRTRenderSettings::dxfOutFields(OdDbDxfFiler *pFiler) const
{
  OdDbRenderSettings::dxfOutFields(pFiler);
  pFiler->wrSubclassMarker(desc()->name());
  pFiler->wrInt16(70, (OdInt16)getVersion());
  OdDbVisualizeRTRenderSettingsIO_dxf(pFiler, m_rtData).outFields();
}

OdUInt32 OdDbVisualizeRTRenderSettings::subSetAttributes(OdGiDrawableTraits *pTraits) const
{
  assertReadEnabled();
  OdUInt32 res = OdDbRenderSettings::subSetAttributes(pTraits);
  res |= kDrawableNone;

  OdGiVisualizeRTRenderSettingsTraitsPtr pSetTraits = OdGiVisualizeRTRenderSettingsTraits::cast(pTraits);
  if (!pSetTraits.isNull())
    ::odGiCopyVisualizeRTTraits(pSetTraits.get(), &m_rtData);
  return res;
}

bool OdDbVisualizeRTRenderSettings::operator ==(const OdDbVisualizeRTRenderSettings &settings)
{
  return OdDbRenderSettings::operator ==(settings) && (m_rtData == settings.m_rtData);
}

//