oculus2_psprite: 5b04743fd3d0 src/main.c

oculus2_psprite

view src/main.c @ 7:5b04743fd3d0

- changed some loose types to make this example more compatible with C++ programs - enabled overdrive (can't see any difference but what the hell)

author	John Tsiombikas <nuclear@member.fsf.org>
date	Mon, 15 Sep 2014 03:00:50 +0300
parents	37c753411934
children	9c36ae39ad95 92acd335620e

line source

1 /* Very simple OculusSDK OpenGL usage example.

2 *

3 * Uses SDL2 (www.libsdl.org) for event handling and OpenGL context management.

4 * Uses GLEW (glew.sourceforge.net) for OpenGL extension wrangling.

5 *

6 * Author: John Tsiombikas <nuclear@member.fsf.org>

7 * This code is in the public domain. Do whatever you like with it.

8 */

9 #include <stdio.h>

10 #include <stdlib.h>

11 #include <assert.h>

12 #include <SDL2/SDL.h>

13 #include <GL/glew.h>

15 #ifdef WIN32

16 #define OVR_OS_WIN32

17 #endif

18 #ifdef __APPLE__

19 #define OVR_OS_MAC

20 #endif

22 #include <OVR_CAPI.h>

23 #include <OVR_CAPI_GL.h>

25 int init(void);

26 void cleanup(void);

27 void toggle_hmd_fullscreen(void);

28 void display(void);

29 void draw_scene(void);

30 void draw_box(float xsz, float ysz, float zsz, float norm_sign);

31 void update_rtarg(int width, int height);

32 int handle_event(SDL_Event *ev);

33 int key_event(int key, int state);

34 void reshape(int x, int y);

35 unsigned int next_pow2(unsigned int x);

36 void quat_to_matrix(const float *quat, float *mat);

37 unsigned int gen_chess_tex(float r0, float g0, float b0, float r1, float g1, float b1);

39 /* forward declaration to avoid including non-public headers of libovr */

40 OVR_EXPORT void ovrhmd_EnableHSWDisplaySDKRender(ovrHmd hmd, ovrBool enable);

42 static SDL_Window *win;

43 static SDL_GLContext ctx;

44 static int win_width, win_height;

46 static unsigned int fbo, fb_tex, fb_depth;

47 static int fb_width, fb_height;

48 static int fb_tex_width, fb_tex_height;

50 static ovrHmd hmd;

51 static ovrSizei eyeres[2];

52 static ovrEyeRenderDesc eye_rdesc[2];

53 static ovrGLTexture fb_ovr_tex[2];

55 static unsigned int chess_tex;

58 int main(int argc, char **argv)

59 {

60 if(init() == -1) {

61 return 1;

62 }

64 for(;;) {

65 SDL_Event ev;

66 while(SDL_PollEvent(&ev)) {

67 if(handle_event(&ev) == -1) {

68 goto done;

69 }

70 }

71 display();

72 }

74 done:

75 cleanup();

76 return 0;

77 }

80 int init(void)

81 {

82 int i, x, y;

83 unsigned int flags, dcaps;

84 union ovrGLConfig glcfg;

86 /* libovr must be initialized before we create the OpenGL context */

87 ovr_Initialize();

89 SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);

91 x = y = SDL_WINDOWPOS_UNDEFINED;

92 flags = SDL_WINDOW_OPENGL;

93 if(!(win = SDL_CreateWindow("press 'f' to move to the HMD", x, y, 1280, 800, flags))) {

94 fprintf(stderr, "failed to create window\n");

95 return -1;

96 }

97 if(!(ctx = SDL_GL_CreateContext(win))) {

98 fprintf(stderr, "failed to create OpenGL context\n");

99 return -1;

100 }

101

102 glewInit();

103

104 if(!(hmd = ovrHmd_Create(0))) {

105 fprintf(stderr, "failed to open Oculus HMD, falling back to virtual debug HMD\n");

106 if(!(hmd = ovrHmd_CreateDebug(ovrHmd_DK2))) {

107 fprintf(stderr, "failed to create virtual debug HMD\n");

108 return -1;

109 }

110 }

111 printf("initialized HMD: %s - %s\n", hmd->Manufacturer, hmd->ProductName);

112

113 /* resize our window to match the HMD resolution */

114 SDL_SetWindowSize(win, hmd->Resolution.w, hmd->Resolution.h);

115 SDL_SetWindowPosition(win, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);

116 win_width = hmd->Resolution.w;

117 win_height = hmd->Resolution.h;

118

119 /* enable position and rotation tracking (and anything else they might add in the future) */

120 ovrHmd_ConfigureTracking(hmd, 0xffffffff, 0);

121 /* retrieve the optimal render target resolution for each eye */

122 eyeres[0] = ovrHmd_GetFovTextureSize(hmd, ovrEye_Left, hmd->DefaultEyeFov[0], 1.0);

123 eyeres[1] = ovrHmd_GetFovTextureSize(hmd, ovrEye_Right, hmd->DefaultEyeFov[1], 1.0);

124

125 /* and create a single render target texture to encompass both eyes */

126 fb_width = eyeres[0].w + eyeres[1].w;

127 fb_height = eyeres[0].h > eyeres[1].h ? eyeres[0].h : eyeres[1].h;

128 update_rtarg(fb_width, fb_height);

129

130 /* fill in the ovrGLTexture structures that describe our render target texture */

131 for(i=0; i<2; i++) {

132 fb_ovr_tex[i].OGL.Header.API = ovrRenderAPI_OpenGL;

133 fb_ovr_tex[i].OGL.Header.TextureSize.w = fb_tex_width;

134 fb_ovr_tex[i].OGL.Header.TextureSize.h = fb_tex_height;

135 /* this next field is the only one that differs between the two eyes */

136 fb_ovr_tex[i].OGL.Header.RenderViewport.Pos.x = i == 0 ? 0 : fb_width / 2.0;

137 fb_ovr_tex[i].OGL.Header.RenderViewport.Pos.y = fb_tex_height - fb_height;

138 fb_ovr_tex[i].OGL.Header.RenderViewport.Size.w = fb_width / 2.0;

139 fb_ovr_tex[i].OGL.Header.RenderViewport.Size.h = fb_height;

140 fb_ovr_tex[i].OGL.TexId = fb_tex; /* both eyes will use the same texture id */

141 }

142

143 /* fill in the ovrGLConfig structure needed by the SDK to draw our stereo pair

144 * to the actual HMD display (SDK-distortion mode)

145 */

146 memset(&glcfg, 0, sizeof glcfg);

147 glcfg.OGL.Header.API = ovrRenderAPI_OpenGL;

148 glcfg.OGL.Header.RTSize = hmd->Resolution;

149 glcfg.OGL.Header.Multisample = 1;

150

151 if(hmd->HmdCaps & ovrHmdCap_ExtendDesktop) {

152 printf("running in \"extended desktop\" mode\n");

153 } else {

154 /* to sucessfully draw to the HMD display in "direct-hmd" mode, we have to

155 * call ovrHmd_AttachToWindow

156 * XXX: this doesn't work properly yet due to bugs in the oculus 0.4.1 sdk/driver

157 */

158 #ifdef WIN32

159 HWND sys_win = GetActiveWindow();

160 glcfg.OGL.Window = sys_win;

161 glcfg.OGL.DC = wglGetCurrentDC();

162 ovrHmd_AttachToWindow(hmd, sys_win, 0, 0);

163 #endif

164 printf("running in \"direct-hmd\" mode\n");

165 }

166

167 /* enable low-persistence display and dynamic prediction for lattency compensation */

168 ovrHmd_SetEnabledCaps(hmd, ovrHmdCap_LowPersistence | ovrHmdCap_DynamicPrediction);

169

170 /* configure SDK-rendering and enable chromatic abberation correction, vignetting, and

171 * timewrap, which shifts the image before drawing to counter any lattency between the call

172 * to ovrHmd_GetEyePose and ovrHmd_EndFrame.

173 */

174 dcaps = ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette | ovrDistortionCap_TimeWarp |

175 ovrDistortionCap_Overdrive;

176 if(!ovrHmd_ConfigureRendering(hmd, &glcfg.Config, dcaps, hmd->DefaultEyeFov, eye_rdesc)) {

177 fprintf(stderr, "failed to configure distortion renderer\n");

178 }

179

180 /* disable the retarded "health and safety warning" */

181 ovrhmd_EnableHSWDisplaySDKRender(hmd, 0);

182

183 glEnable(GL_DEPTH_TEST);

184 glEnable(GL_CULL_FACE);

185 glEnable(GL_LIGHTING);

186 glEnable(GL_LIGHT0);

187 glEnable(GL_LIGHT1);

188 glEnable(GL_NORMALIZE);

189

190 glClearColor(0.1, 0.1, 0.1, 1);

191

192 chess_tex = gen_chess_tex(1.0, 0.7, 0.4, 0.4, 0.7, 1.0);

193 return 0;

194 }

195

196 void cleanup(void)

197 {

198 if(hmd) {

199 ovrHmd_Destroy(hmd);

200 }

201 ovr_Shutdown();

202

203 SDL_Quit();

204 }

205

206 void toggle_hmd_fullscreen(void)

207 {

208 static int fullscr, prev_x, prev_y;

209 fullscr = !fullscr;

210

211 if(fullscr) {

212 /* going fullscreen on the rift. save current window position, and move it

213 * to the rift's part of the desktop before going fullscreen

214 */

215 SDL_GetWindowPosition(win, &prev_x, &prev_y);

216 SDL_SetWindowPosition(win, hmd->WindowsPos.x, hmd->WindowsPos.y);

217 SDL_SetWindowFullscreen(win, SDL_WINDOW_FULLSCREEN_DESKTOP);

218 } else {

219 /* return to windowed mode and move the window back to its original position */

220 SDL_SetWindowFullscreen(win, 0);

221 SDL_SetWindowPosition(win, prev_x, prev_y);

222 }

223 }

224

225 void display(void)

226 {

227 int i;

228 ovrMatrix4f proj;

229 ovrPosef pose[2];

230 float rot_mat[16];

231

232 /* the drawing starts with a call to ovrHmd_BeginFrame */

233 ovrHmd_BeginFrame(hmd, 0);

234

235 /* start drawing onto our texture render target */

236 glBindFramebuffer(GL_FRAMEBUFFER, fbo);

237 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

238

239 /* for each eye ... */

240 for(i=0; i<2; i++) {

241 ovrEyeType eye = hmd->EyeRenderOrder[i];

242

243 /* -- viewport transformation --

244 * setup the viewport to draw in the left half of the framebuffer when we're

245 * rendering the left eye's view (0, 0, width/2, height), and in the right half

246 * of the framebuffer for the right eye's view (width/2, 0, width/2, height)

247 */

248 glViewport(eye == ovrEye_Left ? 0 : fb_width / 2, 0, fb_width / 2, fb_height);

249

250 /* -- projection transformation --

251 * we'll just have to use the projection matrix supplied by the oculus SDK for this eye

252 * note that libovr matrices are the transpose of what OpenGL expects, so we have to

253 * use glLoadTransposeMatrixf instead of glLoadMatrixf to load it.

254 */

255 proj = ovrMatrix4f_Projection(hmd->DefaultEyeFov[eye], 0.5, 500.0, 1);

256 glMatrixMode(GL_PROJECTION);

257 glLoadTransposeMatrixf(proj.M[0]);

258

259 /* -- view/camera transformation --

260 * we need to construct a view matrix by combining all the information provided by the oculus

261 * SDK, about the position and orientation of the user's head in the world.

262 */

263 pose[eye] = ovrHmd_GetEyePose(hmd, eye);

264 glMatrixMode(GL_MODELVIEW);

265 glLoadIdentity();

266 glTranslatef(eye_rdesc[eye].ViewAdjust.x, eye_rdesc[eye].ViewAdjust.y, eye_rdesc[eye].ViewAdjust.z);

267 /* retrieve the orientation quaternion and convert it to a rotation matrix */

268 quat_to_matrix(&pose[eye].Orientation.x, rot_mat);

269 glMultMatrixf(rot_mat);

270 /* translate the view matrix with the positional tracking */

271 glTranslatef(-pose[eye].Position.x, -pose[eye].Position.y, -pose[eye].Position.z);

272 /* move the camera to the eye level of the user */

273 glTranslatef(0, -ovrHmd_GetFloat(hmd, OVR_KEY_EYE_HEIGHT, 1.65), 0);

274

275 /* finally draw the scene for this eye */

276 draw_scene();

277 }

278

279 /* after drawing both eyes into the texture render target, revert to drawing directly to the

280 * display, and we call ovrHmd_EndFrame, to let the Oculus SDK draw both images properly

281 * compensated for lens distortion and chromatic abberation onto the HMD screen.

282 */

283 glBindFramebuffer(GL_FRAMEBUFFER, 0);

284 glViewport(0, 0, win_width, win_height);

285

286 ovrHmd_EndFrame(hmd, pose, &fb_ovr_tex[0].Texture);

287

288 assert(glGetError() == GL_NO_ERROR);

289 }

290

291 void draw_scene(void)

292 {

293 int i;

294 float grey[] = {0.8, 0.8, 0.8, 1};

295 float col[] = {0, 0, 0, 1};

296 float lpos[][4] = {

297 {-8, 2, 10, 1},

298 {0, 15, 0, 1}

299 };

300 float lcol[][4] = {

301 {0.8, 0.8, 0.8, 1},

302 {0.4, 0.3, 0.3, 1}

303 };

304

305 for(i=0; i<2; i++) {

306 glLightfv(GL_LIGHT0 + i, GL_POSITION, lpos[i]);

307 glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, lcol[i]);

308 }

309

310 glMatrixMode(GL_MODELVIEW);

311

312 glPushMatrix();

313 glTranslatef(0, 10, 0);

314 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, grey);

315 glBindTexture(GL_TEXTURE_2D, chess_tex);

316 glEnable(GL_TEXTURE_2D);

317 draw_box(30, 20, 30, -1.0);

318 glDisable(GL_TEXTURE_2D);

319 glPopMatrix();

320

321 for(i=0; i<4; i++) {

322 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, grey);

323 glPushMatrix();

324 glTranslatef(i & 1 ? 5 : -5, 1, i & 2 ? -5 : 5);

325 draw_box(0.5, 2, 0.5, 1.0);

326 glPopMatrix();

327

328 col[0] = i & 1 ? 1.0 : 0.3;

329 col[1] = i == 0 ? 1.0 : 0.3;

330 col[2] = i & 2 ? 1.0 : 0.3;

331 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, col);

332

333 glPushMatrix();

334 if(i & 1) {

335 glTranslatef(0, 0.25, i & 2 ? 2 : -2);

336 } else {

337 glTranslatef(i & 2 ? 2 : -2, 0.25, 0);

338 }

339 draw_box(0.5, 0.5, 0.5, 1.0);

340 glPopMatrix();

341 }

342 }

343

344 void draw_box(float xsz, float ysz, float zsz, float norm_sign)

345 {

346 glMatrixMode(GL_MODELVIEW);

347 glScalef(xsz * 0.5, ysz * 0.5, zsz * 0.5);

348

349 if(norm_sign < 0.0) {

350 glFrontFace(GL_CW);

351 }

352

353 glBegin(GL_QUADS);

354 glNormal3f(0, 0, 1 * norm_sign);

355 glTexCoord2f(0, 0); glVertex3f(-1, -1, 1);

356 glTexCoord2f(1, 0); glVertex3f(1, -1, 1);

357 glTexCoord2f(1, 1); glVertex3f(1, 1, 1);

358 glTexCoord2f(0, 1); glVertex3f(-1, 1, 1);

359 glNormal3f(1 * norm_sign, 0, 0);

360 glTexCoord2f(0, 0); glVertex3f(1, -1, 1);

361 glTexCoord2f(1, 0); glVertex3f(1, -1, -1);

362 glTexCoord2f(1, 1); glVertex3f(1, 1, -1);

363 glTexCoord2f(0, 1); glVertex3f(1, 1, 1);

364 glNormal3f(0, 0, -1 * norm_sign);

365 glTexCoord2f(0, 0); glVertex3f(1, -1, -1);

366 glTexCoord2f(1, 0); glVertex3f(-1, -1, -1);

367 glTexCoord2f(1, 1); glVertex3f(-1, 1, -1);

368 glTexCoord2f(0, 1); glVertex3f(1, 1, -1);

369 glNormal3f(-1 * norm_sign, 0, 0);

370 glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);

371 glTexCoord2f(1, 0); glVertex3f(-1, -1, 1);

372 glTexCoord2f(1, 1); glVertex3f(-1, 1, 1);

373 glTexCoord2f(0, 1); glVertex3f(-1, 1, -1);

374 glEnd();

375 glBegin(GL_TRIANGLE_FAN);

376 glNormal3f(0, 1 * norm_sign, 0);

377 glTexCoord2f(0.5, 0.5); glVertex3f(0, 1, 0);

378 glTexCoord2f(0, 0); glVertex3f(-1, 1, 1);

379 glTexCoord2f(1, 0); glVertex3f(1, 1, 1);

380 glTexCoord2f(1, 1); glVertex3f(1, 1, -1);

381 glTexCoord2f(0, 1); glVertex3f(-1, 1, -1);

382 glTexCoord2f(0, 0); glVertex3f(-1, 1, 1);

383 glEnd();

384 glBegin(GL_TRIANGLE_FAN);

385 glNormal3f(0, -1 * norm_sign, 0);

386 glTexCoord2f(0.5, 0.5); glVertex3f(0, -1, 0);

387 glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);

388 glTexCoord2f(1, 0); glVertex3f(1, -1, -1);

389 glTexCoord2f(1, 1); glVertex3f(1, -1, 1);

390 glTexCoord2f(0, 1); glVertex3f(-1, -1, 1);

391 glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);

392 glEnd();

393

394 glFrontFace(GL_CCW);

395 }

396

397 /* update_rtarg creates (and/or resizes) the render target used to draw the two stero views */

398 void update_rtarg(int width, int height)

399 {

400 if(!fbo) {

401 /* if fbo does not exist, then nothing does... create every opengl object */

402 glGenFramebuffers(1, &fbo);

403 glGenTextures(1, &fb_tex);

404 glGenRenderbuffers(1, &fb_depth);

405

406 glBindTexture(GL_TEXTURE_2D, fb_tex);

407 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

408 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

409 }

410

411 glBindFramebuffer(GL_FRAMEBUFFER, fbo);

412

413 /* calculate the next power of two in both dimensions and use that as a texture size */

414 fb_tex_width = next_pow2(width);

415 fb_tex_height = next_pow2(height);

416

417 /* create and attach the texture that will be used as a color buffer */

418 glBindTexture(GL_TEXTURE_2D, fb_tex);

419 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, fb_tex_width, fb_tex_height, 0,

420 GL_RGBA, GL_UNSIGNED_BYTE, 0);

421 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fb_tex, 0);

422

423 /* create and attach the renderbuffer that will serve as our z-buffer */

424 glBindRenderbuffer(GL_RENDERBUFFER, fb_depth);

425 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, fb_tex_width, fb_tex_height);

426 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fb_depth);

427

428 if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {

429 fprintf(stderr, "incomplete framebuffer!\n");

430 }

431

432 glBindFramebuffer(GL_FRAMEBUFFER, 0);

433 printf("created render target: %dx%d (texture size: %dx%d)\n", width, height, fb_tex_width, fb_tex_height);

434 }

435

436 int handle_event(SDL_Event *ev)

437 {

438 switch(ev->type) {

439 case SDL_QUIT:

440 return -1;

441

442 case SDL_KEYDOWN:

443 case SDL_KEYUP:

444 if(key_event(ev->key.keysym.sym, ev->key.state == SDL_PRESSED) == -1) {

445 return -1;

446 }

447 break;

448

449 default:

450 break;

451 }

452

453 return 0;

454 }

455

456 int key_event(int key, int state)

457 {

458 if(state) {

459 /*

460 ovrHSWDisplayState hsw;

461 ovrHmd_GetHSWDisplayState(hmd, &hsw);

462 if(hsw.Displayed) {

463 ovrHmd_DismissHSWDisplay(hmd);

464 }

465 */

466

467 switch(key) {

468 case 27:

469 return -1;

470

471 case ' ':

472 /* allow the user to recenter by pressing space */

473 ovrHmd_RecenterPose(hmd);

474 break;

475

476 case 'f':

477 /* press f to move the window to the HMD */

478 toggle_hmd_fullscreen();

479 break;

480

481 default:

482 break;

483 }

484 }

485 return 0;

486 }

487

488 unsigned int next_pow2(unsigned int x)

489 {

490 x -= 1;

491 x |= x >> 1;

492 x |= x >> 2;

493 x |= x >> 4;

494 x |= x >> 8;

495 x |= x >> 16;

496 return x + 1;

497 }

498

499 /* convert a quaternion to a rotation matrix */

500 void quat_to_matrix(const float *quat, float *mat)

501 {

502 mat[0] = 1.0 - 2.0 * quat[1] * quat[1] - 2.0 * quat[2] * quat[2];

503 mat[4] = 2.0 * quat[0] * quat[1] + 2.0 * quat[3] * quat[2];

504 mat[8] = 2.0 * quat[2] * quat[0] - 2.0 * quat[3] * quat[1];

505 mat[12] = 0.0f;

506

507 mat[1] = 2.0 * quat[0] * quat[1] - 2.0 * quat[3] * quat[2];

508 mat[5] = 1.0 - 2.0 * quat[0]*quat[0] - 2.0 * quat[2]*quat[2];

509 mat[9] = 2.0 * quat[1] * quat[2] + 2.0 * quat[3] * quat[0];

510 mat[13] = 0.0f;

511

512 mat[2] = 2.0 * quat[2] * quat[0] + 2.0 * quat[3] * quat[1];

513 mat[6] = 2.0 * quat[1] * quat[2] - 2.0 * quat[3] * quat[0];

514 mat[10] = 1.0 - 2.0 * quat[0]*quat[0] - 2.0 * quat[1]*quat[1];

515 mat[14] = 0.0f;

516

517 mat[3] = mat[7] = mat[11] = 0.0f;

518 mat[15] = 1.0f;

519 }

520

521 /* generate a chessboard texture with tiles colored (r0, g0, b0) and (r1, g1, b1) */

522 unsigned int gen_chess_tex(float r0, float g0, float b0, float r1, float g1, float b1)

523 {

524 int i, j;

525 unsigned int tex;

526 unsigned char img[8 * 8 * 3];

527 unsigned char *pix = img;

528

529 for(i=0; i<8; i++) {

530 for(j=0; j<8; j++) {

531 int black = (i & 1) == (j & 1);

532 pix[0] = (black ? r0 : r1) * 255;

533 pix[1] = (black ? g0 : g1) * 255;

534 pix[2] = (black ? b0 : b1) * 255;

535 pix += 3;

536 }

537 }

538

539 glGenTextures(1, &tex);

540 glBindTexture(GL_TEXTURE_2D, tex);

541 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

542 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

543 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, img);

544

545 return tex;

546 }