GAS/GAS_Calculate.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.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GAS_Calculate.h ( GAS Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GAS_Calculate__
#define __GAS_Calculate__

#include "GAS_API.h"

#include <UT/UT_ThreadedAlgorithm.h>
#include <GU/GU_Detail.h>

#include <SIM/SIM_RawField.h>
#include <SIM/SIM_PhysicalParms.h>

#include "GAS_SubSolver.h"
#include "GAS_Utils.h"

class GAS_API GAS_Calculate : public GAS_SubSolver
{
public:
    GET_DATA_FUNC_S(GAS_NAME_FIELDDEST, FieldDstName);
    GET_DATA_FUNC_S(GAS_NAME_FIELDSOURCE, FieldSrcName);
    GET_DATA_FUNC_S("dstblend", DstBlend);
    GET_DATA_FUNC_S("srcblend", SrcBlend);

    GET_DATA_FUNC_S("srcindex", SrcIndexName);
    GET_DATA_FUNC_I("property", Property);

    GET_DATA_FUNC_I("srctimescale", SrcTimeScale);
    GET_DATA_FUNC_I("dsttimescale", DstTimeScale);
    GET_DATA_FUNC_I("posttimescale", PostTimeScale);

    GET_DATA_FUNC_I("calculationtype", CalculationType);
    GET_DATA_FUNC_I("blendmethod", BlendMethod);
    GET_DATA_FUNC_F("dstpreadd", DstPreAdd);
    GET_DATA_FUNC_F("dstpremul", DstPreMul);
    GET_DATA_FUNC_I("dstconvert", DstConvert);
    GET_DATA_FUNC_I("dstscale", DstScale);
    GET_DATA_FUNC_F("srcpreadd", SrcPreAdd);
    GET_DATA_FUNC_F("srcpremul", SrcPreMul);
    GET_DATA_FUNC_I("srcconvert", SrcConvert);
    GET_DATA_FUNC_I("srcscale", SrcScale);
    GET_DATA_FUNC_F("postadd", PostAdd);
    GET_DATA_FUNC_F("postmul", PostMul);
    GET_DATA_FUNC_I("postconvert", PostConvert);
    GET_DATA_FUNC_I("postscale", PostScale);

    GET_DATA_FUNC_F("dstblendpreadd", DstBlendPreAdd);
    GET_DATA_FUNC_F("dstblendpremul", DstBlendPreMul);
    GET_DATA_FUNC_I("dstblendconvert", DstBlendConvert);
    GET_DATA_FUNC_I("dstblendscale", DstBlendScale);
    GET_DATA_FUNC_F("srcblendpreadd", SrcBlendPreAdd);
    GET_DATA_FUNC_F("srcblendpremul", SrcBlendPreMul);
    GET_DATA_FUNC_I("srcblendconvert", SrcBlendConvert);
    GET_DATA_FUNC_I("srcblendscale", SrcBlendScale);

    // Blend methods
    enum BLEND_NAMES
    {
        BLEND_NONE,
        BLEND_WEIGHTEDAVERAGE,
        BLEND_WEIGHTEDSUM,
        BLEND_NETNEWAVERAGE,
        BLEND_NETNEWSDF,
        NUM_BLEND
    };

    // Extra mix methods to handle SDF specific functions
    enum CONVERT_NAMES {
        CONVERT_NONE,
        CONVERT_SDFTOFOG,
        CONVERT_SDFTOSURFACE,
        CONVERT_ABS,
        NUM_CONVERT
    };

    /// Helper methods to apply conversion and blend methods.
    static fpreal        convertValues(CONVERT_NAMES type, LENGTHSCALE_NAMES lengthscale, fpreal premul, fpreal preadd, fpreal value, fpreal width);
    static bool          blendValues(BLEND_NAMES blendmethod, fpreal &d, fpreal dblend, fpreal &sfactor, fpreal sblend);

protected:
    explicit             GAS_Calculate(const SIM_DataFactory *factory);
    virtual             ~GAS_Calculate();

    /// Calculates the desired procedure with dest & src, result
    /// going into dest.
    virtual bool         solveGasSubclass(SIM_Engine &engine,
                                SIM_Object *obj,
                                SIM_Time time,
                                SIM_Time timestep);

    THREADED_METHOD2(GAS_Calculate, dst->shouldMultiThread(),
                     mixEachVoxel,
                     SIM_RawField *, dst,
                     const SIM_RawField *, src)
    void                 mixEachVoxelPartial(SIM_RawField *dst,
                                const SIM_RawField *src,
                                const UT_JobInfo &info);

    THREADED_METHOD4(GAS_Calculate, dst->shouldMultiThread(),
                     mixEachVoxelIndex,
                     SIM_Engine &, engine,
                     SIM_RawField *, dst,
                     const SIM_IndexField *, src,
                     int, srcaxis)
    void                 mixEachVoxelIndexPartial(SIM_Engine &engine,
                                SIM_RawField *dst,
                                const SIM_IndexField *src,
                                int srcaxis,
                                const UT_JobInfo &info);


    THREADED_METHOD4(GAS_Calculate, dst->shouldMultiThread(),
                     blendEachVoxel,
                     SIM_RawField *, dst,
                     const SIM_RawField *, src,
                     const SIM_RawField *, dstblend,
                     const SIM_RawField *, srcblend)
    void                 blendEachVoxelPartial(SIM_RawField *dst,
                                const SIM_RawField *src,
                                const SIM_RawField *dstblend,
                                const SIM_RawField *srcblend,
                                const UT_JobInfo &info);

    THREADED_METHOD6(GAS_Calculate, dst->shouldMultiThread(),
                     blendEachVoxelIndex,
                     SIM_Engine &, engine,
                     SIM_RawField *, dst,
                     const SIM_IndexField *, src,
                     int, srcaxis,
                     const SIM_RawField *, dstblend,
                     const SIM_RawField *, srcblend)
    void                 blendEachVoxelIndexPartial(SIM_Engine &engine,
                                SIM_RawField *dst,
                                const SIM_IndexField *src,
                                int srcaxis,
                                const SIM_RawField *dstblend,
                                const SIM_RawField *srcblend,
                                const UT_JobInfo &info);

    /// Returns true if the current getProperty() is safe to do in
    /// a multithreaded manner.  Ideally would have to invoke
    /// SIM_PropertyResolver for all potential indices, but currently
    /// relies on apriori knowledge that only the fancy velocity
    /// operations are not threadsafe.
    bool        isPropertyThreadsafe() const;

private:
    static const SIM_DopDescription     *getDopDescription();

    DECLARE_STANDARD_GETCASTTOTYPE();
    DECLARE_DATAFACTORY(GAS_Calculate,
                        GAS_SubSolver,
                        "Gas Calculate",
                        getDopDescription());

    // Cache our timestep for so we can calculate the timescale
    // effects.
    float               myTimeStep;
};

#endif

---