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

  const char str_sampler1d   [] = "sampler1d";
  const char str_sampler2d   [] = "sampler2d";
  const char str_sampler3d   [] = "sampler3d";
  const char str_samplerCUBE [] = "samplerCUBE";
  const char str_samplerRECT [] = "samplerRECT";

  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_1f vin::texcoord_1f[8] =
    {
       varying_1f ("TEXCOORD0"), varying_1f ("TEXCOORD1"), varying_1f ("TEXCOORD2"), varying_1f ("TEXCOORD3"),
       varying_1f ("TEXCOORD4"), varying_1f ("TEXCOORD5"), varying_1f ("TEXCOORD6"), varying_1f ("TEXCOORD7"),
    };
  varying_2f vin::texcoord_2f[8] =
    {
       varying_2f ("TEXCOORD0"), varying_2f ("TEXCOORD1"), varying_2f ("TEXCOORD2"), varying_2f ("TEXCOORD3"),
       varying_2f ("TEXCOORD4"), varying_2f ("TEXCOORD5"), varying_2f ("TEXCOORD6"), varying_2f ("TEXCOORD7"),
    };
  varying_3f vin::texcoord_3f[8] =
    {
       varying_3f ("TEXCOORD0"), varying_3f ("TEXCOORD1"), varying_3f ("TEXCOORD2"), varying_3f ("TEXCOORD3"),
       varying_3f ("TEXCOORD4"), varying_3f ("TEXCOORD5"), varying_3f ("TEXCOORD6"), varying_3f ("TEXCOORD7"),
    };
  varying_4f vin::texcoord_4f[8] =
    {
       varying_4f ("TEXCOORD0"), varying_4f ("TEXCOORD1"), varying_4f ("TEXCOORD2"), varying_4f ("TEXCOORD3"),
       varying_4f ("TEXCOORD4"), varying_4f ("TEXCOORD5"), varying_4f ("TEXCOORD6"), varying_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::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]
        || 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::texcoord_4f[8] =
    {
       varying_4f ("TEXCOORD0"), varying_4f ("TEXCOORD1"), varying_4f ("TEXCOORD2"), varying_4f ("TEXCOORD3"),
       varying_4f ("TEXCOORD4"), varying_4f ("TEXCOORD5"), varying_4f ("TEXCOORD6"), varying_4f ("TEXCOORD7"),
    };

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