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_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 (21 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+65 -93 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	root	1.12	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	root	1.11
37	root	1.8	static CGcontext cg_context = cgCreateContext ();
38
39			int var_i::next_name = 0;
40
41	root	1.9	var_i::var_i (CGtype cgtype, const char *typestr)
42			: typestr (typestr)
43	root	1.8	{
44			name = ++next_name;
45			param = cgCreateParameter (cg_context, cgtype);
46			}
47
48			var_i::~var_i ()
49			{
50			cgDestroyParameter (param);
51			}
52
53	root	1.9	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	root	1.12	b << typestr << ' ' << binding;
66	root	1.9	}
67
68	root	1.8	void var_i::build (shader_builder &b)
69			{
70	root	1.9	b << "V" << name;
71	root	1.8	}
72
73	root	1.9	void uniform_i::build (shader_builder &b)
74	root	1.8	{
75	root	1.9	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	root	1.8	}
80
81	root	1.9	void stream_i::build (shader_builder &b)
82	root	1.8	{
83	root	1.12	b << binding;
84	root	1.9
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	root	1.8	}
101
102	root	1.9	struct vin vin;
103
104			// MUST update is-function below
105	root	1.12	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	root	1.11	varying_1f vin::texcoord_1f[8] =
113			{
114	root	1.12	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	root	1.11	};
117			varying_2f vin::texcoord_2f[8] =
118			{
119	root	1.12	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	root	1.11	};
122			varying_3f vin::texcoord_3f[8] =
123			{
124	root	1.12	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	root	1.11	};
127			varying_4f vin::texcoord_4f[8] =
128			{
129	root	1.12	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	root	1.11	};
132	root	1.9	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	root	1.12	\|\| r == vin::color_3f
140			\|\| r == vin::color_4f
141			\|\| r == vin::color2_3f
142			\|\| r == vin::color2_4f
143	root	1.11	\|\| 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	root	1.12	\|\| r == vin::texcoord_4f[4] \|\| r == vin::texcoord_4f[5] \|\| r == vin::texcoord_4f[6] \|\| r == vin::texcoord_4f[7];
151	root	1.9	}
152
153			struct fin fin;
154			struct fin &vout = fin;
155
156			// MUST update is-function below
157	root	1.12	varying_4f fin::position_4f ("gl_Position");
158			varying_4f fin::color_4f ("gl_Color");
159			varying_4f fin::color2_4f ("gl_SecondaryColor");
160	root	1.11	varying_4f fin::texcoord_4f[8] =
161			{
162	root	1.12	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	root	1.11	};
165	root	1.9
166			bool fin::is (const var &r)
167			{
168			return r == fin::position_4f
169	root	1.12	\|\| r == fin::color_4f
170			\|\| r == fin::color2_4f
171	root	1.11	\|\| 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	root	1.9	}
180
181			struct fout fout;
182
183			// MUST update is-function below
184	root	1.12	varying_4f fout::color_4f ("gl_FragColor");
185			varying_1f fout::depth_1f ("gl_FragDepth");
186	root	1.9
187			bool fout::is (const var &r)
188			{
189	root	1.12	return r == fout::color_4f
190	root	1.9	\|\| r == fout::depth_1f;
191			}
192
193	root	1.12	uniform_matrix_4f mvp, mv, proj;
194	root	1.9
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	root	1.12	for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
208	root	1.9	{
209			(*i)->build_decl (os);
210	root	1.12	os << ";\n";
211	root	1.9	}
212
213	root	1.12	#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	root	1.9	{
217	root	1.12	if (vout.is (i) \|\| fout.is (i))
218			os << "varying ";
219			else if (vin.is (*i))
220			os << "attribute ";
221
222	root	1.9	(*i)->build_decl (os);
223	root	1.12	os << ";\n";
224	root	1.9	}
225	root	1.12	#endif
226	root	1.9
227	root	1.12	os << "\nvoid main ()\n{\n";
228	root	1.9
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	root	1.11	temp_4f t1, t2;
247	root	1.12	sampler_2d s2d (1);
248	root	1.9
249	root	1.11	p << t2 << " = tex2D (" << s2d << ", " << vin.position_4f << ".xy);\n";
250			p << t1 << " = mul (" << vin.position_4f << "," << mvp << ");\n";
251	root	1.10	p << vout.position_4f << " = " << t1 << ";\n";
252	root	1.9
253			p.print ();
254	root	1.12	exit (0);
255	root	1.9	}
256
257	root	1.8	}
258
259	root	1.1	material::~material ()
260			{
261			}
262
263	root	1.6	void
264			simple_material::begin ()
265	root	1.1	{
266	root	1.6	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	root	1.1	}
271
272	root	1.6	void
273			simple_material::end ()
274	root	1.1	{
275			}
276	root	1.6
277			void
278			osama_material::begin ()
279	root	1.3	{
280			cgGLEnableProfile (vsh_profile);
281			cgGLEnableProfile (fsh_profile);
282	root	1.6	cgGLEnableTextureParameter (g_Texture);
283	root	1.3	}
284	root	1.6
285			void
286			osama_material::end ()
287	root	1.3	{
288	root	1.6	cgGLDisableTextureParameter (g_Texture);
289			// cgGLUnbindProgram (vsh_profile);
290			// cgGLUnbindProgram (fsh_profile);
291	root	1.3	cgGLDisableProfile (vsh_profile);
292			cgGLDisableProfile (fsh_profile);
293			}
294	root	1.1
295	root	1.6	GLuint
296			texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
297	root	1.3	{
298	root	1.4	GLuint textur;
299	root	1.3	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	root	1.5	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	root	1.3
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	root	1.6
323	root	1.3	if (image == NULL)
324	root	1.6	return 0;
325	root	1.3
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	root	1.6	SDL_SetAlpha (surface, 0, 0);
331	root	1.3
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	root	1.6	SDL_SetAlpha (surface, saved_flags, saved_alpha);
342	root	1.3
343			/* Create an OpenGL texture for the image */
344	root	1.4	glGenTextures (1, &textur);
345			glBindTexture (GL_TEXTURE_2D, textur);
346	root	1.6	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
347			glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
348	root	1.7	glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
349	root	1.3	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	root	1.4	return textur;
355	root	1.3	}
356
357	root	1.6	CGcontext cgc;
358	root	1.3
359	root	1.6	void
360			init_shaders ()
361			{
362	root	1.3	cgc = cgCreateContext ();
363			}
364	root	1.8