third_party/go/src/golang.org/x/mobile/gl/gldebug.go - Issue 1275153002: Remove third_party/golang.org/x/mobile as it is no longer used with Go 1.5.

Side by Side Diff: third_party/go/src/golang.org/x/mobile/gl/gldebug.go

Issue 1275153002: Remove third_party/golang.org/x/mobile as it is no longer used with Go 1.5. (Closed) Base URL: https://github.com/domokit/mojo.git@master

Patch Set: Remove golang.org/x/mobile Created 5 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« no previous file with comments | « third_party/go/src/golang.org/x/mobile/gl/gl.go ('k') | third_party/go/src/golang.org/x/mobile/gl/glutil/context_darwin_amd64.go » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright 2014 The Go Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style

3 // license that can be found in the LICENSE file.

4

5 // Generated from gl.go using go generate. DO NOT EDIT.

6 // See doc.go for details.

7

8 // +build linux darwin

9 // +build gldebug

10

11 package gl

12

13 /*

14 #include <stdlib.h>

15

16 #ifdef os_linux

17 #include <GLES2/gl2.h>

18 #endif

19 #ifdef os_darwin_arm

20 #include <OpenGLES/ES2/gl.h>

21 #endif

22 #ifdef os_darwin_amd64

23 #include <OpenGL/gl3.h>

24 #endif

25 */

26 import "C"

27

28 import (

29 "fmt"

30 "log"

31 "unsafe"

32 )

33

34 func errDrain() string {

35 var errs []Enum

36 for {

37 e := Enum(C.glGetError())

38 if e == 0 {

39 break

40 }

41 errs = append(errs, e)

42 }

43 if len(errs) > 0 {

44 return fmt.Sprintf(" error: %v", errs)

45 }

46 return ""

47 }

48

49 func (v Enum) String() string {

50 switch v {

51 case 0x0:

52 return "0"

53 case 0x1:

54 return "1"

55 case 0x2:

56 return "LINE_LOOP"

57 case 0x3:

58 return "LINE_STRIP"

59 case 0x4:

60 return "TRIANGLES"

61 case 0x5:

62 return "TRIANGLE_STRIP"

63 case 0x6:

64 return "TRIANGLE_FAN"

65 case 0x300:

66 return "SRC_COLOR"

67 case 0x301:

68 return "ONE_MINUS_SRC_COLOR"

69 case 0x302:

70 return "SRC_ALPHA"

71 case 0x303:

72 return "ONE_MINUS_SRC_ALPHA"

73 case 0x304:

74 return "DST_ALPHA"

75 case 0x305:

76 return "ONE_MINUS_DST_ALPHA"

77 case 0x306:

78 return "DST_COLOR"

79 case 0x307:

80 return "ONE_MINUS_DST_COLOR"

81 case 0x308:

82 return "SRC_ALPHA_SATURATE"

83 case 0x8006:

84 return "FUNC_ADD"

85 case 0x8009:

86 return "32777"

87 case 0x883d:

88 return "BLEND_EQUATION_ALPHA"

89 case 0x800a:

90 return "FUNC_SUBTRACT"

91 case 0x800b:

92 return "FUNC_REVERSE_SUBTRACT"

93 case 0x80c8:

94 return "BLEND_DST_RGB"

95 case 0x80c9:

96 return "BLEND_SRC_RGB"

97 case 0x80ca:

98 return "BLEND_DST_ALPHA"

99 case 0x80cb:

100 return "BLEND_SRC_ALPHA"

101 case 0x8001:

102 return "CONSTANT_COLOR"

103 case 0x8002:

104 return "ONE_MINUS_CONSTANT_COLOR"

105 case 0x8003:

106 return "CONSTANT_ALPHA"

107 case 0x8004:

108 return "ONE_MINUS_CONSTANT_ALPHA"

109 case 0x8005:

110 return "BLEND_COLOR"

111 case 0x8892:

112 return "ARRAY_BUFFER"

113 case 0x8893:

114 return "ELEMENT_ARRAY_BUFFER"

115 case 0x8894:

116 return "ARRAY_BUFFER_BINDING"

117 case 0x8895:

118 return "ELEMENT_ARRAY_BUFFER_BINDING"

119 case 0x88e0:

120 return "STREAM_DRAW"

121 case 0x88e4:

122 return "STATIC_DRAW"

123 case 0x88e8:

124 return "DYNAMIC_DRAW"

125 case 0x8764:

126 return "BUFFER_SIZE"

127 case 0x8765:

128 return "BUFFER_USAGE"

129 case 0x8626:

130 return "CURRENT_VERTEX_ATTRIB"

131 case 0x404:

132 return "FRONT"

133 case 0x405:

134 return "BACK"

135 case 0x408:

136 return "FRONT_AND_BACK"

137 case 0xde1:

138 return "TEXTURE_2D"

139 case 0xb44:

140 return "CULL_FACE"

141 case 0xbe2:

142 return "BLEND"

143 case 0xbd0:

144 return "DITHER"

145 case 0xb90:

146 return "STENCIL_TEST"

147 case 0xb71:

148 return "DEPTH_TEST"

149 case 0xc11:

150 return "SCISSOR_TEST"

151 case 0x8037:

152 return "POLYGON_OFFSET_FILL"

153 case 0x809e:

154 return "SAMPLE_ALPHA_TO_COVERAGE"

155 case 0x80a0:

156 return "SAMPLE_COVERAGE"

157 case 0x500:

158 return "INVALID_ENUM"

159 case 0x501:

160 return "INVALID_VALUE"

161 case 0x502:

162 return "INVALID_OPERATION"

163 case 0x505:

164 return "OUT_OF_MEMORY"

165 case 0x900:

166 return "CW"

167 case 0x901:

168 return "CCW"

169 case 0xb21:

170 return "LINE_WIDTH"

171 case 0x846d:

172 return "ALIASED_POINT_SIZE_RANGE"

173 case 0x846e:

174 return "ALIASED_LINE_WIDTH_RANGE"

175 case 0xb45:

176 return "CULL_FACE_MODE"

177 case 0xb46:

178 return "FRONT_FACE"

179 case 0xb70:

180 return "DEPTH_RANGE"

181 case 0xb72:

182 return "DEPTH_WRITEMASK"

183 case 0xb73:

184 return "DEPTH_CLEAR_VALUE"

185 case 0xb74:

186 return "DEPTH_FUNC"

187 case 0xb91:

188 return "STENCIL_CLEAR_VALUE"

189 case 0xb92:

190 return "STENCIL_FUNC"

191 case 0xb94:

192 return "STENCIL_FAIL"

193 case 0xb95:

194 return "STENCIL_PASS_DEPTH_FAIL"

195 case 0xb96:

196 return "STENCIL_PASS_DEPTH_PASS"

197 case 0xb97:

198 return "STENCIL_REF"

199 case 0xb93:

200 return "STENCIL_VALUE_MASK"

201 case 0xb98:

202 return "STENCIL_WRITEMASK"

203 case 0x8800:

204 return "STENCIL_BACK_FUNC"

205 case 0x8801:

206 return "STENCIL_BACK_FAIL"

207 case 0x8802:

208 return "STENCIL_BACK_PASS_DEPTH_FAIL"

209 case 0x8803:

210 return "STENCIL_BACK_PASS_DEPTH_PASS"

211 case 0x8ca3:

212 return "STENCIL_BACK_REF"

213 case 0x8ca4:

214 return "STENCIL_BACK_VALUE_MASK"

215 case 0x8ca5:

216 return "STENCIL_BACK_WRITEMASK"

217 case 0xba2:

218 return "VIEWPORT"

219 case 0xc10:

220 return "SCISSOR_BOX"

221 case 0xc22:

222 return "COLOR_CLEAR_VALUE"

223 case 0xc23:

224 return "COLOR_WRITEMASK"

225 case 0xcf5:

226 return "UNPACK_ALIGNMENT"

227 case 0xd05:

228 return "PACK_ALIGNMENT"

229 case 0xd33:

230 return "MAX_TEXTURE_SIZE"

231 case 0xd3a:

232 return "MAX_VIEWPORT_DIMS"

233 case 0xd50:

234 return "SUBPIXEL_BITS"

235 case 0xd52:

236 return "RED_BITS"

237 case 0xd53:

238 return "GREEN_BITS"

239 case 0xd54:

240 return "BLUE_BITS"

241 case 0xd55:

242 return "ALPHA_BITS"

243 case 0xd56:

244 return "DEPTH_BITS"

245 case 0xd57:

246 return "STENCIL_BITS"

247 case 0x2a00:

248 return "POLYGON_OFFSET_UNITS"

249 case 0x8038:

250 return "POLYGON_OFFSET_FACTOR"

251 case 0x8069:

252 return "TEXTURE_BINDING_2D"

253 case 0x80a8:

254 return "SAMPLE_BUFFERS"

255 case 0x80a9:

256 return "SAMPLES"

257 case 0x80aa:

258 return "SAMPLE_COVERAGE_VALUE"

259 case 0x80ab:

260 return "SAMPLE_COVERAGE_INVERT"

261 case 0x86a2:

262 return "NUM_COMPRESSED_TEXTURE_FORMATS"

263 case 0x86a3:

264 return "COMPRESSED_TEXTURE_FORMATS"

265 case 0x1100:

266 return "DONT_CARE"

267 case 0x1101:

268 return "FASTEST"

269 case 0x1102:

270 return "NICEST"

271 case 0x8192:

272 return "GENERATE_MIPMAP_HINT"

273 case 0x1400:

274 return "BYTE"

275 case 0x1401:

276 return "UNSIGNED_BYTE"

277 case 0x1402:

278 return "SHORT"

279 case 0x1403:

280 return "UNSIGNED_SHORT"

281 case 0x1404:

282 return "INT"

283 case 0x1405:

284 return "UNSIGNED_INT"

285 case 0x1406:

286 return "FLOAT"

287 case 0x140c:

288 return "FIXED"

289 case 0x1902:

290 return "DEPTH_COMPONENT"

291 case 0x1906:

292 return "ALPHA"

293 case 0x1907:

294 return "RGB"

295 case 0x1908:

296 return "RGBA"

297 case 0x1909:

298 return "LUMINANCE"

299 case 0x190a:

300 return "LUMINANCE_ALPHA"

301 case 0x8033:

302 return "UNSIGNED_SHORT_4_4_4_4"

303 case 0x8034:

304 return "UNSIGNED_SHORT_5_5_5_1"

305 case 0x8363:

306 return "UNSIGNED_SHORT_5_6_5"

307 case 0x8869:

308 return "MAX_VERTEX_ATTRIBS"

309 case 0x8dfb:

310 return "MAX_VERTEX_UNIFORM_VECTORS"

311 case 0x8dfc:

312 return "MAX_VARYING_VECTORS"

313 case 0x8b4d:

314 return "MAX_COMBINED_TEXTURE_IMAGE_UNITS"

315 case 0x8b4c:

316 return "MAX_VERTEX_TEXTURE_IMAGE_UNITS"

317 case 0x8872:

318 return "MAX_TEXTURE_IMAGE_UNITS"

319 case 0x8dfd:

320 return "MAX_FRAGMENT_UNIFORM_VECTORS"

321 case 0x8b4f:

322 return "SHADER_TYPE"

323 case 0x8b80:

324 return "DELETE_STATUS"

325 case 0x8b82:

326 return "LINK_STATUS"

327 case 0x8b83:

328 return "VALIDATE_STATUS"

329 case 0x8b85:

330 return "ATTACHED_SHADERS"

331 case 0x8b86:

332 return "ACTIVE_UNIFORMS"

333 case 0x8b87:

334 return "ACTIVE_UNIFORM_MAX_LENGTH"

335 case 0x8b89:

336 return "ACTIVE_ATTRIBUTES"

337 case 0x8b8a:

338 return "ACTIVE_ATTRIBUTE_MAX_LENGTH"

339 case 0x8b8c:

340 return "SHADING_LANGUAGE_VERSION"

341 case 0x8b8d:

342 return "CURRENT_PROGRAM"

343 case 0x200:

344 return "NEVER"

345 case 0x201:

346 return "LESS"

347 case 0x202:

348 return "EQUAL"

349 case 0x203:

350 return "LEQUAL"

351 case 0x204:

352 return "GREATER"

353 case 0x205:

354 return "NOTEQUAL"

355 case 0x206:

356 return "GEQUAL"

357 case 0x207:

358 return "ALWAYS"

359 case 0x1e00:

360 return "KEEP"

361 case 0x1e01:

362 return "REPLACE"

363 case 0x1e02:

364 return "INCR"

365 case 0x1e03:

366 return "DECR"

367 case 0x150a:

368 return "INVERT"

369 case 0x8507:

370 return "INCR_WRAP"

371 case 0x8508:

372 return "DECR_WRAP"

373 case 0x1f00:

374 return "VENDOR"

375 case 0x1f01:

376 return "RENDERER"

377 case 0x1f02:

378 return "VERSION"

379 case 0x1f03:

380 return "EXTENSIONS"

381 case 0x2600:

382 return "NEAREST"

383 case 0x2601:

384 return "LINEAR"

385 case 0x2700:

386 return "NEAREST_MIPMAP_NEAREST"

387 case 0x2701:

388 return "LINEAR_MIPMAP_NEAREST"

389 case 0x2702:

390 return "NEAREST_MIPMAP_LINEAR"

391 case 0x2703:

392 return "LINEAR_MIPMAP_LINEAR"

393 case 0x2800:

394 return "TEXTURE_MAG_FILTER"

395 case 0x2801:

396 return "TEXTURE_MIN_FILTER"

397 case 0x2802:

398 return "TEXTURE_WRAP_S"

399 case 0x2803:

400 return "TEXTURE_WRAP_T"

401 case 0x1702:

402 return "TEXTURE"

403 case 0x8513:

404 return "TEXTURE_CUBE_MAP"

405 case 0x8514:

406 return "TEXTURE_BINDING_CUBE_MAP"

407 case 0x8515:

408 return "TEXTURE_CUBE_MAP_POSITIVE_X"

409 case 0x8516:

410 return "TEXTURE_CUBE_MAP_NEGATIVE_X"

411 case 0x8517:

412 return "TEXTURE_CUBE_MAP_POSITIVE_Y"

413 case 0x8518:

414 return "TEXTURE_CUBE_MAP_NEGATIVE_Y"

415 case 0x8519:

416 return "TEXTURE_CUBE_MAP_POSITIVE_Z"

417 case 0x851a:

418 return "TEXTURE_CUBE_MAP_NEGATIVE_Z"

419 case 0x851c:

420 return "MAX_CUBE_MAP_TEXTURE_SIZE"

421 case 0x84c0:

422 return "TEXTURE0"

423 case 0x84c1:

424 return "TEXTURE1"

425 case 0x84c2:

426 return "TEXTURE2"

427 case 0x84c3:

428 return "TEXTURE3"

429 case 0x84c4:

430 return "TEXTURE4"

431 case 0x84c5:

432 return "TEXTURE5"

433 case 0x84c6:

434 return "TEXTURE6"

435 case 0x84c7:

436 return "TEXTURE7"

437 case 0x84c8:

438 return "TEXTURE8"

439 case 0x84c9:

440 return "TEXTURE9"

441 case 0x84ca:

442 return "TEXTURE10"

443 case 0x84cb:

444 return "TEXTURE11"

445 case 0x84cc:

446 return "TEXTURE12"

447 case 0x84cd:

448 return "TEXTURE13"

449 case 0x84ce:

450 return "TEXTURE14"

451 case 0x84cf:

452 return "TEXTURE15"

453 case 0x84d0:

454 return "TEXTURE16"

455 case 0x84d1:

456 return "TEXTURE17"

457 case 0x84d2:

458 return "TEXTURE18"

459 case 0x84d3:

460 return "TEXTURE19"

461 case 0x84d4:

462 return "TEXTURE20"

463 case 0x84d5:

464 return "TEXTURE21"

465 case 0x84d6:

466 return "TEXTURE22"

467 case 0x84d7:

468 return "TEXTURE23"

469 case 0x84d8:

470 return "TEXTURE24"

471 case 0x84d9:

472 return "TEXTURE25"

473 case 0x84da:

474 return "TEXTURE26"

475 case 0x84db:

476 return "TEXTURE27"

477 case 0x84dc:

478 return "TEXTURE28"

479 case 0x84dd:

480 return "TEXTURE29"

481 case 0x84de:

482 return "TEXTURE30"

483 case 0x84df:

484 return "TEXTURE31"

485 case 0x84e0:

486 return "ACTIVE_TEXTURE"

487 case 0x2901:

488 return "REPEAT"

489 case 0x812f:

490 return "CLAMP_TO_EDGE"

491 case 0x8370:

492 return "MIRRORED_REPEAT"

493 case 0x8622:

494 return "VERTEX_ATTRIB_ARRAY_ENABLED"

495 case 0x8623:

496 return "VERTEX_ATTRIB_ARRAY_SIZE"

497 case 0x8624:

498 return "VERTEX_ATTRIB_ARRAY_STRIDE"

499 case 0x8625:

500 return "VERTEX_ATTRIB_ARRAY_TYPE"

501 case 0x886a:

502 return "VERTEX_ATTRIB_ARRAY_NORMALIZED"

503 case 0x8645:

504 return "VERTEX_ATTRIB_ARRAY_POINTER"

505 case 0x889f:

506 return "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"

507 case 0x8b9a:

508 return "IMPLEMENTATION_COLOR_READ_TYPE"

509 case 0x8b9b:

510 return "IMPLEMENTATION_COLOR_READ_FORMAT"

511 case 0x8b81:

512 return "COMPILE_STATUS"

513 case 0x8b84:

514 return "INFO_LOG_LENGTH"

515 case 0x8b88:

516 return "SHADER_SOURCE_LENGTH"

517 case 0x8dfa:

518 return "SHADER_COMPILER"

519 case 0x8df8:

520 return "SHADER_BINARY_FORMATS"

521 case 0x8df9:

522 return "NUM_SHADER_BINARY_FORMATS"

523 case 0x8df0:

524 return "LOW_FLOAT"

525 case 0x8df1:

526 return "MEDIUM_FLOAT"

527 case 0x8df2:

528 return "HIGH_FLOAT"

529 case 0x8df3:

530 return "LOW_INT"

531 case 0x8df4:

532 return "MEDIUM_INT"

533 case 0x8df5:

534 return "HIGH_INT"

535 case 0x8d40:

536 return "FRAMEBUFFER"

537 case 0x8d41:

538 return "RENDERBUFFER"

539 case 0x8056:

540 return "RGBA4"

541 case 0x8057:

542 return "RGB5_A1"

543 case 0x8d62:

544 return "RGB565"

545 case 0x81a5:

546 return "DEPTH_COMPONENT16"

547 case 0x8d48:

548 return "STENCIL_INDEX8"

549 case 0x8d42:

550 return "RENDERBUFFER_WIDTH"

551 case 0x8d43:

552 return "RENDERBUFFER_HEIGHT"

553 case 0x8d44:

554 return "RENDERBUFFER_INTERNAL_FORMAT"

555 case 0x8d50:

556 return "RENDERBUFFER_RED_SIZE"

557 case 0x8d51:

558 return "RENDERBUFFER_GREEN_SIZE"

559 case 0x8d52:

560 return "RENDERBUFFER_BLUE_SIZE"

561 case 0x8d53:

562 return "RENDERBUFFER_ALPHA_SIZE"

563 case 0x8d54:

564 return "RENDERBUFFER_DEPTH_SIZE"

565 case 0x8d55:

566 return "RENDERBUFFER_STENCIL_SIZE"

567 case 0x8cd0:

568 return "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"

569 case 0x8cd1:

570 return "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"

571 case 0x8cd2:

572 return "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"

573 case 0x8cd3:

574 return "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"

575 case 0x8ce0:

576 return "COLOR_ATTACHMENT0"

577 case 0x8d00:

578 return "DEPTH_ATTACHMENT"

579 case 0x8d20:

580 return "STENCIL_ATTACHMENT"

581 case 0x8cd5:

582 return "FRAMEBUFFER_COMPLETE"

583 case 0x8cd6:

584 return "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"

585 case 0x8cd7:

586 return "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"

587 case 0x8cd9:

588 return "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"

589 case 0x8cdd:

590 return "FRAMEBUFFER_UNSUPPORTED"

591 case 0x8ca6:

592 return "FRAMEBUFFER_BINDING"

593 case 0x8ca7:

594 return "RENDERBUFFER_BINDING"

595 case 0x84e8:

596 return "MAX_RENDERBUFFER_SIZE"

597 case 0x506:

598 return "INVALID_FRAMEBUFFER_OPERATION"

599 case 0x100:

600 return "DEPTH_BUFFER_BIT"

601 case 0x400:

602 return "STENCIL_BUFFER_BIT"

603 case 0x4000:

604 return "COLOR_BUFFER_BIT"

605 case 0x8b50:

606 return "FLOAT_VEC2"

607 case 0x8b51:

608 return "FLOAT_VEC3"

609 case 0x8b52:

610 return "FLOAT_VEC4"

611 case 0x8b53:

612 return "INT_VEC2"

613 case 0x8b54:

614 return "INT_VEC3"

615 case 0x8b55:

616 return "INT_VEC4"

617 case 0x8b56:

618 return "BOOL"

619 case 0x8b57:

620 return "BOOL_VEC2"

621 case 0x8b58:

622 return "BOOL_VEC3"

623 case 0x8b59:

624 return "BOOL_VEC4"

625 case 0x8b5a:

626 return "FLOAT_MAT2"

627 case 0x8b5b:

628 return "FLOAT_MAT3"

629 case 0x8b5c:

630 return "FLOAT_MAT4"

631 case 0x8b5e:

632 return "SAMPLER_2D"

633 case 0x8b60:

634 return "SAMPLER_CUBE"

635 case 0x8b30:

636 return "FRAGMENT_SHADER"

637 case 0x8b31:

638 return "VERTEX_SHADER"

639 default:

640 return fmt.Sprintf("gl.Enum(0x%x)", uint32(v))

641 }

642 }

643

644 func ActiveTexture(texture Enum) {

645 defer func() {

646 errstr := errDrain()

647 log.Printf("gl.ActiveTexture(%v) %v", texture, errstr)

648 }()

649 C.glActiveTexture(texture.c())

650 }

651

652 func AttachShader(p Program, s Shader) {

653 defer func() {

654 errstr := errDrain()

655 log.Printf("gl.AttachShader(%v, %v) %v", p, s, errstr)

656 }()

657 C.glAttachShader(p.c(), s.c())

658 }

659

660 func BindAttribLocation(p Program, a Attrib, name string) {

661 defer func() {

662 errstr := errDrain()

663 log.Printf("gl.BindAttribLocation(%v, %v, %v) %v", p, a, name, e rrstr)

664 }()

665 str := unsafe.Pointer(C.CString(name))

666 defer C.free(str)

667 C.glBindAttribLocation(p.c(), a.c(), (*C.GLchar)(str))

668 }

669

670 func BindBuffer(target Enum, b Buffer) {

671 defer func() {

672 errstr := errDrain()

673 log.Printf("gl.BindBuffer(%v, %v) %v", target, b, errstr)

674 }()

675 C.glBindBuffer(target.c(), b.c())

676 }

677

678 func BindFramebuffer(target Enum, fb Framebuffer) {

679 defer func() {

680 errstr := errDrain()

681 log.Printf("gl.BindFramebuffer(%v, %v) %v", target, fb, errstr)

682 }()

683 C.glBindFramebuffer(target.c(), fb.c())

684 }

685

686 func BindRenderbuffer(target Enum, rb Renderbuffer) {

687 defer func() {

688 errstr := errDrain()

689 log.Printf("gl.BindRenderbuffer(%v, %v) %v", target, rb, errstr)

690 }()

691 C.glBindRenderbuffer(target.c(), rb.c())

692 }

693

694 func BindTexture(target Enum, t Texture) {

695 defer func() {

696 errstr := errDrain()

697 log.Printf("gl.BindTexture(%v, %v) %v", target, t, errstr)

698 }()

699 C.glBindTexture(target.c(), t.c())

700 }

701

702 func BlendColor(red, green, blue, alpha float32) {

703 defer func() {

704 errstr := errDrain()

705 log.Printf("gl.BlendColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)

706 }()

707 blendColor(red, green, blue, alpha)

708 }

709

710 func BlendEquation(mode Enum) {

711 defer func() {

712 errstr := errDrain()

713 log.Printf("gl.BlendEquation(%v) %v", mode, errstr)

714 }()

715 C.glBlendEquation(mode.c())

716 }

717

718 func BlendEquationSeparate(modeRGB, modeAlpha Enum) {

719 defer func() {

720 errstr := errDrain()

721 log.Printf("gl.BlendEquationSeparate(%v, %v) %v", modeRGB, modeA lpha, errstr)

722 }()

723 C.glBlendEquationSeparate(modeRGB.c(), modeAlpha.c())

724 }

725

726 func BlendFunc(sfactor, dfactor Enum) {

727 defer func() {

728 errstr := errDrain()

729 log.Printf("gl.BlendFunc(%v, %v) %v", sfactor, dfactor, errstr)

730 }()

731 C.glBlendFunc(sfactor.c(), dfactor.c())

732 }

733

734 func BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha Enum) {

735 defer func() {

736 errstr := errDrain()

737 log.Printf("gl.BlendFuncSeparate(%v, %v, %v, %v) %v", sfactorRGB , dfactorRGB, sfactorAlpha, dfactorAlpha, errstr)

738 }()

739 C.glBlendFuncSeparate(sfactorRGB.c(), dfactorRGB.c(), sfactorAlpha.c(), dfactorAlpha.c())

740 }

741

742 func BufferData(target Enum, usage Enum, src []byte) {

743 defer func() {

744 errstr := errDrain()

745 log.Printf("gl.BufferData(%v, %v, len(%d)) %v", target, usage, l en(src), errstr)

746 }()

747 C.glBufferData(target.c(), C.GLsizeiptr(len(src)), unsafe.Pointer(&src[0 ]), usage.c())

748 }

749

750 func BufferInit(target Enum, size int, usage Enum) {

751 defer func() {

752 errstr := errDrain()

753 log.Printf("gl.BufferInit(%v, %v, %v) %v", target, size, usage, errstr)

754 }()

755 C.glBufferData(target.c(), C.GLsizeiptr(size), nil, usage.c())

756 }

757

758 func BufferSubData(target Enum, offset int, data []byte) {

759 defer func() {

760 errstr := errDrain()

761 log.Printf("gl.BufferSubData(%v, %v, len(%d)) %v", target, offse t, len(data), errstr)

762 }()

763 C.glBufferSubData(target.c(), C.GLintptr(offset), C.GLsizeiptr(len(data) ), unsafe.Pointer(&data[0]))

764 }

765

766 func CheckFramebufferStatus(target Enum) (r0 Enum) {

767 defer func() {

768 errstr := errDrain()

769 log.Printf("gl.CheckFramebufferStatus(%v) %v%v", target, r0, err str)

770 }()

771 return Enum(C.glCheckFramebufferStatus(target.c()))

772 }

773

774 func Clear(mask Enum) {

775 defer func() {

776 errstr := errDrain()

777 log.Printf("gl.Clear(%v) %v", mask, errstr)

778 }()

779 C.glClear(C.GLbitfield(mask))

780 }

781

782 func ClearColor(red, green, blue, alpha float32) {

783 defer func() {

784 errstr := errDrain()

785 log.Printf("gl.ClearColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)

786 }()

787 clearColor(red, green, blue, alpha)

788 }

789

790 func ClearDepthf(d float32) {

791 defer func() {

792 errstr := errDrain()

793 log.Printf("gl.ClearDepthf(%v) %v", d, errstr)

794 }()

795 clearDepthf(d)

796 }

797

798 func ClearStencil(s int) {

799 defer func() {

800 errstr := errDrain()

801 log.Printf("gl.ClearStencil(%v) %v", s, errstr)

802 }()

803 C.glClearStencil(C.GLint(s))

804 }

805

806 func ColorMask(red, green, blue, alpha bool) {

807 defer func() {

808 errstr := errDrain()

809 log.Printf("gl.ColorMask(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)

810 }()

811 C.glColorMask(glBoolean(red), glBoolean(green), glBoolean(blue), glBoole an(alpha))

812 }

813

814 func CompileShader(s Shader) {

815 defer func() {

816 errstr := errDrain()

817 log.Printf("gl.CompileShader(%v) %v", s, errstr)

818 }()

819 C.glCompileShader(s.c())

820 }

821

822 func CompressedTexImage2D(target Enum, level int, internalformat Enum, width, he ight, border int, data []byte) {

823 defer func() {

824 errstr := errDrain()

825 log.Printf("gl.CompressedTexImage2D(%v, %v, %v, %v, %v, %v, len( %d)) %v", target, level, internalformat, width, height, border, len(data), errst r)

826 }()

827 C.glCompressedTexImage2D(target.c(), C.GLint(level), internalformat.c(), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(len(data)), uns afe.Pointer(&data[0]))

828 }

829

830 func CompressedTexSubImage2D(target Enum, level, xoffset, yoffset, width, height int, format Enum, data []byte) {

831 defer func() {

832 errstr := errDrain()

833 log.Printf("gl.CompressedTexSubImage2D(%v, %v, %v, %v, %v, %v, % v, len(%d)) %v", target, level, xoffset, yoffset, width, height, format, len(dat a), errstr)

834 }()

835 C.glCompressedTexSubImage2D(target.c(), C.GLint(level), C.GLint(xoffset) , C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), format.c(), C.GLsizei(l en(data)), unsafe.Pointer(&data[0]))

836 }

837

838 func CopyTexImage2D(target Enum, level int, internalformat Enum, x, y, width, he ight, border int) {

839 defer func() {

840 errstr := errDrain()

841 log.Printf("gl.CopyTexImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v ", target, level, internalformat, x, y, width, height, border, errstr)

842 }()

843 C.glCopyTexImage2D(target.c(), C.GLint(level), internalformat.c(), C.GLi nt(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border))

844 }

845

846 func CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) {

847 defer func() {

848 errstr := errDrain()

849 log.Printf("gl.CopyTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, xoffset, yoffset, x, y, width, height, errstr)

850 }()

851 C.glCopyTexSubImage2D(target.c(), C.GLint(level), C.GLint(xoffset), C.GL int(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))

852 }

853

854 func CreateProgram() (r0 Program) {

855 defer func() {

856 errstr := errDrain()

857 log.Printf("gl.CreateProgram() %v%v", r0, errstr)

858 }()

859 return Program{Value: uint32(C.glCreateProgram())}

860 }

861

862 func CreateShader(ty Enum) (r0 Shader) {

863 defer func() {

864 errstr := errDrain()

865 log.Printf("gl.CreateShader(%v) %v%v", ty, r0, errstr)

866 }()

867 return Shader{Value: uint32(C.glCreateShader(ty.c()))}

868 }

869

870 func CullFace(mode Enum) {

871 defer func() {

872 errstr := errDrain()

873 log.Printf("gl.CullFace(%v) %v", mode, errstr)

874 }()

875 C.glCullFace(mode.c())

876 }

877

878 func DeleteBuffer(v Buffer) {

879 defer func() {

880 errstr := errDrain()

881 log.Printf("gl.DeleteBuffer(%v) %v", v, errstr)

882 }()

883 C.glDeleteBuffers(1, (*C.GLuint)(&v.Value))

884 }

885

886 func DeleteFramebuffer(v Framebuffer) {

887 defer func() {

888 errstr := errDrain()

889 log.Printf("gl.DeleteFramebuffer(%v) %v", v, errstr)

890 }()

891 C.glDeleteFramebuffers(1, (*C.GLuint)(&v.Value))

892 }

893

894 func DeleteProgram(p Program) {

895 defer func() {

896 errstr := errDrain()

897 log.Printf("gl.DeleteProgram(%v) %v", p, errstr)

898 }()

899 C.glDeleteProgram(p.c())

900 }

901

902 func DeleteRenderbuffer(v Renderbuffer) {

903 defer func() {

904 errstr := errDrain()

905 log.Printf("gl.DeleteRenderbuffer(%v) %v", v, errstr)

906 }()

907 C.glDeleteRenderbuffers(1, (*C.GLuint)(&v.Value))

908 }

909

910 func DeleteShader(s Shader) {

911 defer func() {

912 errstr := errDrain()

913 log.Printf("gl.DeleteShader(%v) %v", s, errstr)

914 }()

915 C.glDeleteShader(s.c())

916 }

917

918 func DeleteTexture(v Texture) {

919 defer func() {

920 errstr := errDrain()

921 log.Printf("gl.DeleteTexture(%v) %v", v, errstr)

922 }()

923 C.glDeleteTextures(1, (*C.GLuint)(&v.Value))

924 }

925

926 func DepthFunc(fn Enum) {

927 defer func() {

928 errstr := errDrain()

929 log.Printf("gl.DepthFunc(%v) %v", fn, errstr)

930 }()

931 C.glDepthFunc(fn.c())

932 }

933

934 func DepthMask(flag bool) {

935 defer func() {

936 errstr := errDrain()

937 log.Printf("gl.DepthMask(%v) %v", flag, errstr)

938 }()

939 C.glDepthMask(glBoolean(flag))

940 }

941

942 func DepthRangef(n, f float32) {

943 defer func() {

944 errstr := errDrain()

945 log.Printf("gl.DepthRangef(%v, %v) %v", n, f, errstr)

946 }()

947 depthRangef(n, f)

948 }

949

950 func DetachShader(p Program, s Shader) {

951 defer func() {

952 errstr := errDrain()

953 log.Printf("gl.DetachShader(%v, %v) %v", p, s, errstr)

954 }()

955 C.glDetachShader(p.c(), s.c())

956 }

957

958 func Disable(cap Enum) {

959 defer func() {

960 errstr := errDrain()

961 log.Printf("gl.Disable(%v) %v", cap, errstr)

962 }()

963 C.glDisable(cap.c())

964 }

965

966 func DisableVertexAttribArray(index Attrib) {

967 defer func() {

968 errstr := errDrain()

969 log.Printf("gl.DisableVertexAttribArray(%v) %v", index, errstr)

970 }()

971 C.glDisableVertexAttribArray(index.c())

972 }

973

974 func DrawArrays(mode Enum, first, count int) {

975 defer func() {

976 errstr := errDrain()

977 log.Printf("gl.DrawArrays(%v, %v, %v) %v", mode, first, count, e rrstr)

978 }()

979 C.glDrawArrays(mode.c(), C.GLint(first), C.GLsizei(count))

980 }

981

982 func DrawElements(mode, ty Enum, offset, count int) {

983 defer func() {

984 errstr := errDrain()

985 log.Printf("gl.DrawElements(%v, %v, %v, %v) %v", mode, ty, offse t, count, errstr)

986 }()

987 C.glDrawElements(mode.c(), C.GLsizei(count), ty.c(), unsafe.Pointer(uint ptr(offset)))

988 }

989

990 func Enable(cap Enum) {

991 defer func() {

992 errstr := errDrain()

993 log.Printf("gl.Enable(%v) %v", cap, errstr)

994 }()

995 C.glEnable(cap.c())

996 }

997

998 func EnableVertexAttribArray(index Attrib) {

999 defer func() {

1000 errstr := errDrain()

1001 log.Printf("gl.EnableVertexAttribArray(%v) %v", index, errstr)

1002 }()

1003 C.glEnableVertexAttribArray(index.c())

1004 }

1005

1006 func Finish() {

1007 defer func() {

1008 errstr := errDrain()

1009 log.Printf("gl.Finish() %v", errstr)

1010 }()

1011 C.glFinish()

1012 }

1013

1014 func Flush() {

1015 defer func() {

1016 errstr := errDrain()

1017 log.Printf("gl.Flush() %v", errstr)

1018 }()

1019 C.glFlush()

1020 }

1021

1022 func FramebufferRenderbuffer(target, attachment, rbTarget Enum, rb Renderbuffer) {

1023 defer func() {

1024 errstr := errDrain()

1025 log.Printf("gl.FramebufferRenderbuffer(%v, %v, %v, %v) %v", targ et, attachment, rbTarget, rb, errstr)

1026 }()

1027 C.glFramebufferRenderbuffer(target.c(), attachment.c(), rbTarget.c(), rb .c())

1028 }

1029

1030 func FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level i nt) {

1031 defer func() {

1032 errstr := errDrain()

1033 log.Printf("gl.FramebufferTexture2D(%v, %v, %v, %v, %v) %v", tar get, attachment, texTarget, t, level, errstr)

1034 }()

1035 C.glFramebufferTexture2D(target.c(), attachment.c(), texTarget.c(), t.c( ), C.GLint(level))

1036 }

1037

1038 func FrontFace(mode Enum) {

1039 defer func() {

1040 errstr := errDrain()

1041 log.Printf("gl.FrontFace(%v) %v", mode, errstr)

1042 }()

1043 C.glFrontFace(mode.c())

1044 }

1045

1046 func GenBuffer() (r0 Buffer) {

1047 defer func() {

1048 errstr := errDrain()

1049 log.Printf("gl.GenBuffer() %v%v", r0, errstr)

1050 }()

1051 var b Buffer

1052 C.glGenBuffers(1, (*C.GLuint)(&b.Value))

1053 return b

1054 }

1055

1056 func GenerateMipmap(target Enum) {

1057 defer func() {

1058 errstr := errDrain()

1059 log.Printf("gl.GenerateMipmap(%v) %v", target, errstr)

1060 }()

1061 C.glGenerateMipmap(target.c())

1062 }

1063

1064 func GenFramebuffer() (r0 Framebuffer) {

1065 defer func() {

1066 errstr := errDrain()

1067 log.Printf("gl.GenFramebuffer() %v%v", r0, errstr)

1068 }()

1069 var b Framebuffer

1070 C.glGenFramebuffers(1, (*C.GLuint)(&b.Value))

1071 return b

1072 }

1073

1074 func GenRenderbuffer() (r0 Renderbuffer) {

1075 defer func() {

1076 errstr := errDrain()

1077 log.Printf("gl.GenRenderbuffer() %v%v", r0, errstr)

1078 }()

1079 var b Renderbuffer

1080 C.glGenRenderbuffers(1, (*C.GLuint)(&b.Value))

1081 return b

1082 }

1083

1084 func GenTexture() (r0 Texture) {

1085 defer func() {

1086 errstr := errDrain()

1087 log.Printf("gl.GenTexture() %v%v", r0, errstr)

1088 }()

1089 var t Texture

1090 C.glGenTextures(1, (*C.GLuint)(&t.Value))

1091 return t

1092 }

1093

1094 func GetActiveAttrib(p Program, a Attrib) (name string, size int, ty Enum) {

1095 defer func() {

1096 errstr := errDrain()

1097 log.Printf("gl.GetActiveAttrib(%v, %v) (%v, %v, %v) %v", p, a, n ame, size, ty, errstr)

1098 }()

1099 bufSize := GetProgrami(p, ACTIVE_ATTRIBUTE_MAX_LENGTH)

1100 buf := C.malloc(C.size_t(bufSize))

1101 defer C.free(buf)

1102 var cSize C.GLint

1103 var cType C.GLenum

1104 C.glGetActiveAttrib(p.c(), a.c(), C.GLsizei(bufSize), nil, &cSize, &cTyp e, (*C.GLchar)(buf))

1105 return C.GoString((*C.char)(buf)), int(cSize), Enum(cType)

1106 }

1107

1108 func GetActiveUniform(p Program, u Uniform) (name string, size int, ty Enum) {

1109 defer func() {

1110 errstr := errDrain()

1111 log.Printf("gl.GetActiveUniform(%v, %v) (%v, %v, %v) %v", p, u, name, size, ty, errstr)

1112 }()

1113 bufSize := GetProgrami(p, ACTIVE_UNIFORM_MAX_LENGTH)

1114 buf := C.malloc(C.size_t(bufSize))

1115 defer C.free(buf)

1116 var cSize C.GLint

1117 var cType C.GLenum

1118 C.glGetActiveUniform(p.c(), C.GLuint(u.Value), C.GLsizei(bufSize), nil, &cSize, &cType, (*C.GLchar)(buf))

1119 return C.GoString((*C.char)(buf)), int(cSize), Enum(cType)

1120 }

1121

1122 func GetAttachedShaders(p Program) (r0 []Shader) {

1123 defer func() {

1124 errstr := errDrain()

1125 log.Printf("gl.GetAttachedShaders(%v) %v%v", p, r0, errstr)

1126 }()

1127 shadersLen := GetProgrami(p, ATTACHED_SHADERS)

1128 var n C.GLsizei

1129 buf := make([]C.GLuint, shadersLen)

1130 C.glGetAttachedShaders(p.c(), C.GLsizei(shadersLen), &n, &buf[0])

1131 buf = buf[:int(n)]

1132 shaders := make([]Shader, len(buf))

1133 for i, s := range buf {

1134 shaders[i] = Shader{Value: uint32(s)}

1135 }

1136 return shaders

1137 }

1138

1139 func GetAttribLocation(p Program, name string) (r0 Attrib) {

1140 defer func() {

1141 errstr := errDrain()

1142 r0.name = name

1143 log.Printf("gl.GetAttribLocation(%v, %v) %v%v", p, name, r0, err str)

1144 }()

1145 str := unsafe.Pointer(C.CString(name))

1146 defer C.free(str)

1147 return Attrib{Value: uint(C.glGetAttribLocation(p.c(), (*C.GLchar)(str)) )}

1148 }

1149

1150 func GetBooleanv(dst []bool, pname Enum) {

1151 defer func() {

1152 errstr := errDrain()

1153 log.Printf("gl.GetBooleanv(%v, %v) %v", dst, pname, errstr)

1154 }()

1155 buf := make([]C.GLboolean, len(dst))

1156 C.glGetBooleanv(pname.c(), &buf[0])

1157 for i, v := range buf {

1158 dst[i] = v != 0

1159 }

1160 }

1161

1162 func GetFloatv(dst []float32, pname Enum) {

1163 defer func() {

1164 errstr := errDrain()

1165 log.Printf("gl.GetFloatv(len(%d), %v) %v", len(dst), pname, errs tr)

1166 }()

1167 C.glGetFloatv(pname.c(), (*C.GLfloat)(&dst[0]))

1168 }

1169

1170 func GetIntegerv(pname Enum, data []int32) {

1171 defer func() {

1172 errstr := errDrain()

1173 log.Printf("gl.GetIntegerv(%v, %v) %v", pname, data, errstr)

1174 }()

1175 buf := make([]C.GLint, len(data))

1176 C.glGetIntegerv(pname.c(), &buf[0])

1177 for i, v := range buf {

1178 data[i] = int32(v)

1179 }

1180 }

1181

1182 func GetInteger(pname Enum) (r0 int) {

1183 defer func() {

1184 errstr := errDrain()

1185 log.Printf("gl.GetInteger(%v) %v%v", pname, r0, errstr)

1186 }()

1187 var v C.GLint

1188 C.glGetIntegerv(pname.c(), &v)

1189 return int(v)

1190 }

1191

1192 func GetBufferParameteri(target, pname Enum) (r0 int) {

1193 defer func() {

1194 errstr := errDrain()

1195 log.Printf("gl.GetBufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)

1196 }()

1197 var params C.GLint

1198 C.glGetBufferParameteriv(target.c(), pname.c(), &params)

1199 return int(params)

1200 }

1201

1202 func GetError() (r0 Enum) {

1203 defer func() {

1204 errstr := errDrain()

1205 log.Printf("gl.GetError() %v%v", r0, errstr)

1206 }()

1207 return Enum(C.glGetError())

1208 }

1209

1210 func GetFramebufferAttachmentParameteri(target, attachment, pname Enum) (r0 int) {

1211 defer func() {

1212 errstr := errDrain()

1213 log.Printf("gl.GetFramebufferAttachmentParameteri(%v, %v, %v) %v %v", target, attachment, pname, r0, errstr)

1214 }()

1215 var params C.GLint

1216 C.glGetFramebufferAttachmentParameteriv(target.c(), attachment.c(), pnam e.c(), &params)

1217 return int(params)

1218 }

1219

1220 func GetProgrami(p Program, pname Enum) (r0 int) {

1221 defer func() {

1222 errstr := errDrain()

1223 log.Printf("gl.GetProgrami(%v, %v) %v%v", p, pname, r0, errstr)

1224 }()

1225 var params C.GLint

1226 C.glGetProgramiv(p.c(), pname.c(), &params)

1227 return int(params)

1228 }

1229

1230 func GetProgramInfoLog(p Program) (r0 string) {

1231 defer func() {

1232 errstr := errDrain()

1233 log.Printf("gl.GetProgramInfoLog(%v) %v%v", p, r0, errstr)

1234 }()

1235 infoLen := GetProgrami(p, INFO_LOG_LENGTH)

1236 buf := C.malloc(C.size_t(infoLen))

1237 C.free(buf)

1238 C.glGetProgramInfoLog(p.c(), C.GLsizei(infoLen), nil, (*C.GLchar)(buf))

1239 return C.GoString((*C.char)(buf))

1240 }

1241

1242 func GetRenderbufferParameteri(target, pname Enum) (r0 int) {

1243 defer func() {

1244 errstr := errDrain()

1245 log.Printf("gl.GetRenderbufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)

1246 }()

1247 var params C.GLint

1248 C.glGetRenderbufferParameteriv(target.c(), pname.c(), &params)

1249 return int(params)

1250 }

1251

1252 func GetShaderi(s Shader, pname Enum) (r0 int) {

1253 defer func() {

1254 errstr := errDrain()

1255 log.Printf("gl.GetShaderi(%v, %v) %v%v", s, pname, r0, errstr)

1256 }()

1257 var params C.GLint

1258 C.glGetShaderiv(s.c(), pname.c(), &params)

1259 return int(params)

1260 }

1261

1262 func GetShaderInfoLog(s Shader) (r0 string) {

1263 defer func() {

1264 errstr := errDrain()

1265 log.Printf("gl.GetShaderInfoLog(%v) %v%v", s, r0, errstr)

1266 }()

1267 infoLen := GetShaderi(s, INFO_LOG_LENGTH)

1268 buf := C.malloc(C.size_t(infoLen))

1269 defer C.free(buf)

1270 C.glGetShaderInfoLog(s.c(), C.GLsizei(infoLen), nil, (*C.GLchar)(buf))

1271 return C.GoString((*C.char)(buf))

1272 }

1273

1274 func GetShaderPrecisionFormat(shadertype, precisiontype Enum) (rangeLow, rangeHi gh, precision int) {

1275 defer func() {

1276 errstr := errDrain()

1277 log.Printf("gl.GetShaderPrecisionFormat(%v, %v) (%v, %v, %v) %v" , shadertype, precisiontype, rangeLow, rangeHigh, precision, errstr)

1278 }()

1279 const glintSize = 4

1280 var cRange [2]C.GLint

1281 var cPrecision C.GLint

1282 C.glGetShaderPrecisionFormat(shadertype.c(), precisiontype.c(), &cRange[ 0], &cPrecision)

1283 return int(cRange[0]), int(cRange[1]), int(cPrecision)

1284 }

1285

1286 func GetShaderSource(s Shader) (r0 string) {

1287 defer func() {

1288 errstr := errDrain()

1289 log.Printf("gl.GetShaderSource(%v) %v%v", s, r0, errstr)

1290 }()

1291 sourceLen := GetShaderi(s, SHADER_SOURCE_LENGTH)

1292 if sourceLen == 0 {

1293 return ""

1294 }

1295 buf := C.malloc(C.size_t(sourceLen))

1296 defer C.free(buf)

1297 C.glGetShaderSource(s.c(), C.GLsizei(sourceLen), nil, (*C.GLchar)(buf))

1298 return C.GoString((*C.char)(buf))

1299 }

1300

1301 func GetString(name Enum) (r0 string) {

1302 defer func() {

1303 errstr := errDrain()

1304 log.Printf("gl.GetString(%v) %v%v", name, r0, errstr)

1305 }()

1306 return C.GoString((*C.char)((unsafe.Pointer)(C.glGetString(name.c()))))

1307 }

1308

1309 func GetTexParameterfv(dst []float32, target, pname Enum) {

1310 defer func() {

1311 errstr := errDrain()

1312 log.Printf("gl.GetTexParameterfv(len(%d), %v, %v) %v", len(dst), target, pname, errstr)

1313 }()

1314 C.glGetTexParameterfv(target.c(), pname.c(), (*C.GLfloat)(&dst[0]))

1315 }

1316

1317 func GetTexParameteriv(dst []int32, target, pname Enum) {

1318 defer func() {

1319 errstr := errDrain()

1320 log.Printf("gl.GetTexParameteriv(%v, %v, %v) %v", dst, target, p name, errstr)

1321 }()

1322 C.glGetTexParameteriv(target.c(), pname.c(), (*C.GLint)(&dst[0]))

1323 }

1324

1325 func GetUniformfv(dst []float32, src Uniform, p Program) {

1326 defer func() {

1327 errstr := errDrain()

1328 log.Printf("gl.GetUniformfv(len(%d), %v, %v) %v", len(dst), src, p, errstr)

1329 }()

1330 C.glGetUniformfv(p.c(), src.c(), (*C.GLfloat)(&dst[0]))

1331 }

1332

1333 func GetUniformiv(dst []int32, src Uniform, p Program) {

1334 defer func() {

1335 errstr := errDrain()

1336 log.Printf("gl.GetUniformiv(%v, %v, %v) %v", dst, src, p, errstr )

1337 }()

1338 C.glGetUniformiv(p.c(), src.c(), (*C.GLint)(&dst[0]))

1339 }

1340

1341 func GetUniformLocation(p Program, name string) (r0 Uniform) {

1342 defer func() {

1343 errstr := errDrain()

1344 r0.name = name

1345 log.Printf("gl.GetUniformLocation(%v, %v) %v%v", p, name, r0, er rstr)

1346 }()

1347 str := C.CString(name)

1348 defer C.free((unsafe.Pointer)(str))

1349 return Uniform{Value: int32(C.glGetUniformLocation(p.c(), (*C.GLchar)(st r)))}

1350 }

1351

1352 func GetVertexAttribf(src Attrib, pname Enum) (r0 float32) {

1353 defer func() {

1354 errstr := errDrain()

1355 log.Printf("gl.GetVertexAttribf(%v, %v) %v%v", src, pname, r0, e rrstr)

1356 }()

1357 var params C.GLfloat

1358 C.glGetVertexAttribfv(src.c(), pname.c(), &params)

1359 return float32(params)

1360 }

1361

1362 func GetVertexAttribfv(dst []float32, src Attrib, pname Enum) {

1363 defer func() {

1364 errstr := errDrain()

1365 log.Printf("gl.GetVertexAttribfv(len(%d), %v, %v) %v", len(dst), src, pname, errstr)

1366 }()

1367 C.glGetVertexAttribfv(src.c(), pname.c(), (*C.GLfloat)(&dst[0]))

1368 }

1369

1370 func GetVertexAttribi(src Attrib, pname Enum) (r0 int32) {

1371 defer func() {

1372 errstr := errDrain()

1373 log.Printf("gl.GetVertexAttribi(%v, %v) %v%v", src, pname, r0, e rrstr)

1374 }()

1375 var params C.GLint

1376 C.glGetVertexAttribiv(src.c(), pname.c(), &params)

1377 return int32(params)

1378 }

1379

1380 func GetVertexAttribiv(dst []int32, src Attrib, pname Enum) {

1381 defer func() {

1382 errstr := errDrain()

1383 log.Printf("gl.GetVertexAttribiv(%v, %v, %v) %v", dst, src, pnam e, errstr)

1384 }()

1385 C.glGetVertexAttribiv(src.c(), pname.c(), (*C.GLint)(&dst[0]))

1386 }

1387

1388 func Hint(target, mode Enum) {

1389 defer func() {

1390 errstr := errDrain()

1391 log.Printf("gl.Hint(%v, %v) %v", target, mode, errstr)

1392 }()

1393 C.glHint(target.c(), mode.c())

1394 }

1395

1396 func IsBuffer(b Buffer) (r0 bool) {

1397 defer func() {

1398 errstr := errDrain()

1399 log.Printf("gl.IsBuffer(%v) %v%v", b, r0, errstr)

1400 }()

1401 return C.glIsBuffer(b.c()) != 0

1402 }

1403

1404 func IsEnabled(cap Enum) (r0 bool) {

1405 defer func() {

1406 errstr := errDrain()

1407 log.Printf("gl.IsEnabled(%v) %v%v", cap, r0, errstr)

1408 }()

1409 return C.glIsEnabled(cap.c()) != 0

1410 }

1411

1412 func IsFramebuffer(fb Framebuffer) (r0 bool) {

1413 defer func() {

1414 errstr := errDrain()

1415 log.Printf("gl.IsFramebuffer(%v) %v%v", fb, r0, errstr)

1416 }()

1417 return C.glIsFramebuffer(fb.c()) != 0

1418 }

1419

1420 func IsProgram(p Program) (r0 bool) {

1421 defer func() {

1422 errstr := errDrain()

1423 log.Printf("gl.IsProgram(%v) %v%v", p, r0, errstr)

1424 }()

1425 return C.glIsProgram(p.c()) != 0

1426 }

1427

1428 func IsRenderbuffer(rb Renderbuffer) (r0 bool) {

1429 defer func() {

1430 errstr := errDrain()

1431 log.Printf("gl.IsRenderbuffer(%v) %v%v", rb, r0, errstr)

1432 }()

1433 return C.glIsRenderbuffer(rb.c()) != 0

1434 }

1435

1436 func IsShader(s Shader) (r0 bool) {

1437 defer func() {

1438 errstr := errDrain()

1439 log.Printf("gl.IsShader(%v) %v%v", s, r0, errstr)

1440 }()

1441 return C.glIsShader(s.c()) != 0

1442 }

1443

1444 func IsTexture(t Texture) (r0 bool) {

1445 defer func() {

1446 errstr := errDrain()

1447 log.Printf("gl.IsTexture(%v) %v%v", t, r0, errstr)

1448 }()

1449 return C.glIsTexture(t.c()) != 0

1450 }

1451

1452 func LineWidth(width float32) {

1453 defer func() {

1454 errstr := errDrain()

1455 log.Printf("gl.LineWidth(%v) %v", width, errstr)

1456 }()

1457 C.glLineWidth(C.GLfloat(width))

1458 }

1459

1460 func LinkProgram(p Program) {

1461 defer func() {

1462 errstr := errDrain()

1463 log.Printf("gl.LinkProgram(%v) %v", p, errstr)

1464 }()

1465 C.glLinkProgram(p.c())

1466 }

1467

1468 func PixelStorei(pname Enum, param int32) {

1469 defer func() {

1470 errstr := errDrain()

1471 log.Printf("gl.PixelStorei(%v, %v) %v", pname, param, errstr)

1472 }()

1473 C.glPixelStorei(pname.c(), C.GLint(param))

1474 }

1475

1476 func PolygonOffset(factor, units float32) {

1477 defer func() {

1478 errstr := errDrain()

1479 log.Printf("gl.PolygonOffset(%v, %v) %v", factor, units, errstr)

1480 }()

1481 C.glPolygonOffset(C.GLfloat(factor), C.GLfloat(units))

1482 }

1483

1484 func ReadPixels(dst []byte, x, y, width, height int, format, ty Enum) {

1485 defer func() {

1486 errstr := errDrain()

1487 log.Printf("gl.ReadPixels(len(%d), %v, %v, %v, %v, %v, %v) %v", len(dst), x, y, width, height, format, ty, errstr)

1488 }()

1489 C.glReadPixels(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(heigh t), format.c(), ty.c(), unsafe.Pointer(&dst[0]))

1490 }

1491

1492 func ReleaseShaderCompiler() {

1493 defer func() {

1494 errstr := errDrain()

1495 log.Printf("gl.ReleaseShaderCompiler() %v", errstr)

1496 }()

1497 C.glReleaseShaderCompiler()

1498 }

1499

1500 func RenderbufferStorage(target, internalFormat Enum, width, height int) {

1501 defer func() {

1502 errstr := errDrain()

1503 log.Printf("gl.RenderbufferStorage(%v, %v, %v, %v) %v", target, internalFormat, width, height, errstr)

1504 }()

1505 C.glRenderbufferStorage(target.c(), internalFormat.c(), C.GLsizei(width) , C.GLsizei(height))

1506 }

1507

1508 func SampleCoverage(value float32, invert bool) {

1509 defer func() {

1510 errstr := errDrain()

1511 log.Printf("gl.SampleCoverage(%v, %v) %v", value, invert, errstr )

1512 }()

1513 sampleCoverage(value, invert)

1514 }

1515

1516 func Scissor(x, y, width, height int32) {

1517 defer func() {

1518 errstr := errDrain()

1519 log.Printf("gl.Scissor(%v, %v, %v, %v) %v", x, y, width, height, errstr)

1520 }()

1521 C.glScissor(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))

1522 }

1523

1524 func ShaderSource(s Shader, src string) {

1525 defer func() {

1526 errstr := errDrain()

1527 log.Printf("gl.ShaderSource(%v, %v) %v", s, src, errstr)

1528 }()

1529 str := (*C.GLchar)(C.CString(src))

1530 defer C.free(unsafe.Pointer(str))

1531 C.glShaderSource(s.c(), 1, &str, nil)

1532 }

1533

1534 func StencilFunc(fn Enum, ref int, mask uint32) {

1535 defer func() {

1536 errstr := errDrain()

1537 log.Printf("gl.StencilFunc(%v, %v, %v) %v", fn, ref, mask, errst r)

1538 }()

1539 C.glStencilFunc(fn.c(), C.GLint(ref), C.GLuint(mask))

1540 }

1541

1542 func StencilFuncSeparate(face, fn Enum, ref int, mask uint32) {

1543 defer func() {

1544 errstr := errDrain()

1545 log.Printf("gl.StencilFuncSeparate(%v, %v, %v, %v) %v", face, fn , ref, mask, errstr)

1546 }()

1547 C.glStencilFuncSeparate(face.c(), fn.c(), C.GLint(ref), C.GLuint(mask))

1548 }

1549

1550 func StencilMask(mask uint32) {

1551 defer func() {

1552 errstr := errDrain()

1553 log.Printf("gl.StencilMask(%v) %v", mask, errstr)

1554 }()

1555 C.glStencilMask(C.GLuint(mask))

1556 }

1557

1558 func StencilMaskSeparate(face Enum, mask uint32) {

1559 defer func() {

1560 errstr := errDrain()

1561 log.Printf("gl.StencilMaskSeparate(%v, %v) %v", face, mask, errs tr)

1562 }()

1563 C.glStencilMaskSeparate(face.c(), C.GLuint(mask))

1564 }

1565

1566 func StencilOp(fail, zfail, zpass Enum) {

1567 defer func() {

1568 errstr := errDrain()

1569 log.Printf("gl.StencilOp(%v, %v, %v) %v", fail, zfail, zpass, er rstr)

1570 }()

1571 C.glStencilOp(fail.c(), zfail.c(), zpass.c())

1572 }

1573

1574 func StencilOpSeparate(face, sfail, dpfail, dppass Enum) {

1575 defer func() {

1576 errstr := errDrain()

1577 log.Printf("gl.StencilOpSeparate(%v, %v, %v, %v) %v", face, sfai l, dpfail, dppass, errstr)

1578 }()

1579 C.glStencilOpSeparate(face.c(), sfail.c(), dpfail.c(), dppass.c())

1580 }

1581

1582 func TexImage2D(target Enum, level int, width, height int, format Enum, ty Enum, data []byte) {

1583 defer func() {

1584 errstr := errDrain()

1585 log.Printf("gl.TexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, width, height, format, ty, len(data), errstr)

1586 }()

1587 p := unsafe.Pointer(nil)

1588 if len(data) > 0 {

1589 p = unsafe.Pointer(&data[0])

1590 }

1591 C.glTexImage2D(target.c(), C.GLint(level), C.GLint(format), C.GLsizei(wi dth), C.GLsizei(height), 0, format.c(), ty.c(), p)

1592 }

1593

1594 func TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty E num, data []byte) {

1595 defer func() {

1596 errstr := errDrain()

1597 log.Printf("gl.TexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v, len (%d)) %v", target, level, x, y, width, height, format, ty, len(data), errstr)

1598 }()

1599 C.glTexSubImage2D(target.c(), C.GLint(level), C.GLint(x), C.GLint(y), C. GLsizei(width), C.GLsizei(height), format.c(), ty.c(), unsafe.Pointer(&data[0]))

1600 }

1601

1602 func TexParameterf(target, pname Enum, param float32) {

1603 defer func() {

1604 errstr := errDrain()

1605 log.Printf("gl.TexParameterf(%v, %v, %v) %v", target, pname, par am, errstr)

1606 }()

1607 C.glTexParameterf(target.c(), pname.c(), C.GLfloat(param))

1608 }

1609

1610 func TexParameterfv(target, pname Enum, params []float32) {

1611 defer func() {

1612 errstr := errDrain()

1613 log.Printf("gl.TexParameterfv(%v, %v, len(%d)) %v", target, pnam e, len(params), errstr)

1614 }()

1615 C.glTexParameterfv(target.c(), pname.c(), (*C.GLfloat)(&params[0]))

1616 }

1617

1618 func TexParameteri(target, pname Enum, param int) {

1619 defer func() {

1620 errstr := errDrain()

1621 log.Printf("gl.TexParameteri(%v, %v, %v) %v", target, pname, par am, errstr)

1622 }()

1623 C.glTexParameteri(target.c(), pname.c(), C.GLint(param))

1624 }

1625

1626 func TexParameteriv(target, pname Enum, params []int32) {

1627 defer func() {

1628 errstr := errDrain()

1629 log.Printf("gl.TexParameteriv(%v, %v, %v) %v", target, pname, pa rams, errstr)

1630 }()

1631 C.glTexParameteriv(target.c(), pname.c(), (*C.GLint)(&params[0]))

1632 }

1633

1634 func Uniform1f(dst Uniform, v float32) {

1635 defer func() {

1636 errstr := errDrain()

1637 log.Printf("gl.Uniform1f(%v, %v) %v", dst, v, errstr)

1638 }()

1639 C.glUniform1f(dst.c(), C.GLfloat(v))

1640 }

1641

1642 func Uniform1fv(dst Uniform, src []float32) {

1643 defer func() {

1644 errstr := errDrain()

1645 log.Printf("gl.Uniform1fv(%v, len(%d)) %v", dst, len(src), errst r)

1646 }()

1647 C.glUniform1fv(dst.c(), C.GLsizei(len(src)), (*C.GLfloat)(&src[0]))

1648 }

1649

1650 func Uniform1i(dst Uniform, v int) {

1651 defer func() {

1652 errstr := errDrain()

1653 log.Printf("gl.Uniform1i(%v, %v) %v", dst, v, errstr)

1654 }()

1655 C.glUniform1i(dst.c(), C.GLint(v))

1656 }

1657

1658 func Uniform1iv(dst Uniform, src []int32) {

1659 defer func() {

1660 errstr := errDrain()

1661 log.Printf("gl.Uniform1iv(%v, %v) %v", dst, src, errstr)

1662 }()

1663 C.glUniform1iv(dst.c(), C.GLsizei(len(src)), (*C.GLint)(&src[0]))

1664 }

1665

1666 func Uniform2f(dst Uniform, v0, v1 float32) {

1667 defer func() {

1668 errstr := errDrain()

1669 log.Printf("gl.Uniform2f(%v, %v, %v) %v", dst, v0, v1, errstr)

1670 }()

1671 C.glUniform2f(dst.c(), C.GLfloat(v0), C.GLfloat(v1))

1672 }

1673

1674 func Uniform2fv(dst Uniform, src []float32) {

1675 defer func() {

1676 errstr := errDrain()

1677 log.Printf("gl.Uniform2fv(%v, len(%d)) %v", dst, len(src), errst r)

1678 }()

1679 C.glUniform2fv(dst.c(), C.GLsizei(len(src)/2), (*C.GLfloat)(&src[0]))

1680 }

1681

1682 func Uniform2i(dst Uniform, v0, v1 int) {

1683 defer func() {

1684 errstr := errDrain()

1685 log.Printf("gl.Uniform2i(%v, %v, %v) %v", dst, v0, v1, errstr)

1686 }()

1687 C.glUniform2i(dst.c(), C.GLint(v0), C.GLint(v1))

1688 }

1689

1690 func Uniform2iv(dst Uniform, src []int32) {

1691 defer func() {

1692 errstr := errDrain()

1693 log.Printf("gl.Uniform2iv(%v, %v) %v", dst, src, errstr)

1694 }()

1695 C.glUniform2iv(dst.c(), C.GLsizei(len(src)/2), (*C.GLint)(&src[0]))

1696 }

1697

1698 func Uniform3f(dst Uniform, v0, v1, v2 float32) {

1699 defer func() {

1700 errstr := errDrain()

1701 log.Printf("gl.Uniform3f(%v, %v, %v, %v) %v", dst, v0, v1, v2, e rrstr)

1702 }()

1703 C.glUniform3f(dst.c(), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2))

1704 }

1705

1706 func Uniform3fv(dst Uniform, src []float32) {

1707 defer func() {

1708 errstr := errDrain()

1709 log.Printf("gl.Uniform3fv(%v, len(%d)) %v", dst, len(src), errst r)

1710 }()

1711 C.glUniform3fv(dst.c(), C.GLsizei(len(src)/3), (*C.GLfloat)(&src[0]))

1712 }

1713

1714 func Uniform3i(dst Uniform, v0, v1, v2 int32) {

1715 defer func() {

1716 errstr := errDrain()

1717 log.Printf("gl.Uniform3i(%v, %v, %v, %v) %v", dst, v0, v1, v2, e rrstr)

1718 }()

1719 C.glUniform3i(dst.c(), C.GLint(v0), C.GLint(v1), C.GLint(v2))

1720 }

1721

1722 func Uniform3iv(dst Uniform, src []int32) {

1723 defer func() {

1724 errstr := errDrain()

1725 log.Printf("gl.Uniform3iv(%v, %v) %v", dst, src, errstr)

1726 }()

1727 C.glUniform3iv(dst.c(), C.GLsizei(len(src)/3), (*C.GLint)(&src[0]))

1728 }

1729

1730 func Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {

1731 defer func() {

1732 errstr := errDrain()

1733 log.Printf("gl.Uniform4f(%v, %v, %v, %v, %v) %v", dst, v0, v1, v 2, v3, errstr)

1734 }()

1735 C.glUniform4f(dst.c(), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GL float(v3))

1736 }

1737

1738 func Uniform4fv(dst Uniform, src []float32) {

1739 defer func() {

1740 errstr := errDrain()

1741 log.Printf("gl.Uniform4fv(%v, len(%d)) %v", dst, len(src), errst r)

1742 }()

1743 C.glUniform4fv(dst.c(), C.GLsizei(len(src)/4), (*C.GLfloat)(&src[0]))

1744 }

1745

1746 func Uniform4i(dst Uniform, v0, v1, v2, v3 int32) {

1747 defer func() {

1748 errstr := errDrain()

1749 log.Printf("gl.Uniform4i(%v, %v, %v, %v, %v) %v", dst, v0, v1, v 2, v3, errstr)

1750 }()

1751 C.glUniform4i(dst.c(), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3 ))

1752 }

1753

1754 func Uniform4iv(dst Uniform, src []int32) {

1755 defer func() {

1756 errstr := errDrain()

1757 log.Printf("gl.Uniform4iv(%v, %v) %v", dst, src, errstr)

1758 }()

1759 C.glUniform4iv(dst.c(), C.GLsizei(len(src)/4), (*C.GLint)(&src[0]))

1760 }

1761

1762 func UniformMatrix2fv(dst Uniform, src []float32) {

1763 defer func() {

1764 errstr := errDrain()

1765 log.Printf("gl.UniformMatrix2fv(%v, len(%d)) %v", dst, len(src), errstr)

1766 }()

1767 C.glUniformMatrix2fv(dst.c(), C.GLsizei(len(src)/4), 0, (*C.GLfloat)(&sr c[0]))

1768 }

1769

1770 func UniformMatrix3fv(dst Uniform, src []float32) {

1771 defer func() {

1772 errstr := errDrain()

1773 log.Printf("gl.UniformMatrix3fv(%v, len(%d)) %v", dst, len(src), errstr)

1774 }()

1775 C.glUniformMatrix3fv(dst.c(), C.GLsizei(len(src)/9), 0, (*C.GLfloat)(&sr c[0]))

1776 }

1777

1778 func UniformMatrix4fv(dst Uniform, src []float32) {

1779 defer func() {

1780 errstr := errDrain()

1781 log.Printf("gl.UniformMatrix4fv(%v, len(%d)) %v", dst, len(src), errstr)

1782 }()

1783 C.glUniformMatrix4fv(dst.c(), C.GLsizei(len(src)/16), 0, (*C.GLfloat)(&s rc[0]))

1784 }

1785

1786 func UseProgram(p Program) {

1787 defer func() {

1788 errstr := errDrain()

1789 log.Printf("gl.UseProgram(%v) %v", p, errstr)

1790 }()

1791 C.glUseProgram(p.c())

1792 }

1793

1794 func ValidateProgram(p Program) {

1795 defer func() {

1796 errstr := errDrain()

1797 log.Printf("gl.ValidateProgram(%v) %v", p, errstr)

1798 }()

1799 C.glValidateProgram(p.c())

1800 }

1801

1802 func VertexAttrib1f(dst Attrib, x float32) {

1803 defer func() {

1804 errstr := errDrain()

1805 log.Printf("gl.VertexAttrib1f(%v, %v) %v", dst, x, errstr)

1806 }()

1807 C.glVertexAttrib1f(dst.c(), C.GLfloat(x))

1808 }

1809

1810 func VertexAttrib1fv(dst Attrib, src []float32) {

1811 defer func() {

1812 errstr := errDrain()

1813 log.Printf("gl.VertexAttrib1fv(%v, len(%d)) %v", dst, len(src), errstr)

1814 }()

1815 C.glVertexAttrib1fv(dst.c(), (*C.GLfloat)(&src[0]))

1816 }

1817

1818 func VertexAttrib2f(dst Attrib, x, y float32) {

1819 defer func() {

1820 errstr := errDrain()

1821 log.Printf("gl.VertexAttrib2f(%v, %v, %v) %v", dst, x, y, errstr )

1822 }()

1823 C.glVertexAttrib2f(dst.c(), C.GLfloat(x), C.GLfloat(y))

1824 }

1825

1826 func VertexAttrib2fv(dst Attrib, src []float32) {

1827 defer func() {

1828 errstr := errDrain()

1829 log.Printf("gl.VertexAttrib2fv(%v, len(%d)) %v", dst, len(src), errstr)

1830 }()

1831 C.glVertexAttrib2fv(dst.c(), (*C.GLfloat)(&src[0]))

1832 }

1833

1834 func VertexAttrib3f(dst Attrib, x, y, z float32) {

1835 defer func() {

1836 errstr := errDrain()

1837 log.Printf("gl.VertexAttrib3f(%v, %v, %v, %v) %v", dst, x, y, z, errstr)

1838 }()

1839 C.glVertexAttrib3f(dst.c(), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z))

1840 }

1841

1842 func VertexAttrib3fv(dst Attrib, src []float32) {

1843 defer func() {

1844 errstr := errDrain()

1845 log.Printf("gl.VertexAttrib3fv(%v, len(%d)) %v", dst, len(src), errstr)

1846 }()

1847 C.glVertexAttrib3fv(dst.c(), (*C.GLfloat)(&src[0]))

1848 }

1849

1850 func VertexAttrib4f(dst Attrib, x, y, z, w float32) {

1851 defer func() {

1852 errstr := errDrain()

1853 log.Printf("gl.VertexAttrib4f(%v, %v, %v, %v, %v) %v", dst, x, y , z, w, errstr)

1854 }()

1855 C.glVertexAttrib4f(dst.c(), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C. GLfloat(w))

1856 }

1857

1858 func VertexAttrib4fv(dst Attrib, src []float32) {

1859 defer func() {

1860 errstr := errDrain()

1861 log.Printf("gl.VertexAttrib4fv(%v, len(%d)) %v", dst, len(src), errstr)

1862 }()

1863 C.glVertexAttrib4fv(dst.c(), (*C.GLfloat)(&src[0]))

1864 }

1865

1866 func VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {

1867 defer func() {

1868 errstr := errDrain()

1869 log.Printf("gl.VertexAttribPointer(%v, %v, %v, %v, %v, %v) %v", dst, size, ty, normalized, stride, offset, errstr)

1870 }()

1871 n := glBoolean(normalized)

1872 s := C.GLsizei(stride)

1873 C.glVertexAttribPointer(dst.c(), C.GLint(size), ty.c(), n, s, unsafe.Poi nter(uintptr(offset)))

1874 }

1875

1876 func Viewport(x, y, width, height int) {

1877 defer func() {

1878 errstr := errDrain()

1879 log.Printf("gl.Viewport(%v, %v, %v, %v) %v", x, y, width, height , errstr)

1880 }()

1881 C.glViewport(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height) )

1882 }

OLD	NEW