internal void SetVertexAttributeArray(bool[] attrs)
{
for (int x = 0; x < attrs.Length; x++)
{
if (attrs[x] && !_enabledVertexAttributes.Contains(x))
{
_enabledVertexAttributes.Add(x);
GL.EnableVertexAttribArray(x);
GraphicsExtensions.CheckGLError();
}
else if (!attrs[x] && _enabledVertexAttributes.Contains(x))
{
_enabledVertexAttributes.Remove(x);
GL.DisableVertexAttribArray(x);
GraphicsExtensions.CheckGLError();
}
}
}
internal void SetVertexAttributeArray(bool[] attrs)
{
for (var x = 0; x < attrs.Length; x++)
{
if (attrs[x] && !_enabledVertexAttributes.ContainsKey(x))
{
_enabledVertexAttributes[x] = true;
gl.enableVertexAttribArray(x);
GraphicsExtensions.CheckGLError();
}
else if (!attrs[x] && _enabledVertexAttributes.ContainsKey(x))
{
_enabledVertexAttributes.Remove(x);
gl.disableVertexAttribArray(x);
GraphicsExtensions.CheckGLError();
}
}
}
private bool PlatformGetResult(out int pixelCount)
{
int resultReady = 0;
GL.GetQueryObject(glQueryId, GetQueryObjectParam.QueryResultAvailable, out resultReady);
GraphicsExtensions.CheckGLError();
if (resultReady == 0)
{
pixelCount = 0;
return(false);
}
GL.GetQueryObject(glQueryId, GetQueryObjectParam.QueryResult, out pixelCount);
GraphicsExtensions.CheckGLError();
return(true);
}
private void GetBufferData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
{
GL.BindBuffer (BufferTarget.ArrayBuffer, vbo);
GraphicsExtensions.CheckGLError();
var elementSizeInByte = Marshal.SizeOf(typeof(T));
IntPtr ptr = GL.MapBuffer (BufferTarget.ArrayBuffer, BufferAccess.ReadOnly);
GraphicsExtensions.CheckGLError();
// Pointer to the start of data to read in the index buffer
ptr = new IntPtr (ptr.ToInt64 () + offsetInBytes);
if (typeof(T) == typeof(byte)) {
byte[] buffer = data as byte[];
// If data is already a byte[] we can skip the temporary buffer
// Copy from the vertex buffer to the destination array
Marshal.Copy (ptr, buffer, 0, buffer.Length);
} else {
// Temporary buffer to store the copied section of data
byte[] buffer = new byte[elementCount * vertexStride - offsetInBytes];
// Copy from the vertex buffer to the temporary buffer
Marshal.Copy(ptr, buffer, 0, buffer.Length);
var dataHandle = GCHandle.Alloc (data, GCHandleType.Pinned);
var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject ().ToInt64 () + startIndex * elementSizeInByte);
// Copy from the temporary buffer to the destination array
int dataSize = Marshal.SizeOf(typeof(T));
if (dataSize == vertexStride)
Marshal.Copy(buffer, 0, dataPtr, buffer.Length);
else
{
// If the user is asking for a specific element within the vertex buffer, copy them one by one...
for (int i = 0; i < elementCount; i++)
{
Marshal.Copy(buffer, i * vertexStride, dataPtr, dataSize);
dataPtr = (IntPtr)(dataPtr.ToInt64() + dataSize);
}
}
dataHandle.Free ();
//Buffer.BlockCopy(buffer, 0, data, startIndex * elementSizeInByte, elementCount * elementSizeInByte);
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
}
internal void Apply(Shader shader, IntPtr offset)
{
VertexDeclarationAttributeInfo attrInfo;
int shaderHash = shader.GetHashCode();
if (!shaderAttributeInfo.TryGetValue(shaderHash, out attrInfo))
{
// Get the vertex attribute info and cache it
attrInfo = new VertexDeclarationAttributeInfo(GraphicsDevice.MaxVertexAttributes);
foreach (var ve in _elements)
{
var attributeLocation = shader.GetAttribLocation(ve.VertexElementUsage, ve.UsageIndex);
// XNA appears to ignore usages it can't find a match for, so we will do the same
if (attributeLocation >= 0)
{
attrInfo.Elements.Add(new VertexDeclarationAttributeInfo.Element()
{
Offset = ve.Offset,
AttributeLocation = attributeLocation,
NumberOfElements = ve.VertexElementFormat.OpenGLNumberOfElements(),
VertexAttribPointerType = ve.VertexElementFormat.OpenGLVertexAttribPointerType(),
Normalized = ve.OpenGLVertexAttribNormalized(),
});
attrInfo.EnabledAttributes[attributeLocation] = true;
}
}
shaderAttributeInfo.Add(shaderHash, attrInfo);
}
// Apply the vertex attribute info
foreach (var element in attrInfo.Elements)
{
GL.VertexAttribPointer(element.AttributeLocation,
element.NumberOfElements,
element.VertexAttribPointerType,
element.Normalized,
this.VertexStride,
(IntPtr)(offset.ToInt64() + element.Offset));
GraphicsExtensions.CheckGLError();
}
GraphicsDevice.SetVertexAttributeArray(attrInfo.EnabledAttributes);
}
internal protected override void GraphicsDeviceResetting()
{
#if OPENGL
if (_shaderHandle != -1)
{
if (GL.IsShader(_shaderHandle))
{
GL.DeleteShader(_shaderHandle);
GraphicsExtensions.CheckGLError();
}
_shaderHandle = -1;
}
#endif
#if DIRECTX
SharpDX.Utilities.Dispose(ref _vertexShader);
SharpDX.Utilities.Dispose(ref _pixelShader);
#endif
}
/// <summary>
/// If the IBO does not exist, create it.
/// </summary>
void GenerateIfRequired()
{
if (ibo == 0)
{
var sizeInBytes = IndexCount * (this.IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4);
#if IOS || ANDROID
GL.GenBuffers(1, ref ibo);
#else
GL.GenBuffers(1, out ibo);
#endif
GraphicsExtensions.CheckGLError();
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo);
GraphicsExtensions.CheckGLError();
GL.BufferData(BufferTarget.ElementArrayBuffer,
(IntPtr)sizeInBytes, IntPtr.Zero, _isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
GraphicsExtensions.CheckGLError();
}
}
private void PlatformSetData <T>(int level,
int left, int top, int right, int bottom, int front, int back,
T[] data, int startIndex, int elementCount, int width, int height, int depth)
{
#if GLES
throw new NotSupportedException("OpenGL ES 2.0 doesn't support 3D textures.");
#else
var elementSizeInByte = Marshal.SizeOf(typeof(T));
var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInByte);
GL.BindTexture(glTarget, glTexture);
GraphicsExtensions.CheckGLError();
GL.TexSubImage3D(glTarget, level, left, top, front, width, height, depth, glFormat, glType, dataPtr);
GraphicsExtensions.CheckGLError();
dataHandle.Free();
#endif
}
private void GetBufferData <T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
{
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GraphicsExtensions.CheckGLError();
// Pointer to the start of data in the vertex buffer
var ptr = GL.MapBuffer(BufferTarget.ArrayBuffer, BufferAccess.ReadOnly);
GraphicsExtensions.CheckGLError();
ptr = (IntPtr)(ptr.ToInt64() + offsetInBytes);
if (typeof(T) == typeof(byte) && vertexStride == 1)
{
// If data is already a byte[] and stride is 1 we can skip the temporary buffer
var buffer = data as byte[];
Marshal.Copy(ptr, buffer, startIndex * vertexStride, elementCount * vertexStride);
}
else
{
// Temporary buffer to store the copied section of data
var tmp = new byte[elementCount * vertexStride];
// Copy from the vertex buffer to the temporary buffer
Marshal.Copy(ptr, tmp, 0, tmp.Length);
// Copy from the temporary buffer to the destination array
var tmpHandle = GCHandle.Alloc(tmp, GCHandleType.Pinned);
var tmpPtr = tmpHandle.AddrOfPinnedObject();
try {
for (var i = 0; i < elementCount; i++)
{
data[startIndex + i] = (T)Marshal.PtrToStructure(tmpPtr, typeof(T));
tmpPtr = (IntPtr)(tmpPtr.ToInt64() + vertexStride);
}
}
finally {
tmpHandle.Free();
}
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
GraphicsExtensions.CheckGLError();
}
internal void ApplyState(GraphicsDevice device)
{
var blendEnabled = !(this.ColorSourceBlend == Blend.One &&
this.ColorDestinationBlend == Blend.Zero &&
this.AlphaSourceBlend == Blend.One &&
this.AlphaDestinationBlend == Blend.Zero);
if (blendEnabled)
{
GL.Enable(EnableCap.Blend);
}
else
{
GL.Disable(EnableCap.Blend);
}
GraphicsExtensions.CheckGLError();
GL.BlendColor(
this.BlendFactor.R / 255.0f,
this.BlendFactor.G / 255.0f,
this.BlendFactor.B / 255.0f,
this.BlendFactor.A / 255.0f);
GraphicsExtensions.CheckGLError();
GL.BlendEquationSeparate(
this.ColorBlendFunction.GetBlendEquationMode(),
this.AlphaBlendFunction.GetBlendEquationMode());
GraphicsExtensions.CheckGLError();
GL.BlendFuncSeparate(
this.ColorSourceBlend.GetBlendFactorSrc(),
this.ColorDestinationBlend.GetBlendFactorDest(),
this.AlphaSourceBlend.GetBlendFactorSrc(),
this.AlphaDestinationBlend.GetBlendFactorDest());
GraphicsExtensions.CheckGLError();
GL.ColorMask(
(this.ColorWriteChannels & ColorWriteChannels.Red) != 0,
(this.ColorWriteChannels & ColorWriteChannels.Green) != 0,
(this.ColorWriteChannels & ColorWriteChannels.Blue) != 0,
(this.ColorWriteChannels & ColorWriteChannels.Alpha) != 0);
GraphicsExtensions.CheckGLError();
}
internal void Activate(TextureTarget target, bool useMipmaps = false)
{
switch (Filter)
{
case TextureFilter.Point:
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapNearest : TextureMinFilter.Nearest));
GraphicsExtensions.CheckGLError();
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
GraphicsExtensions.CheckGLError();
break;
case TextureFilter.Linear:
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear));
GraphicsExtensions.CheckGLError();
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GraphicsExtensions.CheckGLError();
break;
case TextureFilter.Anisotropic:
// TODO: Requires EXT_texture_filter_anisotropic. Use linear filtering for now.
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear));
GraphicsExtensions.CheckGLError();
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GraphicsExtensions.CheckGLError();
break;
case TextureFilter.PointMipLinear:
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapNearest : TextureMinFilter.Nearest));
GraphicsExtensions.CheckGLError();
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
GraphicsExtensions.CheckGLError();
break;
default:
throw new NotImplementedException();
}
// Set up texture addressing.
GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)GetWrapMode(AddressU));
GraphicsExtensions.CheckGLError();
GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)GetWrapMode(AddressV));
GraphicsExtensions.CheckGLError();
}
internal void Apply(Shader shader, int offset, int programHash)
{
var attrInfo = GetAttributeInfo(shader, programHash);
// Apply the vertex attribute info
foreach (var element in attrInfo.Elements)
{
gl.vertexAttribPointer(element.AttributeLocation,
element.NumberOfElements,
element.VertexAttribPointerType,
element.Normalized,
VertexStride,
offset + element.Offset);
GraphicsExtensions.CheckGLError();
}
GraphicsDevice.SetVertexAttributeArray(attrInfo.EnabledAttributes);
GraphicsDevice._attribsDirty = true;
}
private void PlatformSetData <T>(CubeMapFace face, int level, IntPtr dataPtr, int xOffset, int yOffset, int width, int height)
{
Threading.BlockOnUIThread(() =>
{
GL.BindTexture(TextureTarget.TextureCubeMap, this.glTexture);
GraphicsExtensions.CheckGLError();
TextureTarget target = GetGLCubeFace(face);
if (glFormat == (PixelFormat)All.CompressedTextureFormats)
{
throw new NotImplementedException();
}
else
{
GL.TexSubImage2D(target, level, xOffset, yOffset, width, height, glFormat, glType, dataPtr);
GraphicsExtensions.CheckGLError();
}
});
}
private void PlatformSetViewport(ref Viewport value)
{
if (IsRenderTargetBound)
{
gl.viewport(value.X, value.Y, value.Width, value.Height);
}
else
{
gl.viewport(value.X, PresentationParameters.BackBufferHeight - value.Y - value.Height, value.Width, value.Height);
}
GraphicsExtensions.LogGLError("GraphicsDevice.Viewport_set() GL.Viewport");
gl.depthRange(value.MinDepth, value.MaxDepth);
GraphicsExtensions.LogGLError("GraphicsDevice.Viewport_set() GL.DepthRange");
// In OpenGL we have to re-apply the special "posFixup"
// vertex shader uniform if the viewport changes.
_vertexShaderDirty = true;
}
private void PlatformDrawUserIndexedPrimitives <T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
{
ApplyState(true);
var count = GetElementCountArray(primitiveType, primitiveCount);
var vertexArrayBuffer = ConvertVertices(vertexData, vertexOffset, numVertices, vertexDeclaration);
var uintIndexData = new Uint16Array(count.As <uint>());//indexData.As<Uint16Array>();
for (uint i = 0; i < uintIndexData.length; i++)
{
uintIndexData[i] = indexData[indexOffset + i].As <ushort>();
}
var vertexBuffer = gl.createBuffer();
var indexBuffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
GraphicsExtensions.CheckGLError();
gl.bufferData(gl.ARRAY_BUFFER, vertexArrayBuffer, gl.STATIC_DRAW);
GraphicsExtensions.CheckGLError();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
GraphicsExtensions.CheckGLError();
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, uintIndexData, gl.STATIC_DRAW);
GraphicsExtensions.CheckGLError();
_vertexBuffersDirty = true;
_indexBufferDirty = true;
var mode = (uint)GraphicsExtensions.GetPrimitiveTypeGL(primitiveType);
vertexDeclaration.GraphicsDevice = this;
vertexDeclaration.Apply(_vertexShader, vertexOffset, ShaderProgramHash);
GraphicsExtensions.CheckGLError();
gl.drawElements(mode, count, gl.UNSIGNED_SHORT, 0);
GraphicsExtensions.CheckGLError();
gl.bindBuffer(gl.ARRAY_BUFFER, null);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
gl.deleteBuffer(vertexBuffer);
gl.deleteBuffer(indexBuffer);
}
private ShaderProgram Link(Shader vertexShader, Shader pixelShader)
{
// NOTE: No need to worry about background threads here
// as this is only called at draw time when we're in the
// main drawing thread.
var program = GL.CreateProgram();
GraphicsExtensions.CheckGLError();
GL.AttachShader(program, vertexShader.GetShaderHandle());
GraphicsExtensions.CheckGLError();
GL.AttachShader(program, pixelShader.GetShaderHandle());
GraphicsExtensions.CheckGLError();
//vertexShader.BindVertexAttributes(program);
GL.LinkProgram(program);
GraphicsExtensions.CheckGLError();
GL.UseProgram(program);
GraphicsExtensions.CheckGLError();
vertexShader.GetVertexAttributeLocations(program);
pixelShader.ApplySamplerTextureUnits(program);
var linked = 0;
GL.GetProgram(program, GetProgramParameterName.LinkStatus, out linked);
GraphicsExtensions.LogGLError("VertexShaderCache.Link(), GL.GetProgram");
if (linked == (int)Bool.False)
{
var log = GL.GetProgramInfoLog(program);
Console.WriteLine(log);
GL.DetachShader(program, vertexShader.GetShaderHandle());
GL.DetachShader(program, pixelShader.GetShaderHandle());
_graphicsDevice.DisposeProgram(program);
throw new InvalidOperationException("Unable to link effect program");
}
return(new ShaderProgram(program));
}
private ShaderProgram Link(Shader vertexShader, Shader pixelShader)
{
// NOTE: No need to worry about background threads here
// as this is only called at draw time when we're in the
// main drawing thread.
var program = (WebGLProgram)gl.createProgram();
GraphicsExtensions.CheckGLError();
gl.attachShader(program, vertexShader.GetShaderHandle());
GraphicsExtensions.CheckGLError();
gl.attachShader(program, pixelShader.GetShaderHandle());
GraphicsExtensions.CheckGLError();
//vertexShader.BindVertexAttributes(program);
gl.linkProgram(program);
GraphicsExtensions.CheckGLError();
gl.useProgram(program);
GraphicsExtensions.CheckGLError();
vertexShader.GetVertexAttributeLocations(program);
pixelShader.ApplySamplerTextureUnits(program);
var linked = (bool)gl.getProgramParameter(program, gl.LINK_STATUS);
GraphicsExtensions.LogGLError("VertexShaderCache.Link(), GL.GetProgram");
if (!linked)
{
var log = gl.getProgramInfoLog(program);
gl.detachShader(program, vertexShader.GetShaderHandle());
gl.detachShader(program, pixelShader.GetShaderHandle());
_graphicsDevice.DisposeProgram(program);
throw new InvalidOperationException("Unable to link effect program");
}
return(new ShaderProgram(program));
}
private void SetBufferData <T>(int bufferSize, int elementSizeInBytes, int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options) where T : struct
{
GenerateIfRequired();
var sizeInBytes = elementSizeInBytes * elementCount;
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GraphicsExtensions.CheckGLError();
if (options == SetDataOptions.Discard)
{
// By assigning NULL data to the buffer this gives a hint
// to the device to discard the previous content.
GL.BufferData(BufferTarget.ArrayBuffer,
(IntPtr)bufferSize,
IntPtr.Zero,
_isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
GraphicsExtensions.CheckGLError();
}
var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInBytes);
int dataSize = Marshal.SizeOf(typeof(T));
if (dataSize == vertexStride)
{
GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)offsetInBytes, (IntPtr)sizeInBytes, dataPtr);
GraphicsExtensions.CheckGLError();
}
else
{
for (int i = 0; i < elementCount; i++)
{
GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)offsetInBytes + i * vertexStride, (IntPtr)dataSize, dataPtr);
GraphicsExtensions.CheckGLError();
dataPtr = (IntPtr)(dataPtr.ToInt64() + dataSize);
}
}
dataHandle.Free();
}
/// <summary>
/// If the VBO does not exist, create it.
/// </summary>
void GenerateIfRequired()
{
if (vbo == 0)
{
//GLExt.Oes.GenVertexArrays(1, out this.vao);
//GLExt.Oes.BindVertexArray(this.vao);
#if IOS || ANDROID
GL.GenBuffers(1, ref this.vbo);
#else
GL.GenBuffers(1, out this.vbo);
#endif
GraphicsExtensions.CheckGLError();
GL.BindBuffer(BufferTarget.ArrayBuffer, this.vbo);
GraphicsExtensions.CheckGLError();
GL.BufferData(BufferTarget.ArrayBuffer,
new IntPtr(VertexDeclaration.VertexStride * VertexCount), IntPtr.Zero,
_isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
GraphicsExtensions.CheckGLError();
}
}
public override void Dispose()
{
#if DIRECTX
if (_resourceView != null)
{
_resourceView.Dispose();
_resourceView = null;
}
if (_texture != null)
{
_texture.Dispose();
_texture = null;
}
#elif OPENGL
GL.DeleteTextures(1, ref glTexture);
GraphicsExtensions.CheckGLError();
#endif
base.Dispose();
}
private void PlatformSetData <T>(CubeMapFace face, int level, Rectangle rect, T[] data, int startIndex, int elementCount)
{
var subarr = new Uint8Array(data.As <ArrayBuffer>(), startIndex.As <uint>(), elementCount.As <uint>());
gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.glTexture);
GraphicsExtensions.CheckGLError();
var target = GetGLCubeFace(face);
if (glFormat == gl.COMPRESSED_TEXTURE_FORMATS)
{
gl.compressedTexSubImage2D(target, level, rect.X, rect.Y, rect.Width, rect.Height, glInternalFormat, subarr);
GraphicsExtensions.CheckGLError();
}
else
{
gl.texSubImage2D(target, level, rect.X, rect.Y, rect.Width, rect.Height, glFormat, glType, subarr.As <ArrayBufferView>());
GraphicsExtensions.CheckGLError();
}
}
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
GraphicsDevice.AddDisposeAction(() =>
{
if (_shaderHandle != -1)
{
if (GL.IsShader(_shaderHandle))
{
GL.DeleteShader(_shaderHandle);
GraphicsExtensions.CheckGLError();
}
_shaderHandle = -1;
}
});
}
base.Dispose(disposing);
}
public void PlatformPresent()
{
#if WINDOWS || LINUX || ANGLE
Context.SwapBuffers();
#endif
GraphicsExtensions.CheckGLError();
// Dispose of any GL resources that were disposed in another thread
lock (disposeActionsLock)
{
if (disposeActions.Count > 0)
{
foreach (var action in disposeActions)
{
action();
}
disposeActions.Clear();
}
}
}
public Texture3D(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat format)
{
if (graphicsDevice == null)
{
throw new ArgumentNullException("graphicsDevice");
}
this.GraphicsDevice = graphicsDevice;
this.width = width;
this.height = height;
this.depth = depth;
this.levelCount = 1;
this.glTarget = TextureTarget.Texture3D;
GL.GenTextures(1, out this.glTexture);
GL.BindTexture(this.glTarget, this.glTexture);
GraphicsExtensions.GetGLFormat(format, out this.glInternalFormat, out this.glFormat, out this.glType);
GL.TexImage3D(this.glTarget, 0, this.glInternalFormat, width, height, depth, 0, this.glFormat, this.glType, IntPtr.Zero);
if (mipMap)
{
throw new NotImplementedException("Texture3D does not yet support mipmaps.");
}
}
protected virtual void Dispose(bool disposing)
{
if (this._isDisposed)
{
return;
}
if (disposing)
{
GraphicsResource.DisposeAll();
this._programCache.Dispose();
GraphicsDevice.AddDisposeAction((Action)(() =>
{
if (this.glRenderTargetFrameBuffer <= 0U)
{
return;
}
GraphicsExtensions.DeleteFramebuffers(1, ref this.glRenderTargetFrameBuffer);
}));
}
this._isDisposed = true;
}
private void PlatformDrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount)
{
ApplyState(true);
var shortIndices = _indexBuffer.IndexElementSize == IndexElementSize.SixteenBits;
var indexElementType = shortIndices ? DrawElementsType.UnsignedShort : DrawElementsType.UnsignedInt;
var indexElementSize = shortIndices ? 2 : 4;
var indexOffsetInBytes = (IntPtr)(startIndex * indexElementSize);
var indexElementCount = GetElementCountArray(primitiveType, primitiveCount);
var target = PrimitiveTypeGL(primitiveType);
var vertexOffset = (IntPtr)(_vertexBuffer.VertexDeclaration.VertexStride * baseVertex);
_vertexBuffer.VertexDeclaration.Apply(_vertexShader, vertexOffset);
GL.DrawElements(target,
indexElementCount,
indexElementType,
indexOffsetInBytes);
GraphicsExtensions.CheckGLError();
}
internal void ApplyState(GraphicsDevice device)
{
GL.Enable(EnableCap.Blend);
GraphicsExtensions.CheckGLError();
// Set blending mode
var blendMode = ColorBlendFunction.GetBlendEquationMode();
GL.BlendEquation(blendMode);
GraphicsExtensions.CheckGLError();
// Set blending function
var bfs = ColorSourceBlend.GetBlendFactorSrc();
var bfd = ColorDestinationBlend.GetBlendFactorDest();
#if IPHONE
GL.BlendFunc((All)bfs, (All)bfd);
#else
GL.BlendFunc(bfs, bfd);
#endif
GraphicsExtensions.CheckGLError();
}
private void BufferData <T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
{
GenerateIfRequired();
var elementSizeInByte = (IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4);
var bufferSize = IndexCount * elementSizeInByte;
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
GraphicsExtensions.CheckGLError();
if (options == SetDataOptions.Discard)
{
// By assigning NULL data to the buffer this gives a hint
// to the device to discard the previous content.
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Int16Array(0), _isDynamic ? gl.STREAM_DRAW : gl.STATIC_DRAW);
GraphicsExtensions.CheckGLError();
}
if (elementSizeInByte == 2)
{
var arr = new Uint16Array((uint)elementCount);
for (uint i = 0; i < elementCount; i++)
{
arr[i] = data[i + startIndex].As <ushort>();
}
gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, arr);
}
else
{
var arr = new Uint32Array((uint)elementCount);
for (uint i = 0; i < elementCount; i++)
{
arr[i] = data[i + startIndex].As <uint>();
}
gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, arr);
}
GraphicsExtensions.CheckGLError();
}
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
#if DIRECTX
if (disposing)
{
SharpDX.Utilities.Dispose(ref _resourceView);
SharpDX.Utilities.Dispose(ref _texture);
}
#elif OPENGL
GraphicsDevice.AddDisposeAction(() =>
{
GL.DeleteTextures(1, ref glTexture);
GraphicsExtensions.CheckGLError();
glTexture = -1;
});
glLastSamplerState = null;
#endif
}
base.Dispose(disposing);
}
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");
}
#if !PORTABLE
var elementSizeInByte = Marshal.SizeOf(typeof(T));
var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInByte);
int width = right - left;
int height = bottom - top;
int depth = back - front;
#if OPENGL
GL.BindTexture(glTarget, glTexture);
GraphicsExtensions.CheckGLError();
GL.TexSubImage3D(glTarget, level, left, top, front, width, height, depth, glFormat, glType, dataPtr);
GraphicsExtensions.CheckGLError();
#elif DIRECTX
int rowPitch = GetPitch(width);
int slicePitch = rowPitch * height; // For 3D texture: Size of 2D image.
var box = new DataBox(dataPtr, rowPitch, slicePitch);
int subresourceIndex = level;
var region = new ResourceRegion(left, top, front, right, bottom, back);
var d3dContext = GraphicsDevice._d3dContext;
lock (d3dContext)
d3dContext.UpdateSubresource(box, GetTexture(), subresourceIndex, region);
#endif
dataHandle.Free();
#endif
}
public static void LogToFile(GraphicsExtensions.LogSeverity severity, string message)
{
try
{
using (FileStream fileStream = File.Open(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\FEZ\\Debug Log.txt", FileMode.Append))
{
using (StreamWriter streamWriter = new StreamWriter((Stream) fileStream))
streamWriter.WriteLine("({0}) [{1}] {2} : {3}", (object) DateTime.Now.ToString("HH:mm:ss.fff"), (object) "MonoGame", (object) ((object) severity).ToString().ToUpper(CultureInfo.InvariantCulture), (object) message);
}
}
catch (Exception ex)
{
}
}
