fork(2) download
copy 
  1. /*==============================================================================
  2. Copyright (c) 2010-2013 QUALCOMM Austria Research Center GmbH.
  3. All Rights Reserved.
  4.  
  5. @file 
  6.     FrameMarkers.cpp
  7.  
  8. @brief
  9.     Sample for FrameMarkers
  10.  
  11. ==============================================================================*/
  12.  
  13.  
  14. #include <jni.h>
  15. #include <android/log.h>
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <assert.h>
  19.  
  20. #include <GLES2/gl2.h>
  21. #include <GLES2/gl2ext.h>
  22.  
  23. #include <QCAR/QCAR.h>
  24. #include <QCAR/CameraDevice.h>
  25. #include <QCAR/Renderer.h>
  26. #include <QCAR/VideoBackgroundConfig.h>
  27. #include <QCAR/Trackable.h>
  28. #include <QCAR/TrackableResult.h>
  29. #include <QCAR/MarkerResult.h>
  30. #include <QCAR/Tool.h>
  31. #include <QCAR/MarkerTracker.h>
  32. #include <QCAR/TrackerManager.h>
  33. #include <QCAR/CameraCalibration.h>
  34. #include <QCAR/Marker.h>
  35.  
  36. #include "SampleUtils.h"
  37. #include "Texture.h"
  38. #include "CubeShaders.h"
  39. #include "Q_object.h"
  40. #include "C_object.h"
  41. #include "A_object.h"
  42. #include "R_object.h"
  43.  
  44. #include "assimp_loader.h"
  45.  
  46. #ifdef __cplusplus
  47. extern "C"
  48. {
  49. #endif
  50.  
  51. // Textures:
  52. int textureCount                = 0;
  53. Texture** textures              = 0;
  54.  
  55. // OpenGL ES 2.0 specific:
  56. unsigned int shaderProgramID    = 0;
  57. GLint vertexHandle              = 0;
  58. GLint normalHandle              = 0;
  59. GLint textureCoordHandle        = 0;
  60. GLint mvpMatrixHandle           = 0;
  61. GLint texSampler2DHandle        = 0;
  62.  
  63. // Screen dimensions:
  64. unsigned int screenWidth        = 0;
  65. unsigned int screenHeight       = 0;
  66.  
  67. // Indicates whether screen is in portrait (true) or landscape (false) mode
  68. bool isActivityInPortraitMode   = false;
  69.  
  70. // The projection matrix used for rendering virtual objects:
  71. QCAR::Matrix44F projectionMatrix;
  72.  
  73. // Constants:
  74. static const float kLetterScale        = 25.0f;
  75. static const float kLetterTranslate    = 25.0f;
  76.  
  77. JNIEXPORT void JNICALL
  78. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_setActivityPortraitMode(JNIEnv *, jobject, jboolean isPortrait)
  79. {
  80.     isActivityInPortraitMode = isPortrait;
  81. }
  82.  
  83.  
  84. JNIEXPORT int JNICALL
  85. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_initTracker(JNIEnv *, jobject)
  86. {
  87.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_initTracker");
  88.  
  89.     // Initialize the marker tracker:
  90.     QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
  91.     QCAR::Tracker* trackerBase = trackerManager.initTracker(QCAR::Tracker::MARKER_TRACKER);
  92.     QCAR::MarkerTracker* markerTracker = static_cast<QCAR::MarkerTracker*>(trackerBase);
  93.     if (markerTracker == NULL)
  94.     {
  95.         LOG("Failed to initialize MarkerTracker.");
  96.         return 0;
  97.     }
  98.  
  99.     if (!markerTracker->createFrameMarker(0, "MarkerQ", QCAR::Vec2F(50,50)))
  100.     {
  101.         LOG("Failed to create frame marker Q.");
  102.     }
  103.     if (!markerTracker->createFrameMarker(1, "MarkerC", QCAR::Vec2F(50,50)))
  104.     {
  105.         LOG("Failed to create frame marker C.");
  106.     }
  107.     if (!markerTracker->createFrameMarker(2, "MarkerA", QCAR::Vec2F(50,50)))
  108.     {
  109.         LOG("Failed to create frame marker A.");
  110.     }
  111.     if (!markerTracker->createFrameMarker(3, "MarkerR", QCAR::Vec2F(50,50)))
  112.     {
  113.         LOG("Failed to create frame marker R.");
  114.     }
  115.  
  116.     LOG("Successfully initialized MarkerTracker.");
  117.  
  118.     return 1;
  119. }
  120.  
  121.  
  122. JNIEXPORT void JNICALL
  123.     Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_deinitTracker(JNIEnv *, jobject)
  124. {
  125.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_deinitTracker");
  126.  
  127.     // Deinit the marker tracker, this will destroy all created frame markers:
  128.     QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
  129.     trackerManager.deinitTracker(QCAR::Tracker::MARKER_TRACKER);
  130. }
  131.  
  132.  
  133. JNIEXPORT void JNICALL
  134. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkersRenderer_renderFrame(JNIEnv *, jobject)
  135. {
  136.     //LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_GLRenderer_renderFrame");
  137.  
  138.     // Clear color and depth buffer 
  139.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  140.  
  141.     // Get the state from QCAR and mark the beginning of a rendering section
  142.     QCAR::State state = QCAR::Renderer::getInstance().begin();
  143.  
  144.     // Explicitly render the Video Background
  145.     QCAR::Renderer::getInstance().drawVideoBackground();
  146.  
  147.     glEnable(GL_DEPTH_TEST);
  148.  
  149.     // We must detect if background reflection is active and adjust the culling direction. 
  150.     // If the reflection is active, this means the post matrix has been reflected as well,
  151.     // therefore standard counter clockwise face culling will result in "inside out" models. 
  152.     glEnable(GL_CULL_FACE);
  153.     glCullFace(GL_BACK);
  154.     if(QCAR::Renderer::getInstance().getVideoBackgroundConfig().mReflection == QCAR::VIDEO_BACKGROUND_REFLECTION_ON)
  155.         glFrontFace(GL_CW);  //Front camera
  156.     else
  157.         glFrontFace(GL_CCW);   //Back camera
  158.  
  159.     // Did we find any trackables this frame?
  160.     for(int tIdx = 0; tIdx < state.getNumTrackableResults(); tIdx++)
  161.     {
  162.         // Get the trackable:
  163.         const QCAR::TrackableResult* trackableResult = state.getTrackableResult(tIdx);
  164.         QCAR::Matrix44F modelViewMatrix =
  165.             QCAR::Tool::convertPose2GLMatrix(trackableResult->getPose());        
  166.  
  167.         // Choose the texture based on the target name:
  168.         int textureIndex = 0;
  169.  
  170.         // Check the type of the trackable:
  171.         assert(trackableResult->getType() == QCAR::TrackableResult::MARKER_RESULT);
  172.         const QCAR::MarkerResult* markerResult = static_cast<
  173.                                     const QCAR::MarkerResult*>(trackableResult);
  174.         const QCAR::Marker& marker = markerResult->getTrackable();
  175.  
  176.         const aiScene* scene = assimp_getCurrentAiScene();
  177.         textureIndex = marker.getMarkerId();
  178.         if (scene && textureIndex == 0) {
  179.             textureIndex = 4;
  180.         }
  181.  
  182.         assert(textureIndex < textureCount);
  183.  
  184.         const Texture* const thisTexture = textures[textureIndex];
  185.  
  186.         // Select which model to draw:
  187.         const GLvoid* vertices = 0;
  188.         const GLvoid* normals = 0;
  189.         const GLvoid* indices = 0;
  190.         const GLvoid* texCoords = 0;
  191.         int numIndices = 0;
  192.  
  193.         switch (marker.getMarkerId())
  194.         {
  195.         case 0:
  196. 			if (scene) {
  197. 				char logStr[300];
  198. 				sprintf(logStr, "We have %d vertices, %d normals, %d faces, %d indexes and %d texture coordinates to render",
  199. 						scene->mMeshes[0]->mNumVertices,
  200. 						scene->mMeshes[0]->mNumVertices,
  201. 						scene->mMeshes[0]->mNumFaces,
  202. 						scene->mMeshes[0]->mFaces->mNumIndices,
  203. 						scene->mMeshes[0]->mNumVertices
  204. 						);
  205. 				LOG(logStr);
  206. 				vertices = scene->mMeshes[0]->mVertices;
  207. 				normals = scene->mMeshes[0]->mNormals;
  208. 				indices = scene->mMeshes[0]->mFaces->mIndices;
  209. 				texCoords = scene->mMeshes[0]->mTextureCoords;
  210. 				numIndices = scene->mMeshes[0]->mFaces->mNumIndices;
  211. 			} else {
  212. 				vertices = &QobjectVertices[0];
  213. 				normals = &QobjectNormals[0];
  214. 				indices = &QobjectIndices[0];
  215. 				texCoords = &QobjectTexCoords[0];
  216. 				numIndices = NUM_Q_OBJECT_INDEX;
  217. 			}
  218.             break;
  219.         case 1:
  220.             vertices = &CobjectVertices[0];
  221.             normals = &CobjectNormals[0];
  222.             indices = &CobjectIndices[0];
  223.             texCoords = &CobjectTexCoords[0];
  224.             numIndices = NUM_C_OBJECT_INDEX;
  225.             break;
  226.         case 2:
  227.             vertices = &AobjectVertices[0];
  228.             normals = &AobjectNormals[0];
  229.             indices = &AobjectIndices[0];
  230.             texCoords = &AobjectTexCoords[0];
  231.             numIndices = NUM_A_OBJECT_INDEX;
  232.             break;
  233.         default:
  234.             vertices = &RobjectVertices[0];
  235.             normals = &RobjectNormals[0];
  236.             indices = &RobjectIndices[0];
  237.             texCoords = &RobjectTexCoords[0];
  238.             numIndices = NUM_R_OBJECT_INDEX;
  239.             break;
  240.         }
  241.  
  242.         QCAR::Matrix44F modelViewProjection;
  243.  
  244.         SampleUtils::translatePoseMatrix(-kLetterTranslate,
  245.                                          -kLetterTranslate,
  246.                                          0.f,
  247.                                          &modelViewMatrix.data[0]);
  248.         SampleUtils::scalePoseMatrix(kLetterScale, kLetterScale, kLetterScale,
  249.                                      &modelViewMatrix.data[0]);
  250.         SampleUtils::multiplyMatrix(&projectionMatrix.data[0],
  251.                                     &modelViewMatrix.data[0],
  252.                                     &modelViewProjection.data[0]);
  253.  
  254.         glUseProgram(shaderProgramID);
  255.  
  256.         SampleUtils::checkGlError("[assimp] after glUseProgram");
  257.  
  258.         glVertexAttribPointer(vertexHandle, 3, GL_FLOAT, GL_FALSE, 0, vertices);
  259.         SampleUtils::checkGlError("[assimp] after glVertexAttribPointer vertices");
  260.         glVertexAttribPointer(normalHandle, 3, GL_FLOAT, GL_FALSE, 0, normals);
  261.         SampleUtils::checkGlError("[assimp] after glVertexAttribPointer normals");
  262.         glVertexAttribPointer(textureCoordHandle, 2, GL_FLOAT, GL_FALSE,
  263.                               0, texCoords);
  264.         SampleUtils::checkGlError("[assimp] after glVertexAttribPointer texCoords");
  265.  
  266.         glEnableVertexAttribArray(vertexHandle);
  267.         SampleUtils::checkGlError("[assimp] after glEnableVertexAttribArray vertex handle");
  268.         glEnableVertexAttribArray(normalHandle);
  269.         SampleUtils::checkGlError("[assimp] after glEnableVertexAttribArray normal handle");
  270.         glEnableVertexAttribArray(textureCoordHandle);
  271.         SampleUtils::checkGlError("[assimp] after glEnableVertexAttribArray textureCoord handle");
  272.  
  273.         glActiveTexture(GL_TEXTURE0);
  274.         SampleUtils::checkGlError("[assimp] after glActiveTexture");
  275.         glBindTexture(GL_TEXTURE_2D, thisTexture->mTextureID);
  276.         SampleUtils::checkGlError("[assimp] after glBindTexture");
  277.         glUniformMatrix4fv(mvpMatrixHandle, 1, GL_FALSE,
  278.                            (GLfloat*)&modelViewProjection.data[0]);
  279.         SampleUtils::checkGlError("[assimp] after glUniformMatrix4fv");
  280.         glUniform1i(texSampler2DHandle, 0 /*GL_TEXTURE0*/);
  281.         SampleUtils::checkGlError("[assimp] after glUniform1i");
  282.         glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, indices);
  283.         SampleUtils::checkGlError("[assimp] after glDrawElements");
  284.  
  285.         glDisableVertexAttribArray(vertexHandle);
  286.         glDisableVertexAttribArray(normalHandle);
  287.         glDisableVertexAttribArray(textureCoordHandle);
  288.  
  289.         SampleUtils::checkGlError("FrameMarkers render frame");
  290.  
  291.     }
  292.  
  293.     glDisable(GL_DEPTH_TEST);
  294.  
  295.     QCAR::Renderer::getInstance().end();
  296. }
  297.  
  298.  
  299. void
  300. configureVideoBackground()
  301. {
  302.     // Get the default video mode:
  303.     QCAR::CameraDevice& cameraDevice = QCAR::CameraDevice::getInstance();
  304.     QCAR::VideoMode videoMode = cameraDevice.
  305.                                 getVideoMode(QCAR::CameraDevice::MODE_DEFAULT);
  306.  
  307.     // Configure the video background
  308.     QCAR::VideoBackgroundConfig config;
  309.     config.mEnabled = true;
  310.     config.mSynchronous = true;
  311.     config.mPosition.data[0] = 0.0f;
  312.     config.mPosition.data[1] = 0.0f;
  313.  
  314.     if (isActivityInPortraitMode)
  315.     {
  316.         //LOG("configureVideoBackground PORTRAIT");
  317.         config.mSize.data[0] = videoMode.mHeight
  318.                                 * (screenHeight / (float)videoMode.mWidth);
  319.         config.mSize.data[1] = screenHeight;
  320.  
  321.         if(config.mSize.data[0] < screenWidth)
  322.         {
  323.             LOG("Correcting rendering background size to handle missmatch between screen and video aspect ratios.");
  324.             config.mSize.data[0] = screenWidth;
  325.             config.mSize.data[1] = screenWidth * 
  326.                               (videoMode.mWidth / (float)videoMode.mHeight);
  327.         }
  328.     }
  329.     else
  330.     {
  331.         //LOG("configureVideoBackground LANDSCAPE");
  332.         config.mSize.data[0] = screenWidth;
  333.         config.mSize.data[1] = videoMode.mHeight
  334.                             * (screenWidth / (float)videoMode.mWidth);
  335.  
  336.         if(config.mSize.data[1] < screenHeight)
  337.         {
  338.             LOG("Correcting rendering background size to handle missmatch between screen and video aspect ratios.");
  339.             config.mSize.data[0] = screenHeight
  340.                                 * (videoMode.mWidth / (float)videoMode.mHeight);
  341.             config.mSize.data[1] = screenHeight;
  342.         }
  343.     }
  344.  
  345.     LOG("Configure Video Background : Video (%d,%d), Screen (%d,%d), mSize (%d,%d)", videoMode.mWidth, videoMode.mHeight, screenWidth, screenHeight, config.mSize.data[0], config.mSize.data[1]);
  346.  
  347.     // Set the config:
  348.     QCAR::Renderer::getInstance().setVideoBackgroundConfig(config);
  349. }
  350.  
  351.  
  352. JNIEXPORT void JNICALL
  353. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_initApplicationNative(
  354.                             JNIEnv* env, jobject obj, jint width, jint height)
  355. {
  356.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_initApplicationNative");
  357.  
  358.     // Store screen dimensions
  359.     screenWidth = width;
  360.     screenHeight = height;
  361.  
  362.     // Handle to the activity class:
  363.     jclass activityClass = env->GetObjectClass(obj);
  364.  
  365.     jmethodID getTextureCountMethodID = env->GetMethodID(activityClass,
  366.                                                     "getTextureCount", "()I");
  367.     if (getTextureCountMethodID == 0)
  368.     {
  369.         LOG("Function getTextureCount() not found.");
  370.         return;
  371.     }
  372.  
  373.     textureCount = env->CallIntMethod(obj, getTextureCountMethodID);    
  374.     if (!textureCount)
  375.     {
  376.         LOG("getTextureCount() returned zero.");
  377.         return;
  378.     }
  379.  
  380.     textures = new Texture*[textureCount];
  381.  
  382.     jmethodID getTextureMethodID = env->GetMethodID(activityClass,
  383.         "getTexture", "(I)Lcom/qualcomm/QCARSamples/FrameMarkers/Texture;");
  384.  
  385.     if (getTextureMethodID == 0)
  386.     {
  387.         LOG("Function getTexture() not found.");
  388.         return;
  389.     }
  390.  
  391.     // Register the textures
  392.     for (int i = 0; i < textureCount; ++i)
  393.     {
  394.  
  395.         jobject textureObject = env->CallObjectMethod(obj, getTextureMethodID, i); 
  396.         if (textureObject == NULL)
  397.         {
  398.             LOG("GetTexture() returned zero pointer");
  399.             return;
  400.         }
  401.  
  402.         textures[i] = Texture::create(env, textureObject);
  403.     }
  404.  
  405.     bool success = assimp_importAsset("collada/m11_BBJ94_13WishesDollAsst.dae");
  406.     if (success) {
  407.         const aiScene* scene = assimp_getCurrentAiScene();
  408.         if (scene->HasAnimations()) {
  409.             LOG("[assimp] scene has animations");
  410.         }
  411.         if (scene->HasCameras()) {
  412.             LOG("[assimp] scene has cameras");
  413.         }
  414.         if (scene->HasLights()) {
  415.             LOG("[assimp] scene has lights");
  416.         }
  417.         if (scene->HasMaterials()) {
  418.             LOG("[assimp] scene has materials");
  419.         }
  420.         if (scene->HasMeshes()) {
  421.             LOG("[assimp] scene has meshes");
  422.         }
  423.         if (scene->HasTextures()) {
  424.             LOG("[assimp] scene has textures");
  425.         }
  426.  
  427.     	char tmpNum[15];
  428.     	char logScene[1000];
  429.     	strcpy(logScene, "[assimp] Scene with ");
  430.     	sprintf(tmpNum, "%d", scene->mNumAnimations);
  431.     	strcat(logScene, tmpNum);
  432.     	strcat(logScene, " animations, ");
  433.     	sprintf(tmpNum, "%d", scene->mNumCameras);
  434.     	strcat(logScene, tmpNum);
  435.     	strcat(logScene, " cameras, ");
  436.     	sprintf(tmpNum, "%d", scene->mNumLights);
  437.     	strcat(logScene, tmpNum);
  438.     	strcat(logScene, " lights, ");
  439.     	sprintf(tmpNum, "%d", scene->mNumMaterials);
  440.     	strcat(logScene, tmpNum);
  441.     	strcat(logScene, " materials, ");
  442.     	sprintf(tmpNum, "%d", scene->mNumMeshes);
  443.     	strcat(logScene, tmpNum);
  444.     	strcat(logScene, " meshes, ");
  445.     	sprintf(tmpNum, "%d", scene->mNumTextures);
  446.     	strcat(logScene, tmpNum);
  447.     	strcat(logScene, " textures");
  448.         LOG(logScene);
  449.     }
  450. }
  451.  
  452.  
  453. JNIEXPORT void JNICALL
  454. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_deinitApplicationNative(
  455.                                                         JNIEnv* env, jobject obj)
  456. {
  457.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_deinitApplicationNative");
  458.  
  459.     // Release texture resources
  460.     if (textures != 0)
  461.     {    
  462.         for (int i = 0; i < textureCount; ++i)
  463.         {
  464.             delete textures[i];
  465.             textures[i] = NULL;
  466.         }
  467.  
  468.         delete[]textures;
  469.         textures = NULL;
  470.  
  471.         textureCount = 0;
  472.     }
  473. }
  474.  
  475.  
  476. JNIEXPORT void JNICALL
  477. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_startCamera(JNIEnv *,
  478.                                                                          jobject)
  479. {
  480.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_startCamera");
  481.  
  482.     // Select the camera to open, set this to QCAR::CameraDevice::CAMERA_FRONT 
  483.     // to activate the front camera instead.
  484.     QCAR::CameraDevice::CAMERA camera = QCAR::CameraDevice::CAMERA_DEFAULT;
  485.  
  486.     // Initialize the camera:
  487.     if (!QCAR::CameraDevice::getInstance().init(camera))
  488.         return;
  489.  
  490.     // Configure the video background
  491.     configureVideoBackground();
  492.  
  493.     // Select the default mode:
  494.     if (!QCAR::CameraDevice::getInstance().selectVideoMode(
  495.                                 QCAR::CameraDevice::MODE_DEFAULT))
  496.         return;
  497.  
  498.     // Start the camera:
  499.     if (!QCAR::CameraDevice::getInstance().start())
  500.         return;
  501.  
  502.     // Start the tracker:
  503.     QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
  504.     QCAR::Tracker* markerTracker = trackerManager.getTracker(QCAR::Tracker::MARKER_TRACKER);
  505.     if(markerTracker != 0)
  506.         markerTracker->start();
  507. }
  508.  
  509.  
  510. JNIEXPORT void JNICALL
  511. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_stopCamera(JNIEnv *,
  512.                                                                    jobject)
  513. {
  514.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_stopCamera");
  515.  
  516.     // Stop the tracker:
  517.     QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
  518.     QCAR::Tracker* markerTracker = trackerManager.getTracker(QCAR::Tracker::MARKER_TRACKER);
  519.     if(markerTracker != 0)
  520.         markerTracker->stop();
  521.  
  522.     QCAR::CameraDevice::getInstance().stop();
  523.     QCAR::CameraDevice::getInstance().deinit();
  524. }
  525.  
  526. JNIEXPORT void JNICALL
  527. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_setProjectionMatrix(JNIEnv *, jobject)
  528. {
  529.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_setProjectionMatrix");
  530.  
  531.     // Cache the projection matrix:
  532.     const QCAR::CameraCalibration& cameraCalibration =
  533.                                 QCAR::CameraDevice::getInstance().getCameraCalibration();
  534.     projectionMatrix = QCAR::Tool::getProjectionGL(cameraCalibration, 2.0f, 2500.0f);
  535. }
  536.  
  537.  
  538. JNIEXPORT jboolean JNICALL
  539. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_autofocus(JNIEnv*, jobject)
  540. {
  541.     return QCAR::CameraDevice::getInstance().setFocusMode(QCAR::CameraDevice::FOCUS_MODE_TRIGGERAUTO) ? JNI_TRUE : JNI_FALSE;
  542. }
  543.  
  544. JNIEXPORT jboolean JNICALL
  545. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkers_setFocusMode(JNIEnv*, jobject, jint mode)
  546. {
  547.     int qcarFocusMode;
  548.  
  549.     switch ((int)mode)
  550.     {
  551.         case 0:
  552.             qcarFocusMode = QCAR::CameraDevice::FOCUS_MODE_NORMAL;
  553.             break;
  554.  
  555.         case 1:
  556.             qcarFocusMode = QCAR::CameraDevice::FOCUS_MODE_CONTINUOUSAUTO;
  557.             break;
  558.  
  559.         case 2:
  560.             qcarFocusMode = QCAR::CameraDevice::FOCUS_MODE_INFINITY;
  561.             break;
  562.  
  563.         case 3:
  564.             qcarFocusMode = QCAR::CameraDevice::FOCUS_MODE_MACRO;
  565.             break;
  566.  
  567.         default:
  568.             return JNI_FALSE;
  569.     }
  570.  
  571.     return QCAR::CameraDevice::getInstance().setFocusMode(qcarFocusMode) ? JNI_TRUE : JNI_FALSE;
  572. }
  573.  
  574.  
  575. JNIEXPORT void JNICALL
  576. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkersRenderer_initRendering(
  577.                                                     JNIEnv* env, jobject obj)
  578. {
  579.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkersRenderer_initRendering");
  580.  
  581.     // Define clear color
  582.     glClearColor(0.0f, 0.0f, 0.0f, QCAR::requiresAlpha() ? 0.0f : 1.0f);
  583.  
  584.     // Now generate the OpenGL texture objects and add settings
  585.     for (int i = 0; i < textureCount; ++i)
  586.     {
  587.     	char logTxt[100];
  588.     	sprintf(logTxt, "[assimp] Binding Texture %d", i);
  589.     	LOG(logTxt);
  590. 		sprintf(logTxt, "[assimp] Texture ID=%d (%d x %d)", textures[i]->mTextureID, textures[i]->mWidth, textures[i]->mHeight);
  591. 		LOG(logTxt);
  592.         glGenTextures(1, &(textures[i]->mTextureID));
  593.         LOG("[assimp] glGenTextures()");
  594.         glBindTexture(GL_TEXTURE_2D, textures[i]->mTextureID);
  595.         LOG("[assimp] glBindTexture()");
  596.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  597.         LOG("[assimp] glTexParameterf()");
  598.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  599.         LOG("[assimp] glTexParameterf()");
  600.             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textures[i]->mWidth,
  601.                 textures[i]->mHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
  602.                 (GLvoid*)  textures[i]->mData);
  603.             LOG("[assimp] glTexImage2D()");
  604.     }
  605.     LOG("[assimp] All textures have been binded");
  606.  
  607.     const aiScene* scene = assimp_getCurrentAiScene();
  608.     if (scene) {
  609.     	// TODO ?
  610.     }
  611.  
  612.     shaderProgramID     = SampleUtils::createProgramFromBuffer(cubeMeshVertexShader,
  613.                                                             cubeFragmentShader);
  614.  
  615.     vertexHandle        = glGetAttribLocation(shaderProgramID,
  616.                                                 "vertexPosition");
  617.     normalHandle        = glGetAttribLocation(shaderProgramID,
  618.                                                 "vertexNormal");
  619.     textureCoordHandle  = glGetAttribLocation(shaderProgramID,
  620.                                                 "vertexTexCoord");
  621.     mvpMatrixHandle     = glGetUniformLocation(shaderProgramID,
  622.                                                 "modelViewProjectionMatrix");
  623.     texSampler2DHandle  = glGetUniformLocation(shaderProgramID, 
  624.                                                 "texSampler2D");
  625. }
  626.  
  627.  
  628. JNIEXPORT void JNICALL
  629. Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkersRenderer_updateRendering(
  630.                         JNIEnv* env, jobject obj, jint width, jint height)
  631. {
  632.     LOG("Java_com_qualcomm_QCARSamples_FrameMarkers_FrameMarkersRenderer_updateRendering");
  633.  
  634.     // Update screen dimensions
  635.     screenWidth = width;
  636.     screenHeight = height;
  637.  
  638.     // Reconfigure the video background
  639.     configureVideoBackground();
  640. }
  641.  
  642.  
  643. #ifdef __cplusplus
  644. }
  645. #endif
  646.  
Not running #stdin #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/8ifDKv
Error I get:

08-21 17:13:59.387: D/QCAR(23901): We have 66462 vertices, 66462 normals, 122532 faces, 3 indexes and 66462 texture coordinates to render
08-21 17:13:59.387: W/Adreno200-ES20(23901): <gl_draw_error_checks:550>: GL_INVALID_OPERATION
08-21 17:13:59.387: D/QCAR(23901): after [assimp] after glDrawElements() glError (0x502)
language:
C++ (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!