cvsroot/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;

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

  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.9
Committed:	Thu Oct 21 21:20:09 2004 UTC (21 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+249 -24 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
276			p << vout.position_4f << " = mul(" << vin.position_4f << "," << mvp << ");";
277
278			p.print ();
279			exit (0);
280			}
281
282	root	1.8	}
283
284	root	1.1	material::~material ()
285			{
286			}
287
288	root	1.6	void
289			simple_material::begin ()
290	root	1.1	{
291	root	1.6	glMaterialfv (GL_FRONT, GL_DIFFUSE, (GLfloat *) & diffuse);
292			glMaterialfv (GL_FRONT, GL_SPECULAR, (GLfloat *) & specular);
293			glMaterialfv (GL_FRONT, GL_EMISSION, (GLfloat *) & emission);
294			glMaterialf (GL_FRONT, GL_SHININESS, shininess);
295	root	1.1	}
296
297	root	1.6	void
298			simple_material::end ()
299	root	1.1	{
300			}
301	root	1.6
302			void
303			osama_material::begin ()
304	root	1.3	{
305			cgGLEnableProfile (vsh_profile);
306			cgGLEnableProfile (fsh_profile);
307	root	1.6	cgGLEnableTextureParameter (g_Texture);
308	root	1.3	}
309	root	1.6
310			void
311			osama_material::end ()
312	root	1.3	{
313	root	1.6	cgGLDisableTextureParameter (g_Texture);
314			// cgGLUnbindProgram (vsh_profile);
315			// cgGLUnbindProgram (fsh_profile);
316	root	1.3	cgGLDisableProfile (vsh_profile);
317			cgGLDisableProfile (fsh_profile);
318			}
319	root	1.1
320	root	1.6	GLuint
321			texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
322	root	1.3	{
323	root	1.4	GLuint textur;
324	root	1.3	int w, h;
325			SDL_Surface *image;
326			SDL_Rect area;
327			Uint32 saved_flags;
328			Uint8 saved_alpha;
329
330			/* Use the surface width and height expanded to powers of 2 */
331			//w = power_of_two (surface->w);
332			//h = power_of_two (surface->h);
333			w = power_of_two (surface->w);
334			h = power_of_two (surface->h);
335	root	1.5	tex2oord[0] = 0.0f; /* Min X */
336			tex2oord[1] = 0.0f; /* Min Y */
337			tex2oord[2] = (GLfloat) surface->w / w; /* Max X */
338			tex2oord[3] = (GLfloat) surface->h / h; /* Max Y */
339	root	1.3
340			image = SDL_CreateRGBSurface (SDL_SWSURFACE, w, h, 32,
341			#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
342			0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
343			#else
344			0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
345			#endif
346			);
347	root	1.6
348	root	1.3	if (image == NULL)
349	root	1.6	return 0;
350	root	1.3
351			/* Save the alpha blending attributes */
352			saved_flags = surface->flags & (SDL_SRCALPHA \| SDL_RLEACCELOK);
353			saved_alpha = surface->format->alpha;
354			if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
355	root	1.6	SDL_SetAlpha (surface, 0, 0);
356	root	1.3
357			/* Copy the surface into the GL texture image */
358			area.x = 0;
359			area.y = 0;
360			area.w = surface->w;
361			area.h = surface->h;
362			SDL_BlitSurface (surface, &area, image, &area);
363
364			/* Restore the alpha blending attributes */
365			if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
366	root	1.6	SDL_SetAlpha (surface, saved_flags, saved_alpha);
367	root	1.3
368			/* Create an OpenGL texture for the image */
369	root	1.4	glGenTextures (1, &textur);
370			glBindTexture (GL_TEXTURE_2D, textur);
371	root	1.6	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
372			glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
373	root	1.7	glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
374	root	1.3	glTexImage2D (GL_TEXTURE_2D,
375			0,
376			GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
377			SDL_FreeSurface (image); /* No longer needed */
378
379	root	1.4	return textur;
380	root	1.3	}
381
382	root	1.6	CGcontext cgc;
383	root	1.3
384	root	1.6	void
385			init_shaders ()
386			{
387	root	1.3	cgc = cgCreateContext ();
388			}
389	root	1.8