scanmountgoat / sfgraphics Goto Github PK

glTexParameter only works for certain targets, so the base texture constructor should not allow other targets.

Depending on the shape of the object, the bounding sphere's volume may contain part of the object or none of it. Ex: the bounding sphere generated for a cube would fit fully inside the cube, which is not the intended result.

The data can be read using GL.GetBufferSubData after binding the buffer to the appropriate target.

Renderbuffers can be attached but not accessed. Any texture target can be used as long as it is not TextureCubeMap.

• Support render buffers
• Support textures

Newer versions of OpenGL support precompiled shaders that are loaded from a binary format.

• Generate program binary
• Create shader from program binary

The release should show the commit hash and/or timestamp to differentiate between versions.

This should be detected earlier, so a more meaningful exception can be thrown.

This will make uniform buffers of matrices for vertex skinning easier to work with.

• glGetUniformBlockIndex
• glUniformBlockBinding

GetVertexAttributeAndUniformLocation(string name) won't work properly for arrays.

// Shader
#version 330

uniform float[] values;
...

// Fails because the uniform name is "values" instead of "values[0]".
GL.Uniform1(shader.GetVertexAttributeAndUniformLocation("values[0]"), 1);

• float[]
• int[]
• uint[]
• Vec2[]
• Vec3[]
• Vec4[]
• Mat4[]
• Check uniform name with brackets removed. i.e. check "name" instead of "name[0]"
• Change name checking in shader setters to reflect above change

ToString() returns the type (texture, framebuffer, etc) and Id.

Implementing IDisposable allows for more predictable resource cleanup. Calling delete will crash if a context isnt current, however. GLObjectManager could still be used to clean up any remaining OpenGL resources.

Simplify the creation and management of OpenGL Renderbuffer Objects.

• Depth attachment for framebuffer
• Multisampling
• Reference counting and memory management with GLObjectManager

Does deleting a framebuffer delete its attachments?

Create a constructor for cubemaps from mipmap data in an uncompressed format.

Sampler objects allow for modifying texture parameters for texture units without modifying the original texture.

The target should be PixelUnpackBuffer. Any buffer can be bound to this target.

The tests fail with an invalid enum exception.

New test cases to ensure all points are in the bounding sphere.

• Unit Cube

It should be clearer whether the draw buffers are set for all color attachments. Allow specifying which attachments should be used.

// What are the draw buffers?
Framebuffer framebuffer = new Framebuffer(1, 1, PixelInternalFormat.Rgba, 4); 
// Set explicitly.
framebuffer.SetDrawBuffers(0, 1, 3); 
framebuffer.SetReadBuffer(2);

From OpenGL 4 reference for glTexImage2D:
"GL_INVALID_OPERATION is generated if format is GL_DEPTH_COMPONENT and internalFormat is not GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, or GL_DEPTH_COMPONENT32F."

From OpenGL Reference for glTexStorage2D:
"Once a texture is specified with this command, the format and dimensions of all levels become immutable unless it is a proxy texture. The contents of the image may still be modified, however, its storage requirements may not change."

The texture's width/height parameters become incorrect after using GL.TexImage2D to resize a mip level. Resizing a texture requires initializing all the mip levels with new data anyway, so it doesn't make much sense to allow texture resizing. Framebuffer attachments are resized, but a new texture could be created instead.

Pros:

• Prevents resizing texture data, even though width/height parameters cannot be changed.

Cons:

• Attempts to resize the texture will generate GL_INVALID_OPERATION error.

This also applies to buffers. Immutable storage allows for assumptions to be made about the size of the data, making accessing the data easier. The appropriate OpenGL functions aren't core in version 3.30.

Provide methods for initializing bufferobject data from an array of structs.

• GL.BufferData
• GL.BufferSubdata

From OpenGL Image Format Reference:
"Despite being color formats, compressed images are not color-renderable, for obvious reasons. Therefore, attaching a compressed image to a framebuffer object will cause that FBO to be incomplete and thus unusable. For similar reasons, no compressed formats can be used as the internal format of renderbuffers."

• Don't allow compressed texture attachments.
• Don't allow compressed render buffers.

This would probably only require implementing an interface that provides an Attach(Framebuffer target) method.

Don't allow invalid offsets to be used. GL.BufferSubData can't make a buffer bigger.

• Create first release
• Update each release with successful Appveyor build
  Update version number after each successful Appveyor build

Version numbers might be added once the library is more stable.

This project doesn't even need the fancy new Visual Studio.

The collection of vertex attributes and uniforms doesn't need to be public. This could be implemented as follows:

shader.GetUniformLocation("myUniform");
shader.GetUniformLocation("myUniform[2]");
shader.GetAttribLocation("myAttrib");

OpenGL Reference
OpenGL doesn't even recommend these. There isn't a way to upload data directly in this format. The block size also can't be determined.

Add an error message to the shader log if the user attempts to set the wrong type of sampler. Ex: trying to initialize a sampler2D uniform by binding a cube map.

Not all formats are supported, which results in calls to GL.CompressedTexImage2D throwing an InvalidValue error for some formats.

OpenGL Image Formats

• lib
• Projects
  • SFGraphics
• Test Projects
  • SFGraphicsTest
• Example Projects
  • SFGraphicsGui

The mipmap loading methods generate a lot of errors for cube map targets.

The camera class should be tested with other SFGraphics classes.

Simplify attaching textures to color or depth attachments.

The texture functions already allow generic structs for the texture methods. Using generics would allow for texture data to be specified in byte, float, int, or any value type. The user would be responsible for specifying the proper format options to allow OpenGL to interpret the data correctly.

Entire Class:
The existing constructors can be preserved, but this forces collections of textures and other classes using textures to care about what value type was used to initialize the texture's data.

Texture2D<byte> texture = new Texture2D<byte>(width, height, byteArray);

Methods Only:
The original format of the image data is irrelevant once the image is loaded. This simplifies other classes that rely on textures, such as the framebuffer class. The constructors can't be used for loading image data, however.

Texture2D texture = new Texture2D();
texture.LoadData<byte>(width, height, byteArray);

Simply testing the reference count methods themselves would be helpful. There isn't a way to ensure the finalizers are called during a test method.

• Test negative attachment count
• Test compressed PixelInternalFormat

GetData() assumes the number of items returned will be equal to the number of items used to initialize the buffer's data. This works when the types are the same for getting and setting data, but it fails for setting a float array and reading back a byte array.

Possible fix:
Require the size in bytes of T for getting data. Throw an exception if the requested data exceeds the buffer's capacity.

Object binding should be more consistent to avoid redundant and accidental binding of objects.

MyObject myObject = new MyObject(target); // not bound
myObject.LoadData(data); // binds object
myObject.Bind(); // binds object
myObject.Unbind(); // binds default if possible

Names should be consistent for GL objects. Buffer methods should not have buffer in the name, texture methods should not have texture in the name, etc.

buffer.Data()
buffer.Bind()

Show the shader type in error logs to display which errors belong to the which shader type.

Compare the output to an expected value rather than just checking the sign or if it equals a zero vector.

• Normals
• Tangents
• Bitangents

https://www.opengl.org/discussion_boards/showthread.php/199198-Just-Curious-How-Many-Mipmaps-does-glGenerateMipmap-generate

OpenGL already calculates the correct number of mipmaps. If users want a specific number of mipmaps, they should manually specify the data themselves.

• Check when/if GL.GenerateMipmaps needs to be called for manually specified mipmaps.
• Remove mipCount parameter.

The vector and color tools don't depend on any of the other SFGraphics classes, so there's no point keeping the projects together.

• Create separate project
• Add to unstable release
• Update online documentation

The actual value of a uniform can be tested with GL.GetUniform(). This also works for arrays.

• Scalar types
• Vector types
• Matrix types
• Arrays