Beispiel #1
0
        public OpenGLVisualization(IEnumerable <IGraphicalBody> graphicalBodies, bool vr, params ILightSource[] lights) :
            base(1220, 720, new GraphicsMode(GraphicsMode.Default.ColorFormat, GraphicsMode.Default.Depth, GraphicsMode.Default.Stencil, NumFSAASamples, GraphicsMode.Default.AccumulatorFormat),
                 "LabBox Vis")
        {
            VRFlag = vr;
            if (VRFlag)
            {
                vrScene    = OpenVRScene.Create(NearClip, FarClip);
                Input      = vrScene.OpenVRInput;
                vrDrawable = new BasicDrawable((vpMat, camPos) => RenderVR(vpMat, camPos));
            }
            else
            {
                Input = new OpenGLInputObservable(this);
            }

            // not sure how we should handle the ICamera interface in VR yet
            var cam = new FreeCamera(Input);

            cam.MaxRange = FarClip;
            cam.MinRange = NearClip;
            toDispose.Add(cam);
            Camera = cam;

            bodies       = graphicalBodies.ToList();
            lightSources = lights.ToList();

            BindEvents();
        }
Beispiel #2
0
        /// <summary>
        /// I really, really want to make this asynchronous so that we can load render models on the fly without interupting the experience.
        /// I need to look more into how we can accomplish this without casuing errors in OpenGL.
        /// </summary>
        /// <returns></returns>
        public static GLRenderModels Create(OpenVRScene scene)
        {
            const int retryInterval = 10;

            var models = new Dictionary <int, GLRenderModel>();

            foreach (int trackedDeviceIndex in OpenVRUtil.DeviceIndexes)
            {
                if (trackedDeviceIndex == OpenVR.k_unTrackedDeviceIndex_Hmd)
                {
                    continue;                                                          // dont want to render the actual HMD! it would block your face! (yep i did that)
                }
                if (!scene.IsConnected(trackedDeviceIndex))
                {
                    continue;
                }

                string renderModelName =
                    scene.DeviceInfo(trackedDeviceIndex, ETrackedDeviceProperty.Prop_RenderModelName_String)
                    .Validate(propErr => new InvalidOperationException($"Failed to retrieve prop name for connected tracked device: {propErr}"));

                // load render model async
                IntPtr renderModelPtr     = IntPtr.Zero;
                EVRRenderModelError rmErr = EVRRenderModelError.Loading;
                while (rmErr == EVRRenderModelError.Loading) // is this seriously how im supposed to do this? no callback?
                {
                    rmErr = OpenVR.RenderModels.LoadRenderModel_Async(renderModelName, ref renderModelPtr);
                    Thread.Sleep(retryInterval); // async seems to be breaking opengl!?
                    //await Task.Delay(retryInterval); // try again every 0.1 seconds
                }
                if (rmErr != EVRRenderModelError.None || renderModelPtr == IntPtr.Zero)
                {
                    throw new InvalidOperationException($"Failed to load Render Model: {renderModelName}");
                }
                var renderModel = (RenderModel_t)Marshal.PtrToStructure(renderModelPtr, typeof(RenderModel_t));

                // load the render texture async
                IntPtr texturePtr = IntPtr.Zero;
                rmErr = EVRRenderModelError.Loading;
                while (rmErr == EVRRenderModelError.Loading) // is this seriously how im supposed to do this? no callback?
                {
                    rmErr = OpenVR.RenderModels.LoadTexture_Async(renderModel.diffuseTextureId, ref texturePtr);
                    Thread.Sleep(retryInterval); // async seems to be breaking opengl?
                    //await Task.Delay(retryInterval); // try again every 0.1 seconds
                }
                if (rmErr != EVRRenderModelError.None || texturePtr == IntPtr.Zero)
                {
                    throw new InvalidOperationException($"Failed to load texture for Render Model: {renderModelName}");
                }
                var diffuseTexture = (RenderModel_TextureMap_t)Marshal.PtrToStructure(texturePtr, typeof(RenderModel_TextureMap_t));

                models[trackedDeviceIndex] = GLRenderModel.Create(renderModelName, renderModel, diffuseTexture);

                OpenVR.RenderModels.FreeRenderModel(renderModelPtr);
                OpenVR.RenderModels.FreeTexture(texturePtr);
            }

            return(new GLRenderModels(scene, models));
        }
Beispiel #3
0
        public HelloVRWindow(string windowTitle) : base(1280, 720, GraphicsMode.Default, windowTitle, GameWindowFlags.Default)
        {
            scene = OpenVRScene.Create(0.1f, 20.0f);

            Load        += HelloVRWindow_Load;
            UpdateFrame += HelloVRWindow_UpdateFrame;
            RenderFrame += HelloVRWindow_RenderFrame;
        }
Beispiel #4
0
        public HelloVRWindow(string windowTitle) : base(1280, 720, GraphicsMode.Default, windowTitle, GameWindowFlags.Default)
        {
            scene = OpenVRScene.Create(0.1f, 20.0f);

            Load += HelloVRWindow_Load;
            UpdateFrame += HelloVRWindow_UpdateFrame;
            RenderFrame += HelloVRWindow_RenderFrame;
        }
Beispiel #5
0
        public GLVRGraphics(OpenVRScene scene, bool showRenderModels = true)
        {
            this.showRenderModels = showRenderModels;

            var dim = scene.GetRenderTarget();
            renderWidth = dim.Item1;
            renderHeight = dim.Item2;
            leftEyeFrameBuffer = EyeFrameBuffer.Create(renderWidth, renderHeight);
            rightEyeFrameBuffer = EyeFrameBuffer.Create(renderWidth, renderHeight);

            if (showRenderModels) renderModels = GLRenderModels.Create(scene);
        }     
Beispiel #6
0
        public GLVRGraphics(OpenVRScene scene, bool showRenderModels = true)
        {
            this.showRenderModels = showRenderModels;

            var dim = scene.GetRenderTarget();

            renderWidth         = dim.Item1;
            renderHeight        = dim.Item2;
            leftEyeFrameBuffer  = EyeFrameBuffer.Create(renderWidth, renderHeight);
            rightEyeFrameBuffer = EyeFrameBuffer.Create(renderWidth, renderHeight);

            if (showRenderModels)
            {
                renderModels = GLRenderModels.Create(scene);
            }
        }
Beispiel #7
0
        /// <summary>
        /// I really, really want to make this asynchronous so that we can load render models on the fly without interupting the experience.
        /// I need to look more into how we can accomplish this without casuing errors in OpenGL.
        /// </summary>
        /// <returns></returns>
        public static GLRenderModels Create(OpenVRScene scene)
        {
            const int retryInterval = 10;

            var models = new Dictionary<int, GLRenderModel>();
            foreach (int trackedDeviceIndex in OpenVRUtil.DeviceIndexes)
            {
                if (trackedDeviceIndex == OpenVR.k_unTrackedDeviceIndex_Hmd) continue; // dont want to render the actual HMD! it would block your face! (yep i did that)
                if (!scene.IsConnected(trackedDeviceIndex)) continue;

                string renderModelName =
                    scene.DeviceInfo(trackedDeviceIndex, ETrackedDeviceProperty.Prop_RenderModelName_String)
                    .Validate(propErr => new InvalidOperationException($"Failed to retrieve prop name for connected tracked device: {propErr}"));

                // load render model async
                IntPtr renderModelPtr = IntPtr.Zero;
                EVRRenderModelError rmErr = EVRRenderModelError.Loading;
                while (rmErr == EVRRenderModelError.Loading) // is this seriously how im supposed to do this? no callback?
                {
                    rmErr = OpenVR.RenderModels.LoadRenderModel_Async(renderModelName, ref renderModelPtr);
                    Thread.Sleep(retryInterval); // async seems to be breaking opengl!?
                    //await Task.Delay(retryInterval); // try again every 0.1 seconds
                }
                if (rmErr != EVRRenderModelError.None || renderModelPtr == IntPtr.Zero) throw new InvalidOperationException($"Failed to load Render Model: {renderModelName}");
                var renderModel = (RenderModel_t)Marshal.PtrToStructure(renderModelPtr, typeof(RenderModel_t));

                // load the render texture async
                IntPtr texturePtr = IntPtr.Zero;
                rmErr = EVRRenderModelError.Loading;
                while (rmErr == EVRRenderModelError.Loading) // is this seriously how im supposed to do this? no callback?
                {
                    rmErr = OpenVR.RenderModels.LoadTexture_Async(renderModel.diffuseTextureId, ref texturePtr);
                    Thread.Sleep(retryInterval); // async seems to be breaking opengl?
                    //await Task.Delay(retryInterval); // try again every 0.1 seconds
                }
                if (rmErr != EVRRenderModelError.None || texturePtr == IntPtr.Zero) throw new InvalidOperationException($"Failed to load texture for Render Model: {renderModelName}");
                var diffuseTexture = (RenderModel_TextureMap_t)Marshal.PtrToStructure(texturePtr, typeof(RenderModel_TextureMap_t));

                models[trackedDeviceIndex] = GLRenderModel.Create(renderModelName, renderModel, diffuseTexture);

                OpenVR.RenderModels.FreeRenderModel(renderModelPtr);
                OpenVR.RenderModels.FreeTexture(texturePtr);
            }

            return new GLRenderModels(scene, models);
        }
Beispiel #8
0
 private GLRenderModels(OpenVRScene scene, Dictionary<int, GLRenderModel> models)
 {
     this.scene = scene;
     this.models = models;
 }
Beispiel #9
0
 private GLRenderModels(OpenVRScene scene, Dictionary <int, GLRenderModel> models)
 {
     this.scene  = scene;
     this.models = models;
 }