登录 注册
OSG中国官方论坛-有您OSG在中国才更好»论坛 › 技术交流 › OpenSceneGraph › FBO实现SKYBOX
返回列表 发新帖
查看: 9010|回复: 3

FBO实现SKYBOX

[复制链接]
lglgaigogo

该用户从未签到
发表于 2012-12-7 15:34:14 | 显示全部楼层 |阅读模式
1.最近在玩Ladybug3相机。想用它现实一个AR系统，现在刚开始，要求用osg实现。但是Ladybug的例子程序是OpenGL的，我没有学过OpenGL啊。有一个程序不知道怎么改成OSG的。
2.这个程序的大概过程是，Ladybug的成像处理都在显卡中的，它直接把显卡中的某块数据做为Skybox的一个面的贴图。
ladybugRenderOffScreenImage()把图像从相机输入到显卡中
ladybugGetOpenGLTextureID()   获得显卡中OpenGL贴图的ID
glBindTexture()                            绑定贴图


希望各位能看一下，看看应该怎么把它改成osg的。我之所非要这么弄是因为先把图像保存再贴图到一个cubemap上的过程实在是太慢了，这个我已经试过了，如下：
QQ截图20121207153307.png


程序代码如下：
  1. //=============================================================================
  2. // Copyright ?2010 Point Grey Research, Inc. All Rights Reserved.
  3. //
  4. // This software is the confidential and proprietary information of Point
  5. // Grey Research, Inc. ("Confidential Information").  You shall not
  6. // disclose such Confidential Information and shall use it only in
  7. // accordance with the terms of the license agreement you entered into
  8. // with Point Grey Research, Inc. (PGR).
  9. //
  10. // PGR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  11. // SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
  12. // IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  13. // PURPOSE, OR NON-INFRINGEMENT. PGR SHALL NOT BE LIABLE FOR ANY DAMAGES
  14. // SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  15. // THIS SOFTWARE OR ITS DERIVATIVES.

  17. //=============================================================================
  18. //
  19. // ladybugEnvMap.cpp
  20. //
  21. //=============================================================================
  22. // This example illustrates how to apply cube mapping on Ladybug's spherical
  23. // images to construct a skybox.
  24. // In computer graphics, cube mapping is a type of environment mapping used to
  25. // simulate surfaces that reflect the scene at a distant location.
  26. // Here, Ladybug images are used as the environment and are updated in real
  27. // time.
  28. // For each scene, six surfaces of a cube are rendered.
  29. // This is done by rendering Ladybug's spherical view 6 times, setting the
  30. // field of view to 90 degrees and positioning the virtual camera to specific
  31. // surface directions. These rendering results are then used as textures for the
  32. // cube mapping.
  33. // The overall scene, which is comprised of the reflective objects,
  34. // is then rendered.
  35. // All calculations required to construct the cube map are handled inside the
  36. // OpenGL library.
  37. //
  38. // Note: This example must be run with freeglut.dll present.
  39. //
  40. //=============================================================================
  41. //=============================================================================
  42. // System Includes
  43. //=============================================================================
  44. #pragma warning(disable:4786) //Ignore identifier truncation warning in GLUT
  45. #pragma warning(disable:4244)  // suppress warning : conversion from 'int' to 'glh::ns_float::real', possible loss of data
  46. #pragma warning(disable:704)  // suppress warning : truncation from 'double' to 'float'

  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #include <windows.h>
  51. #include <assert.h>
  52. #include <GL/glew.h>
  53. #include <GL/freeglut.h>
  54. #include <glh/glh_glut.h>
  55. //=============================================================================
  56. // PGR Includes
  57. //=============================================================================
  58. #include <ladybug.h>
  59. #include <ladybuggeom.h>
  60. #include <ladybugRenderer.h>

  62. //=============================================================================
  63. // Project Includes
  64. //=============================================================================

  66. using namespace glh;

  68. #define UPDATE_SURFACE

  70. //
  71. // Define some error handlers
  72. //
  73. #define _HANDLE_ERROR \
  74.    if( error != LADYBUG_OK ) \
  75. { \
  76.    printf( "Error! Ladybug library reported %s\n", \
  77.    ladybugErrorToString( error ) ); \
  78.    assert( false ); \
  79.    exit( 1 ); \
  80. } \

  82. #define _DISPLAY_ERROR_MSG \
  83.    if( error != LADYBUG_OK ) \
  84. { \
  85.    printf( "Ladybug library reported %s\n", \
  86.    ladybugErrorToString( error ) ); \
  87. } \
  88.    
  89. #define _DISPLAY_ERROR_MSG_AND_RETURN \
  90.    if( error != LADYBUG_OK ) \
  91. { \
  92.    printf( "Ladybug library reported %s\n", \
  93.    ladybugErrorToString( error ) ); \
  94.    return; \
  95. } \

  97. //
  98. // Define various constants
  99. //
  100. #define            PI                    3.1415926535f

  102. #define CUBE_TEX_SIZE 512
  103. #define NUM_CUBE_SURFACES  6

  105. const GLenum cube_map_targets[ NUM_CUBE_SURFACES] = {
  106.    GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
  107.    GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
  108.    GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
  109.    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
  110.    GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
  111.    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
  112. };

  114. const double sphere_view_params[ NUM_CUBE_SURFACES][ 3] = {
  115.    { PI, 0.0, PI},
  116.    { PI, 0.0, 0.0},
  117.    { PI/2.0, PI/2.0, 0.0},
  118.    { -PI/2.0, -PI/2.0, 0.0},
  119.    { PI, 0.0, -PI/2.0},
  120.    { PI, 0.0, PI/2.0}
  121. };

  123. static const GLubyte colors[ NUM_CUBE_SURFACES][ 3] = {
  124.    { 255,   0,   0 }, // red
  125.    {   0, 255, 255 }, // cyan
  126.    {   0, 255,   0 }, // green
  127.    { 255,   0, 255 }, // magenda
  128.    {   0,   0, 255 }, // blue
  129.    { 255, 255,   0 }  // yellow
  130. };

  132. enum
  133. {
  134.    MENU_TEAPOT,
  135.    MENU_SPHERE,
  136.    MENU_CUBE,
  137.    MENU_EXIT
  138. };

  140. int displayMode = MENU_TEAPOT;

  142. //
  143. // The GLUT mouse interactor. it is used automatically to deal with
  144. // mouse inputs.
  145. //
  146. glut_simple_mouse_interactor object;

  148. //
  149. // Various global variables used in the example
  150. //
  151. LadybugContext                context;
  152. LadybugError                error;
  153. LadybugImage                image;
  154. bool                        b[256];
  155. GLuint                  fbos[NUM_CUBE_SURFACES];
  156. GLuint                  fboTexture;
  157. int                     menu;  
  158. GLUquadricObj           *quadric;  // for sphere

  160. void
  161. handleGLError( const char* pszString )
  162. {
  163.    GLenum error = glGetError();
  164.    
  165.    if ( error != GL_NO_ERROR )
  166.    {
  167.           char  pszErrorText[ 512 ];

  169.           sprintf(
  170.          pszErrorText,
  171.          "OpenGL Error: %s: #(%d) %s\n",
  172.          pszString,
  173.          error,
  174.          ::gluErrorString( error ) );

  176.           fprintf( stderr, pszErrorText );
  177.    }
  178. }

  180. //=============================================================================
  181. //
  182. // Clean up
  183. //
  184. //=============================================================================
  185. void
  186. cleanUp()
  187. {
  188.    printf( "Stopping camera...\n" );
  189.    error = ladybugStop( context );
  190.    _HANDLE_ERROR;

  192.    printf( "Release off-screen image resource...\n" );
  193.    error = ladybugReleaseOffScreenImage(context, LADYBUG_SPHERICAL );
  194.    _HANDLE_ERROR;

  196.    printf( "Destroying context...\n" );
  197.    error = ladybugDestroyContext( &context );
  198.    _HANDLE_ERROR;

  200.    gluDeleteQuadric( quadric);

  202.    glDeleteTextures( 1, &fboTexture);

  204.    glDeleteFramebuffersEXT( NUM_CUBE_SURFACES, &fbos[0]);

  206.    return;
  207. }

  209. void
  210. selectFromMenu( int iCommand )
  211. {  
  212.    if ( iCommand == MENU_EXIT )
  213.    {
  214.           cleanUp();
  215.           exit (0);
  216.    }
  217.    else
  218.    {
  219.           displayMode = iCommand;
  220.    }
  221. }

  223. int
  224. buildPopupMenu (void)
  225. {
  226.    menu = glutCreateMenu( selectFromMenu );

  228.    glutAddMenuEntry(
  229.           "Teapot",
  230.           MENU_TEAPOT );
  231.    
  232.    glutAddMenuEntry(
  233.           "Sphere",
  234.           MENU_SPHERE );

  236.    glutAddMenuEntry(
  237.           "Cube",
  238.           MENU_CUBE);

  240.    glutAddMenuEntry(
  241.           "Exit",
  242.           MENU_EXIT );

  244.    return 0;
  245. }


  248. void init_checkers( void )
  249. {
  250.    GLubyte *image = new GLubyte[ CUBE_TEX_SIZE * CUBE_TEX_SIZE * 3];
  251.    GLint i, j, f;

  253.    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

  255.    /* make colored checkerboard cube faces */
  256.    for (f = 0; f < NUM_CUBE_SURFACES; f++) {
  257.           for (i = 0; i < CUBE_TEX_SIZE; i++) {
  258.                  for (j = 0; j < CUBE_TEX_SIZE; j++) {
  259.                         if ((i/4 + j/4) & 1) {
  260.                            image[ ( i + j * CUBE_TEX_SIZE) * 3 + 0 ] = colors[f][0];
  261.                            image[ ( i + j * CUBE_TEX_SIZE) * 3 + 1 ] = colors[f][1];
  262.                            image[ ( i + j * CUBE_TEX_SIZE) * 3 + 2 ] = colors[f][2];
  263.                         }
  264.                         else {
  265.                            image[ ( i + j * CUBE_TEX_SIZE) * 3 + 0 ] = 255;
  266.                            image[ ( i + j * CUBE_TEX_SIZE) * 3 + 1 ] = 255;
  267.                            image[ ( i + j * CUBE_TEX_SIZE) * 3 + 2 ] = 255;
  268.                         }
  269.                  }
  270.           }

  272.           glTexImage2D( cube_map_targets[f], 0, GL_RGB, CUBE_TEX_SIZE, CUBE_TEX_SIZE, 0,
  273.                                    GL_RGB, GL_UNSIGNED_BYTE, image);
  274.           handleGLError( "glTexImage2D");
  275.    }

  277.    delete []image;
  278. }

  280. void
  281. initEnvMap( void)
  282. {
  283.    GLenum res;

  285.    glGenTextures( 1, &fboTexture);
  286.    
  287.    glBindTexture( GL_TEXTURE_CUBE_MAP, fboTexture);
  288.    handleGLError( "glBindTexture");
  289.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  290.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  291.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
  292.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  293.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  294.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_LOD, 0 );
  295.    glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LOD, 3 );

  297.    init_checkers();

  299.    glGenFramebuffersEXT( NUM_CUBE_SURFACES, &fbos[0]);
  300.    handleGLError( "glGenFramebuffersEXT");

  302.    for ( int i = 0; i < NUM_CUBE_SURFACES; i++){

  304.           glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbos[i]);
  305.           handleGLError( "glBindFramebufferEXT");

  307.           //Attach 2D texture to this FBO
  308.           glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, cube_map_targets[ i], fboTexture, 0);
  309.           handleGLError( "glFramebufferTexture2DEXT");

  311.           res = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT);
  312.           if ( res != GL_FRAMEBUFFER_COMPLETE_EXT)
  313.           {
  314.                  printf( "Failed - glCheckFramebufferStatusEXT = %X\n", res);
  315.           }
  316.    }
  317.    
  318.    // unbind
  319.    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  320.    handleGLError( "glBindFramebufferEXT - unbind");

  322.    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
  323.    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
  324.    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);

  326.    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  327.    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  328.    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  329.    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

  331.    // init for sphere
  332.    quadric=gluNewQuadric();
  333.    gluQuadricNormals( quadric, GLU_SMOOTH);
  334.    gluQuadricTexture( quadric, GL_TRUE);
  335. }

  337. void drawCube()
  338. {
  339.    glBegin(GL_QUADS);

  341.    // Front Face
  342.    glNormal3f( 0.0f, 0.0f, 1.0f);
  343.    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
  344.    glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
  345.    glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
  346.    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
  347.    // Back Face
  348.    glNormal3f( 0.0f, 0.0f,-1.0f);
  349.    glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
  350.    glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
  351.    glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
  352.    glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  353.    // Top Face
  354.    glNormal3f( 0.0f, 1.0f, 0.0f);
  355.    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
  356.    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
  357.    glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
  358.    glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
  359.    // Bottom Face
  360.    glNormal3f( 0.0f,-1.0f, 0.0f);
  361.    glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
  362.    glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  363.    glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
  364.    glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
  365.    // Right face
  366.    glNormal3f( 1.0f, 0.0f, 0.0f);
  367.    glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  368.    glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
  369.    glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
  370.    glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
  371.    // Left Face
  372.    glNormal3f(-1.0f, 0.0f, 0.0f);
  373.    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
  374.    glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
  375.    glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
  376.    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);

  378.    glEnd();
  379. }

  381. void drawSkybox( void )
  382. {
  383.    const GLfloat br = 20.0; /* box radius */

  385.    glBegin(GL_QUADS);

  387.    /* +X side */
  388.    glTexCoord3f(1.0, -1.0, -1.0);  glVertex3f(br, -br, -br);
  389.    glTexCoord3f(1.0, -1.0,  1.0);  glVertex3f(br, -br,  br);
  390.    glTexCoord3f(1.0,  1.0,  1.0);  glVertex3f(br,  br,  br);
  391.    glTexCoord3f(1.0,  1.0, -1.0);  glVertex3f(br,  br, -br);

  393.    /* -X side */
  394.    glTexCoord3f(-1.0,  1.0, -1.0);  glVertex3f(-br,  br, -br);
  395.    glTexCoord3f(-1.0,  1.0,  1.0);  glVertex3f(-br,  br,  br);
  396.    glTexCoord3f(-1.0, -1.0,  1.0);  glVertex3f(-br, -br,  br);
  397.    glTexCoord3f(-1.0, -1.0, -1.0);  glVertex3f(-br, -br, -br);

  399.    /* +Y side */
  400.    glTexCoord3f(-1.0, 1.0, -1.0);  glVertex3f(-br,  br, -br);
  401.    glTexCoord3f(-1.0, 1.0,  1.0);  glVertex3f(-br,  br,  br);
  402.    glTexCoord3f( 1.0, 1.0,  1.0);  glVertex3f( br,  br,  br);
  403.    glTexCoord3f( 1.0, 1.0, -1.0);  glVertex3f( br,  br, -br);

  405.    /* -Y side */
  406.    glTexCoord3f(-1.0, -1.0, -1.0);  glVertex3f(-br, -br, -br);
  407.    glTexCoord3f(-1.0, -1.0,  1.0);  glVertex3f(-br, -br,  br);
  408.    glTexCoord3f( 1.0, -1.0,  1.0);  glVertex3f( br, -br,  br);
  409.    glTexCoord3f( 1.0, -1.0, -1.0);  glVertex3f( br, -br, -br);

  411.    /* +Z side */
  412.    glTexCoord3f( 1.0, -1.0, 1.0);  glVertex3f( br, -br, br);
  413.    glTexCoord3f(-1.0, -1.0, 1.0);  glVertex3f(-br, -br, br);
  414.    glTexCoord3f(-1.0,  1.0, 1.0);  glVertex3f(-br,  br, br);
  415.    glTexCoord3f( 1.0,  1.0, 1.0);  glVertex3f( br,  br, br);

  417.    /* -Z side */
  418.    glTexCoord3f( 1.0,  1.0, -1.0);  glVertex3f( br,  br, -br);
  419.    glTexCoord3f(-1.0,  1.0, -1.0);  glVertex3f(-br,  br, -br);
  420.    glTexCoord3f(-1.0, -1.0, -1.0);  glVertex3f(-br, -br, -br);
  421.    glTexCoord3f( 1.0, -1.0, -1.0);  glVertex3f( br, -br, -br);

  423.    glEnd();
  424. }

  426. void drawUnitSquare( void)
  427. {
  428.    glBegin( GL_QUADS);

  430.    glTexCoord2d( 0.0, 1.0); glVertex3f( 0.0, 0.0, 0.0);
  431.    glTexCoord2d( 1.0, 1.0); glVertex3f( 1.0, 0.0, 0.0);
  432.    glTexCoord2d( 1.0, 0.0); glVertex3f( 1.0, 1.0, 0.0);
  433.    glTexCoord2d( 0.0, 0.0); glVertex3f( 0.0, 1.0, 0.0);

  435.    glEnd();
  436. }

  438. //=============================================================================
  439. //
  440. // Start the first Ladybug camera on the bus
  441. //
  442. //=============================================================================
  443. int  
  444. startCamera()
  445. {   
  446.    //
  447.    // Initialize context.
  448.    //
  449.    printf( "Creating Ladybug context...\n" );
  450.    error = ladybugCreateContext( &context );
  451.    _HANDLE_ERROR;
  452.    
  453.    //
  454.    // Initialize the first ladybug on the bus.
  455.    //
  456.    printf( "Initializing first camera on the bus...\n" );
  457.    error = ladybugInitializeFromIndex( context, 0 );
  458.    _HANDLE_ERROR;
  459.    
  460.    //
  461.    // Start Ladybug2/Ladybug3 with JPEG data format
  462.    //
  463.    printf( "Starting camera in JPEG mode...\n" );
  464.    error = ladybugStart(
  465.           context,
  466.           LADYBUG_RESOLUTION_ANY,
  467.           LADYBUG_DATAFORMAT_COLOR_SEP_SEQUENTIAL_JPEG);
  468.    _HANDLE_ERROR;
  469.    
  470.    //
  471.    // Load config file from the head
  472.    //
  473.    printf( "Loading config info...\n" );
  474.    error = ladybugLoadConfig( context, NULL );
  475.    _HANDLE_ERROR;
  476.    
  477.    //
  478.    // Grab one image
  479.    //
  480.    printf( "Grabbing an image..\n" );
  481.    error = LADYBUG_FAILED;
  482.    for ( int i = 0; i < 10 && error != LADYBUG_OK; i++)
  483.    {
  484.           error = ladybugGrabImage( context, &image);
  485.    }
  486.    if ( error != LADYBUG_OK)
  487.    {
  488.           _HANDLE_ERROR;
  489.    }

  491.    //
  492.    // Set color processing method to quarter downsample
  493.    //
  494.    error = ladybugSetColorProcessingMethod( context, LADYBUG_DOWNSAMPLE4 );
  495.    _HANDLE_ERROR;

  497.    return 0;
  498. }

  500. //=============================================================================
  501. // Draw for environment mapping
  502. //=============================================================================
  503. void drawEnvironmentMapping( void)
  504. {
  505.    unsigned int                *puiTextureID = 0;

  507.    error = ladybugSetSphericalViewParams( context, 90.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
  508.    error = ladybugRenderOffScreenImage( context, LADYBUG_SPHERICAL, LADYBUG_BGR, NULL);
  509.    _DISPLAY_ERROR_MSG;

  511.    float validWidth, validHeight;
  512.    error = ladybugGetOpenGLTextureID(
  513.           context, LADYBUG_SPHERICAL, &puiTextureID, &validWidth, &validHeight );
  514.    _DISPLAY_ERROR_MSG;

  516.    //保存获取到的图片
  517.    LadybugProcessedImage processedImage;

  519.    glPushAttrib (GL_ALL_ATTRIB_BITS);

  521. #ifdef UPDATE_SURFACE
  522.    // update the 6 cube surfaces using the spherical view's rendering output.
  523.    for ( int f = 0; f < NUM_CUBE_SURFACES; f++)
  524.    {
  525.           // bind FBO
  526.           glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbos[ f]);
  527.           handleGLError( "glBindFramebufferEXT");

  529.           GLenum res = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT);
  530.           if ( res != GL_FRAMEBUFFER_COMPLETE_EXT)
  531.           {
  532.                  printf( "Failed - glCheckFramebufferStatusEXT = %X\n", res);
  533.           }
  534.           
  535.           glViewport( 0, 0, CUBE_TEX_SIZE, CUBE_TEX_SIZE);

  537.           glClearColor( colors[f][0], colors[f][1], colors[f][2], 0.0f);
  538.           glClearDepth( 1.0);   
  539.           glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

  541.           glDisable(GL_TEXTURE_GEN_S);
  542.           glDisable(GL_TEXTURE_GEN_T);
  543.           glDisable(GL_TEXTURE_GEN_R);

  545.           glEnable( GL_TEXTURE_2D);
  546.           glDisable( GL_TEXTURE_CUBE_MAP);

  548.           glMatrixMode( GL_PROJECTION);
  549.           glPushMatrix();
  550.           glLoadIdentity();
  551.           gluOrtho2D( 0.0, 1.0, 0.0, 1.0);

  553.           glMatrixMode( GL_MODELVIEW);
  554.           glPushMatrix();      
  555.           glLoadIdentity();

  557.           error = ladybugSetSphericalViewParams( context,
  558.                                                                                          90.0,
  559.                                                                                          sphere_view_params[ f][ 0],
  560.                                                                                          sphere_view_params[ f][ 1],
  561.                                                                                          sphere_view_params[ f][ 2],
  562.                                                                                          0.0,
  563.                                                                                          0.0,
  564.                                                                                          0.0);
  565.           //把立方体的6个面渲染到processedImage这个结构体中
  566.           error = ladybugRenderOffScreenImage( context, LADYBUG_SPHERICAL, LADYBUG_BGR, NULL/*&processedImage*/);
  567.           _DISPLAY_ERROR_MSG;

  569.           //if (error == LADYBUG_OK)
  570.           //{
  571.                  // // Save the output image to a file
  572.                  // char pszOutputName[256];
  573.                  // sprintf( pszOutputName, "PanoStitchOutput_%03d.jpg", f);
  574.                  // printf( "Writing image %s...\n", pszOutputName);
  575.                  // error = ladybugSaveImage( context, &processedImage, pszOutputName, LADYBUG_FILEFORMAT_JPG );
  576.                  // _HANDLE_ERROR
  577.           //}
  578.           
  579.           glEnable( GL_TEXTURE_2D);
  580.           
  581.           glBindTexture( GL_TEXTURE_2D, *puiTextureID);
  582.           handleGLError( "glBindTexture");

  584.           drawUnitSquare();

  586.           glPopMatrix();

  588.           glMatrixMode( GL_PROJECTION);
  589.           glPopMatrix();

  591.    }
  592. #endif

  594.    // unbind FBO
  595.    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

  597.    glPopAttrib();

  599.    //
  600.    // Render the scene
  601.    //

  603.    glEnable( GL_TEXTURE_CUBE_MAP);
  604.    if ( GLEW_EXT_framebuffer_object )
  605.    {
  606.            // Generate Mipmap
  607.            glGenerateMipmapEXT( GL_TEXTURE_CUBE_MAP);
  608.            handleGLError( "glGenerateMipmapEXT");   
  609.    }
  610.    glDisable( GL_TEXTURE_2D);

  612.    glBindTexture( GL_TEXTURE_CUBE_MAP, fboTexture);
  613.    handleGLError( "glBindTexture");   
  614.   
  615.    glDisable(GL_TEXTURE_GEN_S);
  616.    glDisable(GL_TEXTURE_GEN_T);
  617.    glDisable(GL_TEXTURE_GEN_R);

  619.    glMatrixMode( GL_MODELVIEW);
  620.    glPushMatrix();
  621.    glLoadIdentity();

  623.    drawSkybox();

  625.    glPopMatrix();

  627.    glEnable(GL_TEXTURE_GEN_S);
  628.    glEnable(GL_TEXTURE_GEN_T);
  629.    glEnable(GL_TEXTURE_GEN_R);

  631.    switch ( displayMode)
  632.    {
  633.           case MENU_TEAPOT:
  634.                  glutSolidTeapot( 1.0);  
  635.                  break;
  636.           case MENU_SPHERE:
  637.                  gluSphere( quadric, 1.0f, 32, 32);
  638.                  break;
  639.           case MENU_CUBE:
  640.                  drawCube();
  641.                  break;
  642.    }

  644.    glDisable(GL_TEXTURE_CUBE_MAP);
  645.    glEnable( GL_TEXTURE_2D);
  646. }

  648. //=============================================================================
  649. // Display Ladybug images
  650. //=============================================================================
  651. void
  652. display()
  653. {   
  654.    glClearColor((GLclampf)0.2, (GLclampf)0.2, (GLclampf)0.2, (GLclampf)0.0);
  655.    glClearDepth( 1.0);
  656.    
  657.    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  658.    
  659.    glEnable( GL_DEPTH_TEST );

  661.    glMatrixMode( GL_MODELVIEW) ;
  662.    glPushMatrix();
  663.    glLoadIdentity();
  664.    
  665.    //
  666.    // Apply transformation
  667.    //
  668.    object.apply_transform();
  669.    
  670.    glShadeModel( GL_FLAT );
  671.    glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
  672.    glEnable( GL_TEXTURE_2D );
  673.    
  674.    drawEnvironmentMapping();

  676.    glPopMatrix();

  678.    //
  679.    // Make sure changes appear on screen
  680.    //
  681.    glutSwapBuffers();
  682. }

  684. //=============================================================================
  685. //
  686. // Grab image, process it and update image textures on the graphics card
  687. //
  688. //=============================================================================
  689. void
  690. grabImage()
  691. {
  692.    if ( b[' '] )
  693.    {
  694.           object.trackball.increment_rotation();
  695.    }
  696.    
  697.    //
  698.    // Grab an image
  699.    //
  700.    error = ladybugGrabImage( context, &image );
  701.    _DISPLAY_ERROR_MSG_AND_RETURN;
  702.   
  703.    //
  704.    // Parse images to arpBuffers.
  705.    //
  706.    error = ladybugConvertImage( context, &image, NULL );       
  707.    _DISPLAY_ERROR_MSG_AND_RETURN;
  708.    
  709.    //
  710.    // Update images to the graphics card
  711.    //
  712.    error = ladybugUpdateTextures(
  713.           context,
  714.           LADYBUG_NUM_CAMERAS,
  715.           NULL );
  716.    _DISPLAY_ERROR_MSG_AND_RETURN;
  717.    
  718.    //
  719.    // Mark the current window for redisplay
  720.    //
  721.    glutPostRedisplay();
  722. }

  724. void
  725. key(unsigned char k, int x, int y)
  726. {
  727.    b[k] = !b[k];
  728.    
  729.    if( k==27 || k=='q')
  730.    {
  731.           cleanUp();
  732.           exit(0);
  733.    }
  734.    
  735.    object.keyboard(k, x, y);
  736.    
  737.    glutPostRedisplay();
  738. }

  740. void
  741. resize( int w, int h )
  742. {
  743.    if (h == 0)
  744.    {
  745.           h = 1;
  746.    }
  747.    
  748.    glViewport(0, 0, w, h);
  749.    
  750.    //
  751.    // Set OpenGL projection as perspective viewing
  752.    //
  753.    glMatrixMode( GL_PROJECTION );
  754.    glLoadIdentity();
  755.    gluPerspective( 45.0, (GLfloat)w/(GLfloat)h, 0.1, 100.0 );
  756.    
  757.    glMatrixMode( GL_MODELVIEW );
  758.    glLoadIdentity();
  759.    
  760.    object.reshape( w, h );
  761. }

  763. void
  764. mouse( int button, int state, int x, int y )
  765. {
  766.    object.mouse( button, state, x, y );
  767. }

  769. void
  770. motion( int x, int y )
  771. {
  772.    object.motion( x, y );
  773. }

  775. //=============================================================================
  776. //
  777. // Main program
  778. //
  779. //=============================================================================
  780. int
  781. main(int argc, char** argv)
  782. {
  783.    //
  784.    // GLUT Window Initialization
  785.    //
  786.    glutInit( &argc, argv );
  787.    glutInitWindowSize( 800, 600 );
  788.    glutInitDisplayMode ( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
  789.    glutInitWindowPosition( 120, 100 );
  790.    glutCreateWindow ( "Environment mapping with Ladybug" );
  791.    
  792.    //
  793.    // Initialize GLEW
  794.    //
  795.    GLenum err = glewInit();
  796.    if ( err != GLEW_OK )
  797.    {
  798.           printf( "Failed to init GLEW.\n");
  799.           return 0;
  800.    }

  802.    startCamera( );
  803.    
  804.    error = ladybugConfigureOutputImages( context, LADYBUG_SPHERICAL);
  805.    _HANDLE_ERROR;

  807.    error = ladybugSetDisplayWindow( context );
  808.    _HANDLE_ERROR

  810.    initEnvMap();

  812.    // Track ball - left buton
  813.    // Pan - Shift + left button
  814.    // Dolly - Ctrl + left
  815.    object.configure_buttons( 1 );
  816.    
  817.    //
  818.    // Move the view point back
  819.    //
  820.    object.dolly.dolly[2] = -4;
  821.    
  822.    //
  823.    // Register callbacks:
  824.    //
  825.    glutDisplayFunc( display );
  826.    glutIdleFunc( grabImage );
  827.    glutMouseFunc( mouse );
  828.    glutMotionFunc( motion );
  829.    glutKeyboardFunc( key );
  830.    glutReshapeFunc( resize );
  831.    
  832.    b[' '] = true;

  834.    buildPopupMenu( );
  835.    glutAttachMenu( GLUT_RIGHT_BUTTON );
  836.           
  837.    glutCloseFunc( cleanUp );

  839.    //
  840.    // Turn the flow of control over to GLUT
  841.    //
  842.    printf( "Grabbing and display...\n" );
  843.    glutMainLoop( );
  844.    
  845.    return 0;
  846. }
复制代码
回复

使用道具 举报

lglgaigogo

该用户从未签到
 楼主| 发表于 2012-12-7 21:57:29 | 显示全部楼层
我觉得这个问题的关键是，osg中有没有opengl rander context 这个东西？如果有，它能不能像在OpenGL一样被第三方的代码直接进行访问到。
回复 支持 反对

使用道具 举报

lglgaigogo

该用户从未签到
 楼主| 发表于 2012-12-8 17:09:26 | 显示全部楼层
如果不行，我可能要学习OpenGL了。Ladybug保存一幅图片的时间是100毫秒左右。6幅就是600毫秒。太慢了。
回复 支持 反对

使用道具 举报

array

该用户从未签到
发表于 2012-12-11 10:55:35 | 显示全部楼层
有HGLRC，可以通过GraphicsWindowWin32得到
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

OSG中国官方论坛-有您OSG在中国才更好

网站简介：osgChina是国内首个三维相关技术开源社区，旨在为国内更多的技术开发人员提供最前沿的技术资讯，为更多的三维从业者提供一个学习、交流的技术平台。

联系我们

  • 工作时间：09:00--18:00
  • 反馈邮箱：1315785073@qq.com
快速回复 返回顶部 返回列表