// Token: 0x06000DEB RID: 3563 RVA: 0x00058A0C File Offset: 0x00056C0C private RenderModel_t MarshalRenderModel(IntPtr pRenderModel) { if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix) { RenderModel_t_Packed renderModel_t_Packed = (RenderModel_t_Packed)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t_Packed)); RenderModel_t result = default(RenderModel_t); renderModel_t_Packed.Unpack(ref result); return(result); } return((RenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t))); }
/// <summary> /// Helper function to handle the inconvenient fact that the packing for RenderModel_t is /// different on Linux/OSX (4) than it is on Windows (8) /// </summary> /// <param name="pRenderModel">native pointer to the RenderModel_t</param> /// <returns></returns> private RenderModel_t MarshalRenderModel(IntPtr pRenderModel) { if ((Environment.OSVersion.Platform == PlatformID.MacOSX) || (Environment.OSVersion.Platform == PlatformID.Unix)) { var packedModel = (RenderModel_t_Packed)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t_Packed)); RenderModel_t model = new RenderModel_t(); packedModel.Unpack(ref model); return(model); } return((RenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t))); }
public static GLRenderModel Create(string name, RenderModel_t renderModel, RenderModel_TextureMap_t diffuseTexture) { // create and bind a VAO to hold the state for this model int vao = OpenGLUtil.CreateVertexArrayObject(); GL.BindVertexArray(vao); // populate the vertex buffer int vbo = OpenGLUtil.CreateBufferObject(); GL.BindBuffer(BufferTarget.ArrayBuffer, vbo); GL.BufferData(BufferTarget.ArrayBuffer, Marshal.SizeOf <RenderModel_Vertex_t>() * (int)renderModel.unVertexCount, renderModel.rVertexData, BufferUsageHint.StaticDraw); // identity the components in teh vertex buffer GL.EnableVertexAttribArray(0); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, Marshal.SizeOf <RenderModel_Vertex_t>(), Marshal.OffsetOf <RenderModel_Vertex_t>("vPosition")); // this might have to be size of 4? GL.EnableVertexAttribArray(1); GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, false, Marshal.SizeOf <RenderModel_Vertex_t>(), Marshal.OffsetOf <RenderModel_Vertex_t>("vNormal")); GL.EnableVertexAttribArray(2); GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, Marshal.SizeOf <RenderModel_Vertex_t>(), Marshal.OffsetOf <RenderModel_Vertex_t>("rfTextureCoord0")); // create and populate the index buffer int indexBuffer = OpenGLUtil.CreateBufferObject(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer); GL.BufferData(BufferTarget.ElementArrayBuffer, Marshal.SizeOf <ushort>() * (int)renderModel.unTriangleCount * 3, renderModel.rIndexData, BufferUsageHint.StaticDraw); GL.BindVertexArray(0); // create and populate the texture int texture = OpenGLUtil.CreateTexture(); GL.BindTexture(TextureTarget.Texture2D, texture); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, diffuseTexture.unWidth, diffuseTexture.unHeight, 0, PixelFormat.Rgba, PixelType.UnsignedByte, diffuseTexture.rubTextureMapData); GL.GenerateMipmap(GenerateMipmapTarget.Texture2D); GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, new[] { (int)TextureParameterName.ClampToEdge }); GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, new[] { (int)TextureParameterName.ClampToEdge }); GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, new[] { (int)TextureMagFilter.Linear }); GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, new[] { (int)TextureMinFilter.LinearMipmapLinear }); // *****missing stuff about anisotropy ***** // not sure if this is right float largest = GL.GetFloat((GetPName)0x84FF); GL.TexParameter(TextureTarget.Texture2D, (TextureParameterName)0x84FE, largest); GL.BindTexture(TextureTarget.Texture2D, 0); return(new GLRenderModel(vbo, indexBuffer, vao, texture, (int)renderModel.unTriangleCount * 3, name)); }
/// <summary> /// Helper function to handle the inconvenient fact that the packing for RenderModel_t is /// different on Linux/OSX (4) than it is on Windows (8) /// </summary> /// <param name="pRenderModel">native pointer to the RenderModel_t</param> /// <returns></returns> private RenderModel_t MarshalRenderModel(System.IntPtr pRenderModel) { #if UNITY_STANDALONE if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) { var packedModel = (RenderModel_t_Packed)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t_Packed)); RenderModel_t model = new RenderModel_t(); packedModel.Unpack(ref model); return(model); } else { return((RcenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t))); } #else return((RenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t))); #endif }
static RenderModel LoadRenderModel(string renderModelName) { var error = HmdError.None; if (!SteamVR.active) { OpenVR.Init(ref error); if (error != HmdError.None) { return(null); } } var pRenderModels = OpenVR.GetGenericInterface(OpenVR.IVRRenderModels_Version, ref error); if (pRenderModels == System.IntPtr.Zero || error != HmdError.None) { if (!SteamVR.active) { OpenVR.Shutdown(); } return(null); } var renderModels = new CVRRenderModels(pRenderModels); var renderModel = new RenderModel_t(); if (!renderModels.LoadRenderModel(renderModelName, ref renderModel)) { Debug.LogError("Failed to load render model " + renderModelName); if (!SteamVR.active) { OpenVR.Shutdown(); } return(null); } var vertices = new Vector3[renderModel.unVertexCount]; var normals = new Vector3[renderModel.unVertexCount]; var uv = new Vector2[renderModel.unVertexCount]; var type = typeof(RenderModel_Vertex_t); for (int iVert = 0; iVert < renderModel.unVertexCount; iVert++) { var ptr = new System.IntPtr(renderModel.rVertexData.ToInt64() + iVert * Marshal.SizeOf(type)); var vert = (RenderModel_Vertex_t)Marshal.PtrToStructure(ptr, type); vertices[iVert] = new Vector3(vert.vPosition.v[0], vert.vPosition.v[1], -vert.vPosition.v[2]); normals[iVert] = new Vector3(vert.vNormal.v[0], vert.vNormal.v[1], -vert.vNormal.v[2]); uv[iVert] = new Vector2(vert.rfTextureCoord[0], vert.rfTextureCoord[1]); } int indexCount = (int)renderModel.unTriangleCount * 3; var indices = new short[indexCount]; Marshal.Copy(renderModel.rIndexData, indices, 0, indices.Length); var triangles = new int[indexCount]; for (int iTri = 0; iTri < renderModel.unTriangleCount; iTri++) { triangles[iTri * 3 + 0] = (int)indices[iTri * 3 + 2]; triangles[iTri * 3 + 1] = (int)indices[iTri * 3 + 1]; triangles[iTri * 3 + 2] = (int)indices[iTri * 3 + 0]; } var mesh = new Mesh(); mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uv; mesh.triangles = triangles; mesh.Optimize(); //mesh.hideFlags = HideFlags.DontUnloadUnusedAsset; var textureMapData = new byte[renderModel.diffuseTexture.unWidth * renderModel.diffuseTexture.unHeight * 4]; // RGBA Marshal.Copy(renderModel.diffuseTexture.rubTextureMapData, textureMapData, 0, textureMapData.Length); var colors = new Color32[renderModel.diffuseTexture.unWidth * renderModel.diffuseTexture.unHeight]; int iColor = 0; for (int iHeight = 0; iHeight < renderModel.diffuseTexture.unHeight; iHeight++) { for (int iWidth = 0; iWidth < renderModel.diffuseTexture.unWidth; iWidth++) { var r = textureMapData[iColor++]; var g = textureMapData[iColor++]; var b = textureMapData[iColor++]; var a = textureMapData[iColor++]; colors[iHeight * renderModel.diffuseTexture.unWidth + iWidth] = new Color32(r, g, b, a); } } var texture = new Texture2D(renderModel.diffuseTexture.unWidth, renderModel.diffuseTexture.unHeight, TextureFormat.ARGB32, true); texture.SetPixels32(colors); texture.Apply(); //texture.hideFlags = HideFlags.DontUnloadUnusedAsset; renderModels.FreeRenderModel(ref renderModel); if (!SteamVR.active) { OpenVR.Shutdown(); } return(new RenderModel(mesh, texture)); }
public abstract bool LoadRenderModel(string pchRenderModelName,ref RenderModel_t pRenderModel);
public abstract void FreeRenderModel(ref RenderModel_t pRenderModel);
public override bool LoadRenderModel(string pchRenderModelName,ref RenderModel_t pRenderModel) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRRenderModels_LoadRenderModel(m_pVRRenderModels,pchRenderModelName,ref pRenderModel); return result; }
public override void FreeRenderModel(ref RenderModel_t pRenderModel) { CheckIfUsable(); VRNativeEntrypoints.VR_IVRRenderModels_FreeRenderModel(m_pVRRenderModels,ref pRenderModel); }
// Token: 0x06000DDD RID: 3549 RVA: 0x00057F55 File Offset: 0x00056155 private IEnumerator SetModelAsync(string renderModelName) { if (string.IsNullOrEmpty(renderModelName)) { yield break; } using (SteamVR_RenderModel.RenderModelInterfaceHolder holder = new SteamVR_RenderModel.RenderModelInterfaceHolder()) { CVRRenderModels renderModels = holder.instance; if (renderModels == null) { yield break; } uint componentCount = renderModels.GetComponentCount(renderModelName); string[] renderModelNames; if (componentCount > 0U) { renderModelNames = new string[componentCount]; int num = 0; while ((long)num < (long)((ulong)componentCount)) { uint num2 = renderModels.GetComponentName(renderModelName, (uint)num, null, 0U); if (num2 != 0U) { StringBuilder stringBuilder = new StringBuilder((int)num2); if (renderModels.GetComponentName(renderModelName, (uint)num, stringBuilder, num2) != 0U) { num2 = renderModels.GetComponentRenderModelName(renderModelName, stringBuilder.ToString(), null, 0U); if (num2 != 0U) { StringBuilder stringBuilder2 = new StringBuilder((int)num2); if (renderModels.GetComponentRenderModelName(renderModelName, stringBuilder.ToString(), stringBuilder2, num2) != 0U) { string text = stringBuilder2.ToString(); SteamVR_RenderModel.RenderModel renderModel = SteamVR_RenderModel.models[text] as SteamVR_RenderModel.RenderModel; if (renderModel == null || renderModel.mesh == null) { renderModelNames[num] = text; } } } } } num++; } } else { SteamVR_RenderModel.RenderModel renderModel2 = SteamVR_RenderModel.models[renderModelName] as SteamVR_RenderModel.RenderModel; if (renderModel2 == null || renderModel2.mesh == null) { renderModelNames = new string[] { renderModelName }; } else { renderModelNames = new string[0]; } } for (;;) { bool flag = false; foreach (string text2 in renderModelNames) { if (!string.IsNullOrEmpty(text2)) { IntPtr zero = IntPtr.Zero; EVRRenderModelError evrrenderModelError = renderModels.LoadRenderModel_Async(text2, ref zero); if (evrrenderModelError == EVRRenderModelError.Loading) { flag = true; } else if (evrrenderModelError == EVRRenderModelError.None) { RenderModel_t renderModel_t = this.MarshalRenderModel(zero); Material material = SteamVR_RenderModel.materials[renderModel_t.diffuseTextureId] as Material; if (material == null || material.mainTexture == null) { IntPtr zero2 = IntPtr.Zero; evrrenderModelError = renderModels.LoadTexture_Async(renderModel_t.diffuseTextureId, ref zero2); if (evrrenderModelError == EVRRenderModelError.Loading) { flag = true; } } } } } if (!flag) { break; } yield return(new WaitForSeconds(0.1f)); } renderModels = null; renderModelNames = null; } SteamVR_RenderModel.RenderModelInterfaceHolder holder = null; bool arg = this.SetModel(renderModelName); SteamVR_Events.RenderModelLoaded.Send(this, arg); yield break; yield break; }
// Token: 0x06000DDF RID: 3551 RVA: 0x00058090 File Offset: 0x00056290 private SteamVR_RenderModel.RenderModel LoadRenderModel(CVRRenderModels renderModels, string renderModelName, string baseName) { IntPtr zero = IntPtr.Zero; EVRRenderModelError evrrenderModelError; for (;;) { evrrenderModelError = renderModels.LoadRenderModel_Async(renderModelName, ref zero); if (evrrenderModelError != EVRRenderModelError.Loading) { break; } SteamVR_RenderModel.Sleep(); } if (evrrenderModelError != EVRRenderModelError.None) { Debug.LogError(string.Format("Failed to load render model {0} - {1}", renderModelName, evrrenderModelError.ToString())); return(null); } RenderModel_t renderModel_t = this.MarshalRenderModel(zero); Vector3[] array = new Vector3[renderModel_t.unVertexCount]; Vector3[] array2 = new Vector3[renderModel_t.unVertexCount]; Vector2[] array3 = new Vector2[renderModel_t.unVertexCount]; Type typeFromHandle = typeof(RenderModel_Vertex_t); int num = 0; while ((long)num < (long)((ulong)renderModel_t.unVertexCount)) { RenderModel_Vertex_t renderModel_Vertex_t = (RenderModel_Vertex_t)Marshal.PtrToStructure(new IntPtr(renderModel_t.rVertexData.ToInt64() + (long)(num * Marshal.SizeOf(typeFromHandle))), typeFromHandle); array[num] = new Vector3(renderModel_Vertex_t.vPosition.v0, renderModel_Vertex_t.vPosition.v1, -renderModel_Vertex_t.vPosition.v2); array2[num] = new Vector3(renderModel_Vertex_t.vNormal.v0, renderModel_Vertex_t.vNormal.v1, -renderModel_Vertex_t.vNormal.v2); array3[num] = new Vector2(renderModel_Vertex_t.rfTextureCoord0, renderModel_Vertex_t.rfTextureCoord1); num++; } uint num2 = renderModel_t.unTriangleCount * 3U; short[] array4 = new short[num2]; Marshal.Copy(renderModel_t.rIndexData, array4, 0, array4.Length); int[] array5 = new int[num2]; int num3 = 0; while ((long)num3 < (long)((ulong)renderModel_t.unTriangleCount)) { array5[num3 * 3] = (int)array4[num3 * 3 + 2]; array5[num3 * 3 + 1] = (int)array4[num3 * 3 + 1]; array5[num3 * 3 + 2] = (int)array4[num3 * 3]; num3++; } Mesh mesh = new Mesh(); mesh.vertices = array; mesh.normals = array2; mesh.uv = array3; mesh.triangles = array5; Material material = SteamVR_RenderModel.materials[renderModel_t.diffuseTextureId] as Material; if (material == null || material.mainTexture == null) { IntPtr zero2 = IntPtr.Zero; for (;;) { evrrenderModelError = renderModels.LoadTexture_Async(renderModel_t.diffuseTextureId, ref zero2); if (evrrenderModelError != EVRRenderModelError.Loading) { break; } SteamVR_RenderModel.Sleep(); } if (evrrenderModelError == EVRRenderModelError.None) { RenderModel_TextureMap_t renderModel_TextureMap_t = this.MarshalRenderModel_TextureMap(zero2); Texture2D texture2D = new Texture2D((int)renderModel_TextureMap_t.unWidth, (int)renderModel_TextureMap_t.unHeight, TextureFormat.ARGB32, false); if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11) { texture2D.Apply(); for (;;) { evrrenderModelError = renderModels.LoadIntoTextureD3D11_Async(renderModel_t.diffuseTextureId, texture2D.GetNativeTexturePtr()); if (evrrenderModelError != EVRRenderModelError.Loading) { break; } SteamVR_RenderModel.Sleep(); } } else { byte[] array6 = new byte[(int)(renderModel_TextureMap_t.unWidth * renderModel_TextureMap_t.unHeight * '\u0004')]; Marshal.Copy(renderModel_TextureMap_t.rubTextureMapData, array6, 0, array6.Length); Color32[] array7 = new Color32[(int)(renderModel_TextureMap_t.unWidth * renderModel_TextureMap_t.unHeight)]; int num4 = 0; for (int i = 0; i < (int)renderModel_TextureMap_t.unHeight; i++) { for (int j = 0; j < (int)renderModel_TextureMap_t.unWidth; j++) { byte r = array6[num4++]; byte g = array6[num4++]; byte b = array6[num4++]; byte a = array6[num4++]; array7[i * (int)renderModel_TextureMap_t.unWidth + j] = new Color32(r, g, b, a); } } texture2D.SetPixels32(array7); texture2D.Apply(); } material = new Material((this.shader != null) ? this.shader : Shader.Find("Standard")); material.mainTexture = texture2D; SteamVR_RenderModel.materials[renderModel_t.diffuseTextureId] = material; renderModels.FreeTexture(zero2); } else { Debug.Log("Failed to load render model texture for render model " + renderModelName); } } base.StartCoroutine(this.FreeRenderModel(zero)); return(new SteamVR_RenderModel.RenderModel(mesh, material)); }
// return true if is done private bool DoLoadModelJob(CVRRenderModels vrRenderModels, string modelName, Dictionary <int, Texture2D> texturesCache, ref IntPtr modelPtr, ref IntPtr texturePtr, ref IntPtr d3d11TexturePtr) { if (string.IsNullOrEmpty(modelName)) { return(true); } EVRRenderModelError error; Model model; if (!s_modelsCache.TryGetValue(modelName, out model)) { switch (error = vrRenderModels.LoadRenderModel_Async(modelName, ref modelPtr)) { default: Debug.LogError("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadRenderModel_Async failed! " + System.IO.Path.GetFileName(modelName) + " EVRRenderModelError=" + error); return(true); case EVRRenderModelError.Loading: if (s_verbose) { Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadRenderModel_Async loading... " + System.IO.Path.GetFileName(modelName)); } return(false); case EVRRenderModelError.None: if (s_verbose) { Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadRenderModel_Async succeed! " + System.IO.Path.GetFileName(modelName)); } RenderModel_t modelData = MarshalRenderModel(modelPtr); var vertices = new Vector3[modelData.unVertexCount]; var normals = new Vector3[modelData.unVertexCount]; var uv = new Vector2[modelData.unVertexCount]; Type type = typeof(RenderModel_Vertex_t); for (int iVert = 0; iVert < modelData.unVertexCount; iVert++) { var ptr = new IntPtr(modelData.rVertexData.ToInt64() + iVert * Marshal.SizeOf(type)); var vert = (RenderModel_Vertex_t)Marshal.PtrToStructure(ptr, type); vertices[iVert] = new Vector3(vert.vPosition.v0, vert.vPosition.v1, -vert.vPosition.v2); normals[iVert] = new Vector3(vert.vNormal.v0, vert.vNormal.v1, -vert.vNormal.v2); uv[iVert] = new Vector2(vert.rfTextureCoord0, vert.rfTextureCoord1); } var indexCount = (int)modelData.unTriangleCount * 3; var indices = new short[indexCount]; Marshal.Copy(modelData.rIndexData, indices, 0, indices.Length); var triangles = new int[indexCount]; for (int iTri = 0; iTri < modelData.unTriangleCount; iTri++) { triangles[iTri * 3 + 0] = indices[iTri * 3 + 2]; triangles[iTri * 3 + 1] = indices[iTri * 3 + 1]; triangles[iTri * 3 + 2] = indices[iTri * 3 + 0]; } model = new Model() { textureID = modelData.diffuseTextureId, mesh = new Mesh() { hideFlags = HideFlags.HideAndDontSave, vertices = vertices, normals = normals, uv = uv, triangles = triangles, }, }; s_modelsCache.Add(modelName, model); break; } } Texture2D texture; if (!texturesCache.TryGetValue(model.textureID, out texture)) { switch (error = vrRenderModels.LoadTexture_Async(model.textureID, ref texturePtr)) { default: Debug.LogError("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadTexture_Async failed! " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "] EVRRenderModelError=" + error); return(true); case EVRRenderModelError.Loading: if (s_verbose) { Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadTexture_Async loading... " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "]"); } return(false); case EVRRenderModelError.None: if (s_verbose) { Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadTexture_Async succeed! " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "]"); } var textureMap = MarshalRenderModelTextureMap(texturePtr); texture = new Texture2D(textureMap.unWidth, textureMap.unHeight, TextureFormat.RGBA32, false); if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11) { texture.Apply(); d3d11TexturePtr = texture.GetNativeTexturePtr(); } else { var textureMapData = new byte[textureMap.unWidth * textureMap.unHeight * 4]; // RGBA Marshal.Copy(textureMap.rubTextureMapData, textureMapData, 0, textureMapData.Length); var colors = new Color32[textureMap.unWidth * textureMap.unHeight]; int iColor = 0; for (int iHeight = 0; iHeight < textureMap.unHeight; iHeight++) { for (int iWidth = 0; iWidth < textureMap.unWidth; iWidth++) { var r = textureMapData[iColor++]; var g = textureMapData[iColor++]; var b = textureMapData[iColor++]; var a = textureMapData[iColor++]; colors[iHeight * textureMap.unWidth + iWidth] = new Color32(r, g, b, a); } } texture.SetPixels32(colors); texture.Apply(); } texturesCache.Add(model.textureID, texture); break; } } if (d3d11TexturePtr != IntPtr.Zero) { while (true) { switch (error = vrRenderModels.LoadIntoTextureD3D11_Async(model.textureID, d3d11TexturePtr)) { default: Debug.LogError("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadIntoTextureD3D11_Async failed! " + System.IO.Path.GetFileName(modelName) + " EVRRenderModelError=" + error); d3d11TexturePtr = IntPtr.Zero; return(true); case EVRRenderModelError.Loading: if (s_verbose) { Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadIntoTextureD3D11_Async loading... " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "]"); } break; case EVRRenderModelError.None: if (s_verbose) { Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadIntoTextureD3D11_Async succeed! " + System.IO.Path.GetFileName(modelName)); } d3d11TexturePtr = IntPtr.Zero; return(true); } // FIXME: LoadIntoTextureD3D11_Async blocks main thread? Crashes when not calling it in while loop #if !UNITY_METRO System.Threading.Thread.Sleep(1); #endif } } return(true); }