/**
* Set overlay's mouse scale
*/
public void SetMouseScale(float v0, float v1)
{
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v0 = v0;
vecMouseScale.v1 = v1;
ReportError(overlay.SetOverlayMouseScale(handle, ref vecMouseScale));
}
public HmdVector2_t Load(string base64png)
{
if (_glWindow == null)
{
_glWindow = new GameWindow(); // Init OpenGL
}
var size = new HmdVector2_t();
try
{
// Loading image from incoming base64 encoded string
var imageBytes = Convert.FromBase64String(base64png);
var bmp = new Bitmap(new MemoryStream(imageBytes));
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY); // Flip it for OpenGL
// Lock bits so we can supply them to the texture
var bmpBits = bmp.LockBits(
new Rectangle(0, 0, bmp.Width, bmp.Height),
System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb
);
// Create OpenGL texture
var textureId = GL.GenTexture();
_oldTextureId = (IntPtr)textureId;
GL.BindTexture(TextureTarget.Texture2D, textureId);
GL.TexStorage2D(TextureTarget2d.Texture2D, 1, SizedInternalFormat.Rgba8, bmp.Width, bmp.Height);
GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, bmp.Width, bmp.Height, PixelFormat.Bgra, PixelType.UnsignedByte, bmpBits.Scan0);
bmp.UnlockBits(bmpBits);
// Create SteamVR texture
Texture_t texture = new Texture_t();
texture.eType = ETextureType.OpenGL;
texture.eColorSpace = EColorSpace.Auto;
texture.handle = (IntPtr)textureId;
// Assign texture
var error = OpenVR.Overlay.SetOverlayTexture(_overlayHandle, ref texture); // Overlay handle exist and works when setting the overlay directly from file instead of with texture.
if (error != EVROverlayError.None)
{
Debug.WriteLine($"SetOverlayTexture error: {Enum.GetName(error.GetType(), error)}");
}
else
{
size.v0 = bmp.Width;
size.v1 = bmp.Height;
}
}
catch (Exception e)
{
Debug.WriteLine($"Exception when loading texture: {e.Message}");
}
return(size);
}
public void SetMouseScale(float X, float Y)
{
//マウスカーソルスケールを設定する(これにより表示領域のサイズも決定される)
HmdVector2_t vecMouseScale = new HmdVector2_t
{
v0 = X,
v1 = Y
};
overlay.SetOverlayMouseScale(overlayHandle, ref vecMouseScale);
}
public void SetMouseScale(HmdVector2_t v)
{
overlayMouseScale = v;
if (!CheckValid())
{
return;
}
OpenVR.Overlay.SetOverlayMouseScale(handle, ref overlayMouseScale);
}
void OnEnable()
{
// Set target scale
patternSize = new Size((int)pattern.x, (int)pattern.y);
chessboard.transform.localScale = new Vector3(patternScale * (patternSize.Width + 1), patternScale * (patternSize.Height + 1), 1.0f);
// Construct world corner points
Vector2 offset = new Vector2(patternSize.Width / 2.0f * patternScale, patternSize.Height / 2.0f * patternScale);
cvWorldCorners = new Matrix <double>(patternSize.Height * patternSize.Width, 1, 3);
for (int iy = 0; iy < patternSize.Height; iy++)
{
for (int ix = 0; ix < patternSize.Width; ix++)
{
cvWorldCorners.Data[iy * patternSize.Width + ix, 0] = ix * patternScale - offset.x;
cvWorldCorners.Data[iy * patternSize.Width + ix, 1] = iy * patternScale - offset.y;
cvWorldCorners.Data[iy * patternSize.Width + ix, 2] = 0;
}
}
webcamTexture = TrackedCameraScript.GetViveCameraTexture();
if (webcamTexture == null)
{
return;
}
HmdVector2_t focalLength = new HmdVector2_t();
HmdVector2_t opticCenter = new HmdVector2_t();
OpenVR.TrackedCamera.GetCameraIntrinsics(0, EVRTrackedCameraFrameType.Undistorted, ref focalLength, ref opticCenter);
// Initialize intrinsic parameters
cvIntrinsicParams = new Matrix <double>(3, 3, 1);
cvIntrinsicParams[0, 0] = focalLength.v0;
cvIntrinsicParams[0, 1] = 0;
cvIntrinsicParams[0, 2] = opticCenter.v0;
cvIntrinsicParams[1, 0] = 0;
cvIntrinsicParams[1, 1] = focalLength.v1;
cvIntrinsicParams[1, 2] = opticCenter.v1;
cvIntrinsicParams[2, 0] = 0;
cvIntrinsicParams[2, 1] = 0;
cvIntrinsicParams[2, 2] = 1;
cvDistortionParams = new Matrix <double>(4, 1, 1);
cvDistortionParams[0, 0] = 0.0f;
cvDistortionParams[1, 0] = 0.0f;
cvDistortionParams[2, 0] = 0.0f;
cvDistortionParams[3, 0] = 0.0f;
}
public void Update(HmdQuad_t rect, HmdVector2_t size, float height)
{
corners[0] = new Vec3(rect.vCorners0);
corners[1] = new Vec3(rect.vCorners1);
corners[2] = new Vec3(rect.vCorners2);
corners[3] = new Vec3(rect.vCorners3);
corners[4] = new Vec3(rect.vCorners0);
corners[5] = new Vec3(rect.vCorners1);
corners[6] = new Vec3(rect.vCorners2);
corners[7] = new Vec3(rect.vCorners3);
corners[4].y = height;
corners[5].y = height;
corners[6].y = height;
corners[7].y = height;
this.size.x = size.v0;
this.size.y = height;
this.size.z = size.v1;
}
/// <summary>
/// Update our texture if we are a RenderTexture.
/// This is called every frame where nothing else changes, so that we still push RenderTexture updates if needed.
/// </summary>
private void UpdateTexture(bool refresh = false)
{
if (!(OverlayTexture is RenderTexture && AutoUpdateRenderTextures) && !(OverlayTexture is MovieTexture) && !refresh)
{
return; // This covers the null check for OverlayTexture
}
if (_justUpdated)
{
return;
}
if (refresh && OverlayTexture == null)
{
return;
}
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
var tex = new Texture_t
{
handle = OverlayTexture.GetNativeTexturePtr(),
eType = SteamVR.instance.graphicsAPI,
eColorSpace = EColorSpace.Auto
};
var vecMouseScale = new HmdVector2_t
{
v0 = 1f,
v1 = (float)OverlayTexture.height / (float)OverlayTexture.width
};
overlay.SetOverlayMouseScale(_handle, ref vecMouseScale);
overlay.SetOverlayTexture(_handle, ref tex);
}
public abstract VROverlayError SetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale);
public PlayArea(HmdQuad_t rect = new HmdQuad_t(), HmdVector2_t size = new HmdVector2_t(), float height = 0)
{
Update(rect, size, height);
}
public void UpdateOverlay(SteamVR vr)
{
if (texture != null)
{
var error = vr.overlay.ShowOverlay(handle);
if (error == VROverlayError.InvalidHandle || error == VROverlayError.UnknownOverlay)
{
if (vr.overlay.FindOverlay(key, ref handle) != VROverlayError.None)
{
return;
}
}
vr.overlay.SetOverlayTexture(handle, vr.graphicsAPI, texture.GetNativeTexturePtr());
vr.overlay.SetOverlayAlpha(handle, alpha);
vr.overlay.SetOverlayGamma(handle, gamma);
vr.overlay.SetOverlayWidthInMeters(handle, scale);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
vr.overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v = new float[] { mouseScale.x, mouseScale.y };
vr.overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
offset.pos.z += distance;
var t = offset.ToHmdMatrix34();
vr.overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
vr.overlay.SetOverlayInputMethod(handle, inputMethod);
if (curved || antialias)
{
highquality = true;
}
if (highquality)
{
vr.overlay.SetHighQualityOverlay(handle);
vr.overlay.SetOverlayFlag(handle, VROverlayFlags.Curved, curved);
vr.overlay.SetOverlayFlag(handle, VROverlayFlags.RGSS4X, antialias);
}
else if (vr.overlay.GetHighQualityOverlay() == handle)
{
vr.overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
vr.overlay.HideOverlay(handle);
}
}
public override VROverlayError SetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale)
{
CheckIfUsable();
VROverlayError result = VRNativeEntrypoints.VR_IVROverlay_SetOverlayMouseScale(m_pVROverlay,ulOverlayHandle,ref pvecMouseScale);
return result;
}
//位置情報を更新
private void updatePosition()
{
#pragma warning disable 0219
string Tag = "[" + this.GetType().Name + ":" + System.Reflection.MethodBase.GetCurrentMethod(); //クラス名とメソッド名を自動取得
#pragma warning restore 0219
//RenderTextureが生成されているかチェック
if (!renderTexture.IsCreated())
{
Debug.Log(Tag + "RenderTextureがまだ生成されていない");
return;
}
//回転を生成
Quaternion quaternion = Quaternion.Euler(Rotation.x, Rotation.y, Rotation.z);
//座標系を変更(右手系と左手系の入れ替え)
Vector3 position = Position;
position.z = -Position.z;
//HMD視点位置変換行列に書き込む。
Matrix4x4 m = Matrix4x4.TRS(position, quaternion, Scale);
//鏡像反転
Vector3 Mirroring = new Vector3(MirrorX ? -1 : 1, MirrorY ? -1 : 1, 1);
//4x4行列を3x4行列に変換する。
p.m0 = Mirroring.x * m.m00;
p.m1 = Mirroring.y * m.m01;
p.m2 = Mirroring.z * m.m02;
p.m3 = m.m03;
p.m4 = Mirroring.x * m.m10;
p.m5 = Mirroring.y * m.m11;
p.m6 = Mirroring.z * m.m12;
p.m7 = m.m13;
p.m8 = Mirroring.x * m.m20;
p.m9 = Mirroring.y * m.m21;
p.m10 = Mirroring.z * m.m22;
p.m11 = m.m23;
//回転行列を元に相対位置で表示
if (DeviceTracking)
{
//deviceindexを処理(コントローラーなどはその時その時で変わるため)
var idx = OpenVR.k_unTrackedDeviceIndex_Hmd;
switch (DeviceIndex)
{
case TrackingDeviceSelect.LeftController:
idx = openvr.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.LeftHand);
break;
case TrackingDeviceSelect.RightController:
idx = openvr.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.RightHand);
break;
default:
idx = (uint)DeviceIndex;
break;
}
//device情報に変化があったらInspectorに反映
if (DeviceIndexOld != (int)idx)
{
Debug.Log(Tag + "Device Updated");
UpdateDeviceInfo(idx);
DeviceIndexOld = (int)idx;
}
//HMDからの相対的な位置にオーバーレイを表示する。
overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, idx, ref p);
}
else
{
//空間の絶対位置にオーバーレイを表示する
if (!Seated)
{
overlay.SetOverlayTransformAbsolute(overlayHandle, ETrackingUniverseOrigin.TrackingUniverseStanding, ref p);
}
else
{
overlay.SetOverlayTransformAbsolute(overlayHandle, ETrackingUniverseOrigin.TrackingUniverseSeated, ref p);
}
}
if (ResetSeatedCamera)
{
OpenVR.System.ResetSeatedZeroPose();
ResetSeatedCamera = false;
}
//オーバーレイの大きさ設定(幅のみ。高さはテクスチャの比から自動計算される)
overlay.SetOverlayWidthInMeters(overlayHandle, width);
//オーバーレイの透明度を設定
overlay.SetOverlayAlpha(overlayHandle, alpha);
//マウスカーソルスケールを設定する(これにより表示領域のサイズも決定される)
try
{
HmdVector2_t vecMouseScale = new HmdVector2_t
{
v0 = renderTexture.width,
v1 = renderTexture.height
};
overlay.SetOverlayMouseScale(overlayHandle, ref vecMouseScale);
}
catch (UnassignedReferenceException e)
{
Debug.LogError(Tag + "RenderTextureがセットされていません " + e.ToString());
ProcessError();
return;
}
}
/// <summary>
/// Push Updates to our Overlay to the OpenVR System
/// </summary>
private void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (OverlayTexture != null)
{
var error = overlay.ShowOverlay(_handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(HOTK_Overlay.Key + gameObject.GetInstanceID(), ref _handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t
{
handle = OverlayTexture.GetNativeTexturePtr(),
eType = SteamVR.instance.graphicsAPI,
eColorSpace = EColorSpace.Auto
};
overlay.SetOverlayColor(_handle, 1f, 1f, 1f);
//overlay.SetOverlayGamma(_handle, 2.2f); // Doesn't exist yet :(
overlay.SetOverlayTexture(_handle, ref tex);
overlay.SetOverlayAlpha(_handle, _alpha);
overlay.SetOverlayWidthInMeters(_handle, _scale);
var textureBounds = new VRTextureBounds_t
{
uMin = (0 + Overlay.UvOffset.x) * Overlay.UvOffset.z,
vMin = (1 + Overlay.UvOffset.y) * Overlay.UvOffset.w,
uMax = (1 + Overlay.UvOffset.x) * Overlay.UvOffset.z,
vMax = (0 + Overlay.UvOffset.y) * Overlay.UvOffset.w
};
overlay.SetOverlayTextureBounds(_handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t
{
v0 = 1f,
v1 = (float)OverlayTexture.height / (float)OverlayTexture.width
};
overlay.SetOverlayMouseScale(_handle, ref vecMouseScale);
if (_anchor != OpenVR.k_unTrackedDeviceIndexInvalid) // Attached to some HOTK_TrackedDevice, used for Controllers
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_handle, _anchor, ref t);
}
else if (_anchorDevice == HOTK_Overlay.AttachmentDevice.World) // Attached to World
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformAbsolute(_handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else
{
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null) // Attached to Camera (We are Rendering)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(_handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else // Attached to Camera (We are Not Rendering)
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_handle, 0, ref t);
}
}
overlay.SetOverlayInputMethod(_handle, InputMethod);
}
else
{
overlay.HideOverlay(_handle);
}
}
public override bool HandleControllerOverlayInteractionAsMouse(IntPtr overlaySettings,HmdVector2_t vecWindowClientPositionOnScreen,HmdVector2_t vecWindowClientSize,uint unControllerDeviceIndex,uint eOutputType)
{
CheckIfUsable();
bool result = VRNativeEntrypoints.VR_IVRSystem_HandleControllerOverlayInteractionAsMouse(m_pVRSystem,overlaySettings,vecWindowClientPositionOnScreen,vecWindowClientSize,unControllerDeviceIndex,eOutputType);
return result;
}
public override bool ComputeOverlayIntersection(ref Compositor_OverlaySettings pSettings,float fAspectRatio,TrackingUniverseOrigin eOrigin,HmdVector3_t vSource,HmdVector3_t vDirection,ref HmdVector2_t pvecIntersectionUV,ref HmdVector3_t pvecIntersectionTrackingSpace)
{
CheckIfUsable();
bool result = VRNativeEntrypoints.VR_IVRCompositor_ComputeOverlayIntersection(m_pVRCompositor,ref pSettings,fAspectRatio,eOrigin,vSource,vDirection,ref pvecIntersectionUV,ref pvecIntersectionTrackingSpace);
return result;
}
/// <summary>
/// Push Updates to our Overlay to the OpenVR System
/// </summary>
private void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (OverlayTexture != null)
{
var error = overlay.ShowOverlay(_handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(Key, ref _handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t
{
handle = OverlayTexture.GetNativeTexturePtr(),
eType = SteamVR.instance.textureType,
eColorSpace = EColorSpace.Auto
};
overlay.SetOverlayColor(_handle, 1f, 1f, 1f);
//overlay.SetOverlayGamma(_handle, 2.2f); // Doesn't exist yet :(
overlay.SetOverlayTexture(_handle, ref tex);
overlay.SetOverlayAlpha(_handle, AnimateOnGaze == AnimationType.Alpha || AnimateOnGaze == AnimationType.AlphaAndScale ? _alpha : Alpha);
overlay.SetOverlayWidthInMeters(_handle, AnimateOnGaze == AnimationType.Scale || AnimateOnGaze == AnimationType.AlphaAndScale ? _scale : Scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(_handle, CurvedRange.x, CurvedRange.y);
var textureBounds = new VRTextureBounds_t
{
uMin = (0 + UvOffset.x) * UvOffset.z,
vMin = (1 + UvOffset.y) * UvOffset.w,
uMax = (1 + UvOffset.x) * UvOffset.z,
vMax = (0 + UvOffset.y) * UvOffset.w
};
overlay.SetOverlayTextureBounds(_handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t
{
v0 = MouseScale.x,
v1 = MouseScale.y
};
overlay.SetOverlayMouseScale(_handle, ref vecMouseScale);
if (_anchor != OpenVR.k_unTrackedDeviceIndexInvalid) // Attached to some HOTK_TrackedDevice, used for Controllers
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_handle, _anchor, ref t);
}
else if (AnchorDevice == MountDevice.World) // Attached to World
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformAbsolute(_handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else
{
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null) // Attached to Camera (We are Rendering)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(_handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else // Attached to Camera (We are Not Rendering)
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_handle, 0, ref t);
}
}
overlay.SetOverlayInputMethod(_handle, InputMethod);
if (Highquality)
{
if (HighQualityOverlay != this && HighQualityOverlay != null)
{
if (HighQualityOverlay.Highquality)
{
Debug.LogWarning("Only one Overlay can be in HighQuality mode as per the OpenVR API.");
HighQualityOverlay.Highquality = false;
}
HighQualityOverlay = this;
}
else if (HighQualityOverlay == null)
{
HighQualityOverlay = this;
}
overlay.SetHighQualityOverlay(_handle);
overlay.SetOverlayFlag(_handle, VROverlayFlags.Curved, Curved);
overlay.SetOverlayFlag(_handle, VROverlayFlags.RGSS4X, Antialias);
}
else if (overlay.GetHighQualityOverlay() == _handle)
{
overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
overlay.HideOverlay(_handle);
}
}
public void UpdateOverlay(Transform origin, ETrackingUniverseOrigin trackingSpace)
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
var error = EVROverlayError.None;
error = overlay.ShowOverlay(handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(overlayKey, ref handle) != EVROverlayError.None)
{
CreateOverlay();
return;
}
}
while (PollNextEvent(ref pEvent))
{
EventHandler(ref pEvent);
}
if (!_enabled || !isVisible)
{
dontDraw = true;
}
if (dontDraw)
{
overlay.HideOverlay(handle);
dontDraw = false;
return;
}
else if (dontUpdate)
{
dontUpdate = false;
return;
}
var tex = new Texture_t();
tex.handle = texture.GetNativeTexturePtr();
tex.eType = OpenVR_Handler.instance.textureType;
tex.eColorSpace = EColorSpace.Auto;
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
var offset = new SteamVR_Utils.RigidTransform(origin, transform).ToHmdMatrix34();
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v0 = mouseScale.x;
vecMouseScale.v1 = mouseScale.y;
overlay.SetOverlayTexture(handle, ref tex);
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
if (useWorldSpaceForOverlay)
{
overlay.SetOverlayTransformAbsolute(handle, trackingSpace, ref offset);
}
overlay.SetOverlayAlpha(handle, opacity);
overlay.SetOverlayWidthInMeters(handle, scale);
if (highQualityOverlay)
{
overlay.SetHighQualityOverlay(handle);
}
overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
overlay.SetOverlayInputMethod(handle, inputMethod);
overlay.SetOverlayFlag(handle, VROverlayFlags.ShowTouchPadScrollWheel, enableScroller);
}
public abstract bool ComputeOverlayIntersection(ref Compositor_OverlaySettings pSettings,float fAspectRatio,TrackingUniverseOrigin eOrigin,HmdVector3_t vSource,HmdVector3_t vDirection,ref HmdVector2_t pvecIntersectionUV,ref HmdVector3_t pvecIntersectionTrackingSpace);
public void UpdateCursorOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null || guiOverlay == null)
{
return;
}
if (CursorTexture != null && guiOverlay.showCursor && guiOverlay.cursorTargetTransform != null)
{
var error = overlay.ShowOverlay(handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(overlayKey, ref handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t();
tex.handle = CursorTexture.GetNativeTexturePtr();
tex.eType = SteamVR.instance.textureType;
tex.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(handle, ref tex);
overlay.SetOverlayAlpha(handle, 1.0f);
overlay.SetOverlayWidthInMeters(handle, WidthInMeters);
var curvedRange = new Vector2(1, 2);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(handle, curvedRange.x, curvedRange.y);
var uvOffset = new Vector4(0, 0, 1, 1);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
var mouseScale = new Vector2(1, 1);
vecMouseScale.v0 = mouseScale.x;
vecMouseScale.v1 = mouseScale.y;
overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
if (cursorPosition == null)
{
cursorPosition = (new GameObject()).transform;
cursorPosition.SetParent(guiOverlay.cursorTargetTransform);
cursorPosition.localEulerAngles = Vector3.zero;
}
var offset = new SteamVR_Utils.RigidTransform();
var texWidth = guiOverlay.cursorTargetTransform.localScale.x;
var texHeight = guiOverlay.cursorTargetTransform.localScale.y;
var curWidth = WidthInMeters;
var curHeight = (WidthInMeters / CursorTexture.width) * CursorTexture.height;
var scaleWidth = curWidth / texWidth;
var scaleHeight = curHeight / texHeight;
cursorPosition.localPosition = new Vector3(guiOverlay.cursorPosition.x - 0.5f + (scaleWidth / 2), 0.5f - guiOverlay.cursorPosition.y - (scaleHeight / 2), -0.0f);
offset.pos = cursorPosition.position;
offset.rot = cursorPosition.rotation;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
overlay.SetOverlaySortOrder(handle, 1); //SortOrderは数字が大きいほうが後からレンダリングされる
overlay.SetOverlayInputMethod(handle, VROverlayInputMethod.Mouse);
}
else
{
overlay.HideOverlay(handle);
}
}
public abstract EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform);
public override EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform)
{
CheckIfUsable();
EVROverlayError result = VRNativeEntrypoints.VR_IVROverlay_GetTransformForOverlayCoordinates(m_pVROverlay,ulOverlayHandle,eTrackingOrigin,coordinatesInOverlay,ref pmatTransform);
return result;
}
public abstract bool HandleControllerOverlayInteractionAsMouse(IntPtr overlaySettings,HmdVector2_t vecWindowClientPositionOnScreen,HmdVector2_t vecWindowClientSize,uint unControllerDeviceIndex,uint eOutputType);
/// <summary>
/// Update the Overlay
/// </summary>
private void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (OverlayTexture != null) // Texture set
{
var error = overlay.ShowOverlay(_overlayHandle); // Show Overlay
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay) // Overlay handle invalid
{
if (overlay.FindOverlay(Key + gameObject.GetInstanceID(), ref _overlayHandle) != EVROverlayError.None) // Attempt to grab handle by name
{
return;
}
}
// Setup a Native texture
var tex = new Texture_t
{
handle = OverlayTexture.GetNativeTexturePtr(),
eType = SteamVR.instance.graphicsAPI,
eColorSpace = EColorSpace.Auto
};
overlay.SetOverlayColor(_overlayHandle, 1f, 1f, 1f); // Assign Overlay Color
overlay.SetOverlayTexture(_overlayHandle, ref tex); // Assign Overlay Texture
overlay.SetOverlayAlpha(_overlayHandle, 1f); // Assign Overlay Alpha
overlay.SetOverlayWidthInMeters(_overlayHandle, Scale); // Assign Overlay Scale (height is automatic to match texture aspect)
overlay.SetOverlayAutoCurveDistanceRangeInMeters(_overlayHandle, CurvedRange.x, CurvedRange.y);
// Setup Texture bounds
var textureBounds = new VRTextureBounds_t
{
uMin = (0 + UvOffset.x) * UvOffset.z,
vMin = (1 + UvOffset.y) * UvOffset.w,
uMax = (1 + UvOffset.x) * UvOffset.z,
vMax = (0 + UvOffset.y) * UvOffset.w
};
overlay.SetOverlayTextureBounds(_overlayHandle, ref textureBounds);
var vecMouseScale = new HmdVector2_t
{
v0 = 1f,
v1 = (float)OverlayTexture.height / (float)OverlayTexture.width
};
overlay.SetOverlayMouseScale(_overlayHandle, ref vecMouseScale);
// Attach Overlay to relative position
if (AnchorDeviceId != OpenVR.k_unTrackedDeviceIndexInvalid) // Attach to some device (like a controller)
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_overlayHandle, AnchorDeviceId, ref t);
}
else // Attach to position in world
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformAbsolute(_overlayHandle, SteamVR_Render.instance.trackingSpace, ref t);
}
overlay.SetOverlayInputMethod(_overlayHandle, VROverlayInputMethod.None);
}
else // Texture not set, hide overlay
{
overlay.HideOverlay(_overlayHandle);
}
}
public void UpdateOverlay()
{
CVROverlay overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (this.texture != null)
{
EVROverlayError evroverlayError = overlay.ShowOverlay(this.handle);
if ((evroverlayError == EVROverlayError.InvalidHandle || evroverlayError == EVROverlayError.UnknownOverlay) && overlay.FindOverlay(SteamVR_Overlay.key, ref this.handle) != EVROverlayError.None)
{
return;
}
Texture_t texture_t = default(Texture_t);
texture_t.handle = this.texture.GetNativeTexturePtr();
texture_t.eType = SteamVR.instance.textureType;
texture_t.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(this.handle, ref texture_t);
overlay.SetOverlayAlpha(this.handle, this.alpha);
overlay.SetOverlayWidthInMeters(this.handle, this.scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(this.handle, this.curvedRange.x, this.curvedRange.y);
VRTextureBounds_t vrtextureBounds_t = default(VRTextureBounds_t);
vrtextureBounds_t.uMin = this.uvOffset.x * this.uvOffset.z;
vrtextureBounds_t.vMin = (1f + this.uvOffset.y) * this.uvOffset.w;
vrtextureBounds_t.uMax = (1f + this.uvOffset.x) * this.uvOffset.z;
vrtextureBounds_t.vMax = this.uvOffset.y * this.uvOffset.w;
overlay.SetOverlayTextureBounds(this.handle, ref vrtextureBounds_t);
HmdVector2_t hmdVector2_t = default(HmdVector2_t);
hmdVector2_t.v0 = this.mouseScale.x;
hmdVector2_t.v1 = this.mouseScale.y;
overlay.SetOverlayMouseScale(this.handle, ref hmdVector2_t);
SteamVR_Camera steamVR_Camera = SteamVR_Render.Top();
if (steamVR_Camera != null && steamVR_Camera.origin != null)
{
SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(steamVR_Camera.origin, base.transform);
rigidTransform.pos.x = rigidTransform.pos.x / steamVR_Camera.origin.localScale.x;
rigidTransform.pos.y = rigidTransform.pos.y / steamVR_Camera.origin.localScale.y;
rigidTransform.pos.z = rigidTransform.pos.z / steamVR_Camera.origin.localScale.z;
rigidTransform.pos.z = rigidTransform.pos.z + this.distance;
HmdMatrix34_t hmdMatrix34_t = rigidTransform.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(this.handle, SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t);
}
overlay.SetOverlayInputMethod(this.handle, this.inputMethod);
if (this.curved || this.antialias)
{
this.highquality = true;
}
if (this.highquality)
{
overlay.SetHighQualityOverlay(this.handle);
overlay.SetOverlayFlag(this.handle, VROverlayFlags.Curved, this.curved);
overlay.SetOverlayFlag(this.handle, VROverlayFlags.RGSS4X, this.antialias);
}
else if (overlay.GetHighQualityOverlay() == this.handle)
{
overlay.SetHighQualityOverlay(0UL);
}
}
else
{
overlay.HideOverlay(this.handle);
}
}
public void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (texture != null)
{
var error = overlay.ShowOverlay(handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(key, ref handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t();
tex.handle = texture.GetNativeTexturePtr();
tex.eType = SteamVR.instance.textureType;
tex.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(handle, ref tex);
overlay.SetOverlayAlpha(handle, alpha);
overlay.SetOverlayWidthInMeters(handle, scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(handle, curvedRange.x, curvedRange.y);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v0 = mouseScale.x;
vecMouseScale.v1 = mouseScale.y;
overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
offset.pos.z += distance;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
overlay.SetOverlayInputMethod(handle, inputMethod);
if (curved || antialias)
{
highquality = true;
}
if (highquality)
{
overlay.SetHighQualityOverlay(handle);
overlay.SetOverlayFlag(handle, VROverlayFlags.Curved, curved);
overlay.SetOverlayFlag(handle, VROverlayFlags.RGSS4X, antialias);
}
else if (overlay.GetHighQualityOverlay() == handle)
{
overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
overlay.HideOverlay(handle);
}
}
public void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (texture != null)
{
var error = overlay.ShowOverlay(handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(overlayKey, ref handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t();
tex.handle = texture.GetNativeTexturePtr();
switch (SystemInfo.graphicsDeviceType)
{
case UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore:
case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2:
case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3:
tex.eType = ETextureType.OpenGL;
break;
case UnityEngine.Rendering.GraphicsDeviceType.Vulkan:
tex.eType = ETextureType.Vulkan;
break;
default:
tex.eType = ETextureType.DirectX;
break;
}
tex.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(handle, ref tex);
overlay.SetOverlayAlpha(handle, alpha);
overlay.SetOverlayWidthInMeters(handle, WidthInMeters);
var curvedRange = new Vector2(1, 2);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(handle, curvedRange.x, curvedRange.y);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
var mouseScale = new Vector2(1, 1);
vecMouseScale.v0 = mouseScale.x;
vecMouseScale.v1 = mouseScale.y;
overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
if ((lastRenderPosition != RenderPosition || lastWidthInMeters != WidthInMeters || lastPositionOffset != PositionOffset))
{
if (RayTargetQuad != null)
{
Destroy(RayTargetQuad);
}
//Ray飛ばし座標取得用のQuadを配置
RayTargetQuad = GameObject.CreatePrimitive(PrimitiveType.Quad);
RayTargetQuad.GetComponent <MeshRenderer>().enabled = false; // 非表示にする
RayTargetQuad.transform.SetParent(RenderPosition);
RayTargetQuad.transform.localPosition = PositionOffset;
RayTargetQuad.transform.localEulerAngles = Vector3.zero;
RayTargetQuad.transform.localScale = new Vector3(WidthInMeters, (WidthInMeters / texture.width) * texture.height, 1.0f);
lastRenderPosition = RenderPosition;
lastWidthInMeters = WidthInMeters;
lastPositionOffset = PositionOffset;
}
var offset = new SteamVR_Utils.RigidTransform();
if (RayTargetQuad != null)
{
offset.pos = RayTargetQuad.transform.position;
offset.rot = RayTargetQuad.transform.rotation;
}
else
{
offset.pos = new Vector3(0, 0, 0);
offset.rot = Quaternion.Euler(0, 0, 0);
}
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
overlay.SetOverlayInputMethod(handle, VROverlayInputMethod.Mouse);
}
else
{
overlay.HideOverlay(handle);
}
}
