| … | |
… | |
| 15 | template<class T> |
15 | template<class T> |
| 16 | struct sl_expr { |
16 | struct sl_expr { |
| 17 | const T t; |
17 | const T t; |
| 18 | sl_expr (const T &t) : t(t) { } |
18 | sl_expr (const T &t) : t(t) { } |
| 19 | void operator ()() const { t (); } |
19 | void operator ()() const { t (); } |
|
|
20 | template<typename expr> |
|
|
21 | const sl_expr &operator =(const expr &e) const; |
| 20 | }; |
22 | }; |
| 21 | |
23 | |
| 22 | template<class A, class B> |
24 | template<class A, class B> |
| 23 | struct sl_concat2 |
25 | struct sl_concat2 |
| 24 | { |
26 | { |
| … | |
… | |
| 274 | |
276 | |
| 275 | struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { }; |
277 | struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { }; |
| 276 | struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { }; |
278 | struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { }; |
| 277 | struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { }; |
279 | struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { }; |
| 278 | |
280 | |
| 279 | template<class uniform_i> |
281 | template<class var_i> |
| 280 | struct uniform_ref : ref<uniform_i> |
282 | struct var_ref : ref<var_i> |
| 281 | { |
283 | { |
| 282 | uniform_ref (const char *glname = 0) |
284 | var_ref (const char *glname = 0) |
| 283 | : ref<uniform_i> (*new uniform_i) |
285 | : ref<var_i> (*new var_i) |
| 284 | { |
286 | { |
| 285 | if (glname) |
287 | if (glname) |
| 286 | strcpy ((*this)->name, glname); |
288 | strcpy ((*this)->name, glname); |
| 287 | } |
289 | } |
| 288 | }; |
290 | }; |
| 289 | |
291 | |
| 290 | typedef uniform_ref<uniform_1f_i> uniform_1f; |
292 | typedef var_ref<uniform_1f_i> uniform_1f; |
| 291 | typedef uniform_ref<uniform_2f_i> uniform_2f; |
293 | typedef var_ref<uniform_2f_i> uniform_2f; |
| 292 | typedef uniform_ref<uniform_3f_i> uniform_3f; |
294 | typedef var_ref<uniform_3f_i> uniform_3f; |
| 293 | typedef uniform_ref<uniform_4f_i> uniform_4f; |
295 | typedef var_ref<uniform_4f_i> uniform_4f; |
| 294 | typedef uniform_ref<uniform_matrix_2f_i> uniform_matrix_2f; |
296 | typedef var_ref<uniform_matrix_2f_i> uniform_matrix_2f; |
| 295 | typedef uniform_ref<uniform_matrix_3f_i> uniform_matrix_3f; |
297 | typedef var_ref<uniform_matrix_3f_i> uniform_matrix_3f; |
| 296 | typedef uniform_ref<uniform_matrix_4f_i> uniform_matrix_4f; |
298 | typedef var_ref<uniform_matrix_4f_i> uniform_matrix_4f; |
| 297 | |
299 | |
| 298 | struct stream_i : var_i |
300 | struct stream_i : var_i |
| 299 | { |
301 | { |
| 300 | void build (shader_builder &b); |
302 | void build (shader_builder &b); |
| 301 | void build_decl (ostringstream &b); |
303 | void build_decl (ostringstream &b); |
| 302 | stream_i (const char *strtype) : var_i (strtype) { } |
304 | stream_i (const char *strtype); |
| 303 | }; |
305 | }; |
| 304 | |
306 | |
| 305 | template<int dimension, GLenum gltype, const char *strtype> |
307 | template<int dimension, GLenum gltype, const char *strtype> |
| 306 | struct varying_i : stream_i |
308 | struct varying_i : stream_i |
| 307 | { |
309 | { |
| 308 | varying_i (const char *glname) |
310 | varying_i () : stream_i (strtype) { } |
| 309 | : stream_i (strtype) |
|
|
| 310 | { |
|
|
| 311 | strcpy (name, glname); |
|
|
| 312 | } |
|
|
| 313 | |
311 | |
| 314 | void set (GLsizei stride, GLvoid *ptr) |
312 | void set (GLsizei stride, GLvoid *ptr) |
| 315 | { |
313 | { |
| 316 | //cgGLSetParameterPointer (param, dimension, gltype, stride, ptr); |
314 | //cgGLSetParameterPointer (param, dimension, gltype, stride, ptr); |
| 317 | } |
315 | } |
| 318 | }; |
316 | }; |
| 319 | |
317 | |
| 320 | template<int dimension, const char *strtype> |
318 | template<int dimension, const char *strtype> |
| 321 | struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype> |
319 | struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype> |
| 322 | { |
320 | { |
| 323 | varying_f_i (const char *glname) : varying_i<dimension, GL_FLOAT, strtype> (glname) { } |
|
|
| 324 | |
|
|
| 325 | void set (const gl::vertex_buffer_object &vb, GLint offset) |
321 | void set (const gl::vertex_buffer_object &vb, GLint offset) |
| 326 | { |
322 | { |
| 327 | varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset); |
323 | varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset); |
| 328 | } |
324 | } |
| 329 | }; |
325 | }; |
| 330 | |
326 | |
| 331 | struct varying_1f_i : varying_f_i<1, str_float> |
327 | struct varying_1f_i : varying_f_i<1, str_float> |
| 332 | { |
328 | { |
| 333 | varying_1f_i (const char *glname) : varying_f_i<1, str_float> (glname) { } |
|
|
| 334 | }; |
329 | }; |
| 335 | |
330 | |
| 336 | struct varying_2f_i : varying_f_i<2, str_vec2> |
331 | struct varying_2f_i : varying_f_i<2, str_vec2> |
| 337 | { |
332 | { |
| 338 | varying_2f_i (const char *glname) : varying_f_i<2, str_vec2> (glname) { } |
|
|
| 339 | |
|
|
| 340 | void set_t (const gl::vertex_buffer_object &vb) |
333 | void set_t (const gl::vertex_buffer_object &vb) |
| 341 | { |
334 | { |
| 342 | set (vb, gl::format_offset_t (vb.format)); |
335 | set (vb, gl::format_offset_t (vb.format)); |
| 343 | } |
336 | } |
| 344 | }; |
337 | }; |
| 345 | |
338 | |
| 346 | struct varying_3f_i : varying_f_i<3, str_vec3> |
339 | struct varying_3f_i : varying_f_i<3, str_vec3> |
| 347 | { |
340 | { |
| 348 | varying_3f_i (const char *glname) : varying_f_i<3, str_vec3> (glname) { } |
|
|
| 349 | |
|
|
| 350 | void set_p (const gl::vertex_buffer_object &vb) |
341 | void set_p (const gl::vertex_buffer_object &vb) |
| 351 | { |
342 | { |
| 352 | set (vb, gl::format_offset_p (vb.format)); |
343 | set (vb, gl::format_offset_p (vb.format)); |
| 353 | } |
344 | } |
| 354 | |
345 | |
| … | |
… | |
| 358 | } |
349 | } |
| 359 | }; |
350 | }; |
| 360 | |
351 | |
| 361 | struct varying_4f_i : varying_f_i<4, str_vec4> |
352 | struct varying_4f_i : varying_f_i<4, str_vec4> |
| 362 | { |
353 | { |
| 363 | varying_4f_i (const char *glname) : varying_f_i<4, str_vec4> (glname) { } |
|
|
| 364 | }; |
354 | }; |
| 365 | |
355 | |
| 366 | typedef auto_lvalue_ref1<varying_1f_i, const char *> varying_1f; |
356 | typedef var_ref<varying_1f_i> varying_1f; |
| 367 | typedef auto_lvalue_ref1<varying_2f_i, const char *> varying_2f; |
357 | typedef var_ref<varying_2f_i> varying_2f; |
| 368 | typedef auto_lvalue_ref1<varying_3f_i, const char *> varying_3f; |
358 | typedef var_ref<varying_3f_i> varying_3f; |
| 369 | typedef auto_lvalue_ref1<varying_4f_i, const char *> varying_4f; |
359 | typedef var_ref<varying_4f_i> varying_4f; |
| 370 | |
360 | |
| 371 | struct temporary_i : var_i |
361 | struct temporary_i : var_i |
| 372 | { |
362 | { |
| 373 | void build (shader_builder &b); |
363 | void build (shader_builder &b); |
| 374 | |
364 | |
| … | |
… | |
| 501 | void append (const ref<fragment_i> &f) |
491 | void append (const ref<fragment_i> &f) |
| 502 | { |
492 | { |
| 503 | push_back (f); |
493 | push_back (f); |
| 504 | } |
494 | } |
| 505 | |
495 | |
|
|
496 | template<class expr> |
|
|
497 | void append (const sl_expr<expr> &e) |
|
|
498 | { |
|
|
499 | e (); |
|
|
500 | } |
|
|
501 | |
| 506 | void append_const (const char *s) |
502 | void append_const (const char *s) |
| 507 | { |
503 | { |
| 508 | push_back (*new fragment_const_string_i (s)); |
504 | push_back (*new fragment_const_string_i (s)); |
| 509 | } |
505 | } |
| 510 | |
506 | |
| … | |
… | |
| 555 | }; |
551 | }; |
| 556 | |
552 | |
| 557 | typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader; |
553 | typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader; |
| 558 | typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader; |
554 | typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader; |
| 559 | |
555 | |
|
|
556 | template<typename T> |
|
|
557 | struct sl_append |
|
|
558 | { |
|
|
559 | T t; |
|
|
560 | |
|
|
561 | sl_append (const T &t) : t(t) { } |
|
|
562 | |
|
|
563 | void operator ()() const |
|
|
564 | { |
|
|
565 | cur->push_back (t); |
|
|
566 | } |
|
|
567 | }; |
|
|
568 | |
|
|
569 | template<int length> |
|
|
570 | struct sl_string |
|
|
571 | { |
|
|
572 | char str[length]; |
|
|
573 | |
|
|
574 | void operator ()() const |
|
|
575 | { |
|
|
576 | cur->push_back (*new fragment_string_i (str)); |
|
|
577 | } |
|
|
578 | }; |
|
|
579 | |
|
|
580 | // only floats |
|
|
581 | struct sl_float |
|
|
582 | { |
|
|
583 | const GLfloat c; |
|
|
584 | |
|
|
585 | sl_float (GLfloat c) : c(c) { } |
|
|
586 | |
|
|
587 | void operator ()() const |
|
|
588 | { |
|
|
589 | char s[64]; |
|
|
590 | sprintf (s, "%g", c); |
|
|
591 | cur->append_string (s); |
|
|
592 | } |
|
|
593 | }; |
|
|
594 | |
|
|
595 | template<class A, class B> |
|
|
596 | inline sl_expr< sl_concat2<A, B> > |
|
|
597 | concat (const A &a, const B &b) |
|
|
598 | { |
|
|
599 | typedef sl_concat2<A, B> expr; |
|
|
600 | return sl_expr<expr> (expr (a, b)); |
|
|
601 | } |
|
|
602 | |
|
|
603 | template<class A, class B, class C> |
|
|
604 | inline sl_expr< sl_concat3<A, B, C> > |
|
|
605 | concat (const A &a, const B &b, const C &c) |
|
|
606 | { |
|
|
607 | typedef sl_concat3<A, B, C> expr; |
|
|
608 | return sl_expr<expr> (expr (a, b, c)); |
|
|
609 | } |
|
|
610 | |
|
|
611 | template<class A, class B, class C, class D> |
|
|
612 | inline sl_expr< sl_concat4<A, B, C, D> > |
|
|
613 | concat (const A &a, const B &b, const C &c, const D &d) |
|
|
614 | { |
|
|
615 | typedef sl_concat4<A, B, C, D> expr; |
|
|
616 | return sl_expr<expr> (expr (a, b, c, d)); |
|
|
617 | } |
|
|
618 | |
|
|
619 | template<typename expr> |
|
|
620 | struct sl_convert |
|
|
621 | { |
|
|
622 | typedef sl_expr<expr> T; |
|
|
623 | static inline const T &convert (const T &e) |
|
|
624 | { |
|
|
625 | return e; |
|
|
626 | } |
|
|
627 | }; |
|
|
628 | |
|
|
629 | template<> |
|
|
630 | struct sl_convert<GLfloat> |
|
|
631 | { |
|
|
632 | typedef sl_expr<sl_float> T; |
|
|
633 | static inline const T convert (GLfloat f) |
|
|
634 | { |
|
|
635 | return sl_float (f); |
|
|
636 | } |
|
|
637 | }; |
|
|
638 | |
|
|
639 | template<> |
|
|
640 | struct sl_convert<GLdouble> |
|
|
641 | { |
|
|
642 | typedef sl_expr<sl_float> T; |
|
|
643 | static inline const T convert (GLdouble d) |
|
|
644 | { |
|
|
645 | return sl_float (d); |
|
|
646 | } |
|
|
647 | }; |
|
|
648 | |
|
|
649 | template<> |
|
|
650 | struct sl_convert<GLint> |
|
|
651 | { |
|
|
652 | typedef sl_expr<sl_float> T; |
|
|
653 | static inline const T convert (GLint i) |
|
|
654 | { |
|
|
655 | return sl_float (i); |
|
|
656 | } |
|
|
657 | }; |
|
|
658 | |
|
|
659 | template<> |
|
|
660 | struct sl_convert<vec3> |
|
|
661 | { |
|
|
662 | typedef sl_expr< sl_string<256> > T; |
|
|
663 | static inline const T convert (const vec3 &v) |
|
|
664 | { |
|
|
665 | sl_string<256> s; |
|
|
666 | sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z); |
|
|
667 | return s; |
|
|
668 | } |
|
|
669 | }; |
|
|
670 | |
|
|
671 | template<> |
|
|
672 | struct sl_convert<vec4> |
|
|
673 | { |
|
|
674 | typedef sl_expr< sl_string<256> > T; |
|
|
675 | static inline const T convert (const vec4 &v) |
|
|
676 | { |
|
|
677 | sl_string<256> s; |
|
|
678 | sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w); |
|
|
679 | return s; |
|
|
680 | } |
|
|
681 | }; |
|
|
682 | |
|
|
683 | template<> |
|
|
684 | template<class V> |
|
|
685 | struct sl_convert< var_ref<V> > |
|
|
686 | { |
|
|
687 | typedef sl_expr< sl_append< var_ref<V> > > T; |
|
|
688 | static inline const T convert (const var_ref<V> &v) |
|
|
689 | { |
|
|
690 | return sl_append< var_ref<V> > (v); |
|
|
691 | } |
|
|
692 | }; |
|
|
693 | |
|
|
694 | template<> |
|
|
695 | struct sl_convert<glvar> |
|
|
696 | { |
|
|
697 | typedef sl_expr< sl_append<glvar> > T; |
|
|
698 | static inline const T convert (const glvar &v) |
|
|
699 | { |
|
|
700 | return sl_append<glvar> (v); |
|
|
701 | } |
|
|
702 | }; |
|
|
703 | |
|
|
704 | template<> |
|
|
705 | template<const char *strtype> |
|
|
706 | struct sl_convert< temp_ref<strtype> > |
|
|
707 | { |
|
|
708 | typedef sl_expr< sl_append< temp_ref<strtype> > > T; |
|
|
709 | static inline const T convert (const temp_ref<strtype> &v) |
|
|
710 | { |
|
|
711 | return sl_expr< sl_append< temp_ref<strtype> > >( |
|
|
712 | sl_append< temp_ref<strtype> > (v) |
|
|
713 | ); |
|
|
714 | } |
|
|
715 | }; |
|
|
716 | |
|
|
717 | extern const fragment_const_string str_2sp; |
|
|
718 | extern const fragment_const_string str_equal; |
|
|
719 | extern const fragment_const_string str_endl; |
|
|
720 | |
|
|
721 | template<class fragment, typename expr> |
|
|
722 | inline void sl_assign (const fragment &f, const expr &e) |
|
|
723 | { |
|
|
724 | cur->append (str_2sp); |
|
|
725 | cur->append (f); |
|
|
726 | cur->append (str_equal); |
|
|
727 | sl_convert<expr>::convert (e) (); |
|
|
728 | cur->append (str_endl); |
|
|
729 | } |
|
|
730 | |
|
|
731 | template<class type> |
|
|
732 | template<typename expr> |
|
|
733 | inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const |
|
|
734 | { |
|
|
735 | sl_assign (*this, e); |
|
|
736 | return *this; |
|
|
737 | } |
|
|
738 | |
|
|
739 | template<class type, typename arg1> |
|
|
740 | template<typename expr> |
|
|
741 | inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const |
|
|
742 | { |
|
|
743 | sl_assign (*this, e); |
|
|
744 | return *this; |
|
|
745 | } |
|
|
746 | |
|
|
747 | template<class T> |
|
|
748 | template<typename expr> |
|
|
749 | inline const sl_expr<T> &sl_expr<T>::operator =(const expr &e) const |
|
|
750 | { |
|
|
751 | sl_assign (*this, e); |
|
|
752 | return *this; |
|
|
753 | } |
|
|
754 | |
|
|
755 | template<const char *strtype> |
|
|
756 | template<typename expr> |
|
|
757 | inline const temp_ref<strtype> &temp_ref<strtype>::operator =(const expr &e) const |
|
|
758 | { |
|
|
759 | sl_assign (*this, e); |
|
|
760 | return *this; |
|
|
761 | } |
|
|
762 | |
|
|
763 | struct sl_append_const_string |
|
|
764 | { |
|
|
765 | fragment_const_string str; |
|
|
766 | sl_append_const_string (const char *s) |
|
|
767 | : str (s) |
|
|
768 | { } |
|
|
769 | |
|
|
770 | void operator ()() const |
|
|
771 | { |
|
|
772 | cur->push_back (str); |
|
|
773 | } |
|
|
774 | }; |
|
|
775 | |
|
|
776 | # define SHADER_BINOP(op, str) \ |
|
|
777 | extern const sl_append_const_string str_ ## str; \ |
|
|
778 | template<typename A, typename B> \ |
|
|
779 | inline const sl_expr< sl_concat3< typename sl_convert<A>::T, \ |
|
|
780 | sl_append_const_string, \ |
|
|
781 | typename sl_convert<B>::T > > \ |
|
|
782 | operator op(const A &a, const B &b) \ |
|
|
783 | { \ |
|
|
784 | return concat (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b)); \ |
|
|
785 | } |
|
|
786 | |
|
|
787 | SHADER_BINOP (+, plus); |
|
|
788 | SHADER_BINOP (-, minus); |
|
|
789 | SHADER_BINOP (*, mul); |
|
|
790 | SHADER_BINOP (/, div); |
|
|
791 | |
|
|
792 | # undef SHADER_BINOP |
|
|
793 | |
|
|
794 | void swizzle_mask (sl_string<7> &s, int mask); |
| 560 | void debdebdebdebug ();//D |
795 | void debdebdebdebug ();//D |
| 561 | } |
796 | } |
| 562 | |
797 | |
| 563 | #endif |
798 | #endif |
| 564 | |
799 | |
