4631 lines
181 KiB
C#
4631 lines
181 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
using GCSeries.Core;
|
|
using F3Device.Device;
|
|
|
|
namespace GCSeries.zView
|
|
{
|
|
public partial class GView : MonoBehaviour
|
|
{
|
|
//////////////////////////////////////////////////////////////////
|
|
// Events
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
public delegate void EventHandler(GView sender, IntPtr connection);
|
|
|
|
/// <summary>
|
|
/// Event dispatched when a connection has been accepted.
|
|
/// </summary>
|
|
public event EventHandler ConnectionAccepted;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when a connection has switched modes.
|
|
/// </summary>
|
|
public event EventHandler ConnectionModeSwitched;
|
|
|
|
#pragma warning disable 0067
|
|
/// <summary>
|
|
/// Event dispatched when a connection has transitioned
|
|
/// to the ModeActive connection state.
|
|
/// </summary>
|
|
public event EventHandler ConnectionModeActive;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when a connection has transitioned
|
|
/// to the ModePaused connection state.
|
|
/// </summary>
|
|
public event EventHandler ConnectionModePaused;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when a connection has been closed.
|
|
/// </summary>
|
|
public event EventHandler ConnectionClosed;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when a connection error has occurred.
|
|
/// </summary>
|
|
public event EventHandler ConnectionError;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when video recording has transitioned to
|
|
/// an inactive state.
|
|
/// </summary>
|
|
public event EventHandler VideoRecordingInactive;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when video recording has transitioned to
|
|
/// an active recording state.
|
|
/// </summary>
|
|
public event EventHandler VideoRecordingActive;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when video recording has finished.
|
|
/// </summary>
|
|
public event EventHandler VideoRecordingFinished;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when video recording has paused.
|
|
/// </summary>
|
|
public event EventHandler VideoRecordingPaused;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when a video recording error has occurred.
|
|
/// </summary>
|
|
public event EventHandler VideoRecordingError;
|
|
|
|
/// <summary>
|
|
/// Event dispatched when the video recording quality has changed.
|
|
/// </summary>
|
|
public event EventHandler VideoRecordingQualityChanged;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Enumerations
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
/// <summary>
|
|
/// Defines the types of zView nodes that can exist.
|
|
/// </summary>
|
|
public enum NodeType
|
|
{
|
|
Presenter = 0,
|
|
Viewer = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the availability states for zView modes.
|
|
/// </summary>
|
|
public enum ModeAvailability
|
|
{
|
|
/// <summary>
|
|
/// Mode is available.
|
|
/// </summary>
|
|
Available = 0,
|
|
|
|
/// <summary>
|
|
/// Mode is not available.
|
|
/// </summary>
|
|
NotAvailable = 1,
|
|
|
|
/// <summary>
|
|
/// Mode is not available because no webcam hardware is available.
|
|
/// </summary>
|
|
NotAvailableNoWebcam = 2,
|
|
|
|
/// <summary>
|
|
/// Mode is not available because necessary calibration has not been
|
|
/// performed.
|
|
/// </summary>
|
|
NotAvailableNotCalibrated = 3,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the optional capabilities that may be implemented by a zView
|
|
/// node.
|
|
/// </summary>
|
|
public enum Capability
|
|
{
|
|
/// <summary>
|
|
/// The node supports video recording via the video recording APIs.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A zView connection will support this capability as long as the viewer
|
|
/// node in the connection supports this capability. The presenter node
|
|
/// need not support this capability.
|
|
/// </remarks>
|
|
VideoRecording = 0,
|
|
|
|
/// <summary>
|
|
/// The node supports responding to requests to exit the application
|
|
/// hosting the node when a zView connection is closed.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// For a zView node to support this capability, the application hosting
|
|
/// the node must call GetConnectionCloseAction() whenever a zView
|
|
/// connection enters the ConnectionState.Closed state and then exit
|
|
/// if the close action is ConnectionCloseAction.ExitApplication.
|
|
/// </remarks>
|
|
RemoteApplicationExit = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the keys for all mode and mode spec attributes.
|
|
/// </summary>
|
|
public enum ModeAttributeKey
|
|
{
|
|
/// <summary>
|
|
/// The version of the mode.
|
|
/// Datatype: UInt32.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Different versions of a mode may function differently and may have
|
|
/// different settings and frame data/buffers.
|
|
/// </remarks>
|
|
Version = 0,
|
|
|
|
/// <summary>
|
|
/// The mode's compositing mode.
|
|
/// Datatype: CompositingMode (get/set as UInt32).
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This indicates how the viewer node should composite the images it
|
|
/// receives from the presenter node.
|
|
/// </remarks>
|
|
CompositingMode = 1,
|
|
|
|
/// <summary>
|
|
/// The mode's presenter camera mode.
|
|
/// Datatype: CameraMode (get/set as UInt32).
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This indicates how the presenter node's camera should function when the
|
|
/// mode is active.
|
|
/// </remarks>
|
|
PresenterCameraMode = 2,
|
|
|
|
/// <summary>
|
|
/// The order of rows of pixels in images generated for the mode.
|
|
/// Datatype: ImageRowOrder (get/set as UInt32).
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Any images generated by either the presenter or viewer node for the
|
|
/// mode should have their rows of pixels in this order.
|
|
/// </remarks>
|
|
ImageRowOrder = 3,
|
|
|
|
/// <summary>
|
|
/// The format of pixels in color images generated for the mode.
|
|
/// Datatype: PixelFormat (get/set as UInt32).
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Any color images generated by either the presenter or viewer node for
|
|
/// the mode should use this pixel format. The pixel format specifies the
|
|
/// number, type, order, and size of the channels in a pixel.
|
|
/// </remarks>
|
|
ColorImagePixelFormat = 4,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible zView mode compositing modes.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This specifies the valid values that can be used to set the
|
|
/// ModeAttributeKey.CompositingMode mode/mode spec attribute.
|
|
/// </remarks>
|
|
public enum CompositingMode
|
|
{
|
|
/// <summary>
|
|
/// No compositing will be performed.
|
|
/// </summary>
|
|
None = 0,
|
|
|
|
/// <summary>
|
|
/// Images will be composited on top of images from an augmented
|
|
/// reality camera video stream.
|
|
/// </summary>
|
|
AugmentedRealityCamera = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible zView mode camera modes.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This currently specifies the valid values that can be used to set the
|
|
/// ModeAttributeKey.PresenterCameraMode mode/mode spec attribute.
|
|
/// </remarks>
|
|
public enum CameraMode
|
|
{
|
|
/// <summary>
|
|
/// The camera should have a fixed pose that never changes.
|
|
/// </summary>
|
|
Fixed = 0,
|
|
|
|
/// <summary>
|
|
/// The camera's pose should change according to head tracking
|
|
/// information obtained on the local zView node.
|
|
/// </summary>
|
|
LocalHeadTracked = 1,
|
|
|
|
/// <summary>
|
|
/// The camera's pose should change according to information sent
|
|
/// from the remote zView node.
|
|
/// </summary>
|
|
RemoteMovable = 2,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible image pixel formats.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This currently specifies the valid values that can be used to set the
|
|
/// ModeAttributeKey.ColorImagePixelFormat mode/mode spec attribute.
|
|
/// </remarks>
|
|
public enum PixelFormat
|
|
{
|
|
/// <summary>
|
|
/// Pixel format with four 8-bit channels in the following order:
|
|
/// red, green, blue, and alpha.
|
|
/// </summary>
|
|
R8G8B8A8 = 0,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible orderings for pixel rows within images.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This currently specifies the valid values that can be used to set the
|
|
/// ModeAttributeKey.ImageRowOrder mode/mode spec attribute.
|
|
/// </remarks>
|
|
public enum ImageRowOrder
|
|
{
|
|
/// <summary>
|
|
/// The top row of pixels occurs first in the image data and the
|
|
/// remaining rows are ordered from top to bottom.
|
|
/// </summary>
|
|
TopToBottom = 0,
|
|
|
|
/// <summary>
|
|
/// The bottom row of pixels occurs first in the image data and the
|
|
/// remaining rows are ordered from bottom to top.
|
|
/// </summary>
|
|
BottomToTop = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible zView connection states.
|
|
/// </summary>
|
|
public enum ConnectionState
|
|
{
|
|
/// <summary>
|
|
/// The connection is initializing.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code should not perform any zView operations
|
|
/// using the connection.
|
|
///
|
|
/// The connection will automatically transition to the
|
|
/// AwaitingConnectionAcceptance state when it has
|
|
/// finished initializing.
|
|
/// </remarks>
|
|
ConnectionInitialization = 0,
|
|
|
|
/// <summary>
|
|
/// The connection is waiting to be locally accepted or rejected.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// If the connection is accepted, it will transition to the
|
|
/// SwitchingModes state. If the connection is rejected, it will
|
|
/// transition to the Closed state.
|
|
/// </remarks>
|
|
AwaitingConnectionAcceptance = 1,
|
|
|
|
/// <summary>
|
|
/// The connection is internally switching between zView modes.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code is not required to perform any zView
|
|
/// operations using the connection.
|
|
///
|
|
/// The connection will automatically transition to the NoMode state (if
|
|
/// a switch to the NULL mode was requested) or to the ModeSetup state
|
|
/// (if a switch a non-NULL mode was requested) when it has finished switching
|
|
/// modes internally.
|
|
/// </remarks>
|
|
SwitchingModes = 2,
|
|
|
|
/// <summary>
|
|
/// The connection is not currently in any zView mode.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code is not required to perform any zView
|
|
/// operations using the connection.
|
|
///
|
|
/// The connection can be switched into a mode by calling
|
|
/// SetConnectionMode().
|
|
/// </remarks>
|
|
NoMode = 3,
|
|
|
|
/// <summary>
|
|
/// The connection is setting up the current zView mode.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The connection will transition to the ModeActive state once all
|
|
/// mode setup phases for the current mode have been completed by both
|
|
/// the local and remote nodes.
|
|
/// </remarks>
|
|
ModeSetup = 4,
|
|
|
|
/// <summary>
|
|
/// The connection's current zView mode is active.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code should be sending frames to and/or receiving
|
|
/// frames from the remote zView node.
|
|
///
|
|
/// The connection's current zView mode can be paused by calling PauseMode().
|
|
/// This will transition the connection into the ModePaused state.
|
|
/// </remarks>
|
|
ModeActive = 5,
|
|
|
|
/// <summary>
|
|
/// The connection's current zView mode is paused.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code should not be sending frames to nor
|
|
/// receiving frames from the remote zView node. Client code is not
|
|
/// required to perform any zView operations while the connection is in
|
|
/// this state.
|
|
///
|
|
/// The connection's current zView mode can be resumed by calling
|
|
/// ResumeMode(). This will transition the connection into the
|
|
/// ModeResuming state.
|
|
/// </remarks>
|
|
ModePaused = 6,
|
|
|
|
/// <summary>
|
|
/// The connection's current zView mode is resuming.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The connection will automatically transition to the ModeActive state
|
|
/// or to the ModeSetup state when it has finished resuming the current mode.
|
|
/// The ModeSetup state is only transitioned to if there changes have been
|
|
/// made to mode-specific settings (while the mode was paused) that require
|
|
/// one or more mode setup phases to be rerun.
|
|
/// </remarks>
|
|
ModeResuming = 7,
|
|
|
|
/// <summary>
|
|
/// The connection is internally processing a change to a
|
|
/// mode-specific setting that will require one or more mode setup phases
|
|
/// to be rerun.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The connection will automatically transition to the ModeSetup state when it
|
|
/// has finished internally processing the mode-specific settings change.
|
|
/// </remarks>
|
|
ProcessingModeSettingsChange = 8,
|
|
|
|
/// <summary>
|
|
/// The connection is closed and should be cleaned up and destroyed.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code may call GetConnectionCloseReason() to
|
|
/// determine why the connection was closed.
|
|
///
|
|
/// In this state client code may call GetConnectionCloseAction() and
|
|
/// then optionally perform the requested action.
|
|
/// </remarks>
|
|
Closed = 9,
|
|
|
|
/// <summary>
|
|
/// An error has occurred and the connection is no longer usable.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code may call GetConnectionError() to
|
|
/// determine the type of error that occurred.
|
|
/// </remarks>
|
|
Error = 10,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible zView connection close actions.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When closing a connection by calling CloseConnection(), one of these
|
|
/// actions must be specified as the action that the remote zView node should
|
|
/// take after the connection is closed.
|
|
///
|
|
/// Once a connection enters the ConnectionState.Closed state, the close
|
|
/// action for the connection can be queried by calling GetConnectionCloseAction().
|
|
/// </remarks>
|
|
public enum ConnectionCloseAction
|
|
{
|
|
/// <summary>
|
|
/// The application hosting the zView node should not perform any
|
|
/// additional action after the connection is closed.
|
|
/// </summary>
|
|
None = 0,
|
|
|
|
/// <summary>
|
|
/// The application hosting the zView node should exit after the
|
|
/// connection is closed.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// zView nodes may not perform this action is they do not support the
|
|
/// Capability.RemoteApplicationExit capability.
|
|
/// </remarks>
|
|
ExitApplication = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible reasons why a zView connection was closed.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When closing a connection by calling CloseConnection(), one of these
|
|
/// reasons must be specified to indicate why the connection is being closed.
|
|
///
|
|
/// Once a connection enters the ConnectionState.Closed state, the close
|
|
/// reason for the connection can be queried by calling
|
|
/// GetConnectionCloseReason().
|
|
/// </remarks>
|
|
public enum ConnectionCloseReason
|
|
{
|
|
/// <summary>
|
|
/// The connection was closed for an unknown reason.
|
|
/// </summary>
|
|
Unknown = 0,
|
|
|
|
/// <summary>
|
|
/// The connection was closed because the remote zView node's zView
|
|
/// API context was shut down.
|
|
/// </summary>
|
|
ShutDown = 1,
|
|
|
|
/// <summary>
|
|
/// The connection was closed because a user requested it to be
|
|
/// closed.
|
|
/// </summary>
|
|
UserRequested = 2,
|
|
|
|
/// <summary>
|
|
/// The connection was closed because is was rejected by one of the
|
|
/// zView nodes involved in the connection.
|
|
/// </summary>
|
|
ConnectionRejected = 3,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible phases that the setup of a zView mode can go
|
|
/// through.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this version of the zView API, all modes use all of the mode setup
|
|
/// phases defined by this enum. However, future versions of the zView API may
|
|
/// introduce mode setup phases that are only used by some modes.
|
|
/// </remarks>
|
|
public enum ModeSetupPhase
|
|
{
|
|
/// <summary>
|
|
/// Mode setup is initializing.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When in this mode setup phase, client code must set any settings that
|
|
/// the remote node will need to complete mode setup. Exactly which
|
|
/// settings must be set depends on the current mode. Client code may also
|
|
/// begin performing other setup tasks related to the current mode during
|
|
/// this setup phase (e.g. client code might begin creating or loading
|
|
/// resources needed for the current mode).
|
|
/// </remarks>
|
|
Initialization = 0,
|
|
|
|
/// <summary>
|
|
/// Mode setup is completing.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When in this mode setup phase, client code must finish any setup that
|
|
/// is necessary prior to the current mode becoming active. Exactly what
|
|
/// setup must be performed depends on the current mode.
|
|
/// </remarks>
|
|
Completion = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible states that a connection setting can be in.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A setting's state can be queried by calling GetSettingState().
|
|
/// </remarks>
|
|
public enum SettingState
|
|
{
|
|
/// <summary>
|
|
/// Setting's value is up to date.
|
|
/// </summary>
|
|
UpToDate = 0,
|
|
|
|
/// <summary>
|
|
/// Setting's value was changed during the most recent call to
|
|
/// LateUpdate(). State will transition to UpToDate on the next
|
|
/// frame's LateUpdate().
|
|
/// </summary>
|
|
Changed = 1,
|
|
|
|
/// <summary>
|
|
/// Setting's value was changed locally, but the change has not
|
|
/// yet been accepted by the other side of the connection.
|
|
/// </summary>
|
|
ChangePending = 2,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the keys for all possible zView connection settings.
|
|
/// </summary>
|
|
public enum SettingKey
|
|
{
|
|
/// <summary>
|
|
/// The width, in pixels, of the primary images for the connection's
|
|
/// current mode.
|
|
/// Datatype: UInt16.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In standard mode family modes, this should be set by the presenter node
|
|
/// during the ModeSetupPhase.Initialization mode setup phase. In
|
|
/// augmented reality mode family modes, this should be set by the viewer
|
|
/// node during the ModeSetupPhase.Initialization mode setup phase.
|
|
///
|
|
/// If this setting is set after the ModeSetupPhase.Initialization
|
|
/// mode setup phase (i.e. in a later mode setup phase or while the mode is
|
|
/// active or paused), then the connection will automatically transition
|
|
/// back to the ConnectionState.ModeSetup state in the
|
|
/// ModeSetupPhase.Completion mode setup phase in order to allow
|
|
/// both nodes to take into account the new setting value (e.g. by
|
|
/// reallocating image buffers to use the new width).
|
|
///
|
|
/// This setting should generally be set in a batch (by calling
|
|
/// BeginSettingsBatch() and EndSettingsBatch()) with the the
|
|
/// ImageHeight setting. Doing this ensures that remote
|
|
/// nodes will see image width and height changes at the same time (instead
|
|
/// of possibly seeing one of these settings change during one frame and
|
|
/// then the other change in the next frame).
|
|
/// </remarks>
|
|
ImageWidth = 0,
|
|
|
|
/// <summary>
|
|
/// The height, in pixels, of the primary images for the connection's current mode.
|
|
/// Datatype: UInt16.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In standard mode family modes, this should be set by the presenter node
|
|
/// during the ModeSetupPhase.Initialization mode setup phase. In
|
|
/// augmented reality mode family modes, this should be set by the viewer
|
|
/// node during the ::ModeSetupPhase.Initialization mode setup phase.
|
|
///
|
|
/// If this setting is set after the ModeSetupPhase.Initialization
|
|
/// mode setup phase (i.e. in a later mode setup phase or while the mode is
|
|
/// active or paused), then the connection will automatically transition
|
|
/// back to the ConnectionState.ModeSetup state in the
|
|
/// ModeSetupPhase.Completion mode setup phase in order to allow
|
|
/// both nodes to take into account the new setting value (e.g. by
|
|
/// reallocating image buffers to use the new height).
|
|
///
|
|
/// This setting should generally be set in a batch (by calling
|
|
/// BeginSettingsBatch() and EndSettingsBatch()) with the the
|
|
/// ImageWidth setting. Doing this ensures that remote
|
|
/// nodes will see image width and height changes at the same time (instead
|
|
/// of possibly seeing one of these settings change during one frame and
|
|
/// then the other change in the next frame).
|
|
/// </remarks>
|
|
ImageHeight = 1,
|
|
|
|
/// <summary>
|
|
/// The connection's current video recording quality.
|
|
/// Datatype: VideoRecordingQuality (get/set as UInt32).
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This setting may only be set if the connection's video recording state
|
|
/// is currently VideoRecordingState.NotRecording.
|
|
///
|
|
/// Whenever a video recording is started, the current value of this
|
|
/// setting is used as the quality level for the new video recording.
|
|
/// </remarks>
|
|
VideoRecordingQuality = 2,
|
|
|
|
/// <summary>
|
|
/// The current horizontal offset, in pixels, of the primary image
|
|
/// overlay displayed by the viewer node (default 0.0f).
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only available for augmented reality mode family modes. For
|
|
/// these modes the viewer node will use this value to offset the position
|
|
/// of the presenter's color images from the augmented reality mode camera
|
|
/// video stream images when the two are composited.
|
|
/// </remarks>
|
|
OverlayOffsetX = 3,
|
|
|
|
/// <summary>
|
|
/// The current vertical offset, in pixels, of the primary image
|
|
/// overlay displayed by the viewer node (default 0.0f).
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only available for augmented reality mode family modes. For
|
|
/// these modes the viewer node will use this value to offset the position
|
|
/// of the presenter's color images from the augmented reality mode camera
|
|
/// video stream images when the two are composited.
|
|
/// </remarks>
|
|
OverlayOffsetY = 4,
|
|
|
|
/// <summary>
|
|
/// The current horizontal scale factor for the primary image
|
|
/// overlay displayed by the viewer node (default 1.0f).
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only available for augmented reality mode family modes. For
|
|
/// these modes the viewer node will use this value to scale the
|
|
/// presenter's color images before they are composited with the augmented
|
|
/// reality mode camera video stream images.
|
|
/// </remarks>
|
|
OverlayScaleX = 5,
|
|
|
|
/// <summary>
|
|
/// The current vertical scale factor for the primary image overlay
|
|
/// displayed by the viewer node (default 1.0f).
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only available for augmented reality mode family modes. For
|
|
/// these modes the viewer node will use this value to scale the
|
|
/// presenter's color images before they are composited with the augmented
|
|
/// reality mode camera video stream images.
|
|
/// </remarks>
|
|
OverlayScaleY = 6,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible streams that may be used by a zView mode for
|
|
/// sending frame data between the nodes involved in a zView connection.
|
|
/// </summary>
|
|
public enum Stream
|
|
{
|
|
/// <summary>
|
|
/// Stream used sending the primary image data between nodes for a
|
|
/// mode. May also be used to send metadata related to the images being
|
|
/// sent or data necessary for generating images to be sent.
|
|
/// </summary>
|
|
Image = 0,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the keys for all possible pieces of frame data for a zView
|
|
/// mode.
|
|
/// </summary>
|
|
public enum FrameDataKey
|
|
{
|
|
/// <summary>
|
|
/// The frame's frame number.
|
|
/// Datatype: UInt64.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is used for Stream.Image frames in both standard mode family
|
|
/// and augmented reality mode family modes.
|
|
/// </remarks>
|
|
FrameNumber = 0,
|
|
|
|
/// <summary>
|
|
/// The camera pose matrix (position and orientation) to use for rendering the current
|
|
/// mode's primary images.
|
|
/// Datatype: Matrix4x4.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only used for Stream.Image frames sent from the viewer
|
|
/// node to the presenter node in augmented reality mode family modes.
|
|
/// </remarks>
|
|
CameraPose = 1,
|
|
|
|
/// <summary>
|
|
/// The camera focal length to use for rendering the current mode's
|
|
/// primary images.
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only used for Stream.Image frames sent from the viewer
|
|
/// node to the presenter node in augmented reality mode family modes.
|
|
/// </remarks>
|
|
CameraFocalLength = 2,
|
|
|
|
/// <summary>
|
|
/// The horizontal offset of the camera's principal point to use for
|
|
/// rendering the current mode's primary images.
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only used for Stream.Image frames sent from the viewer
|
|
/// node to the presenter node in augmented reality mode family modes.
|
|
/// </remarks>
|
|
CameraPrincipalPointOffsetX = 3,
|
|
|
|
/// <summary>
|
|
/// The vertical offset of the camera's principal point to use for
|
|
/// rendering the current mode's primary images.
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only used for Stream.Image frames sent from the viewer
|
|
/// node to the presenter node in augmented reality mode family modes.
|
|
/// </remarks>
|
|
CameraPrincipalPointOffsetY = 4,
|
|
|
|
/// <summary>
|
|
/// The camera pixel aspect ratio to use for rendering the current
|
|
/// mode's primary images.
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only used for Stream.Image frames sent from the viewer
|
|
/// node to the presenter node in augmented reality mode family modes.
|
|
/// </remarks>
|
|
CameraPixelAspectRatio = 5,
|
|
|
|
/// <summary>
|
|
/// The camera axis skew to use for rendering the current mode's
|
|
/// primary images.
|
|
/// Datatype: float.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This is only used for Stream.Image frames sent from the viewer
|
|
/// node to the presenter node in augmented reality mode family modes.
|
|
/// </remarks>
|
|
CameraAxisSkew = 6,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the keys for all possible frame buffers for a zView mode.
|
|
/// </summary>
|
|
public enum FrameBufferKey
|
|
{
|
|
/// <summary>
|
|
/// Frame buffer for storing the first color image associated with a
|
|
/// zView mode.
|
|
/// </summary>
|
|
ImageColor0 = 0,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible zView connection video recording states.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's current video recording state can be queried by calling
|
|
/// GetVideoRecordingState().
|
|
/// </remarks>
|
|
public enum VideoRecordingState
|
|
{
|
|
/// <summary>
|
|
/// Video recording capability is not currently available and cannot be used.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the NotRecording state if the connection supports the
|
|
/// Capability.VideoRecording capability. This transition will occur once the
|
|
/// connection is fully initialized.
|
|
/// </remarks>
|
|
NotAvailable = 0,
|
|
|
|
/// <summary>
|
|
/// Not actively recording and no current recording exists.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A video recording can be started by calling StartVideoRecording().
|
|
/// This will transition the video recording state to the Starting state.
|
|
/// </remarks>
|
|
NotRecording = 1,
|
|
|
|
/// <summary>
|
|
/// Video recording is in the process of starting.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the Recording state once video recording has fully started.
|
|
/// </remarks>
|
|
Starting = 2,
|
|
|
|
/// <summary>
|
|
/// Acively recording.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Recording can be finished by calling FinishVideoRecording(), which will
|
|
/// transition the video recording state to the Finishing state. Recording
|
|
/// can be paused by calling PauseVideoRecording(), which will transition the
|
|
/// video recording state to the Pausing state.
|
|
/// </remarks>
|
|
Recording = 3,
|
|
|
|
/// <summary>
|
|
/// Video recording is in the process of finishing.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition
|
|
/// fromthis state to the Finished state once video recording has completed
|
|
/// finishing.
|
|
/// </remarks>
|
|
Finishing = 4,
|
|
|
|
/// <summary>
|
|
/// Not actively recording; current finished recording exists.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The finished recording can be saved by calling SaveVideoRecording(),
|
|
/// which will transition the video recording state to the Saving state.
|
|
/// The finished recording can be discarded by calling DiscardVideoRecording(),
|
|
/// which will transition the video recording state to the Discarding state.
|
|
/// </remarks>
|
|
Finished = 5,
|
|
|
|
/// <summary>
|
|
/// Video recording is in the process of pausing.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the Paused state once video recording has completed pausing.
|
|
/// </remarks>
|
|
Pausing = 6,
|
|
|
|
/// <summary>
|
|
/// Not actively recording; current resumable recording exists.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Recording can be resumed by calling ResumeVideoRecording(), which
|
|
/// will transition the video recording state to the Resuming state.
|
|
/// Recording can be finished by calling FinishVideoRecording(), which
|
|
/// will transition the video recording state to the Finishing state.
|
|
/// </remarks>
|
|
Paused = 7,
|
|
|
|
/// <summary>
|
|
/// Video recording is in the process of resuming.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the Recording state once video recording has completed resuming.
|
|
/// </remarks>
|
|
Resuming = 8,
|
|
|
|
/// <summary>
|
|
/// The current finished video recording is in the process of being
|
|
/// saved.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the NotRecording state once saving is complete.
|
|
/// </remarks>
|
|
Saving = 9,
|
|
|
|
/// <summary>
|
|
/// The current finished video recording is in the process of being
|
|
/// discarded.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the NotRecording state once discarding is complete.
|
|
/// </remarks>
|
|
Discarding = 10,
|
|
|
|
/// <summary>
|
|
/// A recoverable video-recording-related error occurred.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// In this state, client code should call ClearVideoRecordingError() to
|
|
/// clear the error and allow new video recordings to be started. This
|
|
/// will transition the video recording state to the ClearingError state.
|
|
///
|
|
/// In this state, client code may call GetVideoRecordingError() to
|
|
/// determine the type of error that occurred.
|
|
/// </remarks>
|
|
Error = 11,
|
|
|
|
/// <summary>
|
|
/// The most recent video recording error is in the process of being
|
|
/// cleared.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// A connection's video recording state will automatically transition from
|
|
/// this state to the NotRecording state once clearing of the video recording
|
|
/// error is complete.
|
|
/// </remarks>
|
|
ClearingError = 12,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines the possible video recording quality levels.
|
|
/// </summary>
|
|
public enum VideoRecordingQuality
|
|
{
|
|
Unknown = -1,
|
|
|
|
/// <summary>
|
|
/// Video recording with 854 x 480 pixel resolution.
|
|
/// </summary>
|
|
Resolution480p = 0,
|
|
|
|
/// <summary>
|
|
/// Video recording with 1280 x 720 pixel resolution.
|
|
/// </summary>
|
|
Resolution720p = 1,
|
|
|
|
/// <summary>
|
|
/// Video recording with 1920 x 1080 pixel resolution.
|
|
/// </summary>
|
|
Resolution1080p = 2,
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Compound Types
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
/// <summary>
|
|
/// Class representing a mode that is supported by a zView node along
|
|
/// with the current availability of that mode.
|
|
/// </summary>
|
|
public class SupportedMode
|
|
{
|
|
/// <summary>
|
|
/// The handle of the mode that is supported.
|
|
/// </summary>
|
|
public IntPtr Mode { get; private set; }
|
|
|
|
/// <summary>
|
|
/// The supported mode's current availability.
|
|
/// </summary>
|
|
public ModeAvailability ModeAvailability { get; private set; }
|
|
|
|
public SupportedMode(IntPtr mode, ModeAvailability modeAvailability)
|
|
{
|
|
this.Mode = mode;
|
|
this.ModeAvailability = modeAvailability;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Unity Inspector Fields
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
/// <summary>
|
|
/// Layers to be ignored by the standard mode's default
|
|
/// virtual camera.
|
|
/// </summary>
|
|
public LayerMask StandardModeIgnoreLayers;
|
|
|
|
/// <summary>
|
|
/// Layers to be ignored by the augmented reality mode's
|
|
/// default virtual camera.
|
|
/// </summary>
|
|
public LayerMask ARModeIgnoreLayers = 0;
|
|
|
|
/// <summary>
|
|
/// Layers to cull out by the augmented reality mode's
|
|
/// default virtual camera if geometry protrudes into
|
|
/// negative parallax outside the bounds of the viewport.
|
|
/// </summary>
|
|
public LayerMask ARModeEnvironmentLayers = 0;
|
|
|
|
/// <summary>
|
|
/// Layer (0 - 31) to be assigned to the augmented reality mode's
|
|
/// box mask. This layer must be unique and should not be used for
|
|
/// any objects in the scene other than the box mask.
|
|
/// </summary>
|
|
public int ARModeMaskLayer = 31;
|
|
|
|
/// <summary>
|
|
/// The render queue priority for the augmented reality mode's
|
|
/// box mask. This is only used when ARModeEnableTransparency
|
|
/// is enabled and should generally be assigned values less than
|
|
/// 2000 (opaque geometry) to ensure that its depth will be rendered
|
|
/// prior to rendering any opaque geometry.
|
|
/// </summary>
|
|
public int ARModeMaskRenderQueue = 1900;
|
|
|
|
/// <summary>
|
|
/// The size of the augmented reality mode's box mask in meters.
|
|
/// </summary>
|
|
public Vector3 ARModeMaskSize = Vector3.one * 2.0f;
|
|
|
|
/// <summary>
|
|
/// Enables debug visualization for the augmented reality mode's
|
|
/// box mask in the Unity Editor's SceneView window.
|
|
/// </summary>
|
|
public bool ARModeShowMask = false;
|
|
|
|
/// <summary>
|
|
/// If not enabled, force all non-mask pixels rendered by the augmented
|
|
/// reality mode's virtual camera to have an alpha value of 1. By default,
|
|
/// this is disabled due to the fact that most standard shaders associated
|
|
/// with both opaque and transparent geometry either have incorrect values
|
|
/// in their alpha channels, or do not write their alpha channels to the
|
|
/// frame buffer.
|
|
/// </summary>
|
|
public bool ARModeEnableTransparency = false;
|
|
|
|
/// <summary>
|
|
/// ZView requires a reference to the active ZCamera. ZView will try
|
|
/// to find an instance of ZCamera on awake if left unassigned. If the
|
|
/// ZCamera is destroyed during the life of the current scene, this
|
|
/// value must be assigned manually.
|
|
/// </summary>
|
|
public ZCamera ActiveZCamera = null;
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Public API
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
/// <summary>
|
|
/// Checks whether the GCSeries zView SDK was properly initialized.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// True if initialized. False otherwise.
|
|
/// </returns>
|
|
public bool IsInitialized()
|
|
{
|
|
return GlobalState.Instance.IsInitialized;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the current version of the GCSeries zView Unity plugin.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The plugin version in major.minor.patch string format.
|
|
/// </returns>
|
|
public string GetPluginVersion()
|
|
{
|
|
int major = 0;
|
|
int minor = 0;
|
|
int patch = 1;
|
|
return string.Format("{0}.{1}.{2}", major, minor, patch);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the current runtime version of the GCSeries zView SDK.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The runtime version in major.minor.patch string format.
|
|
/// </returns>
|
|
public string GetRuntimeVersion()
|
|
{
|
|
int major = 0;
|
|
int minor = 0;
|
|
int patch = 1;
|
|
return string.Format("{0}.{1}.{2}", major, minor, patch);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the node type of the current context.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The node type of the current context.
|
|
/// </returns>
|
|
public NodeType GetNodeType()
|
|
{
|
|
NodeType type = NodeType.Presenter;
|
|
return type;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the node ID of the current context.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The byte buffer to fill with the node ID of the current context.
|
|
/// </returns>
|
|
public byte[] GetNodeId()
|
|
{
|
|
// Get the node id's size in bytes.
|
|
int size = 4;
|
|
byte[] id = new byte[size];
|
|
Array.Clear(id, 0, size);
|
|
Debug.LogWarning("GView.GetNodeId():这个函数目前不使用!");
|
|
return id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the node name string associated with the current context.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The node name string associated with the current context.
|
|
/// </returns>
|
|
public string GetNodeName()
|
|
{
|
|
Debug.LogWarning("GView.GetNodeName():这个函数目前不使用!");
|
|
return "UnmannedNode";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the node name string associated with the current context.
|
|
/// </summary>
|
|
///
|
|
/// <param name="name">
|
|
/// The new node name to use.
|
|
/// </param>
|
|
public void SetNodeName(string name)
|
|
{
|
|
Debug.LogWarning("GView.SetNodeName():这个函数目前不使用!name=" + name);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the node status string associated with the current context.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The node status string associated with the current context.
|
|
/// </returns>
|
|
public string GetNodeStatus()
|
|
{
|
|
Debug.LogWarning("GView.GetNodeStatus():这个函数目前不使用!");
|
|
return "OK";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the node status string associated with the current context.
|
|
/// </summary>
|
|
///
|
|
/// <param name="status">
|
|
/// The new node status to use.
|
|
/// </param>
|
|
public void SetNodeStatus(string status)
|
|
{
|
|
Debug.LogWarning("GView.SetNodeStatus():这个函数目前不使用!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the number of modes supported by the current context.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The number of modes supported by the current context.
|
|
/// </returns>
|
|
public int GetNumSupportedModes()
|
|
{
|
|
Debug.LogWarning("GView.GetNumSupportedModes():这个函数目前不使用!");
|
|
int numModes = 0;
|
|
numModes = 1;
|
|
return numModes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a supported mode from the list of supported modes for the
|
|
/// current context.
|
|
/// </summary>
|
|
///
|
|
/// <param name="modeIndex">
|
|
/// The index of the supported mode to get. This must be
|
|
/// greater than or equal to 0 and less than the number of
|
|
/// supported modes queried via GetNumSupportedModes().
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The requested supported mode.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the mode index is out of range.
|
|
/// </exception>
|
|
public SupportedMode GetSupportedMode(int modeIndex)
|
|
{
|
|
Debug.LogWarning("GView.GetSupportedMode():这个函数目前不使用!");
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the modes supported by the current context.
|
|
/// </summary>
|
|
///
|
|
/// <param name="modes">
|
|
/// The list of supported modes.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidModeException">
|
|
/// Thrown if any supported mode references an invalid mode.
|
|
/// </exception>
|
|
public void SetSupportedModes(IList<SupportedMode> modes)
|
|
{
|
|
Debug.LogWarning("GView.SetSupportedModes():这个函数目前不使用!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the number of capabilities supported by the current context.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The number of capabilities supported by the current context.
|
|
/// </returns>
|
|
public int GetNumSupportedCapabilities()
|
|
{
|
|
Debug.LogWarning("GView.GetNumSupportedCapabilities():这个函数目前不使用!");
|
|
int numCapabilities = 0;
|
|
return numCapabilities;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a supported capability from the list of supported capabilities for
|
|
/// the current context.
|
|
/// </summary>
|
|
///
|
|
/// <param name="capabilityIndex">
|
|
/// The index of the supported capability to get. This must be greater than
|
|
/// or equal to 0 and less than the number of supported capabilities queried
|
|
/// via GetNumSupportedCapabilities().
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The requested supported capability.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the capability index is out of range.
|
|
/// </exception>
|
|
public Capability GetSupportedCapability(int capabilityIndex)
|
|
{
|
|
Debug.LogWarning("GView.GetSupportedCapability():这个函数目前不使用!");
|
|
Capability capability = Capability.VideoRecording;
|
|
return capability;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified mode attribute of type UInt32 for the
|
|
/// specified mode.
|
|
/// </summary>
|
|
///
|
|
/// <param name="mode">
|
|
/// The mode to get the attribute value of.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The mode attribute key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified mode and mode attribute key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the mode is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidModeException">
|
|
/// Thrown if the mode is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidModeAttributeKeyException">
|
|
/// Thrown if the mode attribute key is invalid.
|
|
/// </exception>
|
|
public UInt32 GetModeAttributeUInt32(IntPtr mode, ModeAttributeKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetModeAttributeUInt32():这个函数目前不使用!");
|
|
UInt32 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Connect to the default viewer using the current context.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// This method performs its work asynchronously. Once a connection
|
|
/// to the default viewer is created, it will be accessible via
|
|
/// GetConnection() or GetCurrentActiveConnection() after the next
|
|
/// LateUpdate().
|
|
/// </remarks>
|
|
public void ConnectToDefaultViewer()
|
|
{
|
|
Debug.Log("GView.ConnectToDefaultViewer():进入!");
|
|
IntPtr connection;
|
|
xxConnectToDefaultViewer(out connection);
|
|
//因为我们永远连接成功.所以直接赋值
|
|
GlobalState.Instance.Connection = connection;
|
|
|
|
//这里是否需要进入一个模式呢?
|
|
|
|
//因为永远是连上的,所以这里发个事件算了
|
|
if (this.ConnectionAccepted != null)
|
|
{
|
|
this.ConnectionAccepted(this, GlobalState.Instance.Connection);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Close the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The close action will be queriable by the remote node
|
|
/// once the connection has entered the Closed state. Note: The node
|
|
/// that calls this function for a connection will not be able to query
|
|
/// the action it specifies via GetConnectionCloseAction(), since the
|
|
/// action is meant for the remote node. Instead, GetConnectionCloseAction()
|
|
/// will always return None when called by the node that called this
|
|
/// method.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to close.
|
|
/// </param>
|
|
/// <param name="action">
|
|
/// The action that should be performed by the remote node after the
|
|
/// connection is closed.
|
|
/// </param>
|
|
/// <param name="reason">
|
|
/// The reason why the connection is being closed. This will be queriable
|
|
/// via the GetConnectionCloseReason() function once the connection has
|
|
/// entered the Closed state.
|
|
/// </param>
|
|
/// <param name="reasonDetails">
|
|
/// Additional details on the reason why the connection is being closed.
|
|
/// This is purely for logging purposes and will not be displayed to the
|
|
/// user.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is already in a Closed or Error state.
|
|
/// </exception>
|
|
public void CloseConnection(IntPtr connection, ConnectionCloseAction action, ConnectionCloseReason reason, string reasonDetails)
|
|
{
|
|
Debug.Log("GView.CloseConnection():进入!");
|
|
|
|
CurVirtualCameraMode = IntPtr.Zero;
|
|
GlobalState.Instance.Connection = IntPtr.Zero;//这里关闭了
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the number of currently visible connections for the current context.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The number of currently visible connections will change over the lifetime
|
|
/// of a context. However, the number connections queried by this function
|
|
/// will only change during LateUpdate() (i.e. the value will remain
|
|
/// stable between calls to LateUpdate()).
|
|
/// </remarks>
|
|
///
|
|
/// <returns>
|
|
/// The number of visible connections for the specified context.
|
|
/// </returns>
|
|
public int GetNumConnections()
|
|
{
|
|
if (GlobalState.Instance.Connection == IntPtr.Zero)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a connection from the list of currently visible connections for the
|
|
/// current context.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The list of currently visible connections will change over the lifetime of
|
|
/// a context. However, the list of connections that is accessible via this
|
|
/// function will only change during LateUpdate() (i.e. the list will
|
|
/// remain stable between calls to LateUpdate()).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connectionIndex">
|
|
/// The index of the connection to get. This must be greater than or equal
|
|
/// to 0 and less than the number of connections queried via GetNumConnections().
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The requested connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection index is out of range.
|
|
/// </exception>
|
|
public IntPtr GetConnection(int connectionIndex)
|
|
{
|
|
return GlobalState.Instance.Connection;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the current active connection if it exists.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The current active connection if it exists. Otherwise IntPtr.Zero.
|
|
/// </returns>
|
|
public IntPtr GetCurrentActiveConnection()
|
|
{
|
|
return GlobalState.Instance.Connection;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the state of the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The state of a connection will change over the lifetime of the connection.
|
|
/// However, the state queried via this function will only change during
|
|
/// LateUpdate() (i.e. the state will remain stable between calls to LateUpdate()).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the state of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The state of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
public ConnectionState GetConnectionState(IntPtr connection)
|
|
{
|
|
return ConnectionState.ModeActive;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the error code associated with the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// It is only valid to query the error code associated with a connection when it
|
|
/// is in the Error state (i.e. through callbacks registered against the
|
|
/// ConnectionError event).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the error code of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The error code associated with the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is not in the Error state.
|
|
/// </exception>
|
|
public PluginError GetConnectionError(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectionError():这个函数目前未实现!");
|
|
PluginError connectionError = PluginError.Ok;
|
|
return connectionError;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check whether the specified connection was initiated locally or remotely.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to check whether it was locally initiated.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// Whether the connection was locally initiated.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
public bool WasConnectionLocallyInitiated(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.WasConnectionLocallyInitiated():这个函数目前未实现!");
|
|
bool wasLocallyInitiated = false;
|
|
return wasLocallyInitiated;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the node ID of the remote node that the specified connection is
|
|
/// connected to.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the remote node ID of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The byte buffer to fill with the node ID of the remote node that the
|
|
/// specified connection is connected to.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public byte[] GetConnectedNodeId(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectedNodeId():这个函数目前未实现!");
|
|
// Get the node id's size in bytes.
|
|
int size = 4;
|
|
byte[] id = new byte[size];
|
|
Array.Clear(id, 0, size);
|
|
return id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the node name string of the remote node that the specified connection
|
|
/// is connected to.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the remote node name of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The node name string of the remote node that the specified connection
|
|
/// is connected to.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public string GetConnectedNodeName(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectedNodeName():这个函数目前未实现!");
|
|
return "unnamed";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the node status string of the remote node that the specified
|
|
/// connection is connected to.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the remote node status of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The node status string of the remote node that the specified
|
|
/// connection is connected to.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public string GetConnectedNodeStatus(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectedNodeStatus():这个函数目前未实现!");
|
|
return "OK";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if the specified connection supports the specified capability.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to check the capability support of.
|
|
/// </param>
|
|
/// <param name="capability">
|
|
/// The capability to check for support of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// Whether the specified capability is supported by the specified
|
|
/// connection or not.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public bool DoesConnectionSupportCapability(IntPtr connection, Capability capability)
|
|
{
|
|
if (capability == Capability.RemoteApplicationExit)
|
|
{
|
|
return false;
|
|
}
|
|
if (capability == Capability.VideoRecording)
|
|
{
|
|
bool isSupported = xxGetVideoRecordingCapability();
|
|
return isSupported;
|
|
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the number of modes supported by the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The number of modes supported by a connection may change over the lifetime
|
|
/// of the connection. However, the number of supported modes returned by this
|
|
/// function will only change during LateUpdate() (i.e. the value will remain
|
|
/// stable between calls to LateUpdate()).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the number of supported modes for.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The number of modes supported by the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public int GetNumConnectionSupportedModes(IntPtr connection)
|
|
{
|
|
if (connection != IntPtr.Zero &&
|
|
GlobalState.Instance.Connection == connection)
|
|
return 3;//支持两个模式
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a supported mode and associated mode availability information from the
|
|
/// list of modes supported by the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The list of modes supported by a connection may change over the lifetime of
|
|
/// the connection. However, the list of supported modes accessible via this
|
|
/// function will only change during LateUpdate() (i.e. the value will remain
|
|
/// stable between calls to LateUpdate()).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get a supported mode from.
|
|
/// </param>
|
|
/// <param name="supportedModeIndex">
|
|
/// The index of the supported mode to get. This must be greater than or equal
|
|
/// to 0 and less than the number of supported modes queried via the
|
|
/// GetNumConnectionSupportedModes() function.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The requested supported mode with associated mode availability information.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero) or the supported mode index
|
|
/// is out of range.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public SupportedMode GetConnectionSupportedMode(IntPtr connection, int supportedModeIndex)
|
|
{
|
|
//Debug.LogWarning("GView.GetConnectionSupportedMode():这个函数目前未实现!");
|
|
if (connection != IntPtr.Zero)
|
|
{
|
|
int screenNum = F3Device.DeviceManager.Instance.AllMonitors.Count;
|
|
|
|
if (supportedModeIndex == 0)
|
|
{
|
|
if (screenNum < 2)
|
|
{
|
|
return new SupportedMode(GlobalState.Instance.ModeStandard, ModeAvailability.NotAvailable);
|
|
}
|
|
|
|
return new SupportedMode(GlobalState.Instance.ModeStandard, ModeAvailability.Available);
|
|
}
|
|
else if (supportedModeIndex == 1)
|
|
{
|
|
if (screenNum < 2)
|
|
{
|
|
return new SupportedMode(GlobalState.Instance.ModeThreeD, ModeAvailability.NotAvailable);
|
|
}
|
|
|
|
return new SupportedMode(GlobalState.Instance.ModeThreeD, ModeAvailability.Available);
|
|
}
|
|
else if (supportedModeIndex == 2)
|
|
{
|
|
if (screenNum < 2)
|
|
{
|
|
return new SupportedMode(GlobalState.Instance.ModeAugmentedReality, ModeAvailability.NotAvailable);
|
|
}
|
|
|
|
//如果有罗技相机那么返回可用
|
|
var devices = WebCamTexture.devices;
|
|
foreach (var item in devices)
|
|
{
|
|
if (item.name.Contains("C920"))
|
|
{
|
|
return new SupportedMode(GlobalState.Instance.ModeAugmentedReality, ModeAvailability.Available);
|
|
}
|
|
}
|
|
|
|
//如果没有罗技相机那么返回不可用
|
|
return new SupportedMode(GlobalState.Instance.ModeAugmentedReality, ModeAvailability.NotAvailableNoWebcam);
|
|
}
|
|
}
|
|
return new SupportedMode(IntPtr.Zero, ModeAvailability.NotAvailable);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the standard mode handle.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The standard mode handle.
|
|
/// </returns>
|
|
public IntPtr GetStandardMode()
|
|
{
|
|
return GlobalState.Instance.ModeStandard;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the 3D mode handle.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The 3D mode handle.
|
|
/// </returns>
|
|
public IntPtr GetThreeDMode()
|
|
{
|
|
return GlobalState.Instance.ModeThreeD;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the augmented reality mode handle.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The augmented reality mode.
|
|
/// </returns>
|
|
public IntPtr GetAugmentedRealityMode()
|
|
{
|
|
return GlobalState.Instance.ModeAugmentedReality;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the current mode of the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The current mode of a connection will change over the lifetime of the
|
|
/// connection. However, the mode queried via this function will only change
|
|
/// during LateUpdate() (i.e. the value will remain stable between calls to
|
|
/// LateUpdate()).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the current mode of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The current mode of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public IntPtr GetConnectionMode(IntPtr connection)
|
|
{
|
|
return this.CurVirtualCameraMode;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the current mode of the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// If the current mode of the specified connection is not equal to the mode
|
|
/// specified when this function is called, then this function will initiate a
|
|
/// mode switch (the actual mode switch will occur asynchronously and will only
|
|
/// become visible after the next LateUpdate() is called).
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the current mode of.
|
|
/// </param>
|
|
/// <param name="mode">
|
|
/// The new mode to use as the current mode of the specified connection.
|
|
/// Passing IntPtr.Zero for this argument makes it so that there is no current
|
|
/// mode and transitions the connection into the NodeMode state.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection or the mode is null (IntPtr.Zero). Also thrown
|
|
/// if the mode is not supported or not available.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidModeException">
|
|
/// Thrown if the mode is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public void SetConnectionMode(IntPtr connection, IntPtr mode)
|
|
{
|
|
Debug.Log("GView.SetConnectionMode():进入函数!");
|
|
if (connection != IntPtr.Zero)
|
|
{
|
|
CurVirtualCameraMode = mode;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the user data associated with the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the user data of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The user data of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
public IntPtr GetConnectionUserData(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectionUserData():这个函数目前未实现!");
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the user data associated with the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the user data of.
|
|
/// </param>
|
|
/// <param name="userData">
|
|
/// The user data of the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
public void SetConnectionUserData(IntPtr connection, IntPtr userData)
|
|
{
|
|
Debug.LogWarning("GView.SetConnectionUserData():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the close action associated with the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// The client code should perform this action if possible after a connection
|
|
/// enters the Closed state.
|
|
///
|
|
/// It is only valid to call this function for a connection that is in the
|
|
/// Closed state or in a callback registered against the ConnectedClosed event.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the close action of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The close action of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is not in the Closed state.
|
|
/// </exception>
|
|
public ConnectionCloseAction GetConnectionCloseAction(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectionCloseAction():这个函数目前未实现!");
|
|
return ConnectionCloseAction.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the close reason associated with the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// It is only valid to call this function for a connection that is in the
|
|
/// Closed state or in a callback registered against the ConnectedClosed event.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the close reason of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The close reason of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is not in the Closed state.
|
|
/// </exception>
|
|
public ConnectionCloseReason GetConnectionCloseReason(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetConnectionCloseReason():这个函数目前未实现!");
|
|
ConnectionCloseReason reason = ConnectionCloseReason.Unknown;
|
|
return reason;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request that current mode be paused for the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Pausing will occur asynchronously and eventually become visible after a
|
|
/// call to LateUpdate().
|
|
///
|
|
/// It is only valid to call this function for a connection that is in the
|
|
/// ModeActive state.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to pause frame sending for.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is not in the ModeActive state.
|
|
/// </exception>
|
|
public void PauseMode(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.PauseMode():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request that the current mode be resumed for the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Resuming will occur asynchronously and eventually become visible after a
|
|
/// call to LateUpdate().
|
|
///
|
|
/// It is only valid to call this function for a connection that is in the
|
|
/// ModePaused state.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to resume frame sending for.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is not in the ModePaused state.
|
|
/// </exception>
|
|
public void ResumeMode(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.ResumeMode():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin a settings batch for the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// While a settings batch is active for a connection, changes to setting
|
|
/// values will not be sent over the connection until the settings batch is
|
|
/// ended (via a call to EndSettingsBatch()). This allows multiple settings
|
|
/// value changes to be sent as an atomic unit. This is necessary when a group
|
|
/// of settings are interrelated and changing one setting in the group requires
|
|
/// other settings in the group to also be changed in order to keep all
|
|
/// settings in the group in a consistent state.
|
|
///
|
|
/// At most one settings batch can be active at any time for a particular
|
|
/// connection. Attempting to begin a settings batch for a connection when the
|
|
/// connection already has an active settings batch will result in an error.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to begin a settings batch for.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public void BeginSettingsBatch(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.BeginSettingsBatch():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// End a settings batch for the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Attempting to end a setting batch for a connection that does not have an
|
|
/// active settings batch will result in an error.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to end a settings batch for.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public void EndSettingsBatch(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.EndSettingsBatch():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type bool for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public bool GetSettingBool(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingBool():这个函数目前未实现!key=" + key);
|
|
bool value = false;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type sbyte (Int8) for the
|
|
/// specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public sbyte GetSettingInt8(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingInt8():这个函数目前未实现!key=" + key);
|
|
sbyte value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type Int16 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public Int16 GetSettingInt16(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingInt16():这个函数目前未实现!key=" + key);
|
|
Int16 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type Int32 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public Int32 GetSettingInt32(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingInt32():这个函数目前未实现!key=" + key);
|
|
Int32 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type Int64 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public Int64 GetSettingInt64(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingInt64():这个函数目前未实现!key=" + key);
|
|
Int64 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type byte (UInt8) for the
|
|
/// specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public byte GetSettingUInt8(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingUInt8():这个函数目前未实现!key=" + key);
|
|
byte value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type UInt16 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public UInt16 GetSettingUInt16(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingUInt16():这个函数目前未实现!key=" + key);
|
|
UInt16 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type UInt32 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public UInt32 GetSettingUInt32(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingUInt32():这个函数目前未实现!key=" + key);
|
|
UInt32 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type UInt64 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public UInt64 GetSettingUInt64(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingUInt64():这个函数目前未实现!key=" + key);
|
|
UInt64 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type float for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public float GetSettingFloat(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingFloat():这个函数目前未实现!key=" + key);
|
|
float value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type double for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public double GetSettingDouble(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingDouble():这个函数目前未实现!key=" + key);
|
|
double value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type Vector3 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public Vector3 GetSettingVector3(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingVector3():这个函数目前未实现!key=" + key);
|
|
return Vector3.zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified setting of type Matrix4x4 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified connection and setting key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public Matrix4x4 GetSettingMatrix4x4(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingMatrix4x4():这个函数目前未实现!key=" + key);
|
|
return Matrix4x4.zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type bool for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, bool value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type sbyte (Int8) for the
|
|
/// specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, sbyte value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type Int16 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, Int16 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type Int32 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, Int32 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type Int64 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, Int64 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type byte (UInt8) for the
|
|
/// specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, byte value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type UInt16 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, UInt16 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type UInt32 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, UInt32 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type UInt64 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, UInt64 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type float for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, float value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type double for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, double value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type Vector3 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, Vector3 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the value of the specified setting of type Matrix4x4 for the specified
|
|
/// connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// When the value of a setting is set, its state will transition to
|
|
/// ChangePending until the new value has been accepted by the other side
|
|
/// of the associated connection.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to set the setting value for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to set the value of.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The new value for the specified setting key for the specified connection.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidSettingKeyException">
|
|
/// Thrown if the setting key is invalid.
|
|
/// </exception>
|
|
public void SetSetting(IntPtr connection, SettingKey key, Matrix4x4 value)
|
|
{
|
|
Debug.LogWarning("GView.SetSetting():这个函数目前未实现!key=" + key + ",value=" + value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the state of the specified setting for the specified connection
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the setting state for.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The setting key to get the state of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The state of the specified setting state for the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
public SettingState GetSettingState(IntPtr connection, SettingKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetSettingState():这个函数目前未实现!key=" + key);
|
|
SettingState state;
|
|
state = SettingState.UpToDate;
|
|
return state;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type bool for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public bool GetFrameDataBool(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataBool():这个函数目前未实现!key=" + key);
|
|
bool value = false;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type sbyte (Int8) for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public sbyte GetFrameDataInt8(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataInt8():这个函数目前未实现!key=" + key);
|
|
sbyte value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type Int16 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public Int16 GetFrameDataInt16(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataInt16():这个函数目前未实现!key=" + key);
|
|
Int16 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type Int32 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public Int32 GetFrameDataInt32(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataInt32():这个函数目前未实现!key=" + key);
|
|
Int32 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type Int64 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public Int64 GetFrameDataInt64(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataInt64():这个函数目前未实现!key=" + key);
|
|
Int64 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type byte (UInt8) for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public byte GetFrameDataUInt8(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataUInt8():这个函数目前未实现!key=" + key);
|
|
byte value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type UInt16 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public UInt16 GetFrameDataUInt16(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataUInt16():这个函数目前未实现!key=" + key);
|
|
UInt16 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type UInt32 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public UInt32 GetFrameDataUInt32(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataUInt32():这个函数目前未实现!key=" + key);
|
|
UInt32 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type UInt64 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public UInt64 GetFrameDataUInt64(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataUInt64():这个函数目前未实现!key=" + key);
|
|
UInt64 value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type float for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public float GetFrameDataFloat(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataFloat():这个函数目前未实现!key=" + key);
|
|
float value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type double for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public double GetFrameDataDouble(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataDouble():这个函数目前未实现!key=" + key);
|
|
double value = 0;
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type Vector3 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public Vector3 GetFrameDataVector3(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataVector3():这个函数目前未实现!key=" + key);
|
|
//ZSVector3 value;
|
|
return Vector3.zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the value of the specified frame data of type Matrix4x4 for the
|
|
/// specified frame.
|
|
/// </summary>
|
|
///
|
|
/// <param name="frame">
|
|
/// The frame to get frame data from.
|
|
/// </param>
|
|
/// <param name="key">
|
|
/// The frame data key to get the value of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The value associated with specified frame and frame data key.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the frame is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameException">
|
|
/// Thrown if the frame is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidFrameDataKeyException">
|
|
/// Thrown if the frame data key is invalid.
|
|
/// </exception>
|
|
public Matrix4x4 GetFrameDataMatrix4x4(IntPtr frame, FrameDataKey key)
|
|
{
|
|
Debug.LogWarning("GView.GetFrameDataMatrix4x4():这个函数目前未实现!key=" + key);
|
|
//ZSMatrix4 value;
|
|
return Matrix4x4.zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the current video recording state of the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the video recording state of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The video recording state of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
public VideoRecordingState GetVideoRecordingState(IntPtr connection)
|
|
{
|
|
VideoRecordingState state = VideoRecordingState.NotAvailable;
|
|
if (connection == GlobalState.Instance.Connection)
|
|
{
|
|
try
|
|
{
|
|
xxGetVideoRecordingState(out state);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the current video recording error code of the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Calling this method will fail unless the current video recording state is
|
|
/// Error.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the video recording error code of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The video recording error code of the specified connection.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Error state.
|
|
/// </exception>
|
|
public PluginError GetVideoRecordingError(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetVideoRecordingError():这个函数目前未实现!");
|
|
PluginError videoRecordingError = PluginError.Ok;
|
|
return videoRecordingError;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear the video recording error code of the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection from Error to some
|
|
/// other non-error state. Exactly which video recording state is transitioned
|
|
/// to depends on the video recording state that the connection was in prior to
|
|
/// it entering the Error state. In most cases, this function will transition the
|
|
/// video recording state to NotRecording. A notable exception is when the
|
|
/// video recording state of the connection was Saving prior to it entering the
|
|
/// Error state. In this case, the video recording state may transition back to
|
|
/// Finished after calling this function if a recoverable save error occurred and
|
|
/// it is still possible that the current video recording could be saved (e.g. with
|
|
/// a different file name or after some disk space has been freed).
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Error.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to clear the video recording error code of.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Error state.
|
|
/// </exception>
|
|
public void ClearVideoRecordingError(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.ClearVideoRecordingError():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start video recording on the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection to Recording. While the
|
|
/// video recording state transition is taking place, the video recording state will be
|
|
/// Starting.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// NotRecording.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to start video recording on.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the NotRecording state.
|
|
/// </exception>
|
|
public void StartVideoRecording(IntPtr connection)
|
|
{
|
|
Debug.Log("GView.StartVideoRecording():启动录屏!");
|
|
try
|
|
{
|
|
Debug.Log("GView.StartVideoRecording():临时文件路径:" + tempRecFile);
|
|
FARError err = xxStartScreenRec(tempRecFile);
|
|
if (err != FARError.Ok)
|
|
{
|
|
Debug.LogError("GView.StartVideoRecording():启动录屏失败! err=" + err);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError("GView.StartVideoRecording():启动录屏异常e=" + e.Message);
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finish video recording on the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection to Finished. While
|
|
/// the video recording state transition is taking place, the video recording state
|
|
/// will be Finishing.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Recording or Paused.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to finish video recording on.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Recording or Paused state.
|
|
/// </exception>
|
|
public void FinishVideoRecording(IntPtr connection)
|
|
{
|
|
Debug.Log("GView.FinishVideoRecording():停止录屏!");
|
|
try
|
|
{
|
|
FARError err = xxStopScreenRec();
|
|
if (err != FARError.Ok)
|
|
{
|
|
Debug.LogError("GView.FinishVideoRecording():停止录屏失败! err=" + err);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError("GView.FinishVideoRecording():停止录屏异常e=" + e.Message);
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pause video recording on the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection to Paused. While the
|
|
/// video recording state transition is taking place, the video recording state will
|
|
/// be Pausing.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Recording.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to pause video recording on.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Recording state.
|
|
/// </exception>
|
|
public void PauseVideoRecording(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.PauseVideoRecording():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resume video recording on the specified connection.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection to Recording. While the
|
|
/// video recording state transition is taking place, the video recording state will be
|
|
/// Resuming.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Paused.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to resume video recording on.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Paused state.
|
|
/// </exception>
|
|
public void ResumeVideoRecording(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.ResumeVideoRecording():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin saving the specified connection's current video recording to the
|
|
/// specified file name.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection to Saving. Saving occurs
|
|
/// asynchronously and the video recording state of the connection will automatically
|
|
/// transition to NotRecording if saving finishes successfully. If saving fails, then
|
|
/// the video recording state will automatically transition to Error.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Finished.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to save the current video recording of.
|
|
/// </param>
|
|
/// <param name="fileName">
|
|
/// The file name to save the video recording to.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Finished state.
|
|
/// </exception>
|
|
public void SaveVideoRecording(IntPtr connection, string fileName)
|
|
{
|
|
if (!File.Exists(tempRecFile))
|
|
{
|
|
Debug.LogWarning("GView.SaveVideoRecording():不存在录屏的临时文件,无法作移动!临时文件路径:" + tempRecFile);
|
|
return;
|
|
}
|
|
if (File.Exists(fileName))
|
|
{
|
|
Debug.Log("GView.SaveVideoRecording():移动路径上已经存在文件,删除!");
|
|
File.Delete(fileName);
|
|
}
|
|
try
|
|
{
|
|
//注意这里实际上需要等待ffmpeg.exe完成退出才能移动这个文件.
|
|
Debug.Log("GView.SaveVideoRecording():移动临时录屏文件到" + fileName);
|
|
File.Move(tempRecFile, fileName);
|
|
|
|
xxSaveVideoRecording(fileName);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError("GView.SaveVideoRecording():移动文件异常e=" + e.Message);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin discarding the specified connection's current video recording.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// Transitions the video recording state of the connection to Discarding.
|
|
/// Discarding occurs asynchronously and the video recording state of the connection
|
|
/// will automatically transition to Recording when discarding is finished.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Finished.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="connection">
|
|
/// Transitions the video recording state of the connection to Discarding.
|
|
/// Discarding occurs asynchronously and the video recording state of the
|
|
/// connection will automatically transition to NotRecording when discarding is
|
|
/// finished.
|
|
///
|
|
/// Calling this function will fail unless the current video recording state is
|
|
/// Finished.
|
|
/// </param>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is not in the Finished state.
|
|
/// </exception>
|
|
public void DiscardVideoRecording(IntPtr connection)
|
|
{
|
|
Debug.Log("GView.DiscardVideoRecording():中止录屏!");
|
|
try
|
|
{
|
|
FARError err = xxStopScreenRec();
|
|
if (err != FARError.Ok)
|
|
{
|
|
Debug.LogError("GView.FinishVideoRecording():中止录屏! err=" + err);
|
|
}
|
|
//删除已经存在的录制文件
|
|
if (!File.Exists(tempRecFile))
|
|
{
|
|
File.Delete(tempRecFile);
|
|
}
|
|
|
|
xxDiscardVideoRecording();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.Log("GView.DiscardVideoRecording():异常e=" + e.Message);
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the amount of time that has elapsed, in milliseconds, since the
|
|
/// specified connection's current video recording began.
|
|
/// </summary>
|
|
///
|
|
/// <param name="connection">
|
|
/// The connection to get the current video recording time of.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The current video recording time of the specified connection,
|
|
/// in milliseconds.
|
|
/// </returns>
|
|
///
|
|
/// <exception cref="GCSeries.zView.InvalidParameterException">
|
|
/// Thrown if the connection is null (IntPtr.Zero).
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionException">
|
|
/// Thrown if the connection is invalid.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidConnectionStateException">
|
|
/// Thrown if the connection is in the Closed or Error state.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.UnsupportedCapabilityException">
|
|
/// Thrown if the connection does not support the video recording capability.
|
|
/// </exception>
|
|
/// <exception cref="GCSeries.zView.InvalidVideoRecordingStateException">
|
|
/// Thrown if the video recording is in the NotAvailable, NotRecording, Starting,
|
|
/// Error, or ClearingError state.
|
|
/// </exception>
|
|
public UInt64 GetVideoRecordingTime(IntPtr connection)
|
|
{
|
|
Debug.LogWarning("GView.GetVideoRecordingTime():这个函数目前未实现!");
|
|
UInt64 timeInMilliseconds = 0;
|
|
return timeInMilliseconds;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the specified mode's current active virtual camera.
|
|
/// </summary>
|
|
///
|
|
/// <remarks>
|
|
/// If null is specified for the virtual camera, the mode's virtual camera
|
|
/// will be reset to its default implementation.
|
|
/// </remarks>
|
|
///
|
|
/// <param name="mode">
|
|
/// The mode to specify the virtual camera.
|
|
/// </param>
|
|
/// <param name="virtualCamera">
|
|
/// The virtual camera associated with the specified mode.
|
|
/// </param>
|
|
public void SetVirtualCamera(IntPtr mode, GVirtualCamera virtualCamera)
|
|
{
|
|
Debug.LogWarning("GView.SetVirtualCamera():这个函数目前未实现!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the current active virtual camera associated with the specified mode.
|
|
/// </summary>
|
|
///
|
|
/// <param name="mode">
|
|
/// The mode to get the virtual camera for.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// The current active virtual camera associated with the specified mode.
|
|
/// </returns>
|
|
public GVirtualCamera GetVirtualCamera(IntPtr mode)
|
|
{
|
|
GVirtualCamera virtualCamera = null;
|
|
if (!_virtualCameras.TryGetValue(mode, out virtualCamera))
|
|
{
|
|
Debug.LogError(string.Format("Failed to find virtual camera for mode: {0}.", mode));
|
|
}
|
|
|
|
return virtualCamera;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start ignoring (i.e. not processing) any connections with the
|
|
/// specified user data.
|
|
/// </summary>
|
|
/// <param name="userData">
|
|
/// The user data for which to ignore connections for.
|
|
/// </param>
|
|
public void RegisterConnectionUserDataToIgnore(IntPtr userData)
|
|
{
|
|
Debug.Log("GView.RegisterConnectionUserDataToIgnore():进入!");
|
|
_connectionUserDatasToIgnore.Add(userData);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop ignoring (i.e. not processing) any connections with the
|
|
/// specified user data.
|
|
/// </summary>
|
|
/// <param name="userData">
|
|
/// The user data for which to no longer ignore connections for.
|
|
/// </param>
|
|
public void UnregisterConnectionUserDataToIgnore(IntPtr userData)
|
|
{
|
|
Debug.Log("GView.UnregisterConnectionUserDataToIgnore():进入!");
|
|
_connectionUserDatasToIgnore.Remove(userData);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Private Compound Types
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
private class ConnectionInfo
|
|
{
|
|
public IntPtr Connection { get; private set; }
|
|
public ConnectionState ConnectionState { get; set; }
|
|
public IntPtr Mode { get; set; }
|
|
public IntPtr ReceivedFrame { get; set; }
|
|
public IntPtr FrameToSend { get; set; }
|
|
public VideoRecordingState VideoRecordingState { get; set; }
|
|
public VideoRecordingQuality VideoRecordingQuality { get; set; }
|
|
|
|
public ConnectionInfo(IntPtr connection)
|
|
{
|
|
this.Connection = connection;
|
|
this.ConnectionState = ConnectionState.Error;
|
|
this.Mode = IntPtr.Zero;
|
|
this.ReceivedFrame = IntPtr.Zero;
|
|
this.FrameToSend = IntPtr.Zero;
|
|
this.VideoRecordingState = VideoRecordingState.NotAvailable;
|
|
this.VideoRecordingQuality = VideoRecordingQuality.Unknown;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Private Members
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// private static readonly Matrix4x4 s_flipHandednessMap = Matrix4x4.Scale(new Vector4(1.0f, 1.0f, -1.0f));
|
|
|
|
// private Dictionary<IntPtr, ConnectionInfo> _connectionInfos = new Dictionary<IntPtr, ConnectionInfo>();
|
|
private Dictionary<IntPtr, GVirtualCamera> _defaultVirtualCameras = new Dictionary<IntPtr, GVirtualCamera>();
|
|
private Dictionary<IntPtr, GVirtualCamera> _virtualCameras = new Dictionary<IntPtr, GVirtualCamera>();
|
|
|
|
private HashSet<IntPtr> _connectionUserDatasToIgnore = new HashSet<IntPtr>();
|
|
|
|
// private bool _wasFullScreen = false;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Unity Monobehaviour Callbacks
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
//void Awake()
|
|
//{
|
|
// // Force initialization of the global state.
|
|
// GlobalState globalState = GlobalState.Instance;
|
|
// if (globalState == null || !globalState.IsInitialized)
|
|
// {
|
|
// Debug.LogWarning("Failed to initialize global state. Disabling zView GameObject.");
|
|
// this.gameObject.SetActive(false);
|
|
// return;
|
|
// }
|
|
|
|
// // Continue initialization.
|
|
// this.InitializeVirtualCameras();
|
|
|
|
// // Initialize whether the application is in windowed or fullscreen mode.
|
|
// _wasFullScreen = Screen.fullScreen;
|
|
|
|
// // Kick off the end of frame update coroutine.
|
|
// this.StartCoroutine(EndOfFrameUpdate());
|
|
//}
|
|
|
|
//void Start()
|
|
//{
|
|
// // Handle transitioning from a zView-enabled scene while there
|
|
// // is currently an active connection.
|
|
// this.HandleSceneTransition();
|
|
//}
|
|
|
|
// void LateUpdate()
|
|
// {
|
|
// // Cache whether the application is in windowed or fullscreen mode.
|
|
// _wasFullScreen = Screen.fullScreen;
|
|
// }
|
|
|
|
void OnDrawGizmos()
|
|
{
|
|
// Draw the bounds of the AR mode box mask.
|
|
if (this.ARModeShowMask)
|
|
{
|
|
if (this.ActiveZCamera == null)
|
|
return;
|
|
|
|
// Cache original color and matrix to be restored after
|
|
// drawing is finished.
|
|
Color originalGizmosColor = Gizmos.color;
|
|
Matrix4x4 originalGizmosMatrix = Gizmos.matrix;
|
|
|
|
Gizmos.color = Color.white;
|
|
|
|
// ZCamera's parent represents viewport center and
|
|
// therefore where we align the box mask to it.
|
|
// If ZCamera has no parent, then it will align the
|
|
// box mask to world center as is done with ZCamera.
|
|
Gizmos.matrix =
|
|
this.ActiveZCamera.transform.parent?.localToWorldMatrix ??
|
|
Matrix4x4.identity;
|
|
|
|
Vector3 center = new Vector3(0.0f, 0.0f, -this.ARModeMaskSize.z * 0.5f);
|
|
Vector3 size = this.ARModeMaskSize;
|
|
|
|
Gizmos.DrawWireCube(center, size);
|
|
|
|
// Restore original color and matrix.
|
|
Gizmos.color = originalGizmosColor;
|
|
Gizmos.matrix = originalGizmosMatrix;
|
|
}
|
|
}
|
|
#region ----------------------------------------------- GC一体机的实现 -----------------------------------------------
|
|
/// <summary>
|
|
/// 投屏纹理的宽度
|
|
/// </summary>
|
|
public UInt16 imageWidth = 1920;
|
|
|
|
/// <summary>
|
|
/// 投屏纹理高度
|
|
/// </summary>
|
|
public UInt16 imageHeight = 1080;
|
|
|
|
/// <summary>
|
|
/// CurVirtualCameraMode属性使用的字段
|
|
/// </summary>
|
|
private IntPtr _curVirtualCameraMode = IntPtr.Zero;
|
|
|
|
/// <summary>
|
|
/// 当前的工作模式
|
|
/// </summary>
|
|
private IntPtr CurVirtualCameraMode
|
|
{
|
|
get { return _curVirtualCameraMode; }
|
|
set
|
|
{
|
|
if (value != _curVirtualCameraMode || value == IntPtr.Zero)
|
|
{
|
|
try
|
|
{
|
|
Debug.Log("GView.CurVirtualCameraMode():切换相机模式! mode=" + value);
|
|
GVirtualCamera gVirtualCamera = null;
|
|
if (_defaultVirtualCameras.TryGetValue(_curVirtualCameraMode, out gVirtualCamera))
|
|
{
|
|
gVirtualCamera.TearDown();//关闭老的相机
|
|
}
|
|
|
|
if (_defaultVirtualCameras.TryGetValue(value, out gVirtualCamera))
|
|
{
|
|
gVirtualCamera.SetUp(this, GlobalState.Instance.Connection, ModeSetupPhase.Initialization);
|
|
|
|
_workingCamera = gVirtualCamera;//记录当前相机
|
|
FARStartRenderingView(_workingCamera);
|
|
}
|
|
else
|
|
{
|
|
//None模式这个就找不到
|
|
//Debug.LogError($"GView.CurVirtualCameraMode():没找到要打开的新相机,将无法投屏! mode={value}");
|
|
_workingCamera = null;//没找到要置空
|
|
FARDll.CloseDown();
|
|
}
|
|
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError("GView.CurVirtualCameraMode():异常!Message=" + e.Message);
|
|
FARDll.CloseDown();
|
|
}
|
|
_curVirtualCameraMode = value;
|
|
GlobalState.Instance.virtualCameraMode = value;//记录到全局状态中
|
|
|
|
//事件要在virtualCameraMode值被修改了之后发出
|
|
if (this.ConnectionModeSwitched != null)
|
|
{
|
|
this.ConnectionModeSwitched(this, GlobalState.Instance.Connection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//当前工作相机
|
|
private GVirtualCamera _workingCamera = null;
|
|
|
|
void Awake()
|
|
{
|
|
// Force initialization of the global state.
|
|
GlobalState globalState = GlobalState.Instance;
|
|
if (globalState == null || !globalState.IsInitialized)
|
|
{
|
|
Debug.LogWarning("Failed to initialize global state. Disabling zView GameObject.");
|
|
this.gameObject.SetActive(false);
|
|
return;
|
|
}
|
|
|
|
// Get the first found instance of ZCamera if a reference has not
|
|
// been manually assigned.
|
|
if (this.ActiveZCamera == null)
|
|
{
|
|
this.ActiveZCamera = GameObject.FindObjectOfType<ZCamera>();
|
|
|
|
if (this.ActiveZCamera == null)
|
|
{
|
|
Debug.LogWarning("No instance of ZCamera has been found " +
|
|
"in the scene. ZView will not work correctly unless " +
|
|
"ZView.Instance.ActiveZCamera is not null");
|
|
}
|
|
}
|
|
|
|
|
|
InitializeVirtualCameras();
|
|
|
|
//从streamingAssets里面寻找辅助exe
|
|
string ffmpegPath = Path.Combine(Application.streamingAssetsPath, "ffmpeg.exe");
|
|
|
|
FARError err = xxSetEXE(ffmpegPath);
|
|
if (err != FARError.Ok)
|
|
{
|
|
//去调试路径里拿一个
|
|
err = xxSetEXE("C:\\Test\\ffmpeg.exe");
|
|
}
|
|
|
|
if (err != FARError.Ok)
|
|
{
|
|
Debug.LogError("GView.Awake():设置录屏辅助程序路径失败!");
|
|
}
|
|
}
|
|
|
|
void Start()
|
|
{
|
|
HandleSceneTransition();
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
if (_workingCamera != null)
|
|
{
|
|
_workingCamera.Render(this, IntPtr.Zero, IntPtr.Zero);
|
|
}
|
|
|
|
VideoRecordingState videoRecordingState = GetVideoRecordingState(GlobalState.Instance.Connection);
|
|
if (videoRecordingState != GlobalState.Instance.videoRecordingState)
|
|
{
|
|
switch (videoRecordingState)
|
|
{
|
|
case VideoRecordingState.NotRecording:
|
|
if (this.VideoRecordingInactive != null)
|
|
{
|
|
this.VideoRecordingInactive(this, GlobalState.Instance.Connection);
|
|
}
|
|
break;
|
|
|
|
case VideoRecordingState.Recording:
|
|
if (this.VideoRecordingActive != null)
|
|
{
|
|
this.VideoRecordingActive(this, GlobalState.Instance.Connection);
|
|
}
|
|
break;
|
|
|
|
case VideoRecordingState.Finished:
|
|
if (this.VideoRecordingFinished != null)
|
|
{
|
|
this.VideoRecordingFinished(this, GlobalState.Instance.Connection);
|
|
}
|
|
break;
|
|
|
|
case VideoRecordingState.Paused:
|
|
if (this.VideoRecordingPaused != null)
|
|
{
|
|
this.VideoRecordingPaused(this, GlobalState.Instance.Connection);
|
|
}
|
|
break;
|
|
|
|
case VideoRecordingState.Error:
|
|
if (this.VideoRecordingError != null)
|
|
{
|
|
this.VideoRecordingError(this, GlobalState.Instance.Connection);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
GlobalState.Instance.videoRecordingState = videoRecordingState;
|
|
}
|
|
|
|
}
|
|
|
|
void OnDestroy()
|
|
{
|
|
_virtualCameras.Clear();
|
|
_defaultVirtualCameras.Clear();
|
|
_workingCamera = null;
|
|
}
|
|
|
|
void OnApplicationQuit()
|
|
{
|
|
this.CloseConnection(
|
|
this.GetCurrentActiveConnection(),
|
|
GView.ConnectionCloseAction.None,
|
|
GView.ConnectionCloseReason.UserRequested,
|
|
string.Empty);
|
|
|
|
GlobalState.DestroyInstance();
|
|
FARDll.CloseDown();
|
|
}
|
|
|
|
IntPtr _hViewClient = IntPtr.Zero;
|
|
|
|
FARDll.FAR_Status status = FARDll.FAR_Status.FAR_NotInitialized;
|
|
|
|
|
|
///<summary>
|
|
///通过f-ar接口读取屏幕信息后设置窗口位置
|
|
///</summary>
|
|
///<param name="farwin">投屏窗口句柄</param>
|
|
///<param name="preview">是否为3D预览窗口</param>
|
|
public void UpdateWindowPos(IntPtr farwin)
|
|
{
|
|
F3Device.Screen.Monitor monitor = F3Device.DeviceManager.Instance.FindProjectionMonitor(F3DService.Instance.mainWindowHandle);
|
|
if (monitor != null)
|
|
{
|
|
F3Device.Screen.RECT rect = monitor.m_MonitorInfo.rcMonitor;
|
|
FARDll.MoveWindow(farwin, rect.Left, rect.Top, rect.Width, rect.Height, true);
|
|
}
|
|
else
|
|
{
|
|
UnityEngine.Debug.Log("Direct3DWin.UpdateWindows 没有找到投屏目标显示器");
|
|
}
|
|
}
|
|
|
|
private IEnumerator CreateFARWindow(GVirtualCamera virtualCamera)
|
|
{
|
|
yield return new WaitForEndOfFrame();
|
|
_hViewClient = FARDll.FindWindow(null, "ClientWinCpp");
|
|
status = FARDll.FAR_Status.FAR_NotInitialized;
|
|
if (_hViewClient == IntPtr.Zero)
|
|
{
|
|
string _path = Path.Combine(Application.streamingAssetsPath, "ClientWin.exe");
|
|
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
|
|
startInfo.FileName = _path;
|
|
FARDll.viewProcess = new System.Diagnostics.Process();
|
|
FARDll.viewProcess.StartInfo = startInfo;
|
|
FARDll.viewProcess.Start();
|
|
FARDll.viewProcess.WaitForInputIdle();
|
|
_hViewClient = FARDll.FindWindow(null, "ClientWinCpp");
|
|
}
|
|
if (FARDll.viewProcess != null)
|
|
{
|
|
if (_hViewClient != IntPtr.Zero)
|
|
{
|
|
//全屏到非GC显示器
|
|
UpdateWindowPos(_hViewClient);
|
|
int RTcount = 0;
|
|
RenderTexture[] tempRTs = virtualCamera.GetRenderTexture(out RTcount);
|
|
|
|
if (RTcount == 1)
|
|
{
|
|
status = (FARDll.FAR_Status)FARDll.StartView(_hViewClient, tempRTs[0].GetNativeTexturePtr(), IntPtr.Zero);
|
|
}
|
|
else if (RTcount == 2)
|
|
{
|
|
FARDll.SwitchProjector(FARDll.ProjectorType.LeftRight);
|
|
status = (FARDll.FAR_Status)FARDll.StartView(_hViewClient, tempRTs[0].GetNativeTexturePtr(), tempRTs[1].GetNativeTexturePtr());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
status = FARDll.FAR_Status.FAR_GraphicsCardUnsupported;
|
|
|
|
if (status <= 0)
|
|
{
|
|
UnityEngine.Debug.LogError("Direct3DWin.CreateFARWindow 投屏启动失败" + status);
|
|
FARDll.CloseDown();
|
|
}
|
|
|
|
if (_GLIssueHandle != null)
|
|
this.StopCoroutine(_GLIssueHandle);
|
|
_GLIssueHandle = this.StartCoroutine(CallPluginAtEndOfFrames());
|
|
}
|
|
|
|
private Coroutine _GLIssueHandle;
|
|
private IEnumerator CallPluginAtEndOfFrames()
|
|
{
|
|
while (true)
|
|
{
|
|
yield return new WaitForEndOfFrame();
|
|
GL.IssuePluginEvent(FARDll.GetRenderEventFunc(), 1);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 启动FAR投屏窗口
|
|
/// </summary>
|
|
/// <param name="workmMode">投屏单张纹理或两张纹理</param>
|
|
private void FARStartRenderingView(GVirtualCamera virtualCamera)
|
|
{
|
|
StartCoroutine(CreateFARWindow(virtualCamera));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 初始化两个相机
|
|
/// </summary>
|
|
private void InitializeVirtualCameras()
|
|
{
|
|
//CameraMode.Fixed, CameraMode目前都是固定的,不是跟踪头部的
|
|
_virtualCameras.Clear();
|
|
_defaultVirtualCameras.Clear();
|
|
_workingCamera = null;
|
|
|
|
// Create the default virtual camera for standard mode.
|
|
GameObject virtualCameraStandardObject = new GameObject("GVirtualCameraStandard");
|
|
virtualCameraStandardObject.transform.parent = this.transform;
|
|
_cameraStandard = virtualCameraStandardObject.AddComponent<GVirtualCameraStandard>();
|
|
_defaultVirtualCameras[GlobalState.Instance.ModeStandard] = _cameraStandard;
|
|
_virtualCameras[GlobalState.Instance.ModeStandard] = _cameraStandard;
|
|
|
|
GameObject virtualCameraThreeDObject = new GameObject("GVirtualCameraThreeD");
|
|
virtualCameraThreeDObject.transform.parent = this.transform;
|
|
_cameraThreeD = virtualCameraThreeDObject.AddComponent<GVirtualCameraThreeD>();
|
|
_defaultVirtualCameras[GlobalState.Instance.ModeThreeD] = _cameraThreeD;
|
|
_virtualCameras[GlobalState.Instance.ModeThreeD] = _cameraThreeD;
|
|
|
|
// Create the default virtual camera for AR mode.
|
|
GameObject virtualCameraARObject = new GameObject("GVirtualCameraAR");
|
|
virtualCameraARObject.transform.parent = this.transform;
|
|
_cameraAR = virtualCameraARObject.AddComponent<GVirtualCameraAR>();
|
|
_defaultVirtualCameras[GlobalState.Instance.ModeAugmentedReality] = _cameraAR;
|
|
_virtualCameras[GlobalState.Instance.ModeAugmentedReality] = _cameraAR;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set up the current mode's virtual camera if there is
|
|
/// a connection in the ModeActive state. This logic is necessary
|
|
/// for the purpose of handling scene transitions between two zView-enabled
|
|
/// scenes while a connection is currently active.
|
|
/// </summary>
|
|
private void HandleSceneTransition()
|
|
{
|
|
IntPtr connection = GlobalState.Instance.Connection;
|
|
if (connection == IntPtr.Zero)
|
|
{
|
|
return;
|
|
}
|
|
CurVirtualCameraMode = GlobalState.Instance.virtualCameraMode;
|
|
}
|
|
|
|
private GVirtualCameraStandard _cameraStandard = null;
|
|
private GVirtualCameraThreeD _cameraThreeD = null;
|
|
private GVirtualCameraAR _cameraAR = null;
|
|
|
|
/// <summary>
|
|
/// 默认的录屏临时文件存放目录放桌面算了
|
|
/// </summary>
|
|
private string tempRecFile
|
|
{
|
|
get { return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "FARRecording.mp4"); }
|
|
}
|
|
|
|
public enum FARError
|
|
{
|
|
Unknown = -1,
|
|
Ok = 0,
|
|
NoCalib = 1, // 没标定
|
|
NoLicense = 2, // 没证书
|
|
NoFFmpeg = 3, //没有ffmpeg程序
|
|
NoSendsignal = 4 //没有Sendsignal程序
|
|
}
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
public static extern FARError xxGetARCameraPose(out Matrix4x4 matrix);
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxConnectToDefaultViewer(out IntPtr connect);
|
|
|
|
/// <summary>
|
|
/// 设置辅助exe的路径,其中ffmpeg用来开启录屏进程,sendsignal用来关闭录屏进程.
|
|
/// 注,目前sendsignal.exe已经不需要了.
|
|
/// </summary>
|
|
/// <param name="ffmpeg">ffmpeg.exe的路径</param>
|
|
/// <param name="sendsignal">sendsignal.exe的路径</param>
|
|
/// <returns></returns>
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxSetEXE(string ffmpeg, string sendsignal = "sendsignal.exe");
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern bool xxGetVideoRecordingCapability();
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxGetVideoRecordingState(out VideoRecordingState state);
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxStartScreenRec(string filePath);
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxStopScreenRec();
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxSaveVideoRecording(string filePath);
|
|
|
|
[DllImport("zCoreUnity", CallingConvention = CallingConvention.StdCall)]
|
|
private static extern FARError xxDiscardVideoRecording();
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|