/////////////////////////////////////////////////////////////////////////////// 
// 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 "DgMeshProperties.h"


//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMesh
//-----------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Style
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshStyleProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshPtr pObj = OdDgMesh::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getStyle();

    return eOk;
}


//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMeshFaceLoops
//-----------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: UseColorTableIndexesFlag
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseColorTableIndexesFlagProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getUseColorTableIndexesFlag();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseColorTableIndexesFlagProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setUseColorTableIndexesFlag(*rxvalue_cast<bool>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: UseDoubleColorsFlag
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseDoubleColorsFlagProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getUseDoubleColorsFlag();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseDoubleColorsFlagProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setUseDoubleColorsFlag(*rxvalue_cast<bool>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: UseNormalsFlag
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseNormalsFlagProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getUseNormalsFlag();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseNormalsFlagProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setUseNormalsFlag(*rxvalue_cast<bool>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: UseTextureCoordinatesFlag
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseTextureCoordinatesFlagProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getUseTextureCoordinatesFlag();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsUseTextureCoordinatesFlagProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setUseTextureCoordinatesFlag(*rxvalue_cast<bool>(&value));

    return eOk;
}


//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Points
//-----------------------------------------------------------------------------------------------------------------------

ODDG_DEFINE_RX_VALUE_ARRAY_ITERATOR(OdGePoint3d);

OdRxValueIteratorPtr OdDgMeshFaceLoopsPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxOdGePoint3dValueIterator>::createObject();

    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdGePoint3d> arrPoints;

        for (OdUInt32 i = 0; i < pObj->getPointsNumber(); i++)
            arrPoints.push_back(pObj->getPoint(i));

        ((OdRxOdGePoint3dValueIterator*)res.get())->init(arrPoints, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    count = pObj->getPointsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getPoint(index);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;
    
    if (index < 0 || index >= (int)pObj->getPointsNumber())
        return eInvalidIndex;

    OdGePoint3d point = *rxvalue_cast<OdGePoint3d>(&value);
    pObj->setPoint(index, point);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdGePoint3d point = *rxvalue_cast<OdGePoint3d>(&value);
    pObj->addPoint(point);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    if (index < 0 || index >= (int)pObj->getPointsNumber())
        return eInvalidIndex;

    pObj->removePoint(index);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: FacesPoints
//-----------------------------------------------------------------------------------------------------------------------


struct OdRxFacePointValueIterator : OdRxValueIterator
{
    OdArray<OdDgMeshFaceLoops::FacePoint> m_arrData;
    OdUInt32      m_uCurIndex;
    OdRxFacePointValueIterator() { m_uCurIndex = 0; }
    virtual void init(const OdArray<OdDgMeshFaceLoops::FacePoint>& arrData, OdUInt32 uStartIndex)
    {
        m_arrData = arrData;
        m_uCurIndex = uStartIndex;
    }
    virtual bool done()
    {
        if (m_arrData.isEmpty())
            return true;
        return m_uCurIndex == m_arrData.size();
    }
    virtual bool next()
    {
        if (m_uCurIndex < m_arrData.size())
            m_uCurIndex++;
        return !done();
    }
    virtual OdRxValue current() const
    {
        if (m_uCurIndex >= m_arrData.size())
            throw OdError(eInvalidIndex);
        return m_arrData[m_uCurIndex];
    }
};

OdRxValueIteratorPtr OdDgMeshFaceLoopsFacesPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxFacePointValueIterator>::createObject();

    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdDgMeshFaceLoops::FacePoint> arrFaces;
        for (OdUInt32 i = 0; i < pObj->getFacesNumber(); i++)
        {
            OdDgMeshFaceLoops::VerticesArray vertArr;
            pObj->getFace(i, vertArr);
            for (OdUInt32 j = 0; j < vertArr.size(); j++)
            {
                arrFaces.push_back(vertArr[j]);
            }
        }

        ((OdRxFacePointValueIterator*)res.get())->init(arrFaces, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsFacesPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    int tmpCount = 0;
    for (OdUInt32 i = 0; i < pObj->getFacesNumber(); i++)
    {
        OdDgMeshFaceLoops::VerticesArray vertArr;
        pObj->getFace(i, vertArr);
        tmpCount += vertArr.size();
    }
    count = tmpCount;

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsFacesPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    for (OdUInt32 i = 0; i < pObj->getFacesNumber(); i++)
    {
        OdDgMeshFaceLoops::VerticesArray vertArr;
        pObj->getFace(i, vertArr);
        if (index < (int)vertArr.size())
        {
            value = vertArr[index];
            return eOk;
        }
        
        index -= vertArr.size();
    }
    
    return eInvalidIndex;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsFacesPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;
    
    for (OdUInt32 i = 0; i < pObj->getFacesNumber(); i++)
    {
        OdDgMeshFaceLoops::VerticesArray vertArr;
        pObj->getFace(i, vertArr);
        if (index < (int)vertArr.size())
        {
            OdDgMeshFaceLoops::FacePoint facePoint = *rxvalue_cast<OdDgMeshFaceLoops::FacePoint>(&value);
            vertArr[index] = facePoint;
            pObj->setFace(i, vertArr);
            return eOk;
        }

        index -= vertArr.size();
    }

    return eInvalidIndex;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsFacesPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    for (OdUInt32 i = 0; i < pObj->getFacesNumber(); i++)
    {
        OdDgMeshFaceLoops::VerticesArray vertArr;
        pObj->getFace(i, vertArr);
        if (index < (int)vertArr.size())
        {
            OdDgMeshFaceLoops::FacePoint facePoint = *rxvalue_cast<OdDgMeshFaceLoops::FacePoint>(&value);
            vertArr.insertAt(index, facePoint);
            pObj->setFace(i, vertArr);
            return eOk;
        }

        index -= vertArr.size();
    }

    return eInvalidIndex;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshFaceLoopsFacesPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshFaceLoopsPtr pObj = OdDgMeshFaceLoops::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    for (OdUInt32 i = 0; i < pObj->getFacesNumber(); i++)
    {
        OdDgMeshFaceLoops::VerticesArray vertArr;
        pObj->getFace(i, vertArr);
        if (index < (int)vertArr.size())
        {
            vertArr.removeAt(index);
            pObj->setFace(i, vertArr);
            return eOk;
        }

        index -= vertArr.size();
    }

    return eInvalidIndex;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMeshPointCloud
//-----------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Points
//-----------------------------------------------------------------------------------------------------------------------

OdRxValueIteratorPtr OdDgMeshPointCloudPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxOdGePoint3dValueIterator>::createObject();

    OdDgMeshPointCloudPtr pObj = OdDgMeshPointCloud::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdGePoint3d> arrPoints;

        for (OdUInt32 i = 0; i < pObj->getPointsNumber(); i++)
            arrPoints.push_back(pObj->getPoint(i));

        ((OdRxOdGePoint3dValueIterator*)res.get())->init(arrPoints, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshPointCloudPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshPointCloudPtr pObj = OdDgMeshPointCloud::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    count = pObj->getPointsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshPointCloudPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshPointCloudPtr pObj = OdDgMeshPointCloud::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getPoint(index);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshPointCloudPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshPointCloudPtr pObj = OdDgMeshPointCloud::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    if (index < 0 || index >= (int)pObj->getPointsNumber())
        return eInvalidIndex;

    OdGePoint3d point = *rxvalue_cast<OdGePoint3d>(&value);
    pObj->setPoint(index, point);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshPointCloudPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshPointCloudPtr pObj = OdDgMeshPointCloud::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdGePoint3d point = *rxvalue_cast<OdGePoint3d>(&value);
    pObj->addPoint(point);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshPointCloudPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshPointCloudPtr pObj = OdDgMeshPointCloud::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    if (index < 0 || index >= (int)pObj->getPointsNumber())
        return eInvalidIndex;

    pObj->removePoint(index);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMeshQuadGrid
//-----------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Rows
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridRowsProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getRowsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridRowsProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setRowsNumber(*rxvalue_cast<OdUInt32>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Columns
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridColumnsProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getColumnsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridColumnsProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setColumnsNumber(*rxvalue_cast<OdUInt32>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Points
//-----------------------------------------------------------------------------------------------------------------------

OdRxValueIteratorPtr OdDgMeshQuadGridPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxOdGePoint3dValueIterator>::createObject();

    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdGePoint3d> arrPoints;

        for (OdUInt32 i = 0; i < (pObj->getRowsNumber()); i++)
        {
            for (OdUInt32 j = 0; j < (pObj->getColumnsNumber()); j++)
            {
                arrPoints.push_back(pObj->getPoint(i, j));
            }
        }

        ((OdRxOdGePoint3dValueIterator*)res.get())->init(arrPoints, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;
    
    count = pObj->getRowsNumber() * pObj->getColumnsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdUInt32 row, column = 0;
    row = index / pObj->getColumnsNumber();
    column = index % pObj->getColumnsNumber();
    value = pObj->getPoint(row,column);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdGePoint3d point = *rxvalue_cast<OdGePoint3d>(&value);

    OdUInt32 row, column = 0;
    row = index / pObj->getColumnsNumber();
    column = index % pObj->getColumnsNumber();
    
    pObj->setPoint(row, column, point);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadGridPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshQuadGridPtr pObj = OdDgMeshQuadGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMeshQuadList
//-----------------------------------------------------------------------------------------------------------------------


//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Quads
//-----------------------------------------------------------------------------------------------------------------------

OdRxValueIteratorPtr OdDgMeshQuadListQuadsPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxOdGePoint3dValueIterator>::createObject();

    OdDgMeshQuadListPtr pObj = OdDgMeshQuadList::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdGePoint3d> arrQuadsPoints;

        for (OdUInt32 i = 0; i < pObj->getQuadsNumber(); i++)
        {
            OdDgMeshQuadList::Quad curQuad;
            pObj->getQuad(i, curQuad);
            arrQuadsPoints.push_back(curQuad.m_points[0]);
            arrQuadsPoints.push_back(curQuad.m_points[1]);
            arrQuadsPoints.push_back(curQuad.m_points[2]);
            arrQuadsPoints.push_back(curQuad.m_points[3]);
        }

        ((OdRxOdGePoint3dValueIterator*)res.get())->init(arrQuadsPoints, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadListQuadsPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshQuadListPtr pObj = OdDgMeshQuadList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    count = pObj->getQuadsNumber() * 4;

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadListQuadsPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshQuadListPtr pObj = OdDgMeshQuadList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdDgMeshQuadList::Quad curQuad;
    OdUInt32 quadIndex, pointIndex = 0;

    quadIndex = index / 4;
    pointIndex = index % 4;

    pObj->getQuad(quadIndex, curQuad);
    value = curQuad.m_points[pointIndex];

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadListQuadsPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshQuadListPtr pObj = OdDgMeshQuadList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdDgMeshQuadList::Quad curQuad;
    OdUInt32 quadIndex, pointIndex = 0;
    OdGePoint3d curPoint = *rxvalue_cast<OdGePoint3d>(&value);

    quadIndex = index / 4;
    pointIndex = index % 4;

    pObj->getQuad(quadIndex, curQuad);
    curQuad.m_points[pointIndex] = curPoint;

    pObj->setQuad(quadIndex, curQuad);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadListQuadsPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshQuadListPtr pObj = OdDgMeshQuadList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdGePoint3d curPoint = *rxvalue_cast<OdGePoint3d>(&value);
    OdDgMeshQuadList::Quad curQuad;
    curQuad.m_points[0] = curPoint;
    curQuad.m_points[1] = curPoint;
    curQuad.m_points[2] = curPoint;
    curQuad.m_points[3] = curPoint;

    pObj->addQuad(curQuad);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshQuadListQuadsPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshQuadListPtr pObj = OdDgMeshQuadList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdUInt32 quadIndex = index / 4;
    pObj->removeQuad(quadIndex);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMeshTriangleGrid
//-----------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Rows
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridRowsProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getRowsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridRowsProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setRowsNumber(*rxvalue_cast<OdUInt32>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Columns
//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridColumnsProperty::subGetValue(const OdRxObject* pO, OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    value = pObj->getColumnsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridColumnsProperty::subSetValue(OdRxObject* pO, const OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);
    if (pObj.isNull())
        return eNotApplicable;

    pObj->setColumnsNumber(*rxvalue_cast<OdUInt32>(&value));

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Points
//-----------------------------------------------------------------------------------------------------------------------

OdRxValueIteratorPtr OdDgMeshTriangleGridPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxOdGePoint3dValueIterator>::createObject();

    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdGePoint3d> arrPoints;

        for (OdUInt32 i = 0; i < (pObj->getRowsNumber()); i++)
        {
            for (OdUInt32 j = 0; j < (pObj->getColumnsNumber()); j++)
            {
                arrPoints.push_back(pObj->getPoint(i, j));
            }
        }

        ((OdRxOdGePoint3dValueIterator*)res.get())->init(arrPoints, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    count = pObj->getRowsNumber() * pObj->getColumnsNumber();

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdUInt32 row, column = 0;
    row = index / pObj->getColumnsNumber();
    column = index % pObj->getColumnsNumber();
    value = pObj->getPoint(row, column);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdGePoint3d point = *rxvalue_cast<OdGePoint3d>(&value);

    OdUInt32 row, column = 0;
    row = index / pObj->getColumnsNumber();
    column = index % pObj->getColumnsNumber();

    pObj->setPoint(row, column, point);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleGridPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshTriangleGridPtr pObj = OdDgMeshTriangleGrid::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    return eOk;
}


//-----------------------------------------------------------------------------------------------------------------------
//                                          class: OdDgMeshTriangleList
//-----------------------------------------------------------------------------------------------------------------------


//-----------------------------------------------------------------------------------------------------------------------
//                                          property: Quads
//-----------------------------------------------------------------------------------------------------------------------

OdRxValueIteratorPtr OdDgMeshTriangleListTrianglesPointsProperty::subNewValueIterator(const OdRxObject* pO) const
{
    OdRxValueIteratorPtr res;
    res = OdRxObjectImpl<OdRxOdGePoint3dValueIterator>::createObject();

    OdDgMeshTriangleListPtr pObj = OdDgMeshTriangleList::cast(pO);

    if (!pObj.isNull())
    {
        OdArray<OdGePoint3d> arrTrianglesPoints;

        for (OdUInt32 i = 0; i < pObj->getTrianglesNumber(); i++)
        {
            OdDgMeshTriangleList::Triangle curTriangle;
            pObj->getTriangle(i, curTriangle);
            arrTrianglesPoints.push_back(curTriangle.m_points[0]);
            arrTrianglesPoints.push_back(curTriangle.m_points[1]);
            arrTrianglesPoints.push_back(curTriangle.m_points[2]);
        }

        ((OdRxOdGePoint3dValueIterator*)res.get())->init(arrTrianglesPoints, 0);
    }

    return res;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleListTrianglesPointsProperty::subTryGetCount(const OdRxObject* pO, int& count) const
{
    OdDgMeshTriangleListPtr pObj = OdDgMeshTriangleList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    count = pObj->getTrianglesNumber() * 3;

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleListTrianglesPointsProperty::subGetValue(const OdRxObject* pO, int index, OdRxValue& value) const
{
    OdDgMeshTriangleListPtr pObj = OdDgMeshTriangleList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdDgMeshTriangleList::Triangle curTriangle;
    OdUInt32 triangleIndex, pointIndex = 0;

    triangleIndex = index / 3;
    pointIndex = index % 3;

    pObj->getTriangle(triangleIndex, curTriangle);
    value = curTriangle.m_points[pointIndex];

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleListTrianglesPointsProperty::subSetValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshTriangleListPtr pObj = OdDgMeshTriangleList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdDgMeshTriangleList::Triangle curTriangle;
    OdUInt32 triangleIndex, pointIndex = 0;
    OdGePoint3d curPoint = *rxvalue_cast<OdGePoint3d>(&value);

    triangleIndex = index / 3;
    pointIndex = index % 3;

    pObj->getTriangle(triangleIndex, curTriangle);
    curTriangle.m_points[pointIndex] = curPoint;

    pObj->setTriangle(triangleIndex, curTriangle);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleListTrianglesPointsProperty::subInsertValue(OdRxObject* pO, int index, const OdRxValue& value) const
{
    OdDgMeshTriangleListPtr pObj = OdDgMeshTriangleList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdGePoint3d curPoint = *rxvalue_cast<OdGePoint3d>(&value);
    OdDgMeshTriangleList::Triangle curTriangle;
    curTriangle.m_points[0] = curPoint;
    curTriangle.m_points[1] = curPoint;
    curTriangle.m_points[2] = curPoint;

    pObj->addTriangle(curTriangle);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------

OdResult OdDgMeshTriangleListTrianglesPointsProperty::subRemoveValue(OdRxObject* pO, int index) const
{
    OdDgMeshTriangleListPtr pObj = OdDgMeshTriangleList::cast(pO);

    if (pObj.isNull())
        return eNotApplicable;

    OdUInt32 triangleIndex = index / 3;
    pObj->removeTriangle(triangleIndex);

    return eOk;
}

//-----------------------------------------------------------------------------------------------------------------------