axiometry / sgine Goto Github PK

In OpenGL Generator some methods do not match up perfectly. Support needs to be 
added to the generator to handle these scenarios properly.

Generating the source code inline is inefficient and hacky and should be 
replaced by the utilization of templates.

Currently images can be loaded through ImageIO and pushed into a texture
via BufferedImage but this is inefficient and more CPU intensive than
loading and converting from a filesystem format directly into a GL texture.

Image types that should be supported include:
* PNG
* JPG
* TIF
* GIF
* TGA

Jenkins should be updated to the latest version and sgine builds should rely on 
the SBT plugin rather than executing via a command-line process.

Currently the FPS object prints out the fps every second to the output
stream. It would be much more useful to have a visual fps counter.

See sumary

Utilize http://mtkopone.github.com/scct/ to support code coverage on the SBT 
project.

Finished the method signature support in the OpenGL Generator in the 
multi-project branch.

Tag the current default branch and merge multi-project in.

Applet support needs to be completed for OpenGL

[deleted issue]

Details for methods and fields docs need to be generated at the time code is 
generated.

You are missing rotateZ method on Matrix4.

Add code coverage support for tests with http://mtkopone.github.com/scct/

I don't know if it is a real issue or if the developer using sgine is 
responsible for avoiding this situation. I've got a double property that is 
filtered and animated:

import org.sgine.property.animate.LinearNumericAnimator
import org.sgine.property.FilteredProperty
import org.sgine.property.MutableProperty
import org.sgine.property.AnimatingProperty
import org.sgine.property.FilterType

object AnimatingFilterIssue {
  def main(args: Array[String]) {

    val prop = new MutableProperty[Double] 
                   with FilteredProperty[Double] 
                   with AnimatingProperty[Double] 
    {
      animator = new LinearNumericAnimator(1)
      val filter = (alpha: Double) => Math.max(0, Math.min(value, 1))
      val filterType = FilterType.Modify
    }

    prop := 1.5;
    prop.waitForTarget();
    println("finished") //unreachable because animation target was filtered
  }
}

Trying to set the animation target to a value that will be filtered causes the 
animation to run infinitely, as the snippet shows. The reason is obviously that 
the animation target can't be reached.
Changing the filter type to 'Retrieve' behaves equal.

I guess this problem could be a mine field for complex projects.

I work with version 2.8.1, Windows 7.

When using events in another project I was required to fulfill the dependency 
on libgdx before I could use the lib. This hard requirement should be removed 
to properly allow non-3d applications to leverage Sgine without the need of 
libgdx.

Currently "arg0", "arg1", etc. is being used as argument names. This should be 
changed to properly reference the method names used by OpenGL to make the 
documentation and code-completion much easier to utilize.

Files need to be generated as a result of the opengl-generator project rather 
than simply outputting to the screen.

1.) Bus only fires for listeners registered for a specific class, it does not 
handle sub-classes.
2.) Matching on the partial function doesn't allow fall-through. Throws a match 
error if the case is not matched.

The generator is currently getting stuck on GL methods that deviate based on 
type. Support should be added to handle this scenario.

What steps will reproduce the problem?
1. Run the search demo without vsync

Work needs to be done to isolate and remove garbage creation as a result of
the render loop to remove animation pauses from occurring

Current the generator uses "startsWith" to determine a match between a GL 
method name and the implementation method. This is problematic for cases like 
glClear as they match things like glClearColor.

Child projects need to be created under opengl for "android" and "lwjgl" for 
the generated implementation information and specific details relating to the 
implementation.