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_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";

  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 << ' ' << 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)
  {
    b << binding;

    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  ("gl_Vertex");
  varying_4f vin::position_4f  ("gl_Vertex");
  varying_3f vin::normal_3f    ("gl_Normal");
  varying_3f vin::color_3f     ("gl_Color");
  varying_4f vin::color_4f     ("gl_Color");
  varying_3f vin::color2_3f    ("gl_SecondaryColor");
  varying_4f vin::color2_4f    ("gl_SecondaryColor");
  varying_1f vin::texcoord_1f[8] =
    {
       varying_1f ("gl_TexCoord[0]"), varying_1f ("gl_TexCoord[1]"), varying_1f ("gl_TexCoord[2]"), varying_1f ("gl_TexCoord[3]"),
       varying_1f ("gl_TexCoord[4]"), varying_1f ("gl_TexCoord[5]"), varying_1f ("gl_TexCoord[6]"), varying_1f ("gl_TexCoord[7]"),
    };
  varying_2f vin::texcoord_2f[8] =
    {
       varying_2f ("gl_TexCoord[0]"), varying_2f ("gl_TexCoord[1]"), varying_2f ("gl_TexCoord[2]"), varying_2f ("gl_TexCoord[3]"),
       varying_2f ("gl_TexCoord[4]"), varying_2f ("gl_TexCoord[5]"), varying_2f ("gl_TexCoord[6]"), varying_2f ("gl_TexCoord[7]"),
    };
  varying_3f vin::texcoord_3f[8] =
    {
       varying_3f ("gl_TexCoord[0]"), varying_3f ("gl_TexCoord[1]"), varying_3f ("gl_TexCoord[2]"), varying_3f ("gl_TexCoord[3]"),
       varying_3f ("gl_TexCoord[4]"), varying_3f ("gl_TexCoord[5]"), varying_3f ("gl_TexCoord[6]"), varying_3f ("gl_TexCoord[7]"),
    };
  varying_4f vin::texcoord_4f[8] =
    {
       varying_4f ("gl_TexCoord[0]"), varying_4f ("gl_TexCoord[1]"), varying_4f ("gl_TexCoord[2]"), varying_4f ("gl_TexCoord[3]"),
       varying_4f ("gl_TexCoord[4]"), varying_4f ("gl_TexCoord[5]"), varying_4f ("gl_TexCoord[6]"), varying_4f ("gl_TexCoord[7]"),
    };
  varying_1f vin::psize_1f     ("PSIZE");

  bool vin::is (const var &r)
  {
    return r == vin::position_3f
        || r == vin::position_4f
        || r == vin::normal_3f
        || r == vin::color_3f
        || r == vin::color_4f
        || r == vin::color2_3f
        || r == vin::color2_4f
        || r == vin::texcoord_1f[0] || r == vin::texcoord_1f[1] || r == vin::texcoord_1f[2] || r == vin::texcoord_1f[3]
        || r == vin::texcoord_1f[4] || r == vin::texcoord_1f[5] || r == vin::texcoord_1f[6] || r == vin::texcoord_1f[7]
        || r == vin::texcoord_2f[0] || r == vin::texcoord_2f[1] || r == vin::texcoord_2f[2] || r == vin::texcoord_2f[3]
        || r == vin::texcoord_2f[4] || r == vin::texcoord_2f[5] || r == vin::texcoord_2f[6] || r == vin::texcoord_2f[7]
        || r == vin::texcoord_3f[0] || r == vin::texcoord_3f[1] || r == vin::texcoord_3f[2] || r == vin::texcoord_3f[3]
        || r == vin::texcoord_3f[4] || r == vin::texcoord_3f[5] || r == vin::texcoord_3f[6] || r == vin::texcoord_3f[7]
        || r == vin::texcoord_4f[0] || r == vin::texcoord_4f[1] || r == vin::texcoord_4f[2] || r == vin::texcoord_4f[3]
        || r == vin::texcoord_4f[4] || r == vin::texcoord_4f[5] || r == vin::texcoord_4f[6] || r == vin::texcoord_4f[7];
  }

  struct fin fin;
  struct fin &vout = fin;

  // MUST update is-function below
  varying_4f fin::position_4f  ("gl_Position");
  varying_4f fin::color_4f     ("gl_Color");
  varying_4f fin::color2_4f    ("gl_SecondaryColor");
  varying_4f fin::texcoord_4f[8] =
    {
       varying_4f ("gl_TexCoord[0]"), varying_4f ("gl_TexCoord[1]"), varying_4f ("gl_TexCoord[2]"), varying_4f ("gl_TexCoord[3]"),
       varying_4f ("gl_TexCoord[4]"), varying_4f ("gl_TexCoord[5]"), varying_4f ("gl_TexCoord[6]"), varying_4f ("gl_TexCoord[7]"),
    };

  bool fin::is (const var &r)
  {
    return r == fin::position_4f
        || r == fin::color_4f
        || r == fin::color2_4f
        || r == fin::texcoord_4f[0]
        || r == fin::texcoord_4f[1]
        || r == fin::texcoord_4f[2]
        || r == fin::texcoord_4f[3]
        || r == fin::texcoord_4f[4]
        || r == fin::texcoord_4f[5]
        || r == fin::texcoord_4f[6]
        || r == fin::texcoord_4f[7];
  }

  struct fout fout;

  // MUST update is-function below
  varying_4f fout::color_4f   ("gl_FragColor");
  varying_1f fout::depth_1f   ("gl_FragDepth");

  bool fout::is (const var &r)
  {
    return r == fout::color_4f
        || r == fout::depth_1f;
  }

  uniform_matrix_4f 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;

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

#if 0
    // not neccessary right now, as GLSL is rich on predefinitions
    for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
      {
        if (vout.is (*i) || fout.is (*i))
          os << "varying ";
        else if (vin.is (*i))
          os << "attribute ";

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

    os << "\nvoid main ()\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, t2;
  sampler_2d s2d (1);

  p << t2 << " = tex2D (" << s2d << ", " << vin.position_4f << ".xy);\n";
  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.12
Committed:	Fri Oct 22 00:16:08 2004 UTC (19 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+65 -93 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_vec2 [] = "vec2";
21	const char str_vec3 [] = "vec3";
22	const char str_vec4 [] = "vec4";
23	const char str_mat2 [] = "mat2";
24	const char str_mat3 [] = "mat3";
25	const char str_mat4 [] = "mat4";
26
27	const char str_sampler_1d [] = "sampler1D";
28	const char str_sampler_1d_shadow [] = "sampler1DShadow";
29	const char str_sampler_2d [] = "sampler2D";
30	const char str_sampler_2d_shadow [] = "sampler2DShadow";
31	const char str_sampler_2d_rect [] = "sampler2DRect";
32	const char str_sampler_2d_rect_shadow [] = "sampler2DRectShadow";
33	const char str_sampler_3d [] = "sampler3D";
34	const char str_sampler_3d_rect [] = "sampler3DRect";
35	const char str_sampler_cube [] = "samplerCube";
36
37	static CGcontext cg_context = cgCreateContext ();
38
39	int var_i::next_name = 0;
40
41	var_i::var_i (CGtype cgtype, const char *typestr)
42	: typestr (typestr)
43	{
44	name = ++next_name;
45	param = cgCreateParameter (cg_context, cgtype);
46	}
47
48	var_i::~var_i ()
49	{
50	cgDestroyParameter (param);
51	}
52
53	void var_i::build_decl (ostringstream &b)
54	{
55	b << typestr << ' ' << "V" << name;
56	}
57
58	void uniform_i::build_decl (ostringstream &b)
59	{
60	b << "uniform " << typestr << ' ' << "V" << name;
61	}
62
63	void stream_i::build_decl (ostringstream &b)
64	{
65	b << typestr << ' ' << binding;
66	}
67
68	void var_i::build (shader_builder &b)
69	{
70	b << "V" << name;
71	}
72
73	void uniform_i::build (shader_builder &b)
74	{
75	var_i::build (b);
76
77	if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
78	b.refs.push_back (*this);
79	}
80
81	void stream_i::build (shader_builder &b)
82	{
83	b << binding;
84
85	if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
86	b.streams.push_back (*this);
87	}
88
89	void temporary_i::build (shader_builder &b)
90	{
91	var_i::build (b);
92
93	if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
94	b.temps.push_back (*this);
95	}
96
97	void fragment_const_string_i::build (shader_builder &b)
98	{
99	b << str;
100	}
101
102	struct vin vin;
103
104	// MUST update is-function below
105	varying_3f vin::position_3f ("gl_Vertex");
106	varying_4f vin::position_4f ("gl_Vertex");
107	varying_3f vin::normal_3f ("gl_Normal");
108	varying_3f vin::color_3f ("gl_Color");
109	varying_4f vin::color_4f ("gl_Color");
110	varying_3f vin::color2_3f ("gl_SecondaryColor");
111	varying_4f vin::color2_4f ("gl_SecondaryColor");
112	varying_1f vin::texcoord_1f[8] =
113	{
114	varying_1f ("gl_TexCoord[0]"), varying_1f ("gl_TexCoord[1]"), varying_1f ("gl_TexCoord[2]"), varying_1f ("gl_TexCoord[3]"),
115	varying_1f ("gl_TexCoord[4]"), varying_1f ("gl_TexCoord[5]"), varying_1f ("gl_TexCoord[6]"), varying_1f ("gl_TexCoord[7]"),
116	};
117	varying_2f vin::texcoord_2f[8] =
118	{
119	varying_2f ("gl_TexCoord[0]"), varying_2f ("gl_TexCoord[1]"), varying_2f ("gl_TexCoord[2]"), varying_2f ("gl_TexCoord[3]"),
120	varying_2f ("gl_TexCoord[4]"), varying_2f ("gl_TexCoord[5]"), varying_2f ("gl_TexCoord[6]"), varying_2f ("gl_TexCoord[7]"),
121	};
122	varying_3f vin::texcoord_3f[8] =
123	{
124	varying_3f ("gl_TexCoord[0]"), varying_3f ("gl_TexCoord[1]"), varying_3f ("gl_TexCoord[2]"), varying_3f ("gl_TexCoord[3]"),
125	varying_3f ("gl_TexCoord[4]"), varying_3f ("gl_TexCoord[5]"), varying_3f ("gl_TexCoord[6]"), varying_3f ("gl_TexCoord[7]"),
126	};
127	varying_4f vin::texcoord_4f[8] =
128	{
129	varying_4f ("gl_TexCoord[0]"), varying_4f ("gl_TexCoord[1]"), varying_4f ("gl_TexCoord[2]"), varying_4f ("gl_TexCoord[3]"),
130	varying_4f ("gl_TexCoord[4]"), varying_4f ("gl_TexCoord[5]"), varying_4f ("gl_TexCoord[6]"), varying_4f ("gl_TexCoord[7]"),
131	};
132	varying_1f vin::psize_1f ("PSIZE");
133
134	bool vin::is (const var &r)
135	{
136	return r == vin::position_3f
137	\|\| r == vin::position_4f
138	\|\| r == vin::normal_3f
139	\|\| r == vin::color_3f
140	\|\| r == vin::color_4f
141	\|\| r == vin::color2_3f
142	\|\| r == vin::color2_4f
143	\|\| r == vin::texcoord_1f[0] \|\| r == vin::texcoord_1f[1] \|\| r == vin::texcoord_1f[2] \|\| r == vin::texcoord_1f[3]
144	\|\| r == vin::texcoord_1f[4] \|\| r == vin::texcoord_1f[5] \|\| r == vin::texcoord_1f[6] \|\| r == vin::texcoord_1f[7]
145	\|\| r == vin::texcoord_2f[0] \|\| r == vin::texcoord_2f[1] \|\| r == vin::texcoord_2f[2] \|\| r == vin::texcoord_2f[3]
146	\|\| r == vin::texcoord_2f[4] \|\| r == vin::texcoord_2f[5] \|\| r == vin::texcoord_2f[6] \|\| r == vin::texcoord_2f[7]
147	\|\| r == vin::texcoord_3f[0] \|\| r == vin::texcoord_3f[1] \|\| r == vin::texcoord_3f[2] \|\| r == vin::texcoord_3f[3]
148	\|\| r == vin::texcoord_3f[4] \|\| r == vin::texcoord_3f[5] \|\| r == vin::texcoord_3f[6] \|\| r == vin::texcoord_3f[7]
149	\|\| r == vin::texcoord_4f[0] \|\| r == vin::texcoord_4f[1] \|\| r == vin::texcoord_4f[2] \|\| r == vin::texcoord_4f[3]
150	\|\| r == vin::texcoord_4f[4] \|\| r == vin::texcoord_4f[5] \|\| r == vin::texcoord_4f[6] \|\| r == vin::texcoord_4f[7];
151	}
152
153	struct fin fin;
154	struct fin &vout = fin;
155
156	// MUST update is-function below
157	varying_4f fin::position_4f ("gl_Position");
158	varying_4f fin::color_4f ("gl_Color");
159	varying_4f fin::color2_4f ("gl_SecondaryColor");
160	varying_4f fin::texcoord_4f[8] =
161	{
162	varying_4f ("gl_TexCoord[0]"), varying_4f ("gl_TexCoord[1]"), varying_4f ("gl_TexCoord[2]"), varying_4f ("gl_TexCoord[3]"),
163	varying_4f ("gl_TexCoord[4]"), varying_4f ("gl_TexCoord[5]"), varying_4f ("gl_TexCoord[6]"), varying_4f ("gl_TexCoord[7]"),
164	};
165
166	bool fin::is (const var &r)
167	{
168	return r == fin::position_4f
169	\|\| r == fin::color_4f
170	\|\| r == fin::color2_4f
171	\|\| r == fin::texcoord_4f[0]
172	\|\| r == fin::texcoord_4f[1]
173	\|\| r == fin::texcoord_4f[2]
174	\|\| r == fin::texcoord_4f[3]
175	\|\| r == fin::texcoord_4f[4]
176	\|\| r == fin::texcoord_4f[5]
177	\|\| r == fin::texcoord_4f[6]
178	\|\| r == fin::texcoord_4f[7];
179	}
180
181	struct fout fout;
182
183	// MUST update is-function below
184	varying_4f fout::color_4f ("gl_FragColor");
185	varying_1f fout::depth_1f ("gl_FragDepth");
186
187	bool fout::is (const var &r)
188	{
189	return r == fout::color_4f
190	\|\| r == fout::depth_1f;
191	}
192
193	uniform_matrix_4f mvp, mv, proj;
194
195	void fragment_vector_i::build (shader_builder &b)
196	{
197	for (vector<fragment>::iterator i = begin (); i != end (); i++)
198	(*i)->build (b);
199	}
200
201	void shader_program::print ()
202	{
203	shader_builder b;
204	build (b);
205	ostringstream os;
206
207	for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
208	{
209	(*i)->build_decl (os);
210	os << ";\n";
211	}
212
213	#if 0
214	// not neccessary right now, as GLSL is rich on predefinitions
215	for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
216	{
217	if (vout.is (i) \|\| fout.is (i))
218	os << "varying ";
219	else if (vin.is (*i))
220	os << "attribute ";
221
222	(*i)->build_decl (os);
223	os << ";\n";
224	}
225	#endif
226
227	os << "\nvoid main ()\n{\n";
228
229	for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
230	{
231	(*i)->build_decl (os);
232	os << ";\n";
233	}
234
235	os << "\n";
236	os << b.source.str ();
237	os << "\n}\n";
238
239	printf ("%s\n", os.str ().c_str ());
240
241	}
242
243	void debdebdebdebug ()//D
244	{
245	vertex_program p;
246	temp_4f t1, t2;
247	sampler_2d s2d (1);
248
249	p << t2 << " = tex2D (" << s2d << ", " << vin.position_4f << ".xy);\n";
250	p << t1 << " = mul (" << vin.position_4f << "," << mvp << ");\n";
251	p << vout.position_4f << " = " << t1 << ";\n";
252
253	p.print ();
254	exit (0);
255	}
256
257	}
258
259	material::~material ()
260	{
261	}
262
263	void
264	simple_material::begin ()
265	{
266	glMaterialfv (GL_FRONT, GL_DIFFUSE, (GLfloat *) & diffuse);
267	glMaterialfv (GL_FRONT, GL_SPECULAR, (GLfloat *) & specular);
268	glMaterialfv (GL_FRONT, GL_EMISSION, (GLfloat *) & emission);
269	glMaterialf (GL_FRONT, GL_SHININESS, shininess);
270	}
271
272	void
273	simple_material::end ()
274	{
275	}
276
277	void
278	osama_material::begin ()
279	{
280	cgGLEnableProfile (vsh_profile);
281	cgGLEnableProfile (fsh_profile);
282	cgGLEnableTextureParameter (g_Texture);
283	}
284
285	void
286	osama_material::end ()
287	{
288	cgGLDisableTextureParameter (g_Texture);
289	// cgGLUnbindProgram (vsh_profile);
290	// cgGLUnbindProgram (fsh_profile);
291	cgGLDisableProfile (vsh_profile);
292	cgGLDisableProfile (fsh_profile);
293	}
294
295	GLuint
296	texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
297	{
298	GLuint textur;
299	int w, h;
300	SDL_Surface *image;
301	SDL_Rect area;
302	Uint32 saved_flags;
303	Uint8 saved_alpha;
304
305	/* Use the surface width and height expanded to powers of 2 */
306	//w = power_of_two (surface->w);
307	//h = power_of_two (surface->h);
308	w = power_of_two (surface->w);
309	h = power_of_two (surface->h);
310	tex2oord[0] = 0.0f; /* Min X */
311	tex2oord[1] = 0.0f; /* Min Y */
312	tex2oord[2] = (GLfloat) surface->w / w; /* Max X */
313	tex2oord[3] = (GLfloat) surface->h / h; /* Max Y */
314
315	image = SDL_CreateRGBSurface (SDL_SWSURFACE, w, h, 32,
316	#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
317	0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
318	#else
319	0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
320	#endif
321	);
322
323	if (image == NULL)
324	return 0;
325
326	/* Save the alpha blending attributes */
327	saved_flags = surface->flags & (SDL_SRCALPHA \| SDL_RLEACCELOK);
328	saved_alpha = surface->format->alpha;
329	if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
330	SDL_SetAlpha (surface, 0, 0);
331
332	/* Copy the surface into the GL texture image */
333	area.x = 0;
334	area.y = 0;
335	area.w = surface->w;
336	area.h = surface->h;
337	SDL_BlitSurface (surface, &area, image, &area);
338
339	/* Restore the alpha blending attributes */
340	if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA)
341	SDL_SetAlpha (surface, saved_flags, saved_alpha);
342
343	/* Create an OpenGL texture for the image */
344	glGenTextures (1, &textur);
345	glBindTexture (GL_TEXTURE_2D, textur);
346	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
347	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
348	glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
349	glTexImage2D (GL_TEXTURE_2D,
350	0,
351	GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
352	SDL_FreeSurface (image); /* No longer needed */
353
354	return textur;
355	}
356
357	CGcontext cgc;
358
359	void
360	init_shaders ()
361	{
362	cgc = cgCreateContext ();
363	}
364