ovr_sdk: 1b39a1b46319 LibOVR/Src/CAPI/GL/CAPI_GL

363 pVertexShader = *new VertexShader(&RenderParams, const_cast<char*>(strShader.ToCStr()), strShader.GetLength(), SimpleTexturedQuad_vs_refl, OVR_ARRAY_COUNT(SimpleTexturedQuad_vs_refl));

364 pShaderSet->SetShader(pVertexShader);

365 }

366

367 if(!pFragmentShader)

368 {

369 OVR::String strShader((GLEContext::GetCurrentContext()->WholeVersion >= 302) ? glsl3Prefix : glsl2Prefix);

370 strShader += SimpleTexturedQuad_ps;

371

372 pFragmentShader = *new FragmentShader(&RenderParams, const_cast<char*>(strShader.ToCStr()), strShader.GetLength(), SimpleTexturedQuad_ps_refl, OVR_ARRAY_COUNT(SimpleTexturedQuad_ps_refl));

373 pShaderSet->SetShader(pFragmentShader);

374 }

375

376 if(!pVB)

377 {

378 pVB = *new Buffer(&RenderParams);

379

380 pVB->Data(Buffer_Vertex, NULL, 4 * sizeof(HASWVertex));

381 HASWVertex* pVertices = (HASWVertex*)pVB->Map(0, 4 * sizeof(HASWVertex), Map_Discard);

382 OVR_ASSERT(pVertices);

383

384 if(pVertices)

385 {

386 const bool flip = ((RenderState.DistortionCaps & ovrDistortionCap_FlipInput) != 0);

387 const float left = -1.0f; // We currently draw this in normalized device coordinates with an stereo translation

388 const float top = -1.1f; // applied as a vertex shader uniform. In the future when we have a more formal graphics

389 const float right = 1.0f; // API abstraction we may move this draw to an overlay layer or to a more formal

390 const float bottom = 0.9f; // model/mesh scheme with a perspective projection.

391

392 pVertices[0] = HASWVertex(left, top, 0.f, Color(255, 255, 255, 255), 0.f, flip ? 1.f : 0.f);

393 pVertices[1] = HASWVertex(left, bottom, 0.f, Color(255, 255, 255, 255), 0.f, flip ? 0.f : 1.f);

394 pVertices[2] = HASWVertex(right, top, 0.f, Color(255, 255, 255, 255), 1.f, flip ? 1.f : 0.f);

395 pVertices[3] = HASWVertex(right, bottom, 0.f, Color(255, 255, 255, 255), 1.f, flip ? 0.f : 1.f);

396

397 pVB->Unmap(pVertices);

398 }

399 }

400

401 // We don't bind or initialize the vertex arrays here.

402 if (!VAO && GLE_ARB_vertex_array_object)

403 {

404 OVR_ASSERT(!VAOInitialized);

405 glGenVertexArrays(1, &VAO);

406 }

407 }

408

409

410 void HSWDisplay::RenderInternal(ovrEyeType eye, const ovrTexture* eyeTexture)

411 {

412 if(RenderEnabled && eyeTexture)

413 {

414 // We need to render to the eyeTexture with the texture viewport.

415 // Setup rendering to the texture.

416 ovrGLTexture* eyeTextureGL = const_cast<ovrGLTexture*>(reinterpret_cast<const ovrGLTexture*>(eyeTexture));

417 OVR_ASSERT(eyeTextureGL->Texture.Header.API == ovrRenderAPI_OpenGL);

418

419 GL::AutoContext autoGLContext(GLContext); // Saves the current GL context, binds our GLContext, then at the end of scope re-binds the current GL context.

420

421 // Load the graphics if not loaded already.

422 if (!pTexture)

423 LoadGraphics();

424

425 // Calculate ortho projection.

426 GetOrthoProjection(RenderState, OrthoProjection);

427

428 // Set the rendering to be to the eye texture.

429 glBindFramebuffer(GL_FRAMEBUFFER, FrameBuffer);

430 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, eyeTextureGL->OGL.TexId, 0);

431 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); // We aren't using depth, as we currently want this to overwrite everything.

432 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);

433 OVR_ASSERT(status == GL_FRAMEBUFFER_COMPLETE); OVR_UNUSED(status);

434

435 // Set up the viewport

436 const GLint x = (GLint)eyeTextureGL->Texture.Header.RenderViewport.Pos.x;

437 const GLint y = (GLint)eyeTextureGL->Texture.Header.RenderViewport.Pos.y; // Note that GL uses bottom-up coordinates.

438 const GLsizei w = (GLsizei)eyeTextureGL->Texture.Header.RenderViewport.Size.w;

439 const GLsizei h = (GLsizei)eyeTextureGL->Texture.Header.RenderViewport.Size.h;

440 glViewport(x, y, w, h);

441

442 // Set fixed-function render states.

443 //glDepthRange(0.0, 1.0); // This is the default

444 glDepthMask(GL_FALSE);

445 glDisable(GL_DEPTH_TEST);

446 glFrontFace(GL_CW);

447 glEnable(GL_BLEND);

448 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

449

450 // Enable the buffer and shaders we use.

451 ShaderFill fill(pShaderSet);

452 if (pTexture)

453 fill.SetTexture(0, pTexture);

454

455 // Set shader uniforms.

456 const float scale = HSWDISPLAY_SCALE * ((RenderState.OurHMDInfo.HmdType == HmdType_DK1) ? 0.70f : 1.f);

457 pShaderSet->SetUniform2f("Scale", scale, scale / 2.f); // X and Y scale. Y is a fixed proportion to X in order to give a certain aspect ratio.

458 pShaderSet->SetUniform2f("PositionOffset", OrthoProjection[eye].GetTranslation().x, 0.0f);

459

460 // Set vertex attributes

461 if (GLE_ARB_vertex_array_object)

462 {

463 OVR_ASSERT(VAO != 0);

464 glBindVertexArray(VAO);

465 }

466

467 if(!VAOInitialized) // This executes for the case that VAO isn't supported.

468 {

469 glBindBuffer(GL_ARRAY_BUFFER, pVB->GLBuffer); // This must be called before glVertexAttribPointer is called below.

470

471 const GLuint shaderProgram = pShaderSet->Prog;

472 GLint attributeLocationArray[3];

473

474 attributeLocationArray[0] = glGetAttribLocation(shaderProgram, "Position");

475 glVertexAttribPointer(attributeLocationArray[0], sizeof(Vector3f)/sizeof(float), GL_FLOAT, false, sizeof(HASWVertex), reinterpret_cast<char*>(offsetof(HASWVertex, Pos)));

476

477 attributeLocationArray[1] = glGetAttribLocation(shaderProgram, "Color");

478 glVertexAttribPointer(attributeLocationArray[1], sizeof(Color)/sizeof(uint8_t), GL_UNSIGNED_BYTE, true, sizeof(HASWVertex), reinterpret_cast<char*>(offsetof(HASWVertex, C))); // True because we want it to convert [0,255] to [0,1] for us.

479

480 attributeLocationArray[2] = glGetAttribLocation(shaderProgram, "TexCoord");

481 glVertexAttribPointer(attributeLocationArray[2], sizeof(float[2])/sizeof(float), GL_FLOAT, false, sizeof(HASWVertex), reinterpret_cast<char*>(offsetof(HASWVertex, U)));

482

483 for (size_t i = 0; i < OVR_ARRAY_COUNT(attributeLocationArray); i++)

484 glEnableVertexAttribArray((GLuint)i);

485 }

486

487 fill.Set(Prim_TriangleStrip);

488

489 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

490

491 if (GLE_ARB_vertex_array_object)

492 {

493 VAOInitialized = true;

494 glBindVertexArray(0);

495 }

496 }

497 }

498

499

500 }}} // namespace OVR::CAPI::GL