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 ShareScreenshot(MegacoolRecordingConfig recordingConfig, MegacoolShareConfig shareConfig) { AndroidJavaObject jRecordingConfig = RecordingConfigToJavaObject(recordingConfig); AndroidJavaObject jShareConfig = ShareConfigToJavaObject(shareConfig); megacool.Call("shareScreenshot", CurrentActivity, null, jRecordingConfig, jShareConfig); }
private double GetTimeBetweenCaptures(MegacoolRecordingConfig config) { if (config != null && config._HasFrameRate()) { return(1.0 / config.FrameRate); } return(1.0 / MegacoolConfiguration.Instance.recordingFrameRate); }
private AndroidJavaObject RecordingConfigToJavaObject(MegacoolRecordingConfig config) { if (config == null) { return(null); } AndroidJavaObject jConfig = new AndroidJavaObject("co.megacool.megacool.RecordingConfig"); if (config._HasRecordingId()) { jConfig.Call <AndroidJavaObject>("id", config.RecordingId); } if (config._HasMaxFrames()) { jConfig.Call <AndroidJavaObject>("maxFrames", config.MaxFrames); } if (config._HasFrameRate()) { jConfig.Call <AndroidJavaObject>("frameRate", config.FrameRate); } if (config._HasPlaybackFrameRate()) { jConfig.Call <AndroidJavaObject>("playbackFrameRate", config.PlaybackFrameRate); } if (config._HasLastFrameDelay()) { jConfig.Call <AndroidJavaObject>("lastFrameDelay", config.LastFrameDelay); } if (config._HasPeakLocation()) { jConfig.Call <AndroidJavaObject>("peakLocation", config.PeakLocation); } if (config.LastFrameOverlay != null) { jConfig.Call <AndroidJavaObject>("lastFrameOverlayAsset", config.LastFrameOverlay); } if (config._HasOverflowStrategy()) { AndroidJavaClass overflowStrategyClass = new AndroidJavaClass("co.megacool.megacool.OverflowStrategy"); AndroidJavaObject jOverflowStrategy; if (config.OverflowStrategy == MegacoolOverflowStrategy.HIGHLIGHT) { jOverflowStrategy = overflowStrategyClass.GetStatic <AndroidJavaObject>("HIGHLIGHT"); } else if (config.OverflowStrategy == MegacoolOverflowStrategy.TIMELAPSE) { jOverflowStrategy = overflowStrategyClass.GetStatic <AndroidJavaObject>("TIMELAPSE"); } else { jOverflowStrategy = overflowStrategyClass.GetStatic <AndroidJavaObject>("LATEST"); } jConfig.Call <AndroidJavaObject>("overflowStrategy", jOverflowStrategy); } return(jConfig); }
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd) { if (currentRecording == null || currentRecording.isFinished) { MegacoolRecordingConfig mergedConfig = MergeWithDefault(config); currentRecording = new MegacoolRecording(mergedConfig); currentRecording.Start(); } capturingFrame = true; currentRecording.CaptureFrame(forceAdd); }
/// <summary> /// Capture a single frame. /// </summary> /// <description> /// If the recording doesn't already exist it'll be created with the settings specified in the /// config. /// </description> /// <param name="config">the configuration to use to create the recording, if it doesn't already /// exist.</param> /// <param name="forceAdd">Set to true to ensure the frame is included in the recording, even if /// the overflow strategy otherwise would skip it. Useful for timelapse to include the last /// frame with a score board or final state.</param> public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd) { captureManager = GetManager(); if (!captureManager) { return; } captureManager.StartWrites(0); _RenderThisFrame = true; _platformAgent.CaptureFrame(config, forceAdd); }
/// <summary> /// Start customized GIF recording. /// </summary> /// <remarks> /// This will keep a buffer of 50 frames (default). The frames are overwritten until <c>StopRecording</c> gets called. /// </remarks> /// <param name="config">Config to customize the recording.</param> public void StartRecording(MegacoolRecordingConfig config) { captureManager = GetManager(); if (!captureManager) { return; } captureManager.StartWrites(GetTimeBetweenCaptures(config)); _platformAgent.StartRecording(config); _IsRecording = true; SafeReleaseTextureReady(); }
/// <summary> /// Start customized GIF recording. /// </summary> /// <remarks> /// This will keep a buffer of 50 frames (default). The frames are overwritten until <c>StopRecording</c> gets called. /// </remarks> /// <param name="config">Config to customize the recording.</param> public void StartRecording(MegacoolRecordingConfig config) { config.SetDefaults(); InitializeManager(); #if UNITY_IOS && !UNITY_EDITOR startRecordingWithConfig(config.RecordingId, new Crop(new Rect(0, 0, 0, 0)), config.MaxFrames, config.FrameRate, config.PeakLocation, config.OverflowStrategy.ToString()); #elif UNITY_ANDROID && !UNITY_EDITOR AndroidWrapper.StartRecording(config); #endif _isRecording = true; }
/// <summary> /// Take a screenshot and share it immediately. /// </summary> /// <description> /// <para> /// This is a helper around {@link #captureFrame(View)} and {@link #share(Activity)} when you /// only need to share a screenshot and not all the other bells and whistles for recordings. /// </para> /// <para> /// This method is functionally equivalent to: /// <code> /// Megacool.Instance.PauseRecording(); /// string tempRecording = "random-unused-id"; /// Megacool.Instance.CaptureFrame(new MegacoolRecordingConfig { /// RecordingId = tempRecordingId, /// MaxFrames = 1, /// }); /// Megacool.Instance.Share(new MegacoolShareConfig { /// RecordingId = tempRecordingId, /// }); /// Megacool.Instance.DeleteRecording(tempRecordingId); /// </code> /// Note that if this method is called while a recording is underway the screenshot is likely to /// be missing from the share. To stay on the safe side, leave a couple hundred ms between /// stopping a recording and sharing a screenshot. /// </para> /// </description> /// <param name="recordingConfig">The recording config, or <c>null</c>. Most properties don't /// apply to screenshots, but the last frame overlay does.</param> /// <param name="shareConfig">The share config, or <c>null</c>.</param> public void ShareScreenshot(MegacoolRecordingConfig recordingConfig = null, MegacoolShareConfig shareConfig = null) { captureManager = GetManager(); if (captureManager) { // Only try to capture if we have a manager, but always call down to the SDK to make // sure the share happens anyway captureManager.StartWrites(0); _RenderThisFrame = true; } _platformAgent.ShareScreenshot(recordingConfig, shareConfig); }
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); }
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 StartRecording(MegacoolRecordingConfig config) { if (currentRecording != null && !currentRecording.isFinished) { currentRecording = persistentRecordings.Restore(config.RecordingId); return; } if (!keepCompletedRecordings) { persistentRecordings.Clear(); } MegacoolRecordingConfig mergedConfig = MergeWithDefault(config); currentRecording = new MegacoolRecording(mergedConfig); currentRecording.Start(); }
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); }
MegacoolRecordingConfig MergeWithDefault(MegacoolRecordingConfig config) { if (config == null) { return(DefaultRecordingConfig); } MegacoolRecordingConfig merged = new MegacoolRecordingConfig(); merged.MaxFrames = config._HasMaxFrames() ? config.MaxFrames : DefaultRecordingConfig.MaxFrames; merged.FrameRate = config._HasFrameRate() ? config.FrameRate : DefaultRecordingConfig.FrameRate; merged.LastFrameDelay = config._HasLastFrameDelay() ? config.LastFrameDelay : DefaultRecordingConfig.LastFrameDelay; merged.LastFrameOverlay = config.LastFrameOverlay ?? DefaultRecordingConfig.LastFrameOverlay; merged.OverflowStrategy = config._HasOverflowStrategy() ? config.OverflowStrategy : DefaultRecordingConfig.OverflowStrategy; merged.PeakLocation = config._HasPeakLocation() ? config.PeakLocation : DefaultRecordingConfig.PeakLocation; merged.RecordingId = config._HasRecordingId() ? config.RecordingId : DefaultRecordingConfig.RecordingId; merged.PlaybackFrameRate = config._HasPlaybackFrameRate() ? config.PlaybackFrameRate : DefaultRecordingConfig.PlaybackFrameRate; return(merged); }
public void StartRecording(MegacoolRecordingConfig config) { AndroidJavaObject jConfig = new AndroidJavaObject("co.megacool.megacool.RecordingConfig"); // We have to use the generic version of Call here since the Java methods are not void, even // though we discard the return value jConfig.Call <AndroidJavaObject>("id", config.RecordingId); jConfig.Call <AndroidJavaObject>("maxFrames", config.MaxFrames); jConfig.Call <AndroidJavaObject>("peakLocation", config.PeakLocation); jConfig.Call <AndroidJavaObject>("frameRate", config.FrameRate); jConfig.Call <AndroidJavaObject>("playbackFrameRate", config.PlaybackFrameRate); jConfig.Call <AndroidJavaObject>("lastFrameDelay", config.LastFrameDelay); jConfig.Call <AndroidJavaObject>("overflowStrategy", config.OverflowStrategy.ToString()); // AndroidJavaObject jCrop = new AndroidJavaObject("android.graphics.Rect", // (int)config.Crop.xMin, (int)config.Crop.yMin, (int)config.Crop.xMax, (int)config.Crop.yMax); // jConfig.Call<AndroidJavaObject>("cropRect", jCrop); Android.Call("startRecording", jConfig); }
public MegacoolRecording(MegacoolRecordingConfig config) { recordingId = config.RecordingId; lastFrameDelay = config.LastFrameDelay; playbackFrameRate = config.PlaybackFrameRate; maxFrames = config.MaxFrames; peakLocation = config.PeakLocation; switch (config.OverflowStrategy) { case MegacoolOverflowStrategy.HIGHLIGHT: buffer = new HighlightBuffer(this); break; case MegacoolOverflowStrategy.TIMELAPSE: buffer = new TimelapseBuffer(recordingId, maxFrames); break; default: buffer = new CircularBuffer(recordingId, maxFrames); break; } }
private void SetupDefaultConfiguration() { DefaultShareConfig = new MegacoolShareConfig(); DefaultRecordingConfig = new MegacoolRecordingConfig(); }
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config) { AndroidJavaObject jConfig = RecordingConfigToJavaObject(config); megacool.Call("setDefaultRecordingConfig", jConfig); }
/// <summary> /// Capture a single frame. /// </summary> /// <description> /// If the recording doesn't already exist it'll be created with the settings specified in the /// config. /// </description> /// <param name="config">the configuration to use to create the recording, if it doesn't already /// exist.</param> public void CaptureFrame(MegacoolRecordingConfig config) { CaptureFrame(config, false); }
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd) { AndroidJavaObject jConfig = RecordingConfigToJavaObject(config); megacool.Call("captureFrame", null, jConfig, forceAdd); }
public void StartRecording(MegacoolRecordingConfig config) { AndroidJavaObject jConfig = RecordingConfigToJavaObject(config); megacool.Call("startRecording", null, jConfig); }
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config) { }
public void StartRecording(MegacoolRecordingConfig config) { }
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd) { }
public void ShareScreenshot(MegacoolRecordingConfig recordingConfig, MegacoolShareConfig shareConfig) { ImplementationWarning("ShareScreenshot"); }
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd) { recordingManager.CaptureFrame(config, forceAdd); }
public void ShareScreenshot(MegacoolRecordingConfig recordingConfig, MegacoolShareConfig shareConfig) { }
public void StartRecording(MegacoolRecordingConfig config) { recordingManager.StartRecording(config); }
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config) { recordingManager.DefaultRecordingConfig = config ?? new MegacoolRecordingConfig(); }