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, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.9:	+3 -1 lines
Log Message:	* empty log message *
#	Content
1	#include "opengl.h"
2	#include "material.h"
3
4	#include <cstdlib>
5	#include <cstring>
6
7	#include <algorithm>
8
9	namespace shader {
10
11	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	static CGcontext cg_context = cgCreateContext ();
26
27	int var_i::next_name = 0;
28
29	var_i::var_i (CGtype cgtype, const char *typestr)
30	: typestr (typestr)
31	{
32	name = ++next_name;
33	param = cgCreateParameter (cg_context, cgtype);
34	}
35
36	var_i::~var_i ()
37	{
38	cgDestroyParameter (param);
39	}
40
41	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	void var_i::build (shader_builder &b)
58	{
59	b << "V" << name;
60	}
61
62	void uniform_i::build (shader_builder &b)
63	{
64	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	}
69
70	void stream_i::build (shader_builder &b)
71	{
72	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	}
90
91	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	temp_4f t1;
276
277	p << t1 << " = mul(" << vin.position_4f << "," << mvp << ");\n";
278	p << vout.position_4f << " = " << t1 << ";\n";
279
280	p.print ();
281	exit (0);
282	}
283
284	}
285
286	material::~material ()
287	{
288	}
289
290	void
291	simple_material::begin ()
292	{
293	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	}
298
299	void
300	simple_material::end ()
301	{
302	}
303
304	void
305	osama_material::begin ()
306	{
307	cgGLEnableProfile (vsh_profile);
308	cgGLEnableProfile (fsh_profile);
309	cgGLEnableTextureParameter (g_Texture);
310	}
311
312	void
313	osama_material::end ()
314	{
315	cgGLDisableTextureParameter (g_Texture);
316	// cgGLUnbindProgram (vsh_profile);
317	// cgGLUnbindProgram (fsh_profile);
318	cgGLDisableProfile (vsh_profile);
319	cgGLDisableProfile (fsh_profile);
320	}
321
322	GLuint
323	texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
324	{
325	GLuint textur;
326	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	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
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
350	if (image == NULL)
351	return 0;
352
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	SDL_SetAlpha (surface, 0, 0);
358
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	SDL_SetAlpha (surface, saved_flags, saved_alpha);
369
370	/* Create an OpenGL texture for the image */
371	glGenTextures (1, &textur);
372	glBindTexture (GL_TEXTURE_2D, textur);
373	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
374	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
375	glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
376	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	return textur;
382	}
383
384	CGcontext cgc;
385
386	void
387	init_shaders ()
388	{
389	cgc = cgCreateContext ();
390	}
391