What tutorials and libraries are available which can help beginners to develop 2D and 3D games on Android using OpenGL-ES? I&#39;m looking for tutorials which can help me learn OpenGL-ES, and I&#39;m looking for OpenGL-ES libraries which can make life easier for beginners in OpenGL-ES.

Since Android is still small, I guess it may be help-full to read iPhone OpenGL-ES tutorials as well, as I suppose the OpenGL-ES functionality is much the same.

I have found the following useful information which I would have liked to share:

Android tutorials:  

 - [DroidNova: Basic tutorial covering polygons, no textures](http://www.droidnova.com/android-3d-game-tutorial-part-i,312.html)  
 - [anddev forum with some tutorials](http://www.anddev.org/tut-sequence_android_gl_-_learning_opengl_from_scratch-t229.html)

Other Android OpenGL-ES information:  

 * [Google IO lecture](http://www.youtube.com/watch?v=U4Bk5rmIpic) regarding games, not 
much OpenGLES  
 * The [The Khronos Reference Manual](http://www.khronos.org/opengles/sdk/1.1/docs/man/) is also relevant to have, but its not exactly the best place to start.

iPhone OpenGL-ES tutorials (where the OpenGl-ES information is probably useful):  

 - &lt;http://web.me.com/smaurice/AppleCoder/iPhone_OpenGL/Archive.html&gt;
 - &lt;http://iphonedevelopment.blogspot.com/2009/05/opengl-es-from-ground-up-table-of.html&gt;

As for libraries which a beginner might use to get a simpler hands-on experience with OpenGL-ES, I have only found [Rokon](http://rokon-android.blogspot.com/), which is recently started, thus has many holes and bugs. And it&#39;s gnuGPL licensed (at the moment) which means it cannot be used, if we wish to sell our games.

What else is out there?

Tutorials and libraries for OpenGL-ES games on Android

I&#39;m a physicist, and have been learning some programming, and have come across a lot of people using quaternions for rotations instead of writing things in matrix/vector form. 

In physics, there are very good reasons we don&#39;t use quaternions (despite the bizarre story that&#39;s occasionally told about Hamilton/Gibbs/etc). Physics requires that our descriptions have good analytic behavior (this has a precisely defined meaning, but in some rather technical ways that go far beyond what&#39;s taught in normal intro classes, so I won&#39;t go into any detail). It turns out that quaternions don&#39;t have this nice behavior, and so they aren&#39;t useful, and vectors/matrices do, so we use them.

However, restricted to rigid rotations and descriptions that do not use any analytic structures, 3D rotations can be equivalently described either way (or a few other ways).

Generally, we just want a mapping of a point X = (x, y, z) to a new point X&#39; = (x&#39;, y&#39;, z&#39;) subject to the constraint that X&lt;sup&gt;2&lt;/sup&gt; = X&#39;&lt;sup&gt;2&lt;/sup&gt;. And there are lots of things that do this. 

The naive way is to just draw the triangles this defines and use trigonometry, or use the isomorphism between a point (x, y, z) and a vector (x, y, z) and the function f(X) = X&#39; and a matrix MX = X&#39;, or using quaternions, or projecting out components of the old vector along the new one using some other method (x, y, z)&lt;sup&gt;T&lt;/sup&gt;.(a,b,c) (x&#39;,y&#39;,z&#39;), etc.

From a math point of view, these descriptions are all equivalent in this setting (as a theorem). They all have the same number of degrees of freedom, the same number of constraints, etc.

So why do quaternions seem to preferred over vectors?

The usual reasons I see are no gimbal lock, or numerical issues.

The no gimbal lock argument seems odd, since this is only a problem of euler angles. It is also only a coordinate problem (just like the singularity at r=0 in polar coordinates (the Jacobian looses rank)), which means it is only a local problem, and can be resolved by switching coordinates, rotating out of the degeneracy, or using two overlapping coordinate systems. 

I&#39;m less sure about numerical issues, since I don&#39;t know in detail how both of these (and any alternatives) would be implemented. I&#39;ve read that re-normalizing a quaternion is easier than doing that for a rotation matrix, but this is only true for a general matrix; a rotation has additional constraints that trivializes this (which are built into the definition of quaternions) (In fact, this has to be true since they have the same number of degrees of freedom). 

So what is the reason for the use of quaternions over vectors or other alternatives? 

Why are quaternions used for rotations?

I am currently have a nx3 matrix array. I want plot the three columns as three axis&#39;s. 
How can I do that? 

I have googled and people suggested using **Matlab**, but I am really having a hard time with understanding it. I also need it be a scatter plot.

Can someone teach me? 


How to make a 3D scatter plot in matplotlib

For what purposes are we using Model View Projection Matrix?
Why do shaders require Model View Projection Matrix?

The purpose of Model View Projection Matrix

I use Jupyter Notebook to make analysis of datasets. There are a lot of plots in the notebook, and some of them are 3d plots. 

[![enter image description here][1]][1]

I&#39;m wondering if it is possible to make the 3d plot interactive, so I can later play with it in more details?

Maybe we can add a button on it? Clicking it can pop out a 3d plot and people can zoom, pan, rotate etc.

----

My thougths:

### 1. matplotlib, %qt
This does not fit my case, because I need to continue plot after the 3d plot. `%qt` will interfere with later plots.

### 2. mpld3
`mpld3` is almost ideal in my case, no need to rewrite anything, compatible with matplotlib. However, it only support 2D plot. And I didn&#39;t see any plan working on 3D (https://github.com/mpld3/mpld3/issues/223).

### 3. bokeh + visjs
Didn&#39;t find any actualy example of 3d plot in `bokeh` gallery. I only find https://demo.bokeh.org/surface3d, which uses `visjs`.

### 4. Javascript 3D plot?
Since what I need is just line and surce, is it possible to pass the data to js plot using js in the browser to make it interacive? (Then we may need to add 3d axis as well.) This may be similar to `visjs`, and `mpld3`.

  [1]: http://i.stack.imgur.com/cPwoQ.png

Python &amp; Matplotlib: Make 3D plot interactive in Jupyter Notebook

Sometimes you need to check whether you Linux 3D acceleration is really working (besides the `glxinfo` output). This can be quickly done by the `glxgears` tool. However, the FPS are often limited to the displays vertical refresh rate (i.e. 60 fps). So the tool becomes more or less useless since even a software render can produce 60FPS glxgears easily on modern CPUs. 

I found it rather hard to get a quick and easy solution for this, I answer my own question. Hopefully it saves your time.

Disable vertical sync for glxgears

I search how to plot something with less instruction as possible with Matplotlib but I don&#39;t find any help for this in the documentation.

I want to plot the following things:

- a wireframe cube centered in 0 with a side length of 2
- a &quot;wireframe&quot; sphere centered in 0 with a radius of 1
- a point at coordinates [0, 0, 0]
- a vector that starts at this point and goes to [1, 1, 1]

How to do that?

Plotting a 3d cube, a sphere and a vector in Matplotlib

I have recently learned about binary space partitioning trees and their application to 3d graphics and collision detection.  I have also briefly perused material relating to quadtrees and octrees.  When would you use quadtrees over bsp trees, or vice versa?  Are they interchangeable?  I would be satisfied if I had enough information to fill out a table like this:

                | BSP | Quadtree | Octree
    ------------+----------------+-------
    Situation A |  X  |          |
    Situation B |     |     X    |
    Situation C |     |          |   X

What are A, B, and C?

When to use Binary Space Partitioning, Quadtree, Octree?

I am trying to figure out what algorithms there are to do surface reconstruction from 3D range data. At a first glance, it seems that the *Ball pivoting algorithm* (**BPA**) and *Poisson surface reconstruction* are the more established methods?

- What are the established, more robust algorithm in the field other than BPA and Poisson surface reconstruction algorithm?
- Recommended research publications?
- Is there available source code?



robust algorithm for surface reconstruction from 3D point cloud?

I have 4 2D points in screen-space, and I need to reverse-project them back into 3D space. I know that each of the 4 points is a corner of a 3D-rotated rigid rectangle, and I know the size of the rectangle. How can I get 3D coordinates from this?

I am not using any particular API, and I do not have an existing projection matrix. I&#39;m just looking for basic math to do this. Of course there isn&#39;t enough data to convert a single 2D point to 3D with no other reference, but I imagine that if you have 4 points, you know that they&#39;re all at right-angles to each other on the same plane, and you know the distance between them, you should be able to figure it out from there. Unfortunately I can&#39;t quite work out how though.

This might fall under the umbrella of photogrammetry, but google searches for that haven&#39;t led me to any helpful information. 

How do I reverse-project 2D points into 3D?

I have quite a few objects in my scene so rotating all of them could be a pain. So what is the most easy way to move camera around origin on mouse click and drag? This way all the lights, objects in the scene are in the same location, so the only thing changing is the camera. Three.js does not provide a way to rotate a camera around a point, or does it?

Thank you

Rotate camera in Three.js with mouse

I have used a 3D iphone (.pod) model, its showing correctly in PVRShammon.

But when I imported that 3D model into isgl3D, its not showing correctly with the textured image, the image is covering only some of the areas of the object with some lines and triangles.





--------------------------------------------------------------------------------------------

    _cameraController = [[Isgl3dDemoCameraController alloc] initWithCamera:self.camera andView:self];
    _cameraController.orbit = 10;
    _cameraController.theta = 20;
    _cameraController.phi = 0;
    _cameraController.doubleTapEnabled = NO;
        

    Isgl3dPODImporter * podImporter = [Isgl3dPODImporter podImporterWithFile:@&quot;iPhone5Spod.pod&quot;];
    [podImporter printPODInfo];
    [podImporter buildSceneObjects];


    Isgl3dTextureMaterial *material2 = [[[Isgl3dTextureMaterial alloc] 
                                             initWithTextureFile:@&quot;DiffuseBody2.jpg&quot;  
                                             shininess:0.0  
                                             precision:Isgl3dTexturePrecisionHigh  
                                             repeatX:YES  
                                             repeatY:YES] autorelease];


    mesh2 = [podImporter meshAtIndex:4];
    node2 = [self.scene createNodeWithMesh: mesh2 andMaterial:material2];
    mesh2.normalizationEnabled = YES;
    node2.position = iv3(0, 0, 0);
    node2.rotationY = 180;
    [podImporter addMeshesToScene:self.scene];
    
    
    Isgl3dLight * light  = [Isgl3dLight lightWithHexColor:@&quot;FFFFFF&quot; diffuseColor:@&quot;FFFFFF&quot; specularColor:@&quot;FFFFFF&quot; attenuation:0.000];
    light.lightType = DirectionalLight;
    [light setDirection:-1 y:-1 z:0];
    
    
    [self setSceneAmbient:[Isgl3dColorUtil rgbString:[podImporter ambientColor]]];
    [self schedule:@selector(tick:)];

--------------------------------------------------------------------------------------------
For More Information Please have a look at the image.
[Output image in isgl3D view][1]




  

  [1]: http://i.stack.imgur.com/SDO4s.png

Texture Mapping in 3D Object (.pod) not happening correctly using isgl3D

I am making an android project in opengl es that uses accelerometer to calculate change in specific axes and my aim is to rotate my spacecraft-like object&#39;s movement vector. The problem is that i can&#39;t understand the math behind rotation matrices. Default movement vector is 0,1,0 , means +y, so the object looks upward in the beginning. and i am trying to rotate its movement vector so i can move the object where it points. I can gather rotation changes in phone. x-axis : rotate[0], y-axis : rotate[1], z-axis : rotate[2]. How can i rotate my movement vector using rotation matrix ?

Rotating a Vector in 3D Space

What I need is a signed angle of rotation between two vectors Va and Vb lying within the same 3D plane and having the same origin knowing that:

1. The plane contatining both vectors is an arbitrary and is not parallel to XY or any other of cardinal planes
2. Vn - is a plane normal
3. Both vectors along with the normal have the same origin O = { 0, 0, 0 }
4. Va - is a reference for measuring the left handed rotation at Vn

The angle should be measured in such a way so if the plane would be XY plane the Va would stand for X axis unit vector of it.

I guess I should perform a kind of coordinate space transformation by using the Va as the X-axis and the cross product of Vb and Vn as the Y-axis and then just using some 2d method like with atan2() or something. Any ideas? Formulas?

Signed angle between two 3D vectors with same origin within the same plane

I am currently working with using Bezier curves and surfaces to draw the famous Utah teapot. Using Bezier patches of 16 control points, I have been able to draw the teapot and display it using a &#39;world to camera&#39; function which gives the ability to rotate the resulting teapot, and am currently using an orthographic projection.

The result is that I have a &#39;flat&#39; teapot, which is expected as the purpose of an orthographic projection is to preserve parallel lines.

However, I would like to use a perspective projection to give the teapot depth. My question is, how does one take the 3D xyz vertex returned from the &#39;world to camera&#39; function, and convert this into a 2D coordinate. I am wanting to use the projection plane at z=0, and allow the user to determine the focal length and image size using the arrow keys on the keyboard.

I am programming this in java and have all of the input event handler set up, and have also written a matrix class which handles basic matrix multiplication. I&#39;ve been reading through wikipedia and other resources for a while, but I can&#39;t quite get a handle on how one performs this transformation. 


How to convert a 3D point into 2D perspective projection?

I have a 3-tuple data set (X,Y,Z points) that I want to plot using R.

I want to create a surface plot from the data, and superimpose a contour map on the surface plot, so as to create the impression of the contour map being the &quot;shadow&quot; or projection from the surface plot. The contour map is to appear below the surface plot.

My data set looks somewhat like this:

    Axis  |  Data Type
    -------------------
    X     |  Date value
    Y     |  Float value
    Z     |  Float value

How can I achieve this?


Plotting a 3D surface plot with contour map overlay, using R

Why are triangles always used for drawing surfaces in 3D? Why not a square or some other shape?

Why do 3D engines primarily use triangles to draw surfaces?

Back in the day it was easy; You made your own 3D stuff, then came DirectX, then came OpenGL. For .Net developers MDX was nice. Then XNA took over for MDX, but it its not the same. XNA seems to be very game-centric with all the content pipelining and preloading of fixed models and stuff.

So where do we stand now? After a couple of days of reasearch/trial&amp;error I feel everywhere I look I find half developed libraries, libraries with overhead, severe limitations or libraries that are overly complex.

I want to do &quot;free-hand&quot; 3D stuff. For instance displaying 200k dots on a screen in 3D and move them around at 30fps (Kinect depth image). I want to make 3D screensavers, audio analysis plugins, etc. All of which is not prefabs for a content pipeline, and which require high performance. And (ehm) I want to do it from .Net.

Anyone have experience with libraries that are easy/understandable and still gives some fair amount of freedom and speed?

What to use? Tao, SharpGL, OpenTK, DirectX P/Invoke, XNA, MDX, SlimDX, Windows API Codec Pack

I have been working on an area lighting implementation in WebGL similar to this demo:

http://threejs.org/examples/webgldeferred_arealights.html

The above implementation in three.js was ported from the work of ArKano22 over on gamedev.net:

http://www.gamedev.net/topic/552315-glsl-area-light-implementation/

Though these solutions are very impressive, they both have a few limitations. The primary issue with ArKano22&#39;s original implementation is that the calculation of the diffuse term does not account for surface normals.

I have been augmenting this solution for some weeks now, working with the improvements by redPlant to address this problem. Currently I have normal calculations incorporated into the solution, BUT the result is also flawed.

Here is a sneak preview of my current implementation:

![area lighting teaser][1]

## Introduction

The steps for calculating the diffuse term for each fragment is as follows:

1. Project the vertex onto the plane that the area light sits on, so that the projected vector is coincident with the light&#39;s normal/direction.
2. Check that the vertex is on the correct side of the area light plane by comparing the projection vector with the light&#39;s normal.
3. Calculate the 2D offset of this projected point on the plane from the light&#39;s center/position.
4. Clamp this 2D offset vector so that it sits inside the light&#39;s area (defined by its width and height).
5. Derive the 3D world position of the projected and clamped 2D point. This is the **nearest point** on the area light to the vertex.
6. Perform the usual diffuse calculations that you would for a point light by taking the dot product between the the vertex-to-nearest-point vector (normalised) and the vertex normal.

## Problem

The issue with this solution is that the lighting calculations are done from the **nearest point** and do not account for other points on the lights surface that could be illuminating the fragment even more so. Let me try and explain why…

Consider the following diagram:

![problematic area lighting situation][2]

The area light is both perpendicular to the surface and intersects it. Each of the fragments on the surface will always return a **nearest point** on the area light where the surface and the light intersect. Since the surface normal and the vertex-to-light vectors are always perpendicular, the dot product between them is zero. Subsequently, the calculation of the diffuse contribution is zero despite there being a large area of light looming over the surface.

## Potential Solution

I propose that rather than calculate the light from the **nearest point** on the area light, we calculate it from a point on the area light that yields the greatest dot product between the vertex-to-light vector (normalised) and the vertex normal. In the diagram above, this would be the purple dot, rather than the blue dot.

## Help!

And so, this is where I need your help. In my head, I have a pretty good idea of how this point can be derived, but don&#39;t have the mathematical competence to arrive at the solution.

Currently I have the following information available in my fragment shader:

* vertex position
* vertex normal (unit vector)
* light position, width and height
* light normal (unit vector)
* light right (unit vector)
* light up (unit vector)
* projected point from the vertex onto the lights plane (3D)
* projected point offset from the lights center (2D)
* clamped offset (2D)
* world position of this clamped offset – the **nearest point** (3D)

To put all this information into a visual context, I created this diagram (hope it helps):

![available lighting information][3]

To test my proposal, I need the **casting point** on the area light – represented by the red dots, so that I can perform the dot product between the vertex-to-casting-point (normalised) and the vertex normal. Again, this should yield the maximum possible contribution value.

# UPDATE!!!

I have created an interactive sketch over on CodePen that visualises the mathematics that I currently have implemented:

## http://codepen.io/wagerfield/pen/ywqCp

![codepen][4]

The relavent code that you should focus on is line **318**.

`castingPoint.location` is an instance of `THREE.Vector3` and is the missing piece of the puzzle. You should also notice that there are 2 values at the lower left of the sketch – these are dynamically updated to display the dot product between the relevant vectors.

I imagine that the solution would require another pseudo plane that aligns with the direction of the vertex normal AND is perpendicular to the light&#39;s plane, but I could be wrong!


  [1]: http://i.stack.imgur.com/4V5c0.png
  [2]: http://i.stack.imgur.com/ubZ4v.png
  [3]: http://i.stack.imgur.com/pZUEf.png
  [4]: http://i.stack.imgur.com/USld4.png

Improved Area Lighting in WebGL &amp; ThreeJS

Is it possible to create a simple 3D model (for example in 3DS MAX) and then import it to Android?

Is there a way to import a 3D model into Android?

I&#39;v always wondered this. In a game like [GTA][1] where there are 10s of thousands of objects, how does the game know as soon as you&#39;re on a health pack?

There can&#39;t possibly be an event listener for each object? Iterating isn&#39;t good either? I&#39;m just wondering how it&#39;s actually done.

  [1]: http://en.wikipedia.org/wiki/Grand_Theft_Auto_%28series%29


How does 3D collision / object detection work?

I have a 3D dataset:

    data = data.frame(
    	x = rep( c(0.1, 0.2, 0.3, 0.4, 0.5), each=5),
    	y = rep( c(1, 2, 3, 4, 5), 5)
    )

    data$z = runif(
    	25,
    	min = (data$x*data$y - 0.1 * (data$x*data$y)),
    	max = (data$x*data$y + 0.1 * (data$x*data$y))
    )

    data
    str(data)

And I want to plot it, but the built-in-functions of R alwyas give the error 

&gt; increasing &#39;x&#39; and &#39;y&#39; values expected

    # ### 3D Plots ######################################################
    # built-in function always give the error
    #    &quot;increasing &#39;x&#39; and &#39;y&#39; values expected&quot;
    demo(image)
    image(x = data$x, y = data$y, z = data$z)

    demo(persp)
    persp(data$x,data$y,data$z)

    contour(data$x,data$y,data$z)

When I searched on the internet, I found that this message happens when combinations of X and Y values are not unique. But here they are unique.


I tried some other libraries and there it works without problems. But I don&#39;t like the default style of the plots (the built-in functions should fulfill my expectations).

    # ### 3D Scatterplot ######################################################
    # Nice plots without surface maps?
    install.packages(&quot;scatterplot3d&quot;, dependencies = TRUE)
    library(scatterplot3d)
    scatterplot3d(x = data$x, y = data$y, z = data$z)

    # ### 3D Scatterplot ######################################################
    # Only to play around?
    install.packages(&quot;rgl&quot;, dependencies = TRUE)
    library(rgl)
    plot3d(x = data$x, y = data$y, z = data$z)
    lines3d(x = data$x, y = data$y, z = data$z)
    surface3d(x = data$x, y = data$y, z = data$z)

Why are my datasets not accepted by the built-in functions?


Plot 3D data in R

I&#39;d like to get a list of all the uniforms &amp; attribs used by a shader program object.  `glGetAttribLocation()` &amp; `glGetUniformLocation()` can be used to map a string to a location, but what I would really like is the list of strings without having to parse the glsl code.

Note: In OpenGL 2.0 `glGetObjectParameteriv()` is replaced by `glGetProgramiv()`.  And the enum is `GL_ACTIVE_UNIFORMS` &amp; `GL_ACTIVE_ATTRIBUTES`.


In OpenGL is there a way to get a list of all uniforms &amp; attribs used by a shader program?

I have a mesh that I want to rotate by 90 degrees inside Three JS. 
Here is the image of the current situation:
![enter image description here][1]


  [1]: http://i.stack.imgur.com/v0tPX.png

I want the selected mesh to be rotated parallelly to the large mesh.
I have tried rotating the matrix like this:

    matrix =   new THREE.Matrix4().makeRotationX(1.57)

But the mesh goes into strange rotations. Is there any easier way to rotate it by 90 degrees ? 

How can I rotate a mesh by 90 degrees in ThreeJS?

I am searching for a graph which has **3 dimensions (x, y, and z)** and uses **D3.js**. Please let me know if there are any data visualization site where I can find such graph or if there is one on [d3js.org][1] that I have missed  out somehow.


  [1]: http://d3js.org

3 dimension (X, Y and Z) graph using D3.js

assuming the texture, vertex, and shader data are already on the graphics card, you don&#39;t need to send much data to the card. there&#39;s a few bytes to identify the data, and presumably a 4x4 matrix, and some assorted other parameters.

so where is all of the overhead coming from? do the operations require a handshake of some sort with the gpu?

why is sending a single mesh containing a bunch of small models, calculated on the CPU, often faster than sending the vertex id and transformation matrices? (the second option looks like there should be less data sent, unless the models are smaller than a 4x4 matrix)

why are draw calls expensive?

I have used WPF&#39;s 3D capabilities for learning, and for a few implementations, and I have found it to be very capable, and I am also learning DirectX 11, and it is very tricky compared to using 3D classes in WPF. I have only used WPF 3D for very basic stuff, my question is:

Is WPF 3D equally good for advanced applications such as 3D modelling tools, game engines and 3D simulations etc to be an alternative to DirectX and OpenGL?

If there is anything else in the same league, please mention it too.

Is WPF 3D good alternate of DirectX and OpenGL for complex applications?

What is the preferred 3d model format of THREE.JS which is widely used by 3d modelling softwares (can export to that format). I ask this, because I have my 3d models in an own unique format, and would like to use them in THREE.JS. While I could write an own loader, but I think it&#39;s better to convert them to a standard format.



All 3d Solutions on Gang of Coders

Total of 28 3d Solutions