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 (21 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+53 -52 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.11	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	root	1.8	static CGcontext cg_context = cgCreateContext ();
32
33			int var_i::next_name = 0;
34
35	root	1.9	var_i::var_i (CGtype cgtype, const char *typestr)
36			: typestr (typestr)
37	root	1.8	{
38			name = ++next_name;
39			param = cgCreateParameter (cg_context, cgtype);
40			}
41
42			var_i::~var_i ()
43			{
44			cgDestroyParameter (param);
45			}
46
47	root	1.9	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	root	1.8	void var_i::build (shader_builder &b)
64			{
65	root	1.9	b << "V" << name;
66	root	1.8	}
67
68	root	1.9	void uniform_i::build (shader_builder &b)
69	root	1.8	{
70	root	1.9	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	root	1.8	}
75
76	root	1.9	void stream_i::build (shader_builder &b)
77	root	1.8	{
78	root	1.9	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	root	1.8	}
96
97	root	1.9	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	root	1.11	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	root	1.9	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	root	1.11	\|\| 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	root	1.9	\|\| 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	root	1.11	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	root	1.9
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	root	1.11	\|\| 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	root	1.9	}
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	root	1.11	uniform_matrix_f mvp, mv, proj;
214	root	1.9
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	root	1.11	temp_4f t1, t2;
275			sampler2d s2d (1);
276	root	1.9
277	root	1.11	p << t2 << " = tex2D (" << s2d << ", " << vin.position_4f << ".xy);\n";
278			p << t1 << " = mul (" << vin.position_4f << "," << mvp << ");\n";
279	root	1.10	p << vout.position_4f << " = " << t1 << ";\n";
280	root	1.9
281			p.print ();
282	root	1.11	//exit (0);
283	root	1.9	}
284
285	root	1.8	}
286
287	root	1.1	material::~material ()
288			{
289			}
290
291	root	1.6	void
292			simple_material::begin ()
293	root	1.1	{
294	root	1.6	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	root	1.1	}
299
300	root	1.6	void
301			simple_material::end ()
302	root	1.1	{
303			}
304	root	1.6
305			void
306			osama_material::begin ()
307	root	1.3	{
308			cgGLEnableProfile (vsh_profile);
309			cgGLEnableProfile (fsh_profile);
310	root	1.6	cgGLEnableTextureParameter (g_Texture);
311	root	1.3	}
312	root	1.6
313			void
314			osama_material::end ()
315	root	1.3	{
316	root	1.6	cgGLDisableTextureParameter (g_Texture);
317			// cgGLUnbindProgram (vsh_profile);
318			// cgGLUnbindProgram (fsh_profile);
319	root	1.3	cgGLDisableProfile (vsh_profile);
320			cgGLDisableProfile (fsh_profile);
321			}
322	root	1.1
323	root	1.6	GLuint
324			texture::load_texture (SDL_Surface * surface, GLfloat * tex2oord)
325	root	1.3	{
326	root	1.4	GLuint textur;
327	root	1.3	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	root	1.5	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	root	1.3
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	root	1.6
351	root	1.3	if (image == NULL)
352	root	1.6	return 0;
353	root	1.3
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	root	1.6	SDL_SetAlpha (surface, 0, 0);
359	root	1.3
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	root	1.6	SDL_SetAlpha (surface, saved_flags, saved_alpha);
370	root	1.3
371			/* Create an OpenGL texture for the image */
372	root	1.4	glGenTextures (1, &textur);
373			glBindTexture (GL_TEXTURE_2D, textur);
374	root	1.6	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
375			glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
376	root	1.7	glTexParameteri (GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // GENERATE_MIPMAP_SGIS
377	root	1.3	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	root	1.4	return textur;
383	root	1.3	}
384
385	root	1.6	CGcontext cgc;
386	root	1.3
387	root	1.6	void
388			init_shaders ()
389			{
390	root	1.3	cgc = cgCreateContext ();
391			}
392	root	1.8