I tried removing that line but I get the same crash...

I get this problem both on my Galaxy Nexus and on my tablet (with 4.0.3).

The tablet throws this error to LogCat constantly (although it seems to be working exactly the same as the nexus):

01-21 17:29:29.409: E/SurfaceTexture(2074): [unnamed-2074-3] dequeueBuffer: no available buffer slots

I tried to use this one:
setEGLConfigChooser(5,6,5,0,16,0);

but I get a crash on the ContextFactory:

01-21 15:04:31.037: I/QCAR(8209): Creating OpenGL ES 2.0 context
01-21 15:04:31.045: W/dalvikvm(8209): threadid=14: thread exiting with uncaught exception (group=0x41cef930)
01-21 15:04:31.045: E/AndroidRuntime(8209): FATAL EXCEPTION: GLThread 760
01-21 15:04:31.045: E/AndroidRuntime(8209): java.lang.RuntimeException: createContext failed: EGL_SUCCESS
01-21 15:04:31.045: E/AndroidRuntime(8209): at android.opengl.GLSurfaceView$EglHelper.throwEglException(GLSurfaceView.java:1193)
01-21 15:04:31.045: E/AndroidRuntime(8209): at android.opengl.GLSurfaceView$EglHelper.throwEglException(GLSurfaceView.java:1184)
01-21 15:04:31.045: E/AndroidRuntime(8209): at android.opengl.GLSurfaceView$EglHelper.start(GLSurfaceView.java:1034)
01-21 15:04:31.045: E/AndroidRuntime(8209): at android.opengl.GLSurfaceView$GLThread.guardedRun(GLSurfaceView.java:1401)
01-21 15:04:31.045: E/AndroidRuntime(8209): at android.opengl.GLSurfaceView$GLThread.run(GLSurfaceView.java:1240)


I'm not sure I follow understand how this initialization process works. 

It says depth size is 24.

I just checked... after calling init() my depthBuffer is still 16... I used Eclipse's debug mode to check. Don't know if there's a better/more reliable way to check this.

[attachment deleted by admin]

The Config chooser is saying my depth buffer size is 16 so I guess it's activated.

The objects themselves shouldn't have any transparency, they load nicely in the helloworld demo. Anyway I tried setting it to -1 as you said, but it changed nothing...

I have this obj model of a building, which I tried both on the jpct and jpct-ae helloworld demos, with good results:



Now if I try this same model in my vuforia - jpct-ae integration it shows up like this, with some meshes overlapping others:



I tried another obj model in the vuforia+jpct-ae and it rendered without this problem.

The piece of code used to load and render the model is the same in both cases:


                     torre = Loader.loadOBJ(mActivity.getResources().openRawResource(R.raw.torresola), mActivity.getResources().openRawResource(R.raw.torremat), 10.0f);
torreSingle = Object3D.mergeAll(torre);
world.addObject(torreSingle);

Also, i'm posting Vuiforia's demo own config chooser, maybe that's were the problem is. Or maybe its because the use of OpenGL ES 2.0?

/*==============================================================================
            Copyright (c) 2010-2012 QUALCOMM Austria Research Center GmbH.
            All Rights Reserved.
            Qualcomm Confidential and Proprietary
==============================================================================*/

package com.qualcomm.QCARSamples.ImageTargets;

import com.qualcomm.QCAR.QCAR;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;

import android.content.Context;
import android.graphics.PixelFormat;
import android.opengl.GLSurfaceView;

/**
* QCARSampleGLView is a support class for the QCAR samples applications.
* Responsible for setting up and configuring the OpenGL surface view.
*/
public class QCARSampleGLView extends GLSurfaceView {
private static boolean mUseOpenGLES2 = true;

/** Constructor. */
public QCARSampleGLView(Context context) {
super(context);
}

/** Initialization. */
public void init(int flags, boolean translucent, int depth, int stencil) {
// By default GLSurfaceView tries to find a surface that is as close
// as possible to a 16-bit RGB frame buffer with a 16-bit depth buffer.
// This function can override the default values and set custom values.

// Extract OpenGL ES version from flags
mUseOpenGLES2 = (flags & QCAR.GL_20) != 0;

// By default, GLSurfaceView() creates a RGB_565 opaque surface.
// If we want a translucent one, we should change the surface's
// format here, using PixelFormat.TRANSLUCENT for GL Surfaces
// is interpreted as any 32-bit surface with alpha by SurfaceFlinger.

DebugLog.LOGI("Using OpenGL ES " + (mUseOpenGLES2 ? "2.0" : "1.x"));
DebugLog.LOGI("Using " + (translucent ? "translucent" : "opaque") + " GLView, depth buffer size: " + depth + ", stencil size: " + stencil);

// If required set translucent format to allow camera image to
// show through in the background
if (translucent) {
this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
}
// Setup the context factory for 1.x / 2.0 rendering
setEGLContextFactory(new ContextFactory());

// We need to choose an EGLConfig that matches the format of
// our surface exactly. This is going to be done in our
// custom config chooser. See ConfigChooser class definition
// below.
setEGLConfigChooser(translucent ? new ConfigChooser(8, 8, 8, 8, depth, stencil) : new ConfigChooser(5, 6, 5, 0, depth, stencil));


}

/** Creates OpenGL contexts. */
private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
EGLContext context;
if (mUseOpenGLES2) {
DebugLog.LOGI("Creating OpenGL ES 2.0 context");
checkEglError("Before eglCreateContext", egl);
int[] attrib_list_gl20 = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list_gl20);
} else {
DebugLog.LOGI("Creating OpenGL ES 1.x context");
checkEglError("Before eglCreateContext", egl);
int[] attrib_list_gl1x = { EGL_CONTEXT_CLIENT_VERSION, 1, EGL10.EGL_NONE };
context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list_gl1x);
}

checkEglError("After eglCreateContext", egl);
return context;
}

public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
egl.eglDestroyContext(display, context);
}
}

/** Checks the OpenGL error. */
private static void checkEglError(String prompt, EGL10 egl) {
int error;
while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
DebugLog.LOGE(String.format("%s: EGL error: 0x%x", prompt, error));
}
}

/** The config chooser. */
private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
mRedSize = r;
mGreenSize = g;
mBlueSize = b;
mAlphaSize = a;
mDepthSize = depth;
mStencilSize = stencil;
}

private EGLConfig getMatchingConfig(EGL10 egl, EGLDisplay display, int[] configAttribs) {
// Get the number of minimally matching EGL configurations
int[] num_config = new int[1];
egl.eglChooseConfig(display, configAttribs, null, 0, num_config);

int numConfigs = num_config[0];
if (numConfigs <= 0)
throw new IllegalArgumentException("No matching EGL configs");

// Allocate then read the array of minimally matching EGL configs
EGLConfig[] configs = new EGLConfig[numConfigs];
egl.eglChooseConfig(display, configAttribs, configs, numConfigs, num_config);

// Now return the "best" one
return chooseConfig(egl, display, configs);
}

public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
if (mUseOpenGLES2) {
// This EGL config specification is used to specify 2.0
// rendering. We use a minimum size of 4 bits for
// red/green/blue, but will perform actual matching in
// chooseConfig() below.
final int EGL_OPENGL_ES2_BIT = 0x0004;
final int[] s_configAttribs_gl20 = { EGL10.EGL_RED_SIZE, 4, EGL10.EGL_GREEN_SIZE, 4, EGL10.EGL_BLUE_SIZE, 4, EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL10.EGL_NONE };

return getMatchingConfig(egl, display, s_configAttribs_gl20);
} else {
final int EGL_OPENGL_ES1X_BIT = 0x0001;
final int[] s_configAttribs_gl1x = { EGL10.EGL_RED_SIZE, 5, EGL10.EGL_GREEN_SIZE, 6, EGL10.EGL_BLUE_SIZE, 5, EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES1X_BIT, EGL10.EGL_NONE };

return getMatchingConfig(egl, display, s_configAttribs_gl1x);
}
}

public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display, EGLConfig[] configs) {
for (EGLConfig config : configs) {
int d = findConfigAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
int s = findConfigAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);

// We need at least mDepthSize and mStencilSize bits
if (d < mDepthSize || s < mStencilSize)
continue;

// We want an *exact* match for red/green/blue/alpha
int r = findConfigAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);

if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
return config;
}

return null;
}

private int findConfigAttrib(EGL10 egl, EGLDisplay display, EGLConfig config, int attribute, int defaultValue) {

if (egl.eglGetConfigAttrib(display, config, attribute, mValue))
return mValue[0];

return defaultValue;
}

// Subclasses can adjust these values:
protected int mRedSize;
protected int mGreenSize;
protected int mBlueSize;
protected int mAlphaSize;
protected int mDepthSize;
protected int mStencilSize;
private int[] mValue = new int[1];
}
}


EDIT: correction: it does happen with other models as well.

Those sound like promising approaches. I will try them, thanks!

just one more question, I read here: http://www.jpct.net/forum2/index.php?topic=3005.0

that the modelview matrix needs some transformations before applying it in JPCT-AE.

I just took the matrix and directly applied it to the camera like this:


com.threed.jpct.Matrix _cameraMatrix = new com.threed.jpct.Matrix();;
SimpleVector _cameraPosition = new SimpleVector();

_camer4aPosition.set(modelViewMat[3],modelViewMat[7],modelViewMat[11]);
modelViewMat[3] = modelViewMat[7] = modelViewMat[11] = 0;

_cameraMatrix.setDump(modelViewMat);
//_cameraMatrix = _cameraMatrix.invert();

cam.setBack(_cameraMatrix);
cam.setPosition(_cameraPosition);


And seems to be working fine. Maybe I am missing something here? Do I actually need to transform the matrix in any way?

I was thinking of doing something similar to this:

https://www.youtube.com/watch?v=dUBxHd3bMhg (from 1:25)

And maybe this is a very stupid and simple question, but how would you restrict the rendering to that specific area? I know Portal rendering has something to do with this but I think it isn't included in JPCT-AE and it's not really that used anymore.

Is it possible to achieve something like this with jpct-ae?

Yes, that worked

Yes, that was it. Thanks!

Is it possible to make the background transparent? Using a RGBA color when calling clear() does not do it.

I do initialize it, like this:

mGlView = new QCARSampleGLView(this);

getWindow().setFormat(PixelFormat.TRANSLUCENT);

mRenderer = new ImageTargetsRenderer(this);
mGlView.setRenderer(mRenderer);


the init() method of QCARSampleGlView just sets the config.

Anyway here's the stacktrace:

01-17 17:40:02.776: I/jPCT-AE(24147): OpenGL version:    OpenGL ES 2.0 build 1.8@905891
01-17 17:40:02.776: I/jPCT-AE(24147): OpenGL renderer initialized (using 0 texture stages)
01-17 17:40:02.776: E/libEGL(24147): called unimplemented OpenGL ES API
01-17 17:40:02.776: E/libEGL(24147): called unimplemented OpenGL ES API
01-17 17:40:02.776: E/libEGL(24147): called unimplemented OpenGL ES API
01-17 17:40:02.776: I/jPCT-AE(24147): [ 1358440802791 ] - WARNING: State: 0/0/0/0/0/0/0
01-17 17:40:02.831: W/dalvikvm(24147): threadid=13: thread exiting with uncaught exception (group=0x40e57930)
01-17 17:40:02.839: E/AndroidRuntime(24147): FATAL EXCEPTION: GLThread 46650
01-17 17:40:02.839: E/AndroidRuntime(24147): java.lang.ArrayIndexOutOfBoundsException: length=0; index=0
01-17 17:40:02.839: E/AndroidRuntime(24147): at com.threed.jpct.CompiledInstance._fill(CompiledInstance.java:1206)
01-17 17:40:02.839: E/AndroidRuntime(24147): at com.threed.jpct.CompiledInstance.fill(CompiledInstance.java:746)
01-17 17:40:02.839: E/AndroidRuntime(24147): at com.threed.jpct.Object3DCompiler.compile(Object3DCompiler.java:148)
01-17 17:40:02.839: E/AndroidRuntime(24147): at com.threed.jpct.World.compile(World.java:1951)
01-17 17:40:02.839: E/AndroidRuntime(24147): at com.threed.jpct.World.renderScene(World.java:1046)
01-17 17:40:02.839: E/AndroidRuntime(24147): at com.qualcomm.QCARSamples.ImageTargets.ImageTargetsRenderer.onDrawFrame(ImageTargetsRenderer.java:134)
01-17 17:40:02.839: E/AndroidRuntime(24147): at android.opengl.GLSurfaceView$GLThread.guardedRun(GLSurfaceView.java:1516)
01-17 17:40:02.839: E/AndroidRuntime(24147): at android.opengl.GLSurfaceView$GLThread.run(GLSurfaceView.java:1240)

I know there are a few posts regarding this integration already, but they are all of a point much more advanced that the one I am

I am trying to integrate the basic ImageTargets from Vuforia with JPCT-AE's simple HelloWorld demo, but I am facing some problems.

First I started from Vuforia's code, using their extension of GlSurfaceView. Then on ImageRendered I pasted the code from JPCT's hello world, like this:

public ImageTargetsRenderer(ImageTargets activity) {

this.mActivity = activity;

world = new World();
world.setAmbientLight(20, 20, 20);
sun = new Light(world);
sun.setIntensity(250, 250, 250);

// Create a texture out of the icon...:-)
Texture texture = new Texture(BitmapHelper.rescale(BitmapHelper.convert(mActivity.getResources().getDrawable(R.drawable.ic_launcher)), 64, 64));
TextureManager.getInstance().addTexture("texture", texture);

cube = Primitives.getCube(10);
cube.calcTextureWrapSpherical();
cube.setTexture("texture");
cube.strip();
cube.build();

world.addObject(cube);

Camera cam = world.getCamera();
cam.moveCamera(Camera.CAMERA_MOVEOUT, 50);
cam.lookAt(cube.getTransformedCenter());

SimpleVector sv = new SimpleVector();
sv.set(cube.getTransformedCenter());
sv.y -= 100;
sv.z -= 100;
sun.setPosition(sv);
MemoryHelper.compact();
}

/** Called when the surface is created or recreated. */
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
DebugLog.LOGD("GLRenderer::onSurfaceCreated");

// Call native function to initialize rendering:
initRendering();

// Call QCAR function to (re)initialize rendering after first use
// or after OpenGL ES context was lost (e.g. after onPause/onResume):
QCAR.onSurfaceCreated();
}

/** Called when the surface changed size. */
public void onSurfaceChanged(GL10 gl, int width, int height) {
DebugLog.LOGD("GLRenderer::onSurfaceChanged");

// Call native function to update rendering when render surface
// parameters have changed:
updateRendering(width, height);

// Call QCAR function to handle render surface size changes:
QCAR.onSurfaceChanged(width, height);

if (fb != null) {
fb.dispose();
}
fb = new FrameBuffer(gl, width, height);

}

/** The native render function. */
public native void renderFrame();

/** Called to draw the current frame. */
public void onDrawFrame(GL10 gl) {

fb.clear(back);
world.renderScene(fb);
world.draw(fb);
fb.display();

if (!mIsActive)
return;

// Update render view (projection matrix and viewport) if needed:
mActivity.updateRenderView();
// Call our native function to render content
renderFrame();

}
:
But when I launch my app I get an ArrayIndexOutOfBounds error on the world.renderScene method. If I comment vuforia's mGlView.init() code:

public void init(int flags, boolean translucent, int depth, int stencil) {
// By default GLSurfaceView tries to find a surface that is as close
// as possible to a 16-bit RGB frame buffer with a 16-bit depth buffer.
// This function can override the default values and set custom values.

// Extract OpenGL ES version from flags
mUseOpenGLES2 = (flags & QCAR.GL_20) != 0;

// By default, GLSurfaceView() creates a RGB_565 opaque surface.
// If we want a translucent one, we should change the surface's
// format here, using PixelFormat.TRANSLUCENT for GL Surfaces
// is interpreted as any 32-bit surface with alpha by SurfaceFlinger.

DebugLog.LOGI("Using OpenGL ES " + (mUseOpenGLES2 ? "2.0" : "1.x"));
DebugLog.LOGI("Using " + (translucent ? "translucent" : "opaque") + " GLView, depth buffer size: " + depth + ", stencil size: " + stencil);

// If required set translucent format to allow camera image to
// show through in the background
if (translucent) {
this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
}
// Setup the context factory for 1.x / 2.0 rendering
setEGLContextFactory(new ContextFactory());

// We need to choose an EGLConfig that matches the format of
// our surface exactly. This is going to be done in our
// custom config chooser. See ConfigChooser class definition
// below.
setEGLConfigChooser(translucent ? new ConfigChooser(8, 8, 8, 8, depth, stencil) : new ConfigChooser(5, 6, 5, 0, depth, stencil));

}

/** Creates OpenGL contexts. */
private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
EGLContext context;
if (mUseOpenGLES2) {
DebugLog.LOGI("Creating OpenGL ES 2.0 context");
checkEglError("Before eglCreateContext", egl);
int[] attrib_list_gl20 = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list_gl20);
} else {
DebugLog.LOGI("Creating OpenGL ES 1.x context");
checkEglError("Before eglCreateContext", egl);
int[] attrib_list_gl1x = { EGL_CONTEXT_CLIENT_VERSION, 1, EGL10.EGL_NONE };
context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list_gl1x);
}

checkEglError("After eglCreateContext", egl);
return context;
}

public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
egl.eglDestroyContext(display, context);
}
}

Then my app runs but I get "called unimplemented OpenGL ES API" errors constnatly.

Am I approaching anything badly here?