VCC_Utils.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        VCC_Utils.h ( CVEX Library, C++)
 *
 * COMMENTS:    This file contains utility functions for compiling VEX code.
 */

#ifndef __VCC_Utils__
#define __VCC_Utils__

#include "VCC_API.h"
#include <CVEX/CVEX_Function.h>

#include <VEX/VEX_PodTypes.h>
template <VEX_Precision PREC> class CVEX_ContextT;

class UT_WorkBuffer;
class UT_JSONParser;
class UT_JSONWriter;

class VCC_API VCC_Utils
{
public:
    template <VEX_Precision PREC>
    static CVEX_Function         preloadLocalFunction(
                                        CVEX_ContextT<PREC> &context,
                                        const UT_WorkBuffer &source_code,
                                        int node_id = -1);

    /// Information about VEX shader parameter.
    class VCC_API ShaderParmInfo
    {
    public:
        /// Constructors.
        ShaderParmInfo();
        ShaderParmInfo( const UT_StringRef& name,
                VEX_Type type,
                const UT_StringRef& struct_name = UT_StringRef());

        /// Parameter name.
        const UT_StringHolder & getName() const
                                    { return myName; }

        /// @{ Parameter type.
        VEX_Type                getType() const
                                    { return myType; }
        const UT_StringHolder & getStructName() const
                                    { return myStructName; }
        bool                    isStruct() const
                                    { return myStructName; }
        /// @}

        /// @{ Export (outgoing parm flag) info.
        bool                    isExport() const
                                    { return myIsExport; }
        void                    setIsExport( bool is_export )
                                    { myIsExport = is_export; }

        /// @}

        /// @{ Array info.
        bool                    isArray() const
                                    { return myIsArray; }
        void                    setIsArray( bool is_array )
                                    { myIsArray = is_array; }

        exint                   getArraySize() const
                                    { return myArraySize; }
        void                    setArraySize( exint array_size )
                                    { myArraySize = array_size; }
        /// @}

        /// @{ Default values.
        const UT_DoubleArray &  getFloatValues() const
                                    { return myFloatValues; }
        void                    setFloatValues( const UT_DoubleArray &values )
                                    { myFloatValues = values; }

        const UT_IntArray &     getIntValues() const
                                    { return myIntValues; }
        void                    setIntValues( const UT_IntArray &values )
                                    { myIntValues = values; }

        const UT_StringArray &  getStringValues() const
                                    { return myStringValues; }
        void                    setStringValues( const UT_StringArray &values )
                                    { myStringValues = values; }
        /// @}

        bool            save(UT_JSONWriter &w) const;
        bool            load(UT_JSONParser &p);

    private:
        UT_StringHolder             myName;
        UT_StringHolder             myStructName;
        UT_DoubleArray              myFloatValues;
        UT_IntArray                 myIntValues;
        UT_StringArray              myStringValues;
        VEX_Type                    myType;
        bool                        myIsExport;
        bool                        myIsArray;
        exint                       myArraySize;
    };

    /// Information about the VEX shader.
    class VCC_API ShaderInfo
    {
    public:
        // Constructor
                                ShaderInfo();

        /// @{ VEX context type (surface, displacement, etc).
        VEX_ContextType         getContextType() const
                                    { return myContextType; }
        void                    setContextType( VEX_ContextType type)
                                    { myContextType = type; }
        /// @}

        /// @{ Shader function name.
        const UT_StringHolder & getFunctionName() const
                                    { return myFunctionName; }
        void                    setFunctionName(const UT_StringRef &name)
                                    { myFunctionName = name; }
        /// @}

        /// @{ Shader function parameters.
        const UT_Array<ShaderParmInfo>  &getParameters() const
                                    { return myParms; }
        void                    setParameterArrayCapacity( exint capacity )
                                    { myParms.setCapacity( capacity ); }

        void                    appendParameter( ShaderParmInfo &&parm )
                                    { myParms.emplace_back( parm ); }

        /// @}

        bool            save(UT_JSONWriter &w) const;
        bool            load(UT_JSONParser &p);

    private:
        VEX_ContextType             myContextType;
        UT_StringHolder             myFunctionName;
        UT_Array<ShaderParmInfo>    myParms;
    };

    /// Returns information about VEX shader given the shader file path.
    static bool                 getShaderInfoFromFile(
                                        VCC_Utils::ShaderInfo &info,
                                        const UT_StringRef &file);

    /// Returns information about VEX shader given the shader source code.
    static bool                 getShaderInfoFromCode(
                                        VCC_Utils::ShaderInfo &info,
                                        const UT_StringRef &code);
};

#endif