libgender/shader.C

#include "shader.h"
#include "shader_vars.h"

namespace shader {

  refcounted::~refcounted ()
  {
#if 0
    if (refcnt)
      abort ();
#endif
  }

  const char str_float  [] = "float";
  const char str_vec2   [] = "vec2";
  const char str_vec3   [] = "vec3";
  const char str_vec4   [] = "vec4";
  const char str_mat2   [] = "mat2";
  const char str_mat3   [] = "mat3";
  const char str_mat4   [] = "mat4";

  const char str_sampler_1d             [] = "sampler1D";
  const char str_sampler_1d_shadow      [] = "sampler1DShadow";
  const char str_sampler_2d             [] = "sampler2D";
  const char str_sampler_2d_shadow      [] = "sampler2DShadow";
  const char str_sampler_2d_rect        [] = "sampler2DRect";
  const char str_sampler_2d_rect_shadow [] = "sampler2DRectShadow";
  const char str_sampler_3d             [] = "sampler3D";
  const char str_sampler_3d_rect        [] = "sampler3DRect";
  const char str_sampler_cube           [] = "samplerCube";

  unsigned int var_i::next_id = 0;

  var_i::var_i (const char *typestr)
  : typestr (typestr)
  {
    //param = cgCreateParameter (cg_context, cgtype);
  }

  var_i::~var_i ()
  {
    //cgDestroyParameter (param);
  }

  temporary_i::temporary_i (const char *strtype)
  : var_i (strtype)
  {
    sprintf (name, "T%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
  }

  uniform_i::uniform_i (const char *strtype)
  : var_i (strtype), dirty (true)
  {
    sprintf (name, "U%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
  }

  fragment_string_i::~fragment_string_i ()
  {
    free (str);
  }

  ////////////////////////////////////////////////////////////////////////////

  void var_i::build_decl (ostringstream &b)
  {
    b << typestr << ' ' << name;
  }

  void uniform_i::build_decl (ostringstream &b)
  {
    b << "uniform " << typestr << ' ' << name;
  }

  void stream_i::build_decl (ostringstream &b)
  {
    b << typestr << ' ' << name;
  }

  ////////////////////////////////////////////////////////////////////////////

  void glvar_i::build (shader_builder &b)
  {
    b << name;
  }

  void var_i::build (shader_builder &b)
  {
    b << name;
  }

  void uniform_i::build (shader_builder &b)
  {
    var_i::build (b);

    if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
      b.refs.push_back (*this);
  }

  void stream_i::build (shader_builder &b)
  {
    var_i::build (b);

    if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
      b.streams.push_back (*this);
  }

  void temporary_i::build (shader_builder &b)
  {
    var_i::build (b);

    if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
      b.temps.push_back (*this);
  }

  void fragment_vector_i::build (shader_builder &b)
  {
    for (vector<fragment>::iterator i = begin (); i != end (); i++)
      (*i)->build (b);
  }

  void fragment_const_string_i::build (shader_builder &b)
  {
    b << str;
  }

  void fragment_string_i::build (shader_builder &b)
  {
    b << str;
  }

#if 0
  void statement_i::build (shader_builder &b)
  {
    b << "  ";
    fragment_vector_i::build (b);
    b << ";\n";
  }
#endif

  ////////////////////////////////////////////////////////////////////////////

  shader_object_i *cur = 0;

  shader_object_i::shader_object_i (GLenum type)
  : type (type)
  {
    id = glCreateShaderObjectARB (type);
  }

  shader_object_i::~shader_object_i ()
  {
    glDeleteObjectARB (id);
  }

  void shader_object_i::start ()
  {
    clear ();
    cur = this;
  }

  void shader_object_i::stop ()
  {
    cur = 0;
  }

  string shader_object_i::source ()
  {
    shader_builder b;
    build (b);
    ostringstream os;

    for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
      {
        (*i)->build_decl (os);
        os << ";\n";
      }

    // not neccessary right now, as GLSL is rich on predefinitions
    for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
      {
        os << "attribute ";
        (*i)->build_decl (os);
        os << ";\n";
      }

    os << "\nvoid main (void)\n{\n";

    for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
      {
        os << "  ";
        (*i)->build_decl (os);
        os << ";\n";
      }

    os << "\n";
    os << b.source.str ();
    os << "}\n";

    return os.str ();
  }

  void shader_object_i::compile ()
  {
    string src = source ();
    const char *sptr = src.data ();
    const int slen = src.size ();

        printf ("SOURCE<%s>\n", src.c_str ());
        abort ();
    glShaderSourceARB (id, 1, &sptr, &slen);
    glCompileShaderARB (id);

    GLint compiled;
    glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);

    if (!compiled)
      {
        char infolog[8192];
        glGetInfoLogARB (id, 8192, NULL, infolog);
        printf ("SOURCE<%s>\n", src.c_str ());
        printf ("INFOLOG<%s>\n", infolog);
        abort ();
      }
  }

  const sl_append_const_string str_plus  (" + "); 
  const sl_append_const_string str_minus (" - "); 
  const sl_append_const_string str_mul   (" * "); 
  const sl_append_const_string str_div   (" / "); 

  const sl_append_const_string str_rpar  (")");

  void debdebdebdebug ()//D
  {
    vertex_shader vsh;
    fragment_shader fsh;
    temp_4f t1, t2;
    sampler_2d s2d (1);

    vsh->start ();

    temp_4f lightpos;
    temp_3f wpos;

    lightpos = vec4 (10, -10, 0, 1);
    wpos = gl.model_view_matrix_inverse_transpose * vin.normal;
    vout.position = wpos;

    vsh->end ();
    vsh->compile ();
  }

}

Revision:	1.3
Committed:	Sat Oct 23 21:53:06 2004 UTC (21 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+0 -206 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "shader.h"
2			#include "shader_vars.h"
3
4			namespace shader {
5
6			refcounted::~refcounted ()
7			{
8			#if 0
9			if (refcnt)
10			abort ();
11			#endif
12			}
13
14			const char str_float [] = "float";
15			const char str_vec2 [] = "vec2";
16			const char str_vec3 [] = "vec3";
17			const char str_vec4 [] = "vec4";
18			const char str_mat2 [] = "mat2";
19			const char str_mat3 [] = "mat3";
20			const char str_mat4 [] = "mat4";
21
22			const char str_sampler_1d [] = "sampler1D";
23			const char str_sampler_1d_shadow [] = "sampler1DShadow";
24			const char str_sampler_2d [] = "sampler2D";
25			const char str_sampler_2d_shadow [] = "sampler2DShadow";
26			const char str_sampler_2d_rect [] = "sampler2DRect";
27			const char str_sampler_2d_rect_shadow [] = "sampler2DRectShadow";
28			const char str_sampler_3d [] = "sampler3D";
29			const char str_sampler_3d_rect [] = "sampler3DRect";
30			const char str_sampler_cube [] = "samplerCube";
31
32			unsigned int var_i::next_id = 0;
33
34			var_i::var_i (const char *typestr)
35			: typestr (typestr)
36			{
37			//param = cgCreateParameter (cg_context, cgtype);
38			}
39
40			var_i::~var_i ()
41			{
42			//cgDestroyParameter (param);
43			}
44
45			temporary_i::temporary_i (const char *strtype)
46			: var_i (strtype)
47			{
48			sprintf (name, "T%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
49			}
50
51			uniform_i::uniform_i (const char *strtype)
52			: var_i (strtype), dirty (true)
53			{
54			sprintf (name, "U%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
55			}
56
57			fragment_string_i::~fragment_string_i ()
58			{
59			free (str);
60			}
61
62			////////////////////////////////////////////////////////////////////////////
63
64			void var_i::build_decl (ostringstream &b)
65			{
66			b << typestr << ' ' << name;
67			}
68
69			void uniform_i::build_decl (ostringstream &b)
70			{
71			b << "uniform " << typestr << ' ' << name;
72			}
73
74			void stream_i::build_decl (ostringstream &b)
75			{
76			b << typestr << ' ' << name;
77			}
78
79			////////////////////////////////////////////////////////////////////////////
80
81			void glvar_i::build (shader_builder &b)
82			{
83			b << name;
84			}
85
86			void var_i::build (shader_builder &b)
87			{
88			b << name;
89			}
90
91			void uniform_i::build (shader_builder &b)
92			{
93			var_i::build (b);
94
95			if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
96			b.refs.push_back (*this);
97			}
98
99			void stream_i::build (shader_builder &b)
100			{
101			var_i::build (b);
102
103			if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
104			b.streams.push_back (*this);
105			}
106
107			void temporary_i::build (shader_builder &b)
108			{
109			var_i::build (b);
110
111			if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
112			b.temps.push_back (*this);
113			}
114
115			void fragment_vector_i::build (shader_builder &b)
116			{
117			for (vector<fragment>::iterator i = begin (); i != end (); i++)
118			(*i)->build (b);
119			}
120
121			void fragment_const_string_i::build (shader_builder &b)
122			{
123			b << str;
124			}
125
126			void fragment_string_i::build (shader_builder &b)
127			{
128			b << str;
129			}
130
131			#if 0
132			void statement_i::build (shader_builder &b)
133			{
134			b << " ";
135			fragment_vector_i::build (b);
136			b << ";\n";
137			}
138			#endif
139
140			////////////////////////////////////////////////////////////////////////////
141
142			shader_object_i *cur = 0;
143
144			shader_object_i::shader_object_i (GLenum type)
145			: type (type)
146			{
147			id = glCreateShaderObjectARB (type);
148			}
149
150			shader_object_i::~shader_object_i ()
151			{
152			glDeleteObjectARB (id);
153			}
154
155			void shader_object_i::start ()
156			{
157			clear ();
158			cur = this;
159			}
160
161			void shader_object_i::stop ()
162			{
163			cur = 0;
164			}
165
166			string shader_object_i::source ()
167			{
168			shader_builder b;
169			build (b);
170			ostringstream os;
171
172			for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
173			{
174			(*i)->build_decl (os);
175			os << ";\n";
176			}
177
178			// not neccessary right now, as GLSL is rich on predefinitions
179			for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
180			{
181			os << "attribute ";
182			(*i)->build_decl (os);
183			os << ";\n";
184			}
185
186			os << "\nvoid main (void)\n{\n";
187
188			for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
189			{
190			os << " ";
191			(*i)->build_decl (os);
192			os << ";\n";
193			}
194
195			os << "\n";
196			os << b.source.str ();
197			os << "}\n";
198
199			return os.str ();
200			}
201
202			void shader_object_i::compile ()
203			{
204			string src = source ();
205			const char *sptr = src.data ();
206			const int slen = src.size ();
207
208			printf ("SOURCE<%s>\n", src.c_str ());
209			abort ();
210			glShaderSourceARB (id, 1, &sptr, &slen);
211			glCompileShaderARB (id);
212
213			GLint compiled;
214			glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
215
216			if (!compiled)
217			{
218			char infolog[8192];
219			glGetInfoLogARB (id, 8192, NULL, infolog);
220			printf ("SOURCE<%s>\n", src.c_str ());
221			printf ("INFOLOG<%s>\n", infolog);
222			abort ();
223			}
224			}
225
226			const sl_append_const_string str_plus (" + ");
227			const sl_append_const_string str_minus (" - ");
228			const sl_append_const_string str_mul (" * ");
229			const sl_append_const_string str_div (" / ");
230
231			const sl_append_const_string str_rpar (")");
232
233			void debdebdebdebug ()//D
234			{
235			vertex_shader vsh;
236			fragment_shader fsh;
237			temp_4f t1, t2;
238			sampler_2d s2d (1);
239
240			vsh->start ();
241
242			temp_4f lightpos;
243			temp_3f wpos;
244
245			lightpos = vec4 (10, -10, 0, 1);
246			wpos = gl.model_view_matrix_inverse_transpose * vin.normal;
247			vout.position = wpos;
248
249			vsh->end ();
250			vsh->compile ();
251			}
252
253			}
254