// Copyright Epic Games, Inc. All Rights Reserved.


#include "MuR/Operations.h"

#include "MuR/ModelPrivate.h"


namespace mu
{
    MUTABLE_IMPLEMENT_POD_SERIALISABLE(OP);
    MUTABLE_IMPLEMENT_POD_VECTOR_SERIALISABLE(OP);

    // clang-format off
    static const FOpDesc SOperationRuntimeDescs[] =
	{ 
		// DataType				
        { EDataType::None,			},	// NONE

		{ EDataType::Bool,			},	// BO_CONSTANT
		{ EDataType::Int,			},	// NU_CONSTANT
		{ EDataType::Scalar,		},	// SC_CONSTANT
		{ EDataType::Color,			},	// CO_CONSTANT
		{ EDataType::Image,			},	// IM_CONSTANT
		{ EDataType::Mesh,			},	// ME_CONSTANT
		{ EDataType::Layout,		},	// LA_CONSTANT
		{ EDataType::Projector,		},	// PR_CONSTANT
		{ EDataType::String,		},	// ST_CONSTANT
		{ EDataType::ExtensionData,	},	// ED_CONSTANT
		{ EDataType::Matrix,		},	// MA_CONSTANT

		{ EDataType::Bool,			},	// BO_PARAMETER
		{ EDataType::Int,			},	// NU_PARAMETER
		{ EDataType::Scalar,		},	// SC_PARAMETER
		{ EDataType::Color,			},	// CO_PARAMETER
		{ EDataType::Projector,		},	// PR_PARAMETER
		{ EDataType::Image,			},	// IM_PARAMETER
		{ EDataType::Mesh,			},	// ME_PARAMETER
		{ EDataType::String,		},	// ST_PARAMETER
		{ EDataType::Matrix,		},	// MA_PARAMETER

		{ EDataType::Image,			},	// IM_REFERENCE
		{ EDataType::Mesh,			},	// ME_REFERENCE

		{ EDataType::Int,			},	// NU_CONDITIONAL
		{ EDataType::Scalar,		},	// SC_CONDITIONAL
		{ EDataType::Color,			},	// CO_CONDITIONAL
		{ EDataType::Image,			},	// IM_CONDITIONAL
		{ EDataType::Mesh,			},	// ME_CONDITIONAL
		{ EDataType::Layout,		},	// LA_CONDITIONAL
		{ EDataType::Instance,		},	// IN_CONDITIONAL
		{ EDataType::ExtensionData,	},	// ED_CONDITIONAL

		{ EDataType::Int,			},	// NU_SWITCH
		{ EDataType::Scalar,		},	// SC_SWITCH
		{ EDataType::Color,			},	// CO_SWITCH
		{ EDataType::Image,			},	// IM_SWITCH
		{ EDataType::Mesh,			},	// ME_SWITCH
		{ EDataType::Layout,		},	// LA_SWITCH
		{ EDataType::Instance,		},	// IN_SWITCH
		{ EDataType::ExtensionData,	},	// ED_SWITCH

		{ EDataType::Bool,			},	// BO_EQUAL_SC_CONST
		{ EDataType::Bool,			},	// BO_AND
		{ EDataType::Bool,			},	// BO_OR
		{ EDataType::Bool,			},	// BO_NOT

		{ EDataType::Scalar,		},	// SC_ARITHMETIC
		{ EDataType::Scalar,		},	// SC_CURVE

		{ EDataType::Color,			},	// CO_SAMPLEIMAGE
		{ EDataType::Color,			},	// CO_SWIZZLE
		{ EDataType::Color,			},	// CO_FROMSCALARS
		{ EDataType::Color,			},	// CO_ARITHMETIC

		{ EDataType::Image,			},	// IM_LAYER
		{ EDataType::Image,			},	// IM_LAYERCOLOUR
		{ EDataType::Image,			},	// IM_PIXELFORMAT
		{ EDataType::Image,			},	// IM_MIPMAP
		{ EDataType::Image,			},	// IM_RESIZE
		{ EDataType::Image,			},	// IM_RESIZELIKE
		{ EDataType::Image,			},	// IM_RESIZEREL
		{ EDataType::Image,			},	// IM_BLANKLAYOUT
		{ EDataType::Image,			},	// IM_COMPOSE
		{ EDataType::Image,			},	// IM_INTERPOLATE
		{ EDataType::Image,			},	// IM_SATURATE
		{ EDataType::Image,			},	// IM_LUMINANCE
		{ EDataType::Image,			},	// IM_SWIZZLE
		{ EDataType::Image,			},	// IM_COLOURMAP
		{ EDataType::Image,			},	// IM_BINARISE
		{ EDataType::Image,			},	// IM_PLAINCOLOUR
		{ EDataType::Image,			},	// IM_CROP
		{ EDataType::Image,			},	// IM_PATCH
		{ EDataType::Image,			},	// IM_RASTERMESH
		{ EDataType::Image,			},	// IM_MAKEGROWMAP
		{ EDataType::Image,			},	// IM_DISPLACE
		{ EDataType::Image,			},	// IM_MULTILAYER
		{ EDataType::Image,			},	// IM_INVERT
		{ EDataType::Image,			},	// IM_NORMALCOMPOSITE
		{ EDataType::Image,			},	// IM_TRANSFORM

		{ EDataType::Mesh,			},	// ME_APPLYLAYOUT
		{ EDataType::Mesh,			},	// ME_PREPARELAYOUT
		{ EDataType::Mesh,			},	// ME_DIFFERENCE
		{ EDataType::Mesh,			},	// ME_MORPH
		{ EDataType::Mesh,			},	// ME_MERGE
		{ EDataType::Mesh,			},	// ME_MASKCLIPMESH
		{ EDataType::Mesh,			},	// ME_MASKCLIPUVMASK
		{ EDataType::Mesh,			},	// ME_MASKDIFF
		{ EDataType::Mesh,			},	// ME_REMOVEMASK
		{ EDataType::Mesh,			},	// ME_FORMAT
		{ EDataType::Mesh,			},	// ME_EXTRACTLAYOUTBLOCK
		{ EDataType::Mesh,			},	// ME_TRANSFORM
		{ EDataType::Mesh,			},	// ME_CLIPMORPHPLANE
		{ EDataType::Mesh,			},	// ME_CLIPWITHMESH
		{ EDataType::Mesh,			},	// ME_SETSKELETON
		{ EDataType::Mesh,			},	// ME_PROJECT
		{ EDataType::Mesh,			},	// ME_APPLYPOSE
		{ EDataType::Mesh,			},	// ME_BINDSHAPE
		{ EDataType::Mesh,			},	// ME_APPLYSHAPE
		{ EDataType::Mesh,			},	// ME_CLIPDEFORM
		{ EDataType::Mesh,			},	// ME_MORPHRESHAPE
		{ EDataType::Mesh,			},	// ME_OPTIMIZESKINNING
		{ EDataType::Mesh,			},	// ME_ADDMETADATA
		{ EDataType::Mesh,			},	// ME_TRANSFORMWITHMESH

		{ EDataType::Instance,		},	// IN_ADDMESH
		{ EDataType::Instance,		},	// IN_ADDIMAGE
		{ EDataType::Instance,		},	// IN_ADDVECTOR
		{ EDataType::Instance,		},	// IN_ADDSCALAR
		{ EDataType::Instance,		},	// IN_ADDSTRING
		{ EDataType::Instance,		},	// IN_ADDSURFACE
		{ EDataType::Instance,		},	// IN_ADDCOMPONENT
		{ EDataType::Instance,		},	// IN_ADDLOD
		{ EDataType::Instance,		},	// IN_ADDEXTENSIONDATA
		{ EDataType::Instance,		},	// IN_ADDOVERLAYMATERIAL

		{ EDataType::Layout,		},	// LA_PACK
		{ EDataType::Layout,		},	// LA_MERGE
		{ EDataType::Layout,		},	// LA_REMOVEBLOCKS
		{ EDataType::Layout,		},	// LA_FROMMESH
	};

    // clang-format on

    static_assert(UE_ARRAY_COUNT(SOperationRuntimeDescs) == int32(EOpType::COUNT), "OperationDescMismatch");

	const FOpDesc& GetOpDesc( EOpType type )
	{
        return SOperationRuntimeDescs[ (int32)type ];
	}


    //---------------------------------------------------------------------------------------------
    void ForEachReference( const FProgram& program, OP::ADDRESS at, const TFunctionRef<void(OP::ADDRESS)> f )
    {
        EOpType type = program.GetOpType(at);
        switch ( type )
        {
        case EOpType::NONE:
        case EOpType::BO_CONSTANT:
        case EOpType::NU_CONSTANT:
        case EOpType::SC_CONSTANT:
        case EOpType::ST_CONSTANT:
        case EOpType::CO_CONSTANT:
        case EOpType::IM_CONSTANT:
        case EOpType::ME_CONSTANT:
        case EOpType::LA_CONSTANT:
        case EOpType::PR_CONSTANT:
		case EOpType::ED_CONSTANT:
		case EOpType::MA_CONSTANT:
        case EOpType::BO_PARAMETER:
        case EOpType::NU_PARAMETER:
        case EOpType::SC_PARAMETER:
        case EOpType::CO_PARAMETER:
        case EOpType::PR_PARAMETER:
		case EOpType::IM_PARAMETER:
		case EOpType::ME_PARAMETER:
		case EOpType::MA_PARAMETER:
		case EOpType::IM_REFERENCE:
		case EOpType::ME_REFERENCE:
			break;

        case EOpType::SC_CURVE:
        {
			OP::ScalarCurveArgs args = program.GetOpArgs<OP::ScalarCurveArgs>(at);
            f(args.time );
            break;
        }

        case EOpType::NU_CONDITIONAL:
        case EOpType::SC_CONDITIONAL:
        case EOpType::CO_CONDITIONAL:
        case EOpType::IM_CONDITIONAL:
        case EOpType::ME_CONDITIONAL:
        case EOpType::LA_CONDITIONAL:
        case EOpType::IN_CONDITIONAL:
		case EOpType::ED_CONDITIONAL:
        {
			OP::ConditionalArgs args = program.GetOpArgs<OP::ConditionalArgs>(at);
            f(args.condition );
            f(args.yes );
            f(args.no );
            break;
        }

        case EOpType::NU_SWITCH:
        case EOpType::SC_SWITCH:
        case EOpType::CO_SWITCH:
        case EOpType::IM_SWITCH:
        case EOpType::ME_SWITCH:
        case EOpType::LA_SWITCH:
        case EOpType::IN_SWITCH:
		case EOpType::ED_SWITCH:
        {
			const uint8_t* data = program.GetOpArgsPointer(at);
			
			OP::ADDRESS VarAddress;
			FMemory::Memcpy( &VarAddress, data, sizeof(OP::ADDRESS));
			data += sizeof(OP::ADDRESS);

			OP::ADDRESS DefAddress;
			FMemory::Memcpy( &DefAddress, data, sizeof(OP::ADDRESS));
			data += sizeof(OP::ADDRESS);

			uint32 CaseCount;
			FMemory::Memcpy( &CaseCount, data, sizeof(uint32));
			data += sizeof(uint32);

			f(VarAddress);
			f(DefAddress);

			for ( uint32 C = 0; C < CaseCount; ++C )
			{	
				//int32 Condition;
				//FMemory::Memcpy( &Condition, data, sizeof(int32_t));
				data += sizeof(int32);
				
				OP::ADDRESS At;
				FMemory::Memcpy( &At, data, sizeof(OP::ADDRESS) );
				data += sizeof(OP::ADDRESS);

				f(At);
			}

            break;
        }

        //-------------------------------------------------------------------------------------
        case EOpType::BO_EQUAL_INT_CONST:
        {
			OP::BoolEqualScalarConstArgs args = program.GetOpArgs<OP::BoolEqualScalarConstArgs>(at);
            f(args.Value );
            break;
        }

        case EOpType::BO_AND:
        case EOpType::BO_OR:
        {
			OP::BoolBinaryArgs args = program.GetOpArgs<OP::BoolBinaryArgs>(at);
            f(args.A );
            f(args.B );
            break;
        }

        case EOpType::BO_NOT:
        {
			OP::BoolNotArgs args = program.GetOpArgs<OP::BoolNotArgs>(at);
            f(args.A );
            break;
        }

        case EOpType::SC_ARITHMETIC:
        {
			OP::ArithmeticArgs args = program.GetOpArgs<OP::ArithmeticArgs>(at);
            f(args.A );
            f(args.B );
            break;
        }

        case EOpType::CO_SAMPLEIMAGE:
        {
			OP::ColourSampleImageArgs args = program.GetOpArgs<OP::ColourSampleImageArgs>(at);
            f(args.Image );
            f(args.X );
            f(args.Y );
            break;
        }

        case EOpType::CO_SWIZZLE:
        {
			OP::ColourSwizzleArgs args = program.GetOpArgs<OP::ColourSwizzleArgs>(at);
            for (int t=0;t<MUTABLE_OP_MAX_SWIZZLE_CHANNELS;++t)
            {
                f(args.sources[t] );
            }
            break;
        }

        case EOpType::CO_FROMSCALARS:
        {
			OP::ColourFromScalarsArgs args = program.GetOpArgs<OP::ColourFromScalarsArgs>(at);
			for (int32 t = 0; t < MUTABLE_OP_MAX_SWIZZLE_CHANNELS; ++t)
			{
				f(args.V[t]);
			}
            break;
        }

        case EOpType::CO_ARITHMETIC:
        {
			OP::ArithmeticArgs args = program.GetOpArgs<OP::ArithmeticArgs>(at);
            f(args.A);
            f(args.B);
            break;
        }

        //-------------------------------------------------------------------------------------
        case EOpType::IM_LAYER:
        {
			OP::ImageLayerArgs args = program.GetOpArgs<OP::ImageLayerArgs>(at);
            f(args.base );
        	f(args.mask );
            f(args.blended );
            break;
        }

        case EOpType::IM_LAYERCOLOUR:
        {
			OP::ImageLayerColourArgs args = program.GetOpArgs<OP::ImageLayerColourArgs>(at);
            f(args.base );
        	f(args.mask );
            f(args.colour );
            break;
        }

        case EOpType::IM_MULTILAYER:
        {
			OP::ImageMultiLayerArgs args = program.GetOpArgs<OP::ImageMultiLayerArgs>(at);
            f(args.rangeSize );
            f(args.base );
            f(args.mask );
            f(args.blended );
            break;
        }

		case EOpType::IM_NORMALCOMPOSITE:
		{
			OP::ImageNormalCompositeArgs args = program.GetOpArgs<OP::ImageNormalCompositeArgs>(at);
			f(args.base);
			f(args.normal);

			break;
		}

        case EOpType::IM_PIXELFORMAT:
        {
			OP::ImagePixelFormatArgs args = program.GetOpArgs<OP::ImagePixelFormatArgs>(at);
            f(args.source );
            break;
        }

        case EOpType::IM_MIPMAP:
        {
			OP::ImageMipmapArgs args = program.GetOpArgs<OP::ImageMipmapArgs>(at);
            f(args.source );
            break;
        }

        case EOpType::IM_RESIZE:
        {
			OP::ImageResizeArgs Args = program.GetOpArgs<OP::ImageResizeArgs>(at);
            f(Args.Source );
            break;
        }

        case EOpType::IM_RESIZELIKE:
        {
			OP::ImageResizeLikeArgs Args = program.GetOpArgs<OP::ImageResizeLikeArgs>(at);
            f(Args.Source );
            f(Args.SizeSource );
            break;
        }

        case EOpType::IM_RESIZEREL:
        {
			OP::ImageResizeRelArgs Args = program.GetOpArgs<OP::ImageResizeRelArgs>(at);
            f(Args.Source );
            break;
        }

        case EOpType::IM_BLANKLAYOUT:
        {
			OP::ImageBlankLayoutArgs Args = program.GetOpArgs<OP::ImageBlankLayoutArgs>(at);
            f(Args.Layout );
            break;
        }

        case EOpType::IM_COMPOSE:
        {
			OP::ImageComposeArgs args = program.GetOpArgs<OP::ImageComposeArgs>(at);
            f(args.layout );
            f(args.base );
            f(args.blockImage );
            f(args.mask );
            break;
        }

        case EOpType::IM_INTERPOLATE:
        {
			OP::ImageInterpolateArgs Args = program.GetOpArgs<OP::ImageInterpolateArgs>(at);
            f(Args.Factor );

            for (int32 TargetIndex=0; TargetIndex <MUTABLE_OP_MAX_INTERPOLATE_COUNT;++TargetIndex)
            {
                f(Args.Targets[TargetIndex]);
            }
            break;
        }

        case EOpType::IM_SWIZZLE:
        {
			OP::ImageSwizzleArgs args = program.GetOpArgs<OP::ImageSwizzleArgs>(at);
            for (int t=0;t<MUTABLE_OP_MAX_SWIZZLE_CHANNELS;++t)
            {
                f(args.sources[t] );
            }
            break;
        }

        case EOpType::IM_SATURATE:
        {
			OP::ImageSaturateArgs Args = program.GetOpArgs<OP::ImageSaturateArgs>(at);
            f(Args.Base );
            f(Args.Factor );
            break;
        }

        case EOpType::IM_LUMINANCE:
        {
			OP::ImageLuminanceArgs Args = program.GetOpArgs<OP::ImageLuminanceArgs>(at);
            f(Args.Base );
            break;
        }

        case EOpType::IM_COLOURMAP:
        {
			OP::ImageColourMapArgs Args = program.GetOpArgs<OP::ImageColourMapArgs>(at);
            f(Args.Base );
            f(Args.Mask );
            f(Args.Map );
            break;
        }

        case EOpType::IM_BINARISE:
        {
			OP::ImageBinariseArgs Args = program.GetOpArgs<OP::ImageBinariseArgs>(at);
            f(Args.Base );
            f(Args.Threshold );
            break;
        }

        case EOpType::IM_PLAINCOLOUR:
        {
			OP::ImagePlainColorArgs args = program.GetOpArgs<OP::ImagePlainColorArgs>(at);
            f(args.Color );
            break;
        }

        case EOpType::IM_CROP:
        {
			OP::ImageCropArgs args = program.GetOpArgs<OP::ImageCropArgs>(at);
            f(args.source );
            break;
        }

        case EOpType::IM_PATCH:
        {
			OP::ImagePatchArgs args = program.GetOpArgs<OP::ImagePatchArgs>(at);
            f(args.base );
            f(args.patch );
            break;
        }

        case EOpType::IM_RASTERMESH:
        {
			OP::ImageRasterMeshArgs args = program.GetOpArgs<OP::ImageRasterMeshArgs>(at);
            f(args.mesh );
            f(args.image );
            f(args.mask );
            f(args.angleFadeProperties );
            f(args.projector );
            break;
        }

        case EOpType::IM_MAKEGROWMAP:
        {
			OP::ImageMakeGrowMapArgs args = program.GetOpArgs<OP::ImageMakeGrowMapArgs>(at);
            f(args.mask );
            break;
        }

        case EOpType::IM_DISPLACE:
        {
			OP::ImageDisplaceArgs Args = program.GetOpArgs<OP::ImageDisplaceArgs>(at);
            f(Args.Source );
            f(Args.DisplacementMap );
            break;
        }

		case EOpType::IM_INVERT:
		{
			OP::ImageInvertArgs args = program.GetOpArgs<OP::ImageInvertArgs>(at);
			f(args.Base);
			break;
		}

		case EOpType::IM_TRANSFORM:
		{
			OP::ImageTransformArgs Args = program.GetOpArgs<OP::ImageTransformArgs>(at);
			f(Args.Base);
			f(Args.OffsetX);
			f(Args.OffsetY);
			f(Args.ScaleX);
			f(Args.ScaleY);
			f(Args.Rotation);
			break;
		}

        //-------------------------------------------------------------------------------------
        case EOpType::ME_APPLYLAYOUT:
        {
			OP::MeshApplyLayoutArgs args = program.GetOpArgs<OP::MeshApplyLayoutArgs>(at);
            f(args.Layout );
            f(args.Mesh );
            break;
        }

		case EOpType::ME_PREPARELAYOUT:
		{
			OP::MeshPrepareLayoutArgs Args = program.GetOpArgs<OP::MeshPrepareLayoutArgs>(at);
			f(Args.Layout);
			f(Args.Mesh);
			break;
		}

        case EOpType::ME_DIFFERENCE:
        {
			const uint8_t* data = program.GetOpArgsPointer(at);

			OP::ADDRESS BaseAt = 0;
			FMemory::Memcpy(&BaseAt, data, sizeof(OP::ADDRESS)); data += sizeof(OP::ADDRESS);
			f(BaseAt);

			OP::ADDRESS TargetAt = 0;
			FMemory::Memcpy(&TargetAt, data, sizeof(OP::ADDRESS)); data += sizeof(OP::ADDRESS);
			f(TargetAt);
			break;
        }

        case EOpType::ME_MORPH:
        {
			const uint8_t* data = program.GetOpArgsPointer(at);

			OP::ADDRESS FactorAt = 0;
			FMemory::Memcpy(&FactorAt, data, sizeof(OP::ADDRESS)); data += sizeof(OP::ADDRESS);
			f(FactorAt);

			OP::ADDRESS BaseAt = 0;
			FMemory::Memcpy(&BaseAt, data, sizeof(OP::ADDRESS)); data += sizeof(OP::ADDRESS);
			f(BaseAt);

			OP::ADDRESS TargetAt = 0;
			FMemory::Memcpy(&TargetAt, data, sizeof(OP::ADDRESS)); data += sizeof(OP::ADDRESS);
			f(TargetAt);
			break;
        }

        case EOpType::ME_MERGE:
        {
			OP::MeshMergeArgs args = program.GetOpArgs<OP::MeshMergeArgs>(at);
            f(args.Base );
            f(args.Added );
            break;
        }

		case EOpType::ME_MASKCLIPMESH:
		{
			OP::MeshMaskClipMeshArgs args = program.GetOpArgs<OP::MeshMaskClipMeshArgs>(at);
			f(args.source);
			f(args.clip);
			break;
		}

		case EOpType::ME_MASKCLIPUVMASK:
		{
			OP::MeshMaskClipUVMaskArgs Args = program.GetOpArgs<OP::MeshMaskClipUVMaskArgs>(at);
			f(Args.Source);
			f(Args.UVSource);
			f(Args.MaskImage);
			f(Args.MaskLayout);
			break;
		}

        case EOpType::ME_MASKDIFF:
        {
			OP::MeshMaskDiffArgs args = program.GetOpArgs<OP::MeshMaskDiffArgs>(at);
            f(args.Source );
            f(args.Fragment );
            break;
        }

        case EOpType::ME_REMOVEMASK:
        {
            const uint8* data = program.GetOpArgsPointer(at);
            mu::OP::ADDRESS source;
            FMemory::Memcpy( &source, data, sizeof(OP::ADDRESS) ); data+=sizeof(OP::ADDRESS);
            f(source);

			EFaceCullStrategy FaceCullStrategy;
			FMemory::Memcpy(&FaceCullStrategy, data, sizeof(EFaceCullStrategy));
			data += sizeof(EFaceCullStrategy);

            uint16 removes = 0;
			FMemory::Memcpy( &removes, data, sizeof(uint16) ); data+=sizeof(uint16);
            for (uint16 r=0; r<removes; ++r)
            {
                mu::OP::ADDRESS condition;
				FMemory::Memcpy( &condition, data, sizeof(OP::ADDRESS) ); data+=sizeof(OP::ADDRESS);
                f(condition);

                mu::OP::ADDRESS mask;
				FMemory::Memcpy( &mask, data, sizeof(OP::ADDRESS) ); data+=sizeof(OP::ADDRESS);
                f(mask);
            }
            break;
        }

		case EOpType::ME_ADDMETADATA:
		{
			OP::MeshAddMetadataArgs Args = program.GetOpArgs<OP::MeshAddMetadataArgs>(at);
			f(Args.Source);
			break;
		}

        case EOpType::ME_FORMAT:
        {
			OP::MeshFormatArgs args = program.GetOpArgs<OP::MeshFormatArgs>(at);
            f(args.source );
            f(args.format );
            break;
        }

        case EOpType::ME_TRANSFORM:
        {
			OP::MeshTransformArgs args = program.GetOpArgs<OP::MeshTransformArgs>(at);
            f(args.source );
            break;
        }

        case EOpType::ME_EXTRACTLAYOUTBLOCK:
        {
            const uint8_t* data = program.GetOpArgsPointer(at);
            mu::OP::ADDRESS source;
			FMemory::Memcpy( &source, data, sizeof(OP::ADDRESS) );
            f(source);
            break;
        }

        case EOpType::ME_CLIPMORPHPLANE:
        {
			OP::MeshClipMorphPlaneArgs args = program.GetOpArgs<OP::MeshClipMorphPlaneArgs>(at);
            f(args.Source);
            break;
        }

        case EOpType::ME_CLIPWITHMESH :
        {
			OP::MeshClipWithMeshArgs Args = program.GetOpArgs<OP::MeshClipWithMeshArgs>(at);
            f(Args.Source);
            f(Args.ClipMesh);
            break;
        }

        case EOpType::ME_CLIPDEFORM:
        {
			OP::MeshClipDeformArgs args = program.GetOpArgs<OP::MeshClipDeformArgs>(at);
            f(args.mesh);
            f(args.clipShape);
            break;
        }
       
		case EOpType::ME_MORPHRESHAPE:
		{
			OP::MeshMorphReshapeArgs Args = program.GetOpArgs<OP::MeshMorphReshapeArgs>(at);
			f(Args.Morph);
			f(Args.Reshape);

			break;
		}
 
        case EOpType::ME_SETSKELETON :
        {
			OP::MeshSetSkeletonArgs Args = program.GetOpArgs<OP::MeshSetSkeletonArgs>(at);
            f(Args.Source);
            f(Args.Skeleton);
            break;
        }

        case EOpType::ME_PROJECT :
        {
			OP::MeshProjectArgs Args = program.GetOpArgs<OP::MeshProjectArgs>(at);
            f(Args.Mesh);
            f(Args.Projector);
            break;
        }

		case EOpType::ME_APPLYPOSE:
		{
			OP::MeshApplyPoseArgs Args = program.GetOpArgs<OP::MeshApplyPoseArgs>(at);
			f(Args.base);
			f(Args.pose);
			break;
		}

		case EOpType::ME_BINDSHAPE:
		{
			OP::MeshBindShapeArgs args = program.GetOpArgs<OP::MeshBindShapeArgs>(at);
			f(args.mesh);
			f(args.shape);
			break;
		}

		case EOpType::ME_APPLYSHAPE:
		{
			OP::MeshApplyShapeArgs args = program.GetOpArgs<OP::MeshApplyShapeArgs>(at);
			f(args.mesh);
			f(args.shape);
			break;
		}

		case EOpType::ME_OPTIMIZESKINNING:
		{
			OP::MeshOptimizeSkinningArgs args = program.GetOpArgs<OP::MeshOptimizeSkinningArgs>(at);
			f(args.source);
			break;
		}

        case EOpType::ME_TRANSFORMWITHMESH :
        {
        	OP::MeshTransformWithinMeshArgs args = program.GetOpArgs<OP::MeshTransformWithinMeshArgs>(at);
        	f(args.sourceMesh);
        	f(args.boundingMesh);
        	f(args.matrix);
        	break;
        }
        	
        //-------------------------------------------------------------------------------------
        case EOpType::IN_ADDMESH:
        case EOpType::IN_ADDIMAGE:
        case EOpType::IN_ADDVECTOR:
        case EOpType::IN_ADDSCALAR:
        case EOpType::IN_ADDSTRING:
        case EOpType::IN_ADDCOMPONENT:
        case EOpType::IN_ADDSURFACE:
        {
			OP::InstanceAddArgs args = program.GetOpArgs<OP::InstanceAddArgs>(at);
            f(args.instance );
            f(args.value );
            break;
        }

        case EOpType::IN_ADDLOD:
        {
			const uint8* Data = program.GetOpArgsPointer(at);

			uint8 LODCount;
			FMemory::Memcpy(&LODCount, Data, sizeof(uint8));
			Data += sizeof(uint8);

			for (int8 LODIndex = 0; LODIndex < LODCount; ++LODIndex)
			{
				OP::ADDRESS LODAddress;
				FMemory::Memcpy(&LODAddress, Data, sizeof(OP::ADDRESS));
				Data += sizeof(OP::ADDRESS);

				f(LODAddress);
            }
            break;
        }

		case EOpType::IN_ADDEXTENSIONDATA:
		{
			const OP::InstanceAddExtensionDataArgs Args = program.GetOpArgs<OP::InstanceAddExtensionDataArgs>(at);

			f(Args.Instance);
			f(Args.ExtensionData);

			break;
		}

		case EOpType::IN_ADDOVERLAYMATERIAL:
		{
			const OP::InstanceAddOverlayMaterialArgs Args = program.GetOpArgs<OP::InstanceAddOverlayMaterialArgs>(at);

			f(Args.Instance);
			f(Args.OverlayMaterialId);

			break;
		}

        //-------------------------------------------------------------------------------------
        case EOpType::LA_PACK:
        {
			OP::LayoutPackArgs args = program.GetOpArgs<OP::LayoutPackArgs>(at);
            f(args.Source );
            break;
        }

        case EOpType::LA_MERGE:
        {
			OP::LayoutMergeArgs args = program.GetOpArgs<OP::LayoutMergeArgs>(at);
            f(args.Base );
            f(args.Added );
            break;
        }

		case EOpType::LA_REMOVEBLOCKS:
		{
			OP::LayoutRemoveBlocksArgs args = program.GetOpArgs<OP::LayoutRemoveBlocksArgs>(at);
			f(args.Source);
			f(args.ReferenceLayout);
			break;
		}

		case EOpType::LA_FROMMESH:
		{
			OP::LayoutFromMeshArgs args = program.GetOpArgs<OP::LayoutFromMeshArgs>(at);
			f(args.Mesh);
			break;
		}

        default:
			check( false );
            break;
        }

    }


}