libgender/material.C

#include "opengl.h"
#include "material.h"

#include <cstdlib>
#include <cstring>

#include <algorithm>

namespace shader {

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

  const char str_float    [] = "float";
  const char str_float2   [] = "float2";
  const char str_float3   [] = "float3";
  const char str_float4   [] = "float4";
  const char str_float4x4 [] = "float4x4";

  static CGcontext cg_context = cgCreateContext ();

  int var_i::next_name = 0;

  var_i::var_i (CGtype cgtype, const char *typestr)
  : typestr (typestr)
  {
    name = ++next_name;
    param = cgCreateParameter (cg_context, cgtype);
  }

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

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

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

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

  void var_i::build (shader_builder &b)
  {
    b << "V" << 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_const_string_i::build (shader_builder &b)
  {
    b << str;
  }

  struct vin vin;

  // MUST update is-function below
  varying_3f vin::position_3f  ("POSITION");
  varying_4f vin::position_4f  ("POSITION");
  varying_3f vin::normal_3f    ("NORMAL");
  varying_4f vin::normal_4f    ("NORMAL");
  varying_3f vin::color0_3f    ("COLOR0");
  varying_4f vin::color0_4f    ("COLOR0");
  varying_3f vin::color1_3f    ("COLOR1");
  varying_4f vin::color1_4f    ("COLOR1");
  varying_2f vin::texcoord0_2f ("TEXCOORD0");
  varying_4f vin::texcoord0_4f ("TEXCOORD0");
  varying_2f vin::texcoord1_2f ("TEXCOORD1");
  varying_4f vin::texcoord1_4f ("TEXCOORD1");
  varying_2f vin::texcoord2_2f ("TEXCOORD2");
  varying_4f vin::texcoord2_4f ("TEXCOORD2");
  varying_2f vin::texcoord3_2f ("TEXCOORD3");
  varying_4f vin::texcoord3_4f ("TEXCOORD3");
  varying_2f vin::texcoord4_2f ("TEXCOORD4");
  varying_4f vin::texcoord4_4f ("TEXCOORD4");
  varying_2f vin::texcoord5_2f ("TEXCOORD5");
  varying_4f vin::texcoord5_4f ("TEXCOORD5");
  varying_2f vin::texcoord6_2f ("TEXCOORD6");
  varying_4f vin::texcoord6_4f ("TEXCOORD6");
  varying_2f vin::texcoord7_2f ("TEXCOORD7");
  varying_4f vin::texcoord7_4f ("TEXCOORD7");
  varying_1f vin::psize_1f     ("PSIZE");
  varying_1f vin::attr6_1f     ("ATTR6");
  varying_1f vin::attr7_1f     ("ATTR7");
  varying_2f vin::attr6_2f     ("ATTR6");
  varying_2f vin::attr7_2f     ("ATTR7");
  varying_3f vin::attr6_3f     ("ATTR6");
  varying_3f vin::attr7_3f     ("ATTR7");
  varying_4f vin::attr6_4f     ("ATTR6");
  varying_4f vin::attr7_4f     ("ATTR7");

  bool vin::is (const var &r)
  {
    return r == vin::position_3f
        || r == vin::position_4f
        || r == vin::normal_3f
        || r == vin::normal_4f
        || r == vin::color0_3f
        || r == vin::color0_4f
        || r == vin::color1_3f
        || r == vin::color1_4f
        || r == vin::texcoord0_2f
        || r == vin::texcoord0_4f
        || r == vin::texcoord1_2f
        || r == vin::texcoord1_4f
        || r == vin::texcoord2_2f
        || r == vin::texcoord2_4f
        || r == vin::texcoord3_2f
        || r == vin::texcoord3_4f
        || r == vin::texcoord4_2f
        || r == vin::texcoord4_4f
        || r == vin::texcoord5_2f
        || r == vin::texcoord5_4f
        || r == vin::texcoord6_2f
        || r == vin::texcoord6_4f
        || r == vin::texcoord7_2f
        || r == vin::texcoord7_4f
        || r == vin::psize_1f
        || r == vin::attr6_1f
        || r == vin::attr7_1f
        || r == vin::attr6_2f
        || r == vin::attr7_2f
        || r == vin::attr6_3f
        || r == vin::attr7_3f
        || r == vin::attr6_4f
        || r == vin::attr7_4f;
  }

  struct fin fin;
  struct fin &vout = fin;

  // MUST update is-function below
  varying_4f fin::position_4f  ("HPOS");
  varying_4f fin::color0_4f    ("COLOR0");
  varying_4f fin::color1_4f    ("COLOR1");
  varying_4f fin::texcoord0_4f ("TEXCOORD0");
  varying_4f fin::texcoord1_4f ("TEXCOORD1");
  varying_4f fin::texcoord2_4f ("TEXCOORD2");
  varying_4f fin::texcoord3_4f ("TEXCOORD3");
  varying_4f fin::texcoord4_4f ("TEXCOORD4");
  varying_4f fin::texcoord5_4f ("TEXCOORD5");
  varying_4f fin::texcoord6_4f ("TEXCOORD6");
  varying_4f fin::texcoord7_4f ("TEXCOORD7");

  bool fin::is (const var &r)
  {
    return r == fin::position_4f
        || r == fin::color0_4f
        || r == fin::color1_4f
        || r == fin::texcoord0_4f
        || r == fin::texcoord1_4f
        || r == fin::texcoord2_4f
        || r == fin::texcoord3_4f
        || r == fin::texcoord4_4f
        || r == fin::texcoord5_4f
        || r == fin::texcoord6_4f
        || r == fin::texcoord7_4f;
  }

  struct fout fout;

  // MUST update is-function below
  varying_4f fout::color0_4f   ("COLOR0");
  varying_3f fout::color0_3f   ("COLOR0");
  varying_4f fout::color1_4f   ("COLOR1");
  varying_3f fout::color1_3f   ("COLOR1");
  varying_1f fout::depth_1f    ("DEPTH");

  bool fout::is (const var &r)
  {
    return r == fout::color0_4f
        || r == fout::color0_3f
        || r == fout::color1_4f
        || r == fout::color1_3f
        || r == fout::depth_1f;
  }

  uniform_matrix_f_i mvp, mv, proj;

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

  void shader_program::print ()
  {
    shader_builder b;
    build (b);
    ostringstream os;

    os << "void main (\n";
    for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
      {
        os << "   ";

        if (is_vertex)
          {
            if (vin.is  (*i)) os << "in "; 
            if (vout.is (*i)) os << "out ";
          }
        else
          {
            if (fin.is  (*i)) os << "in "; 
            if (fout.is (*i)) os << "out ";
          }

        (*i)->build_decl (os);
        os << ",\n";
      }

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

    os << "   uniform float unused_cg_broken_syntax\n";
    os << ")\n{\n";

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

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

    printf ("%s\n", os.str ().c_str ());

  }

void debdebdebdebug ()//D
{
  vertex_program p;
  temp_4f t1;

  p << t1 << " = mul(" << vin.position_4f << "," << mvp << ");\n";
  p << vout.position_4f << " = " << t1 << ";\n";

  p.print ();
  exit (0);
}

}

material::~material ()
{
}

void
simple_material::begin ()
{
  glMaterialfv (GL_FRONT, GL_DIFFUSE, (GLfloat *) & diffuse);
  glMaterialfv (GL_FRONT, GL_SPECULAR, (GLfloat *) & specular);
  glMaterialfv (GL_FRONT, GL_EMISSION, (GLfloat *) & emission);
  glMaterialf (GL_FRONT, GL_SHININESS, shininess);
}

void
simple_material::end ()
{
}

void
osama_material::begin ()
{
  cgGLEnableProfile (vsh_profile);
  cgGLEnableProfile (fsh_profile);
  cgGLEnableTextureParameter (g_Texture);
}

void
osama_material::end ()
{
  cgGLDisableTextureParameter (g_Texture);
  // cgGLUnbindProgram (vsh_profile);
  // cgGLUnbindProgram (fsh_profile);
  cgGLDisableProfile (vsh_profile);
  cgGLDisableProfile (fsh_profile);
}

GLuint
texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
{
  GLuint textur;
  int w, h;
  SDL_Surface *image;
  SDL_Rect area;
  Uint32 saved_flags;
  Uint8 saved_alpha;

  /* Use the surface width and height expanded to powers of 2 */
  //w = power_of_two (surface->w);
  //h = power_of_two (surface->h);
  w = power_of_two (surface->w);
  h = power_of_two (surface->h);
  tex2oord[0] = 0.0f;           /* Min X */
  tex2oord[1] = 0.0f;           /* Min Y */
  tex2oord[2] = (GLfloat) surface->w / w;       /* Max X */
  tex2oord[3] = (GLfloat) surface->h / h;       /* Max Y */

  image = SDL_CreateRGBSurface (SDL_SWSURFACE, w, h, 32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN     /* OpenGL RGBA masks */
                                0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
                                0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
    );

  if (image == NULL)
    return 0;

  /* Save the alpha blending attributes */
  saved_flags = surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
  saved_alpha = surface->format->alpha;
  if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
    SDL_SetAlpha (surface, 0, 0);

  /* Copy the surface into the GL texture image */
  area.x = 0;
  area.y = 0;
  area.w = surface->w;
  area.h = surface->h;
  SDL_BlitSurface (surface, &area, image, &area);

  /* Restore the alpha blending attributes */
  if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
    SDL_SetAlpha (surface, saved_flags, saved_alpha);

  /* Create an OpenGL texture for the image */
  glGenTextures (1, &textur);
  glBindTexture (GL_TEXTURE_2D, textur);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
  glTexImage2D (GL_TEXTURE_2D,
                0,
                GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
  SDL_FreeSurface (image);      /* No longer needed */

  return textur;
}

CGcontext cgc;

void
init_shaders ()
{
  cgc = cgCreateContext ();
}

Revision:	1.10
Committed:	Thu Oct 21 21:30:34 2004 UTC (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.9:	+3 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "opengl.h"
2			#include "material.h"
3
4	root	1.8	#include <cstdlib>
5			#include <cstring>
6
7	root	1.9	#include <algorithm>
8
9	root	1.8	namespace shader {
10
11	root	1.9	refcounted::~refcounted ()
12			{
13			#if 0
14			if (refcnt)
15			abort ();
16			#endif
17			}
18
19			const char str_float [] = "float";
20			const char str_float2 [] = "float2";
21			const char str_float3 [] = "float3";
22			const char str_float4 [] = "float4";
23			const char str_float4x4 [] = "float4x4";
24
25	root	1.8	static CGcontext cg_context = cgCreateContext ();
26
27			int var_i::next_name = 0;
28
29	root	1.9	var_i::var_i (CGtype cgtype, const char *typestr)
30			: typestr (typestr)
31	root	1.8	{
32			name = ++next_name;
33			param = cgCreateParameter (cg_context, cgtype);
34			}
35
36			var_i::~var_i ()
37			{
38			cgDestroyParameter (param);
39			}
40
41	root	1.9	void var_i::build_decl (ostringstream &b)
42			{
43			b << typestr << ' ' << "V" << name;
44			}
45
46			void uniform_i::build_decl (ostringstream &b)
47			{
48			b << "uniform " << typestr << ' ' << "V" << name;
49			}
50
51			void stream_i::build_decl (ostringstream &b)
52			{
53			b << typestr << ' ' << "V" << name;
54			b << " : " << binding;
55			}
56
57	root	1.8	void var_i::build (shader_builder &b)
58			{
59	root	1.9	b << "V" << name;
60	root	1.8	}
61
62	root	1.9	void uniform_i::build (shader_builder &b)
63	root	1.8	{
64	root	1.9	var_i::build (b);
65
66			if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
67			b.refs.push_back (*this);
68	root	1.8	}
69
70	root	1.9	void stream_i::build (shader_builder &b)
71	root	1.8	{
72	root	1.9	var_i::build (b);
73
74			if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
75			b.streams.push_back (*this);
76			}
77
78			void temporary_i::build (shader_builder &b)
79			{
80			var_i::build (b);
81
82			if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
83			b.temps.push_back (*this);
84			}
85
86			void fragment_const_string_i::build (shader_builder &b)
87			{
88			b << str;
89	root	1.8	}
90
91	root	1.9	struct vin vin;
92
93			// MUST update is-function below
94			varying_3f vin::position_3f ("POSITION");
95			varying_4f vin::position_4f ("POSITION");
96			varying_3f vin::normal_3f ("NORMAL");
97			varying_4f vin::normal_4f ("NORMAL");
98			varying_3f vin::color0_3f ("COLOR0");
99			varying_4f vin::color0_4f ("COLOR0");
100			varying_3f vin::color1_3f ("COLOR1");
101			varying_4f vin::color1_4f ("COLOR1");
102			varying_2f vin::texcoord0_2f ("TEXCOORD0");
103			varying_4f vin::texcoord0_4f ("TEXCOORD0");
104			varying_2f vin::texcoord1_2f ("TEXCOORD1");
105			varying_4f vin::texcoord1_4f ("TEXCOORD1");
106			varying_2f vin::texcoord2_2f ("TEXCOORD2");
107			varying_4f vin::texcoord2_4f ("TEXCOORD2");
108			varying_2f vin::texcoord3_2f ("TEXCOORD3");
109			varying_4f vin::texcoord3_4f ("TEXCOORD3");
110			varying_2f vin::texcoord4_2f ("TEXCOORD4");
111			varying_4f vin::texcoord4_4f ("TEXCOORD4");
112			varying_2f vin::texcoord5_2f ("TEXCOORD5");
113			varying_4f vin::texcoord5_4f ("TEXCOORD5");
114			varying_2f vin::texcoord6_2f ("TEXCOORD6");
115			varying_4f vin::texcoord6_4f ("TEXCOORD6");
116			varying_2f vin::texcoord7_2f ("TEXCOORD7");
117			varying_4f vin::texcoord7_4f ("TEXCOORD7");
118			varying_1f vin::psize_1f ("PSIZE");
119			varying_1f vin::attr6_1f ("ATTR6");
120			varying_1f vin::attr7_1f ("ATTR7");
121			varying_2f vin::attr6_2f ("ATTR6");
122			varying_2f vin::attr7_2f ("ATTR7");
123			varying_3f vin::attr6_3f ("ATTR6");
124			varying_3f vin::attr7_3f ("ATTR7");
125			varying_4f vin::attr6_4f ("ATTR6");
126			varying_4f vin::attr7_4f ("ATTR7");
127
128			bool vin::is (const var &r)
129			{
130			return r == vin::position_3f
131			\|\| r == vin::position_4f
132			\|\| r == vin::normal_3f
133			\|\| r == vin::normal_4f
134			\|\| r == vin::color0_3f
135			\|\| r == vin::color0_4f
136			\|\| r == vin::color1_3f
137			\|\| r == vin::color1_4f
138			\|\| r == vin::texcoord0_2f
139			\|\| r == vin::texcoord0_4f
140			\|\| r == vin::texcoord1_2f
141			\|\| r == vin::texcoord1_4f
142			\|\| r == vin::texcoord2_2f
143			\|\| r == vin::texcoord2_4f
144			\|\| r == vin::texcoord3_2f
145			\|\| r == vin::texcoord3_4f
146			\|\| r == vin::texcoord4_2f
147			\|\| r == vin::texcoord4_4f
148			\|\| r == vin::texcoord5_2f
149			\|\| r == vin::texcoord5_4f
150			\|\| r == vin::texcoord6_2f
151			\|\| r == vin::texcoord6_4f
152			\|\| r == vin::texcoord7_2f
153			\|\| r == vin::texcoord7_4f
154			\|\| r == vin::psize_1f
155			\|\| r == vin::attr6_1f
156			\|\| r == vin::attr7_1f
157			\|\| r == vin::attr6_2f
158			\|\| r == vin::attr7_2f
159			\|\| r == vin::attr6_3f
160			\|\| r == vin::attr7_3f
161			\|\| r == vin::attr6_4f
162			\|\| r == vin::attr7_4f;
163			}
164
165			struct fin fin;
166			struct fin &vout = fin;
167
168			// MUST update is-function below
169			varying_4f fin::position_4f ("HPOS");
170			varying_4f fin::color0_4f ("COLOR0");
171			varying_4f fin::color1_4f ("COLOR1");
172			varying_4f fin::texcoord0_4f ("TEXCOORD0");
173			varying_4f fin::texcoord1_4f ("TEXCOORD1");
174			varying_4f fin::texcoord2_4f ("TEXCOORD2");
175			varying_4f fin::texcoord3_4f ("TEXCOORD3");
176			varying_4f fin::texcoord4_4f ("TEXCOORD4");
177			varying_4f fin::texcoord5_4f ("TEXCOORD5");
178			varying_4f fin::texcoord6_4f ("TEXCOORD6");
179			varying_4f fin::texcoord7_4f ("TEXCOORD7");
180
181			bool fin::is (const var &r)
182			{
183			return r == fin::position_4f
184			\|\| r == fin::color0_4f
185			\|\| r == fin::color1_4f
186			\|\| r == fin::texcoord0_4f
187			\|\| r == fin::texcoord1_4f
188			\|\| r == fin::texcoord2_4f
189			\|\| r == fin::texcoord3_4f
190			\|\| r == fin::texcoord4_4f
191			\|\| r == fin::texcoord5_4f
192			\|\| r == fin::texcoord6_4f
193			\|\| r == fin::texcoord7_4f;
194			}
195
196			struct fout fout;
197
198			// MUST update is-function below
199			varying_4f fout::color0_4f ("COLOR0");
200			varying_3f fout::color0_3f ("COLOR0");
201			varying_4f fout::color1_4f ("COLOR1");
202			varying_3f fout::color1_3f ("COLOR1");
203			varying_1f fout::depth_1f ("DEPTH");
204
205			bool fout::is (const var &r)
206			{
207			return r == fout::color0_4f
208			\|\| r == fout::color0_3f
209			\|\| r == fout::color1_4f
210			\|\| r == fout::color1_3f
211			\|\| r == fout::depth_1f;
212			}
213
214			uniform_matrix_f_i mvp, mv, proj;
215
216			void fragment_vector_i::build (shader_builder &b)
217			{
218			for (vector<fragment>::iterator i = begin (); i != end (); i++)
219			(*i)->build (b);
220			}
221
222			void shader_program::print ()
223			{
224			shader_builder b;
225			build (b);
226			ostringstream os;
227
228			os << "void main (\n";
229			for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
230			{
231			os << " ";
232
233			if (is_vertex)
234			{
235			if (vin.is (*i)) os << "in ";
236			if (vout.is (*i)) os << "out ";
237			}
238			else
239			{
240			if (fin.is (*i)) os << "in ";
241			if (fout.is (*i)) os << "out ";
242			}
243
244			(*i)->build_decl (os);
245			os << ",\n";
246			}
247
248			for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
249			{
250			os << " ";
251			(*i)->build_decl (os);
252			os << ",\n";
253			}
254
255			os << " uniform float unused_cg_broken_syntax\n";
256			os << ")\n{\n";
257
258			for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
259			{
260			(*i)->build_decl (os);
261			os << ";\n";
262			}
263
264			os << "\n";
265			os << b.source.str ();
266			os << "\n}\n";
267
268			printf ("%s\n", os.str ().c_str ());
269
270			}
271
272			void debdebdebdebug ()//D
273			{
274			vertex_program p;
275	root	1.10	temp_4f t1;
276	root	1.9
277	root	1.10	p << t1 << " = mul(" << vin.position_4f << "," << mvp << ");\n";
278			p << vout.position_4f << " = " << t1 << ";\n";
279	root	1.9
280			p.print ();
281			exit (0);
282			}
283
284	root	1.8	}
285
286	root	1.1	material::~material ()
287			{
288			}
289
290	root	1.6	void
291			simple_material::begin ()
292	root	1.1	{
293	root	1.6	glMaterialfv (GL_FRONT, GL_DIFFUSE, (GLfloat *) & diffuse);
294			glMaterialfv (GL_FRONT, GL_SPECULAR, (GLfloat *) & specular);
295			glMaterialfv (GL_FRONT, GL_EMISSION, (GLfloat *) & emission);
296			glMaterialf (GL_FRONT, GL_SHININESS, shininess);
297	root	1.1	}
298
299	root	1.6	void
300			simple_material::end ()
301	root	1.1	{
302			}
303	root	1.6
304			void
305			osama_material::begin ()
306	root	1.3	{
307			cgGLEnableProfile (vsh_profile);
308			cgGLEnableProfile (fsh_profile);
309	root	1.6	cgGLEnableTextureParameter (g_Texture);
310	root	1.3	}
311	root	1.6
312			void
313			osama_material::end ()
314	root	1.3	{
315	root	1.6	cgGLDisableTextureParameter (g_Texture);
316			// cgGLUnbindProgram (vsh_profile);
317			// cgGLUnbindProgram (fsh_profile);
318	root	1.3	cgGLDisableProfile (vsh_profile);
319			cgGLDisableProfile (fsh_profile);
320			}
321	root	1.1
322	root	1.6	GLuint
323			texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
324	root	1.3	{
325	root	1.4	GLuint textur;
326	root	1.3	int w, h;
327			SDL_Surface *image;
328			SDL_Rect area;
329			Uint32 saved_flags;
330			Uint8 saved_alpha;
331
332			/* Use the surface width and height expanded to powers of 2 */
333			//w = power_of_two (surface->w);
334			//h = power_of_two (surface->h);
335			w = power_of_two (surface->w);
336			h = power_of_two (surface->h);
337	root	1.5	tex2oord[0] = 0.0f; /* Min X */
338			tex2oord[1] = 0.0f; /* Min Y */
339			tex2oord[2] = (GLfloat) surface->w / w; /* Max X */
340			tex2oord[3] = (GLfloat) surface->h / h; /* Max Y */
341	root	1.3
342			image = SDL_CreateRGBSurface (SDL_SWSURFACE, w, h, 32,
343			#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
344			0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
345			#else
346			0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
347			#endif
348			);
349	root	1.6
350	root	1.3	if (image == NULL)
351	root	1.6	return 0;
352	root	1.3
353			/* Save the alpha blending attributes */
354			saved_flags = surface->flags & (SDL_SRCALPHA \| SDL_RLEACCELOK);
355			saved_alpha = surface->format->alpha;
356			if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
357	root	1.6	SDL_SetAlpha (surface, 0, 0);
358	root	1.3
359			/* Copy the surface into the GL texture image */
360			area.x = 0;
361			area.y = 0;
362			area.w = surface->w;
363			area.h = surface->h;
364			SDL_BlitSurface (surface, &area, image, &area);
365
366			/* Restore the alpha blending attributes */
367			if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
368	root	1.6	SDL_SetAlpha (surface, saved_flags, saved_alpha);
369	root	1.3
370			/* Create an OpenGL texture for the image */
371	root	1.4	glGenTextures (1, &textur);
372			glBindTexture (GL_TEXTURE_2D, textur);
373	root	1.6	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
374			glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
375	root	1.7	glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
376	root	1.3	glTexImage2D (GL_TEXTURE_2D,
377			0,
378			GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
379			SDL_FreeSurface (image); /* No longer needed */
380
381	root	1.4	return textur;
382	root	1.3	}
383
384	root	1.6	CGcontext cgc;
385	root	1.3
386	root	1.6	void
387			init_shaders ()
388			{
389	root	1.3	cgc = cgCreateContext ();
390			}
391	root	1.8