protected IndexBuffer( GraphicsDevice graphicsDevice, IndexElementSize indexElementSize, int indexCount, BufferUsage usage, bool dynamic ) { if (graphicsDevice == null) { throw new ArgumentNullException("GraphicsDevice is null"); } GraphicsDevice = graphicsDevice; IndexElementSize = indexElementSize; IndexCount = indexCount; BufferUsage = usage; INTERNAL_isDynamic = dynamic; Threading.ForceToMainThread(() => { Handle = GL.GenBuffer(); OpenGLDevice.Instance.BindIndexBuffer(Handle); GL.BufferData( BufferTarget.ElementArrayBuffer, (IntPtr)(IndexCount * (IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4)), IntPtr.Zero, INTERNAL_isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw ); }); }
protected void SetDataInternal <T>( int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options ) where T : struct { if (data == null) { throw new ArgumentNullException("data is null"); } if (data.Length < (startIndex + elementCount)) { throw new InvalidOperationException("The array specified in the data parameter is not the correct size for the amount of data requested."); } Threading.ForceToMainThread(() => OpenGLDevice.Instance.SetIndexBufferData( Handle, offsetInBytes, data, startIndex, elementCount, options ) ); }
public void GetData <T>( int offsetInBytes, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data is null"); } if (data.Length < (startIndex + elementCount)) { throw new InvalidOperationException("The array specified in the data parameter is not the correct size for the amount of data requested."); } if (BufferUsage == BufferUsage.WriteOnly) { throw new NotSupportedException( "This IndexBuffer was created with a usage type of BufferUsage.WriteOnly. " + "Calling GetData on a resource that was created with BufferUsage.WriteOnly is not supported." ); } Threading.ForceToMainThread(() => OpenGLDevice.Instance.GetIndexBufferData( Handle, offsetInBytes, data, startIndex, elementCount ) ); }
/// <summary> /// Initializes a new instance of the <see cref="RenderTargetCube"/> class. /// </summary> /// <param name="graphicsDevice">The graphics device.</param> /// <param name="size">The width and height of a texture cube face in pixels.</param> /// <param name="mipMap"> /// <see langword="true"/> to generate a full mipmap chain; otherwise <see langword="false"/>. /// </param> /// <param name="preferredFormat">The preferred format of the surface.</param> /// <param name="preferredDepthFormat">The preferred format of the depth-stencil buffer.</param> /// <param name="preferredMultiSampleCount">The preferred number of multisample locations.</param> /// <param name="usage">The usage mode of the render target.</param> public RenderTargetCube( GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage ) : base( graphicsDevice, size, mipMap, preferredFormat ) { DepthStencilFormat = preferredDepthFormat; MultiSampleCount = preferredMultiSampleCount; RenderTargetUsage = usage; // If we don't need a depth buffer then we're done. if (preferredDepthFormat == DepthFormat.None) { return; } Threading.ForceToMainThread(() => { glDepthStencilBuffer = graphicsDevice.GLDevice.GenRenderbuffer( size, size, preferredDepthFormat ); }); }
protected VertexBuffer( GraphicsDevice graphicsDevice, VertexDeclaration vertexDeclaration, int vertexCount, BufferUsage bufferUsage, bool dynamic ) { if (graphicsDevice == null) { throw new ArgumentNullException("GraphicsDevice cannot be null"); } GraphicsDevice = graphicsDevice; VertexDeclaration = vertexDeclaration; VertexCount = vertexCount; BufferUsage = bufferUsage; // Make sure the graphics device is assigned in the vertex declaration. if (vertexDeclaration.GraphicsDevice != graphicsDevice) { vertexDeclaration.GraphicsDevice = graphicsDevice; } Threading.ForceToMainThread(() => { Handle = new OpenGLDevice.OpenGLVertexBuffer( GraphicsDevice, dynamic, VertexCount, VertexDeclaration.VertexStride ); }); }
protected IndexBuffer( GraphicsDevice graphicsDevice, IndexElementSize indexElementSize, int indexCount, BufferUsage usage, bool dynamic ) { if (graphicsDevice == null) { throw new ArgumentNullException("GraphicsDevice is null"); } GraphicsDevice = graphicsDevice; IndexElementSize = indexElementSize; IndexCount = indexCount; BufferUsage = usage; Threading.ForceToMainThread(() => { Handle = new OpenGLDevice.OpenGLIndexBuffer( dynamic, IndexCount, IndexElementSize ); }); }
public Texture3D( GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat format ) { if (graphicsDevice == null) { throw new ArgumentNullException("graphicsDevice"); } GraphicsDevice = graphicsDevice; Width = width; Height = height; Depth = depth; LevelCount = mipMap ? CalculateMipLevels(width, height) : 1; Format = format; GetGLSurfaceFormat(); Threading.ForceToMainThread(() => { texture = GraphicsDevice.GLDevice.CreateTexture( typeof(Texture3D), Format, mipMap ); for (int i = 0; i < LevelCount; i += 1) { GraphicsDevice.GLDevice.glTexImage3D( OpenGLDevice.GLenum.GL_TEXTURE_3D, i, (int)glInternalFormat, Math.Max(width >> i, 1), Math.Max(height >> i, 1), depth, 0, glFormat, glType, IntPtr.Zero ); } }); }
protected void SetDataInternal <T>( int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options ) where T : struct { if (data == null) { throw new ArgumentNullException("data is null"); } if (data.Length < (startIndex + elementCount)) { throw new InvalidOperationException("The array specified in the data parameter is not the correct size for the amount of data requested."); } int bufferSize = VertexCount * VertexDeclaration.VertexStride; if (vertexStride > bufferSize || vertexStride < VertexDeclaration.VertexStride) { throw new ArgumentOutOfRangeException( "One of the following conditions is true:\n" + "The vertex stride is larger than the vertex buffer.\n" + "The vertex stride is too small for the type of data requested." ); } int elementSizeInBytes = Marshal.SizeOf(typeof(T)); Threading.ForceToMainThread(() => GraphicsDevice.GLDevice.SetVertexBufferData( Handle, bufferSize, elementSizeInBytes, offsetInBytes, data, startIndex, elementCount, vertexStride, options ) ); }
public void SetData <T>( int level, int left, int top, int right, int bottom, int front, int back, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data"); } Threading.ForceToMainThread(() => { GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); try { GraphicsDevice.GLDevice.BindTexture(texture); GraphicsDevice.GLDevice.glTexSubImage3D( OpenGLDevice.GLenum.GL_TEXTURE_3D, level, left, top, front, right - left, bottom - top, back - front, glFormat, glType, (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * Marshal.SizeOf(typeof(T))) ); } finally { dataHandle.Free(); } }); }
public void GetData <T>( int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride ) where T : struct { if (data == null) { throw new ArgumentNullException( "data", "This method does not accept null for this parameter." ); } if (data.Length < (startIndex + elementCount)) { throw new ArgumentOutOfRangeException( "elementCount", "This parameter must be a valid index within the array." ); } if (BufferUsage == BufferUsage.WriteOnly) { throw new NotSupportedException("Calling GetData on a resource that was created with BufferUsage.WriteOnly is not supported."); } if ((elementCount * vertexStride) > (VertexCount * VertexDeclaration.VertexStride)) { throw new InvalidOperationException("The array is not the correct size for the amount of data requested."); } Threading.ForceToMainThread(() => GraphicsDevice.GLDevice.GetVertexBufferData( Handle, offsetInBytes, data, startIndex, elementCount, vertexStride ) ); }
protected VertexBuffer( GraphicsDevice graphicsDevice, VertexDeclaration vertexDeclaration, int vertexCount, BufferUsage bufferUsage, bool dynamic ) { if (graphicsDevice == null) { throw new ArgumentNullException("GraphicsDevice cannot be null"); } GraphicsDevice = graphicsDevice; VertexDeclaration = vertexDeclaration; VertexCount = vertexCount; BufferUsage = bufferUsage; // Make sure the graphics device is assigned in the vertex declaration. if (vertexDeclaration.GraphicsDevice != graphicsDevice) { vertexDeclaration.GraphicsDevice = graphicsDevice; } INTERNAL_isDynamic = dynamic; Threading.ForceToMainThread(() => { Handle = GL.GenBuffer(); OpenGLDevice.Instance.BindVertexBuffer(Handle); GL.BufferData( BufferTarget.ArrayBuffer, new IntPtr(VertexDeclaration.VertexStride * VertexCount), IntPtr.Zero, INTERNAL_isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw ); }); }
public void SetData <T>( int level, Rectangle?rect, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data"); } int x, y, w, h; if (rect.HasValue) { x = rect.Value.X; y = rect.Value.Y; w = rect.Value.Width; h = rect.Value.Height; } else { x = 0; y = 0; w = Math.Max(Width >> level, 1); h = Math.Max(Height >> level, 1); } Threading.ForceToMainThread(() => { GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); int elementSizeInBytes = Marshal.SizeOf(typeof(T)); int startByte = startIndex * elementSizeInBytes; IntPtr dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startByte); try { GraphicsDevice.GLDevice.BindTexture(texture); if (glFormat == (PixelFormat)All.CompressedTextureFormats) { int dataLength; if (elementCount > 0) { dataLength = elementCount * elementSizeInBytes; } else { dataLength = data.Length - startByte; } /* Note that we're using glInternalFormat, not glFormat. * In this case, they should actually be the same thing, * but we use glFormat somewhat differently for * compressed textures. * -flibit */ GL.CompressedTexSubImage2D( TextureTarget.Texture2D, level, x, y, w, h, (PixelFormat)glInternalFormat, dataLength, dataPtr ); } else { // Set pixel alignment to match texel size in bytes int packSize = GetFormatSize(); if (packSize != 4) { GL.PixelStore( PixelStoreParameter.UnpackAlignment, packSize ); } GL.TexSubImage2D( TextureTarget.Texture2D, level, x, y, w, h, glFormat, glType, dataPtr ); // Keep this state sane -flibit if (packSize != 4) { GL.PixelStore( PixelStoreParameter.UnpackAlignment, 4 ); } } } finally { dataHandle.Free(); } }); }
public Texture2D( GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat format ) { if (graphicsDevice == null) { throw new ArgumentNullException("graphicsDevice"); } GraphicsDevice = graphicsDevice; Width = width; Height = height; LevelCount = mipMap ? CalculateMipLevels(width, height) : 1; Format = format; GetGLSurfaceFormat(); Threading.ForceToMainThread(() => { texture = GraphicsDevice.GLDevice.CreateTexture( typeof(Texture2D), Format, mipMap ); if (Format == SurfaceFormat.Dxt1 || Format == SurfaceFormat.Dxt3 || Format == SurfaceFormat.Dxt5) { for (int i = 0; i < LevelCount; i += 1) { int levelWidth = Math.Max(Width >> i, 1); int levelHeight = Math.Max(Height >> i, 1); graphicsDevice.GLDevice.glCompressedTexImage2D( OpenGLDevice.GLenum.GL_TEXTURE_2D, i, (int)glInternalFormat, levelWidth, levelHeight, 0, ((levelWidth + 3) / 4) * ((levelHeight + 3) / 4) * GetFormatSize(), IntPtr.Zero ); } } else { for (int i = 0; i < LevelCount; i += 1) { graphicsDevice.GLDevice.glTexImage2D( OpenGLDevice.GLenum.GL_TEXTURE_2D, i, (int)glInternalFormat, Math.Max(Width >> i, 1), Math.Max(Height >> i, 1), 0, glFormat, glType, IntPtr.Zero ); } } }); }
public static string GetGUIDEXT(PlayerIndex playerIndex) { IntPtr device = INTERNAL_devices[(int)playerIndex]; if (device == IntPtr.Zero) { return(String.Empty); } if (INTERNAL_isGameController[(int)playerIndex]) { device = SDL.SDL_GameControllerGetJoystick(device); } StringBuilder result = new StringBuilder(); Threading.ForceToMainThread(() => { byte[] resChar = new byte[33]; // FIXME: Sort of arbitrary. SDL.SDL_JoystickGetGUIDString( SDL.SDL_JoystickGetGUID(device), resChar, resChar.Length ); if (Game.Instance.Platform.OSVersion.Equals("Linux")) { result.Append((char)resChar[8]); result.Append((char)resChar[9]); result.Append((char)resChar[10]); result.Append((char)resChar[11]); result.Append((char)resChar[16]); result.Append((char)resChar[17]); result.Append((char)resChar[18]); result.Append((char)resChar[19]); } else if (Game.Instance.Platform.OSVersion.Equals("Mac OS X")) { result.Append((char)resChar[0]); result.Append((char)resChar[1]); result.Append((char)resChar[2]); result.Append((char)resChar[3]); result.Append((char)resChar[16]); result.Append((char)resChar[17]); result.Append((char)resChar[18]); result.Append((char)resChar[19]); } else if (Game.Instance.Platform.OSVersion.Equals("Windows")) { bool isXInput = true; foreach (byte b in resChar) { if (((char)b) != '0' && b != 0) { isXInput = false; break; } } if (isXInput) { result.Append("xinput"); } else { result.Append((char)resChar[0]); result.Append((char)resChar[1]); result.Append((char)resChar[2]); result.Append((char)resChar[3]); result.Append((char)resChar[4]); result.Append((char)resChar[5]); result.Append((char)resChar[6]); result.Append((char)resChar[7]); } } else { throw new Exception("SDL2_GamePad: Platform.OSVersion not handled!"); } }); return(result.ToString()); }
public void SetData <T>( int level, Rectangle?rect, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data"); } int x, y, w, h; if (rect.HasValue) { x = rect.Value.X; y = rect.Value.Y; w = rect.Value.Width; h = rect.Value.Height; } else { x = 0; y = 0; w = Math.Max(Width >> level, 1); h = Math.Max(Height >> level, 1); } Threading.ForceToMainThread(() => { int elementSizeInBytes = Marshal.SizeOf(typeof(T)); int startByte = startIndex * elementSizeInBytes; #if !JSIL GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); IntPtr dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startByte); #endif try { GraphicsDevice.GLDevice.BindTexture(texture); if (glFormat == OpenGLDevice.GLenum.GL_COMPRESSED_TEXTURE_FORMATS) { int dataLength; if (elementCount > 0) { dataLength = elementCount * elementSizeInBytes; } else { dataLength = data.Length - startByte; } /* Note that we're using glInternalFormat, not glFormat. * In this case, they should actually be the same thing, * but we use glFormat somewhat differently for * compressed textures. * -flibit */ #if JSIL dynamic Document = Builtins.Global["document"]; dynamic Canvas = Document.getElementById("canvas"); dynamic gl = Canvas.getContext("webgl"); gl.compressedTexSubImage2D( OpenGLDevice.GLenum.GL_TEXTURE_2D, level, x, y, w, h, glInternalFormat, data ); #else GraphicsDevice.GLDevice.glCompressedTexSubImage2D( OpenGLDevice.GLenum.GL_TEXTURE_2D, level, x, y, w, h, glInternalFormat, dataLength, dataPtr ); #endif } else { // Set pixel alignment to match texel size in bytes int packSize = GetFormatSize(); if (packSize != 4) { GraphicsDevice.GLDevice.glPixelStorei( OpenGLDevice.GLenum.GL_UNPACK_ALIGNMENT, packSize ); } #if JSIL dynamic Document = Builtins.Global["document"]; dynamic Canvas = Document.getElementById("canvas"); dynamic gl = Canvas.getContext("webgl"); gl.texSubImage2D( OpenGLDevice.GLenum.GL_TEXTURE_2D, level, x, y, w, h, glFormat, glType, data ); #else GraphicsDevice.GLDevice.glTexSubImage2D( OpenGLDevice.GLenum.GL_TEXTURE_2D, level, x, y, w, h, glFormat, glType, dataPtr ); #endif // Keep this state sane -flibit if (packSize != 4) { GraphicsDevice.GLDevice.glPixelStorei( OpenGLDevice.GLenum.GL_UNPACK_ALIGNMENT, 4 ); } } } finally { #if !JSIL dataHandle.Free(); #endif } }); }
public void GetData <T>( int level, Rectangle?rect, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null || data.Length == 0) { throw new ArgumentException("data cannot be null"); } if (data.Length < startIndex + elementCount) { throw new ArgumentException( "The data passed has a length of " + data.Length.ToString() + " but " + elementCount.ToString() + " pixels have been requested." ); } Threading.ForceToMainThread(() => { if (GraphicsDevice.GLDevice.ReadTargetIfApplicable(texture, level, data, rect)) { return; } GraphicsDevice.GLDevice.BindTexture(texture); if (glFormat == OpenGLDevice.GLenum.GL_COMPRESSED_TEXTURE_FORMATS) { throw new NotImplementedException("GetData, CompressedTexture"); } else if (rect == null) { // Just throw the whole texture into the user array. GCHandle ptr = GCHandle.Alloc(data, GCHandleType.Pinned); try { GraphicsDevice.GLDevice.glGetTexImage( OpenGLDevice.GLenum.GL_TEXTURE_2D, 0, glFormat, glType, ptr.AddrOfPinnedObject() ); } finally { ptr.Free(); } } else { // Get the whole texture... T[] texData = new T[Width * Height]; GCHandle ptr = GCHandle.Alloc(texData, GCHandleType.Pinned); try { GraphicsDevice.GLDevice.glGetTexImage( OpenGLDevice.GLenum.GL_TEXTURE_2D, 0, glFormat, glType, ptr.AddrOfPinnedObject() ); } finally { ptr.Free(); } // Now, blit the rect region into the user array. Rectangle region = rect.Value; int curPixel = -1; for (int row = region.Y; row < region.Y + region.Height; row += 1) { for (int col = region.X; col < region.X + region.Width; col += 1) { curPixel += 1; if (curPixel < startIndex) { // If we're not at the start yet, just keep going... continue; } if (curPixel > elementCount) { // If we're past the end, we're done! return; } data[curPixel - startIndex] = texData[(row * Width) + col]; } } } }); }
public Texture2D( GraphicsDevice graphicsDevice, int width, int height, bool mipmap, SurfaceFormat format ) { if (graphicsDevice == null) { throw new ArgumentNullException("graphicsDevice"); } GraphicsDevice = graphicsDevice; Width = width; Height = height; LevelCount = mipmap ? CalculateMipLevels(width, height) : 1; Format = format; GetGLSurfaceFormat(); Threading.ForceToMainThread(() => { texture = new OpenGLDevice.OpenGLTexture( TextureTarget.Texture2D, Format, LevelCount > 1 ); if (((Width & (Width - 1)) != 0) || ((Height & (Height - 1)) != 0)) { texture.WrapS.Set(TextureAddressMode.Clamp); texture.WrapT.Set(TextureAddressMode.Clamp); } OpenGLDevice.Instance.BindTexture(texture); if (Format == SurfaceFormat.Dxt1 || Format == SurfaceFormat.Dxt3 || Format == SurfaceFormat.Dxt5) { GL.CompressedTexImage2D( TextureTarget.Texture2D, 0, glInternalFormat, Width, Height, 0, ((Width + 3) / 4) * ((Height + 3) / 4) * GetFormatSize(), IntPtr.Zero ); } else { GL.TexImage2D( TextureTarget.Texture2D, 0, glInternalFormat, Width, Height, 0, glFormat, glType, IntPtr.Zero ); } texture.Flush(true); }); }
public void SetData <T>( int level, Rectangle?rect, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data"); } int x, y, w, h; if (rect.HasValue) { x = rect.Value.X; y = rect.Value.Y; w = rect.Value.Width; h = rect.Value.Height; } else { x = 0; y = 0; w = Math.Max(Width >> level, 1); h = Math.Max(Height >> level, 1); } Threading.ForceToMainThread(() => { GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); try { int elementSizeInBytes = Marshal.SizeOf(typeof(T)); int startByte = startIndex * elementSizeInBytes; IntPtr dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startByte); OpenGLDevice.Instance.BindTexture(texture); if (glFormat == (PixelFormat)All.CompressedTextureFormats) { int dataLength; if (elementCount > 0) { dataLength = elementCount * elementSizeInBytes; } else { dataLength = data.Length - startByte; } if (rect.HasValue) { GL.CompressedTexSubImage2D( TextureTarget.Texture2D, level, x, y, w, h, glFormat, dataLength, dataPtr ); } else { GL.CompressedTexImage2D( TextureTarget.Texture2D, level, glInternalFormat, w, h, 0, dataLength, dataPtr ); } } else { // Set pixel alignment to match texel size in bytes GL.PixelStore( PixelStoreParameter.UnpackAlignment, GetFormatSize() ); if (rect.HasValue) { GL.TexSubImage2D( TextureTarget.Texture2D, level, x, y, w, h, glFormat, glType, dataPtr ); } else { GL.TexImage2D( TextureTarget.Texture2D, level, glInternalFormat, w, h, 0, glFormat, glType, dataPtr ); } // Return to default pixel alignment GL.PixelStore( PixelStoreParameter.UnpackAlignment, 4 ); } GL.Finish(); } finally { dataHandle.Free(); } }); }
public TextureCube( GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format ) { if (graphicsDevice == null) { throw new ArgumentNullException("graphicsDevice"); } GraphicsDevice = graphicsDevice; Size = size; LevelCount = mipMap ? CalculateMipLevels(size) : 1; Format = format; GetGLSurfaceFormat(); Threading.ForceToMainThread(() => { texture = new OpenGLDevice.OpenGLTexture( TextureTarget.TextureCubeMap, Format, LevelCount > 1 ); texture.WrapS.Set(TextureAddressMode.Clamp); texture.WrapT.Set(TextureAddressMode.Clamp); OpenGLDevice.Instance.BindTexture(texture); for (int i = 0; i < 6; i += 1) { TextureTarget target = GetGLCubeFace((CubeMapFace)i); if (glFormat == (PixelFormat)All.CompressedTextureFormats) { throw new NotImplementedException(); } else { GL.TexImage2D( target, 0, glInternalFormat, size, size, 0, glFormat, glType, IntPtr.Zero ); } } texture.Flush(true); if (mipMap) { GL.TexParameter( TextureTarget.TextureCubeMap, TextureParameterName.GenerateMipmap, 1 ); } }); }
public void SetData <T>( CubeMapFace cubeMapFace, int level, Rectangle?rect, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data"); } int xOffset, yOffset, width, height; if (rect.HasValue) { xOffset = rect.Value.X; yOffset = rect.Value.Y; width = rect.Value.Width; height = rect.Value.Height; } else { xOffset = 0; yOffset = 0; width = Math.Max(1, Size >> level); height = Math.Max(1, Size >> level); } Threading.ForceToMainThread(() => { GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); int elementSizeInBytes = Marshal.SizeOf(typeof(T)); int startByte = startIndex * elementSizeInBytes; IntPtr dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startByte); try { GraphicsDevice.GLDevice.BindTexture(texture); if (glFormat == (PixelFormat)All.CompressedTextureFormats) { int dataLength; if (elementCount > 0) { dataLength = elementCount * elementSizeInBytes; } else { dataLength = data.Length - startByte; } /* Note that we're using glInternalFormat, not glFormat. * In this case, they should actually be the same thing, * but we use glFormat somewhat differently for * compressed textures. * -flibit */ GL.CompressedTexSubImage2D( GetGLCubeFace(cubeMapFace), level, xOffset, yOffset, width, height, (PixelFormat)glInternalFormat, dataLength, dataPtr ); } else { GL.TexSubImage2D( GetGLCubeFace(cubeMapFace), level, xOffset, yOffset, width, height, glFormat, glType, dataPtr ); } } finally { dataHandle.Free(); } }); }
public TextureCube( GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format ) { if (graphicsDevice == null) { throw new ArgumentNullException("graphicsDevice"); } GraphicsDevice = graphicsDevice; Size = size; LevelCount = mipMap ? CalculateMipLevels(size) : 1; Format = format; GetGLSurfaceFormat(); Threading.ForceToMainThread(() => { texture = GraphicsDevice.GLDevice.CreateTexture( typeof(TextureCube), Format, mipMap ); if (glFormat == (PixelFormat)All.CompressedTextureFormats) { for (int i = 0; i < 6; i += 1) { for (int l = 0; l < LevelCount; l += 1) { int levelSize = Math.Max(size >> l, 1); GL.CompressedTexImage2D( GetGLCubeFace((CubeMapFace)i), l, glInternalFormat, levelSize, levelSize, 0, ((levelSize + 3) / 4) * ((levelSize + 3) / 4) * GetFormatSize(), IntPtr.Zero ); } } } else { for (int i = 0; i < 6; i += 1) { for (int l = 0; l < LevelCount; l += 1) { GL.TexImage2D( GetGLCubeFace((CubeMapFace)i), l, glInternalFormat, size, size, 0, glFormat, glType, IntPtr.Zero ); } } } }); }
public void SetData <T>( CubeMapFace face, int level, Rectangle?rect, T[] data, int startIndex, int elementCount ) where T : struct { if (data == null) { throw new ArgumentNullException("data"); } int xOffset, yOffset, width, height; if (rect.HasValue) { xOffset = rect.Value.X; yOffset = rect.Value.Y; width = rect.Value.Width; height = rect.Value.Height; } else { xOffset = 0; yOffset = 0; width = Math.Max(1, Size >> level); height = Math.Max(1, Size >> level); } Threading.ForceToMainThread(() => { GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); try { OpenGLDevice.Instance.BindTexture(texture); if (glFormat == (PixelFormat)All.CompressedTextureFormats) { throw new NotImplementedException(); } else { GL.TexSubImage2D( GetGLCubeFace(face), level, xOffset, yOffset, width, height, glFormat, glType, (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * Marshal.SizeOf(typeof(T))) ); } } finally { dataHandle.Free(); } }); }
public TextureCube( GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format ) { if (graphicsDevice == null) { throw new ArgumentNullException("graphicsDevice"); } GraphicsDevice = graphicsDevice; Size = size; LevelCount = mipMap ? CalculateMipLevels(size) : 1; Format = format; GetGLSurfaceFormat(); Threading.ForceToMainThread(() => { texture = GraphicsDevice.GLDevice.CreateTexture( typeof(TextureCube), Format, mipMap ); if (glFormat == OpenGLDevice.GLenum.GL_COMPRESSED_TEXTURE_FORMATS) { for (int i = 0; i < 6; i += 1) { for (int l = 0; l < LevelCount; l += 1) { int levelSize = Math.Max(size >> l, 1); graphicsDevice.GLDevice.glCompressedTexImage2D( OpenGLDevice.GLenum.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, l, (int)glInternalFormat, levelSize, levelSize, 0, ((levelSize + 3) / 4) * ((levelSize + 3) / 4) * GetFormatSize(), IntPtr.Zero ); } } } else { for (int i = 0; i < 6; i += 1) { for (int l = 0; l < LevelCount; l += 1) { int levelSize = Math.Max(size >> l, 1); graphicsDevice.GLDevice.glTexImage2D( OpenGLDevice.GLenum.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, l, (int)glInternalFormat, levelSize, levelSize, 0, glFormat, glType, IntPtr.Zero ); } } } }); }