CE_Snippet.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: CE_Snippet.h ( CE Library, C++)
 *
 * COMMENTS: Snippet manipulation for OpenCL
 */

#ifndef __CE_Snippet__
#define __CE_Snippet__

#include "CE_API.h"
#include "CE_Precision.h"

#include <UT/UT_String.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_Array.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_Error.h>

class UT_ErrorManager;
class UT_Options;

namespace CE_Snippet
{
    enum class RunOver
    {
        ATTRIBUTE = 0,
        VOLUME,
        WORKSETS,
        FIELDS,
        VDB,
        LAYER
    };

    enum class BindingType
    {
        INVALID = -1,
        INT,
        INTARRAY,
        FLOAT,
        FLOAT2,
        FLOAT3,
        FLOAT4,
        FLOAT8,
        FLOAT16,
        FIELD_S,
        FIELD_V,
        FIELD_M,
        RAMP,
        ATTRIBUTE,
        VOLUME,
        VDB,
        OPTION,
        LAYER,
        NUM_TYPES
    };
    CE_API const char *bindingTypeToString(BindingType type);

    enum class BindingAttribClass
    {
        DETAIL,
        PRIMITIVE,
        POINT,
        VERTEX,
    };
    CE_API const char *bindingAttribClassToString(BindingAttribClass type);

    enum class BindingAttribType
    {
        FLOAT,
        INT,
        FLOATARRAY,
        INTARRAY,
    };
    CE_API const char *bindingAttribTypeToString(BindingAttribType type);

    enum class BindingVDBType
    {
        ANY,
        FLOAT,
        VECTOR,
    };
    CE_API const char *bindingVDBTypeToString(BindingVDBType type);

    enum class BindingPrecision
    {
        NODE,
        _16,
        _32,
        _64,
    };
    CE_API const char *bindingPrecisionToString(BindingPrecision type);

    enum class BindingTimescale
    {
        NONE,
        MULT,
        INVERT,
        POW,
    };
    CE_API const char *bindingTimescaleToString(BindingTimescale type);

    enum class BindingRampType
    {
        FLOAT,
        VECTOR,
    };
    CE_API const char *bindingRampTypeToString(BindingRampType type);

    enum class BindingLayerType
    {
        INT,
        FLOAT,
        FLOAT2,
        FLOAT3,
        FLOAT4,
        FLOATN,
    };
    CE_API const char *bindingLayerTypeToString(BindingLayerType type);

    enum class BindingLayerBorder // must be IMX_BorderType + 1!
    {
        INPUT,
        CONSTANT,
        CLAMP,
        MIRROR,
        WRAP,
    };
    CE_API const char *bindingLayerBorderToString(BindingLayerBorder type);

    enum class BindingOptionType
    {
        FLOAT,
        INT,
    };
    CE_API const char *bindingOptionTypeToString(BindingOptionType type);

    struct Binding
    {
        UT_StringHolder         name;
        BindingType             type            = BindingType::INT;
        UT_SharedPtr<UT_Ramp>   ramp;
        UT_Array<float>         rampdata;
        BindingRampType         ramptype        = BindingRampType::FLOAT;
        int64                   rampsize        = 1024;
        UT_Array<int>           intarray;
        BindingLayerType        layertype       = BindingLayerType::FLOATN;
        BindingLayerBorder      layerborder     = BindingLayerBorder::INPUT;
        UT_StringHolder         fieldname;
        bool                    fieldoffsets    = true;
        int                     input           = 0;
        UT_StringHolder         portname;
        UT_StringHolder         volume;
        UT_StringHolder         geometry        = UTmakeUnsafeRef("Geometry");
        BindingVDBType          vdbtype         = BindingVDBType::ANY;
        bool                    forcealign      = true;
        bool                    resolution      = false;
        bool                    voxelsize       = false;
        bool                    xformtoworld    = false;
        bool                    xformtovoxel    = false;
        UT_StringHolder         attribute;
        BindingAttribClass      attribclass     = BindingAttribClass::POINT;
        BindingAttribType       attribtype      = BindingAttribType::FLOAT;
        int64                   attribsize      = 1;
        BindingPrecision        precision       = BindingPrecision::NODE;
        bool                    readable        = true;
        bool                    writeable       = false;
        bool                    optional        = false;
        bool                    defval          = false;
        int64                   intval          = 0;
        fpreal64                fval            = 0;
        UT_Vector2D             v2val           { 0, 0 };
        UT_Vector3D             v3val           { 0, 0, 0 };
        UT_Vector4D             v4val           { 0, 0, 0, 0 };
        UT_Vector4D             v4bval          { 0, 0, 0, 0 };
        UT_Matrix4D             m4val           { 0, 0, 0, 0,
                                                  0, 0, 0, 0,
                                                  0, 0, 0, 0,
                                                  0, 0, 0, 0 };
        BindingTimescale        timescale       = BindingTimescale::NONE;
        UT_StringHolder         dataname;
        UT_StringHolder         optionname;
        BindingOptionType       optiontype      = BindingOptionType::FLOAT;
        int                     optionsize      = 1;
    };


    /// Protect @s that shouldn't be parsed because they are in comments
    /// or in quotes with ATSAFESTRING
    CE_API UT_StringHolder protectAts(UT_StringHolder code);

    /// Expands a path into the matching include file on the search
    /// path
    CE_API UT_StringHolder findIncludeFile(const char *path, 
                           bool searchcwd,
                           UT_ErrorManager *error);

    /// Loads an import, searching the include path to locate it.
    CE_API UT_StringHolder loadImport(const char *path, bool searchcwd,
                       UT_ErrorManager *error);
    /// Expands all #import directives.
    CE_API UT_StringHolder expandImportDirectives(UT_StringHolder code,
                            UT_ErrorManager *error);

    /// Process all @BIND commands appending to the provided Bindings
    /// array.   Returns the code with the @BIND elided
    CE_API UT_StringHolder extractBindings(UT_StringHolder code,
                            UT_Array<Binding> &bindings,
                            UT_ErrorManager *error);

    /// Returns the kernel code transformed by the bindings, ie, all
    /// @ commands turned into accessors and the appropriate prequel
    /// code generated.
    /// Globals generate @KEY := _bound_VAL
    CE_API UT_StringHolder generateAtCode(UT_StringHolder code,
                        RunOver runover,
                        UT_Options *opt,
                        UT_StringMap<UT_StringHolder> *globals, 
                        UT_StringMap<UT_StringHolder> *missing_globals, 
                        const UT_Array<Binding> &bindings,
                        const char *kernelsig, const char *writebacksig,
                        UT_ErrorManager *error);

    /// Restore protected @s to be @ again.
    CE_API UT_StringHolder restoreAts(UT_StringHolder code);


    /// Given an opencl decorated typename break it into type, precision, and size.
    /// TYPE#[]
    /// TYPE: half, float, double, fpreal, short, int, long exint
    /// #: missing means scalar, ? means -1.
    /// [] optional to flag array.
    CE_API bool parseType(const UT_StringRef &attribtypename,
                        BindingAttribType &attribtype,
                        BindingPrecision &precision,
                        int &tuplesize);

    /// Return a syntax string that is byte-for-byte with code
    /// describing the state at that point.
    CE_API UT_StringHolder computeSyntax(const char *code);

    /// Append into sign the argument signature for a binding
    CE_API void buildArgumentSign(const Binding &binding, 
                            int p, int maxparam,
                            UT_WorkBuffer &sign, 
                            UT_StringHolder &firstwriteable,
                            bool &firstwriteable_forced,
                            BindingVDBType &firstvdbtype,
                            bool prefixbound,
                            RunOver runover,
                            bool fieldsarealigned,
                            UT_WorkBuffer &paraminitcode);

    /// Append into signature the arguments required for the
    /// runover mode.
    CE_API void buildKernelRunOverArguments(UT_WorkBuffer &signature,
                        RunOver runover, bool singleworkgroup,
                        bool filedsarealigned, bool prefixbound);

    CE_API void addKernelArgument(UT_WorkBuffer &signature,
                                  const char * type,
                                  const char * name,
                                  bool prefixbound);

    /// Append into sign the code to start the provided runover mode.
    CE_API void buildKernelRunOverCode(UT_WorkBuffer &signature,
                        RunOver runover, BindingVDBType firstvdbtype,
                        bool singleworkgroup, bool fieldsarealigned,
                        bool firstname_forced, bool prefixbound,
                        UT_StringRef firstname);

}

#endif