fulldebug.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

namespace Kaim
{

struct FullDebug
{
    enum Enum
    {
        Inputs                            = 1 << 0,
        Traversal                         = 1 << 1,
        TraversalPath                     = 1 << 2,
        Refiner                           = 1 << 3,
        RefinedPath                       = 1 << 4,
        DiagonalStripComputer             = 1 << 5,
        DiagonalStrip                     = 1 << 6,
        DiagonalStripBubbleArray          = 1 << 7,
        StringPuller                      = 1 << 8,
        StringPulledBubbleList            = 1 << 9,
        GateArrayComputer                 = 1 << 10,
        GateDefinitionComputer            = 1 << 11,
        GateDefinitionArray               = 1 << 12,
        ChannelSectionWidener             = 1 << 13,
        ChannelBorderSimplifier           = 1 << 14,
        PreAndPostChannelPolylineComputer = 1 << 15,
        ChannelPath                       = 1 << 16
    };

    struct Names
    {
        // Because displaylists are sorted by name
        static const char* Inputs()                   { return "(A) Inputs"; }
        static const char* Traversal()                { return "(B) Traversal"; }
        static const char* TraversalPath()            { return "(B.R) [ TraversalPath ]"; }
        static const char* Refiner()                  { return "(C) Refiner"; }
        static const char* RefinedPath()              { return "(C.R) [ RefinedPath ]"; }
        static const char* DiagonalStripComputer()    { return "(D) DiagonalStripComputer"; }
        static const char* DiagonalStrip()            { return "(D.R1) [ DiagonalStrip ]"; }
        static const char* DiagonalStripBubbleArray() { return "(D.R2) [ DiagonalStripBubbleArray ]"; }
        static const char* StringPuller()             { return "(E) StringPuller"; }
        static const char* StringPulledBubbleList()   { return "(E.R) [ StringPulledBubbleList ]"; }
        static const char* GateArrayComputer()        { return "(F) GateArrayComputer"; } // foreach section in between navgraphs
        static const char* GateDefinitionComputer()   { return "(F.1) GateDefinitionComputer"; }
        static const char* GateDefinitionArray()      { return "(F.1.R) [ GateDefinitionArray ]"; }
        static const char* ChannelSectionWidener()    { return "(F.2) ChannelSectionWidener"; }
        static const char* ChannelBorderSimplifier()  { return "(F.2.1) ChannelBorderSimplifier"; }
        static const char* PrePostPolylineSections()  { return "(G) PrePostChannelSections"; }
        static const char* ChannelPath()              { return "(H) [ ChannelPath ]"; } // [ChannelArray] => CreateAggregatedPath => [ChannelPath]
    };

    static KyUInt32 AllIntermediatesMask() { return RefinedPath | DiagonalStrip | DiagonalStripBubbleArray | GateDefinitionArray | ChannelPath; }

    static FullDebug None()                   { return FullDebug(); }
    static FullDebug RefinedAndChannelPaths() { return FullDebug(RefinedPath | ChannelPath); }
    static FullDebug IntermediatePaths()      { return FullDebug(TraversalPath | RefinedPath | ChannelPath); }
    static FullDebug AllIntermediates()       { return FullDebug(AllIntermediatesMask()); }
    static FullDebug All()                    { return FullDebug(KyUInt32MAXVAL); }

public:
    FullDebug() : m_mask(0) {}
    explicit FullDebug(KyUInt32 mask) : m_mask(mask) {}
    void Clear() { m_mask = 0; }
    void Set(KyUInt32 mask) { m_mask = mask; }
    bool Has(KyUInt32 e) const { return (m_mask & e) != 0; }
    bool HasNone() const { return m_mask == 0; }
    bool HasSome() const { return m_mask != 0; }

public:
    KyUInt32 m_mask;
};

KY_INLINE void SwapEndianness(Endianness::Target e, FullDebug& self)
{
    SwapEndianness(e, self.m_mask);
}

}