public void ShareScreenshot(MegacoolRecordingConfig recordingConfig,
                                MegacoolShareConfig shareConfig)
    {
        IntPtr recordingPointer = IntPtr.Zero;

        if (recordingConfig != null)
        {
            recordingPointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLRecordingConfig)));
            MCLRecordingConfig nativeRecordingConfig = GetNativeRecordingConfig(recordingConfig);
            Marshal.StructureToPtr(nativeRecordingConfig, recordingPointer, false);
        }
        IntPtr sharePointer = IntPtr.Zero;

        if (shareConfig != null)
        {
            sharePointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLShareConfig)));
            MCLShareConfig nativeShareConfig = GetNativeShareConfig(shareConfig);
            Marshal.StructureToPtr(nativeShareConfig, sharePointer, false);
        }

        mcl_share_screenshot(recordingPointer, sharePointer);

        if (recordingConfig != null)
        {
            Marshal.FreeHGlobal(recordingPointer);
        }
        if (shareConfig != null)
        {
            Marshal.FreeHGlobal(sharePointer);
        }
    }
    public void SetDefaultRecordingConfig(MegacoolRecordingConfig config)
    {
        if (config == null)
        {
            mcl_set_default_recording_config(IntPtr.Zero);
            return;
        }
        MCLRecordingConfig nativeConfig = GetNativeRecordingConfig(config);
        IntPtr             pointer      = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLRecordingConfig)));

        Marshal.StructureToPtr(nativeConfig, pointer, false);
        mcl_set_default_recording_config(pointer);
        Marshal.FreeHGlobal(pointer);
    }
    public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
    {
        if (config == null)
        {
            mcl_capture_frame(IntPtr.Zero, forceAdd);
            return;
        }
        MCLRecordingConfig nativeConfig = GetNativeRecordingConfig(config);
        IntPtr             pointer      = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLRecordingConfig)));

        Marshal.StructureToPtr(nativeConfig, pointer, false);
        mcl_capture_frame(pointer, forceAdd);
        Marshal.FreeHGlobal(pointer);
    }
    private MCLRecordingConfig GetNativeRecordingConfig(MegacoolRecordingConfig config)
    {
        MCLRecordingConfig nativeConfig = new MCLRecordingConfig {
            overflowStrategy  = -1,
            maxFrames         = -1,
            frameRate         = -1,
            playbackFrameRate = -1,
            peakLocation      = -1.0,
            lastFrameDelay    = -1,
        };

        if (config._HasOverflowStrategy())
        {
            nativeConfig.overflowStrategy = (int)config.OverflowStrategy;
        }
        if (config._HasFrameRate())
        {
            nativeConfig.frameRate = config.FrameRate;
        }
        if (config._HasPlaybackFrameRate())
        {
            nativeConfig.playbackFrameRate = config.PlaybackFrameRate;
        }
        if (config._HasMaxFrames())
        {
            nativeConfig.maxFrames = config.MaxFrames;
        }
        if (config._HasRecordingId())
        {
            nativeConfig.recordingId = config.RecordingId;
        }
        if (config._HasPeakLocation())
        {
            nativeConfig.peakLocation = config.PeakLocation;
        }
        if (config._HasLastFrameDelay())
        {
            nativeConfig.lastFrameDelay = config.LastFrameDelay;
        }
        if (config.LastFrameOverlay != null)
        {
            nativeConfig.lastFrameOverlay =
                Application.streamingAssetsPath + "/" + config.LastFrameOverlay;
        }
        return(nativeConfig);
    }