diff --git a/examples/gfx/ambient_occlusion1.py b/examples/gfx/ambient_occlusion1.py
new file mode 100644
index 0000000000000000000000000000000000000000..afacacc51a8c792cb7de12c8513b3fb4bb28cba1
--- /dev/null
+++ b/examples/gfx/ambient_occlusion1.py
@@ -0,0 +1,24 @@
+s=io.LoadSurface("../surf/sdh","msms")
+scene.Add(gfx.Surface("s",s))
+
+# alternative shading mode
+scene.SetShadingMode("hf")
+
+# add outlines to surface
+scene["s"].Outline(True)
+scene["s"].SetOutlineMode(3)
+
+# turn on realtime ambient occlusion
+scene.SetAmbientOcclusion(True)
+
+# strength of the AO effect, default is 1.0
+scene.SetAmbientOcclusionWeight(1.0)
+
+# AO algorithms 0-3, default is 1
+scene.SetAmbientOcclusionMode(1)
+
+# orientation
+scene.SetRTC(geom.Mat4(0.827929,-0.460893,-0.319547,29.688,
+ 0.174973,0.753608,-0.633609,19.9405,
+ 0.532839,0.468671,0.704578,73.0075,
+ -5.4704,1.54823,-116,1))
diff --git a/examples/gfx/ambient_occlusion2.py b/examples/gfx/ambient_occlusion2.py
new file mode 100644
index 0000000000000000000000000000000000000000..d22af87f3db3345057a15de16b417f1a67d74478
--- /dev/null
+++ b/examples/gfx/ambient_occlusion2.py
@@ -0,0 +1,20 @@
+e=io.LoadPDB("../entity/sdh.pdb")
+scene.Add(gfx.Entity("x",gfx.CPK,e.Select("chain=A")))
+
+# fast spheres with 3D sprites, default
+scene["x"].GetOptions(gfx.CPK).SetSphereMode(1)
+
+# turn on realtime ambient occlusion
+scene.SetAmbientOcclusion(True)
+
+# strength of the AO effect, default is 1.0
+scene.SetAmbientOcclusionWeight(1.0)
+
+# AO algorithms 0-3, default is 1
+scene.SetAmbientOcclusionMode(1)
+
+# orientation
+scene.SetRTC(geom.Mat4(0.827929,-0.460893,-0.319547,29.688,
+ 0.174973,0.753608,-0.633609,19.9405,
+ 0.532839,0.468671,0.704578,73.0075,
+ -5.4704,1.54823,-116,1))
diff --git a/examples/gfx/hsc_hemilight.py b/examples/gfx/hsc_hemilight.py
new file mode 100644
index 0000000000000000000000000000000000000000..b02b76f3131590cef390689d21144448abebb4a3
--- /dev/null
+++ b/examples/gfx/hsc_hemilight.py
@@ -0,0 +1,30 @@
+e=io.LoadPDB("../entity/sdh.pdb")
+scene.Add(gfx.Entity("x",gfx.HSC,e.Select("chain=A")))
+scene["x"].GetOptions(gfx.HSC).SetTubeRadius(0.6)
+# spiral helices (default)
+scene["x"].GetOptions(gfx.HSC).SetHelixMode(0)
+# straight strands
+scene["x"].GetOptions(gfx.HSC).SetStrandMode(1)
+# colors
+scene["x"].SetColor(gfx.Color(0.9,0.95,1.0))
+scene["x"].SetColor(gfx.Color(1.0,0.9,0.7),"rtype=helix")
+scene["x"].SetDetailColor(gfx.Color(1.0,0.95,0.78),"rtype=helix")
+scene["x"].SetColor(gfx.Color(0.5,1.0,0.7),"rtype=strand")
+scene["x"].SetDetailColor(gfx.Color(0.7,1.0,0.79),"rtype=strand")
+
+# switch to hemilighting mode
+scene.SetShadingMode("hf")
+# add outline to improved visibility
+scene["x"].Outline(True)
+scene["x"].SetOutlineMode(1)
+scene["x"].SetOutlineWidth(4.5)
+
+# looks best on white bg
+scene.bg=gfx.WHITE
+
+scene.SetRTC(geom.Mat4(-0.589889,-0.594876,0.546034,28.2245,
+ 0.806165,-0.472502,0.356147,20.1685,
+ 0.0461388,0.65028,0.758291,73.5665,
+ -3.52709,1.72253,-120,1))
+
+
diff --git a/examples/gfx/shadow_mapping.py b/examples/gfx/shadow_mapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..bba436139aab664361e0617208b7e1a0cfa7b85e
--- /dev/null
+++ b/examples/gfx/shadow_mapping.py
@@ -0,0 +1,22 @@
+s=io.LoadSurface("../surf/sdh","msms")
+scene.Add(gfx.Surface("s",s))
+
+# alternative shading mode
+scene.SetShadingMode("hf")
+
+# add outlines to surface
+scene["s"].Outline(True)
+scene["s"].SetOutlineMode(3)
+
+# turn on realtime shadow mapping
+scene.SetShadow(True)
+
+# this influences the size of the shadow map
+# size = (quality+1)*256, up to quality=8
+scene.SetShadowQuality(1) # default
+
+# orientation
+scene.SetRTC(geom.Mat4(0.827929,-0.460893,-0.319547,29.688,
+ 0.174973,0.753608,-0.633609,19.9405,
+ 0.532839,0.468671,0.704578,73.0075,
+ -5.4704,1.54823,-116,1))
diff --git a/examples/gfx/transp.py b/examples/gfx/transp.py
new file mode 100644
index 0000000000000000000000000000000000000000..dba10b4c9a73b8b13c68dd372e5a0188daa76186
--- /dev/null
+++ b/examples/gfx/transp.py
@@ -0,0 +1,20 @@
+e=io.LoadPDB("../entity/sdh.pdb")
+s=io.LoadSurface("../surf/sdh","msms")
+
+scene.Add(gfx.Entity("x",gfx.HSC,e.Select("chain=A")))
+scene["x"].SetColor(gfx.Color(0.9,0.95,1.0))
+scene["x"].SetColor(gfx.Color(1.0,0.9,0.7),"rtype=helix")
+scene["x"].SetColor(gfx.Color(0.5,1.0,0.7),"rtype=strand")
+
+scene.Add(gfx.Surface("s",s))
+scene["s"].SetOpacity(0.4)
+scene["s"].SetMat(0,1,0,0)
+
+scene.bg=gfx.WHITE
+
+scene.SetRTC(geom.Mat4(-0.589889,-0.594876,0.546034,28.2245,
+ 0.806165,-0.472502,0.356147,20.1685,
+ 0.0461388,0.65028,0.758291,73.5665,
+ -3.52709,1.72253,-120,1))
+
+
diff --git a/modules/gfx/pymod/color_by_def.hh b/modules/gfx/pymod/color_by_def.hh
index 1c4643acd6ec55c61df7a483d5c05a13282da574..d45bb327e87db0772e4e09f41b939cc467727ecd 100644
--- a/modules/gfx/pymod/color_by_def.hh
+++ b/modules/gfx/pymod/color_by_def.hh
@@ -22,13 +22,16 @@
#include <ost/config.hh>
#include <ost/gfx/gfx_object.hh>
+#if OST_IMG_ENABLED
+#include <ost/img/alg/stat.hh>
+#endif
+
using namespace ost;
using namespace ost::gfx;
namespace ost_gfx {
-#if OST_IMG_ENABLED
-inline void color_by_01(GfxObj* go,
+inline void color_by_e0(GfxObj* go,
const mol::EntityView& ev,
const String& prop,
const Gradient& g, float minv, float maxv)
@@ -36,117 +39,141 @@ inline void color_by_01(GfxObj* go,
go->ColorBy(ev,prop,g,minv,maxv);
}
-inline void color_by_02(GfxObj* go,
- const ::img::MapHandle& mh,
- const String& prop,
- const Gradient& g, float minv, float maxv)
+inline void color_by_e1(GfxObj* go,
+ const mol::EntityView& ev,
+ const String& prop,
+ const Color& c1, const Color& c2, float minv, float maxv)
{
- go->ColorBy(mh,prop,g,minv,maxv);
+ Gradient g;
+ g.SetColorAt(0.0,c1);
+ g.SetColorAt(1.0,c2);
+ go->ColorBy(ev,prop,g,minv,maxv);
}
-
-inline void color_by_11(GfxObj* go,
- const ::img::MapHandle& mh,
- const String& prop,
- const Gradient& g)
+inline void color_by_e2(GfxObj* go,
+ const mol::EntityHandle& eh,
+ const String& prop,
+ const Gradient& g, float minv, float maxv)
{
- go->ColorBy(mh,prop,g);
+ go->ColorBy(eh.CreateFullView(),prop,g,minv,maxv);
}
-inline void color_by_12(GfxObj* go,
- const ::img::MapHandle& mh,
- const String& prop,
- const Color& c1, const Color& c2)
+inline void color_by_e3(GfxObj* go,
+ const mol::EntityHandle& eh,
+ const String& prop,
+ const Color& c1, const Color& c2, float minv, float maxv)
{
- go->ColorBy(mh,prop,c1,c2);
+ Gradient g;
+ g.SetColorAt(0.0,c1);
+ g.SetColorAt(1.0,c2);
+ go->ColorBy(eh.CreateFullView(),prop,g,minv,maxv);
}
-
-inline void color_by_04(GfxObj* go,
- const ::img::MapHandle& mh,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv)
+inline void color_by_e4(GfxObj* go,
+ const mol::EntityView& ev,
+ const String& prop,
+ const Gradient& g)
{
- go->ColorBy(mh,prop,c1,c2,minv,maxv);
+ std::pair<float,float> minmax = ev.GetMinMax(prop);
+ go->ColorBy(ev,prop,g,minmax.first, minmax.second);
}
-#endif
-
-inline void color_by_03(GfxObj* go,
- const mol::EntityView& ev,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv)
+inline void color_by_e5(GfxObj* go,
+ const mol::EntityView& ev,
+ const String& prop,
+ const Color& c1, const Color& c2)
{
- go->ColorBy(ev,prop,c1,c2,minv,maxv);
+ Gradient g;
+ g.SetColorAt(0.0,c1);
+ g.SetColorAt(1.0,c2);
+ std::pair<float,float> minmax = ev.GetMinMax(prop);
+ go->ColorBy(ev,prop,g,minmax.first, minmax.second);
}
-
-
-inline void color_by_05(GfxObj* go,
- const mol::EntityHandle& eh,
- const String& prop,
- const Gradient& g, float minv, float maxv)
+inline void color_by_e6(GfxObj* go,
+ const mol::EntityHandle& eh,
+ const String& prop,
+ const Gradient& g)
{
- go->ColorBy(eh,prop,g,minv,maxv);
+ color_by_e4(go,eh.CreateFullView(),prop,g);
}
-inline void color_by_06(GfxObj* go,
- const mol::EntityHandle& eh,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv)
+inline void color_by_e7(GfxObj* go,
+ const mol::EntityHandle& eh,
+ const String& prop,
+ const Color& c1, const Color& c2)
{
- go->ColorBy(eh,prop,c1,c2,minv,maxv);
+ color_by_e5(go,eh.CreateFullView(),prop,c1,c2);
}
-inline void color_by_07(GfxObj* go,
- const mol::EntityView& ev,
- const String& prop,
- const Gradient& g){
- go->ColorBy(ev,prop,g);
+#if OST_IMG_ENABLED
+inline void color_by_m0(GfxObj* go,
+ const ::img::MapHandle& mh,
+ const String& prop,
+ const Gradient& g, float minv, float maxv)
+{
+ go->ColorBy(mh,prop,g,minv,maxv);
}
-inline void color_by_08(GfxObj* go,
- const mol::EntityView& ev,
- const String& prop,
- const Color& c1, const Color& c2)
+inline void color_by_m1(GfxObj* go,
+ const ::img::MapHandle& mh,
+ const String& prop,
+ const Gradient& g)
{
- go->ColorBy(ev,prop,c1,c2);
+ ost::img::alg::Stat stat;
+ mh.Apply(stat);
+ float min = static_cast<float>(stat.GetMinimum());
+ float max = static_cast<float>(stat.GetMaximum());
+ std::pair<float,float> minmax = std::make_pair(min,max);
+ go->ColorBy(mh,prop,g,minmax.first, minmax.second);
}
-inline void color_by_09(GfxObj* go,
- const mol::EntityHandle& ev,
- const String& prop,
- const Gradient& g)
+inline void color_by_m2(GfxObj* go,
+ const ::img::MapHandle& mh,
+ const String& prop,
+ const Color& c1, const Color& c2)
{
- go->ColorBy(ev,prop,g);
+ Gradient g;
+ g.SetColorAt(0.0,c1);
+ g.SetColorAt(1.0,c2);
+ ost::img::alg::Stat stat;
+ mh.Apply(stat);
+ float min = static_cast<float>(stat.GetMinimum());
+ float max = static_cast<float>(stat.GetMaximum());
+ std::pair<float,float> minmax = std::make_pair(min,max);
+ go->ColorBy(mh,prop,g,minmax.first, minmax.second);
}
-inline void color_by_10(GfxObj* go,
- const mol::EntityHandle& ev,
- const String& prop,
- const Color& c1, const Color& c2)
+inline void color_by_m3(GfxObj* go,
+ const ::img::MapHandle& mh,
+ const String& prop,
+ const Color& c1, const Color& c2, float minv, float maxv)
{
- go->ColorBy(ev,prop,c1,c2);
+ Gradient g;
+ g.SetColorAt(0.0,c1);
+ g.SetColorAt(1.0,c2);
+ go->ColorBy(mh,prop,g,minv, maxv);
}
+#endif
}
#define COLOR_BY_DEF_STD() \
- .def("ColorBy",ost_gfx::color_by_03)\
- .def("ColorBy",ost_gfx::color_by_05)\
- .def("ColorBy",ost_gfx::color_by_06)\
- .def("ColorBy",ost_gfx::color_by_07)\
- .def("ColorBy",ost_gfx::color_by_08)\
- .def("ColorBy",ost_gfx::color_by_09)\
- .def("ColorBy",ost_gfx::color_by_10)
+ .def("ColorBy",ost_gfx::color_by_e0)\
+ .def("ColorBy",ost_gfx::color_by_e1)\
+ .def("ColorBy",ost_gfx::color_by_e2)\
+ .def("ColorBy",ost_gfx::color_by_e3)\
+ .def("ColorBy",ost_gfx::color_by_e4)\
+ .def("ColorBy",ost_gfx::color_by_e5)\
+ .def("ColorBy",ost_gfx::color_by_e6)\
+ .def("ColorBy",ost_gfx::color_by_e7)
#if OST_IMG_ENABLED
# define COLOR_BY_DEF_MAP() \
- .def("ColorBy",ost_gfx::color_by_01)\
- .def("ColorBy",ost_gfx::color_by_02)\
- .def("ColorBy",ost_gfx::color_by_04)\
- .def("ColorBy",ost_gfx::color_by_11)\
- .def("ColorBy",ost_gfx::color_by_12)
+ .def("ColorBy",ost_gfx::color_by_m0)\
+ .def("ColorBy",ost_gfx::color_by_m1)\
+ .def("ColorBy",ost_gfx::color_by_m2)\
+ .def("ColorBy",ost_gfx::color_by_m3)
#else
# define COLOR_BY_DEF_MAP()
#endif
diff --git a/modules/gfx/pymod/export_entity.cc b/modules/gfx/pymod/export_entity.cc
index a81f8299ea0cdc549b1fb34b0255cdb66f4938d7..2df144bbc1a5bae4727d1632718d77a2993cb80c 100644
--- a/modules/gfx/pymod/export_entity.cc
+++ b/modules/gfx/pymod/export_entity.cc
@@ -92,6 +92,16 @@ void color_by_08(Entity* e,
e->ColorBy(prop,c1,c2);
}
+// temporary, see comment in gfx/entity.hh
+void detail_color_by_02(Entity* e,
+ const String& prop,
+ const Gradient& gradient,
+ float minv,float maxv)
+{
+ e->DetailColorBy(prop,gradient,minv,maxv);
+}
+
+
void radius_by_01(Entity* e,
const String& prop,
float rmin,float rmax,
@@ -177,7 +187,6 @@ void ent_apply_62(Entity* e, MapHandleColorOp& mhco){
}
#endif //OST_IMG_ENABLED
-
RenderOptionsPtr ent_sline_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::SLINE);
@@ -185,6 +194,11 @@ RenderOptionsPtr ent_sline_opts(Entity* ent)
void (Entity::*set_rm1)(RenderMode::Type, const mol::EntityView&, bool)=&Entity::SetRenderMode;
void (Entity::*set_rm2)(RenderMode::Type)=&Entity::SetRenderMode;
RenderOptionsPtr ent_trace_opts(Entity* ent)
+{
+ return ent->GetOptions(RenderMode::TRACE);
+}
+
+RenderOptionsPtr ent_line_trace_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::LINE_TRACE);
}
@@ -237,6 +251,7 @@ void export_Entity()
.add_property("selection", &Entity::GetSelection,
&Entity::SetSelection)
.def("GetView", &Entity::GetView)
+ .def("UpdateView", &Entity::UpdateView)
.def("GetRenderModeName", &Entity::GetRenderModeName)
.def("GetNotEmptyRenderModes", &Entity::GetNotEmptyRenderModes)
.def("SetRenderMode", set_rm1, arg("keep")=false)
@@ -253,6 +268,7 @@ void export_Entity()
.def("ColorBy", color_by_06)
.def("ColorBy", color_by_07)
.def("ColorBy", color_by_08)
+ .def("DetailColorBy", detail_color_by_02)
COLOR_BY_DEF()
.def("RadiusBy", radius_by_01)
.def("RadiusBy", radius_by_02)
@@ -273,6 +289,7 @@ void export_Entity()
.add_property("cartoon_options", &ent_hsc_opts)
.add_property("cpk_options", &ent_cpk_opts)
.add_property("trace_options", &ent_trace_opts)
+ .add_property("line_trace_options", &ent_line_trace_opts)
.def("ApplyOptions", &Entity::ApplyOptions)
.def("SetOptions", &Entity::SetOptions)
.def("Apply",&ent_apply_11)
diff --git a/modules/gfx/pymod/export_gfx_obj.cc b/modules/gfx/pymod/export_gfx_obj.cc
index 18e3454eead7e34dcfc09493cfcf87dc219a74ac..6210c9c9880dd01d79ee505d87fc1b9d66f06879 100644
--- a/modules/gfx/pymod/export_gfx_obj.cc
+++ b/modules/gfx/pymod/export_gfx_obj.cc
@@ -25,61 +25,90 @@ using namespace ost::gfx;
#include "color_by_def.hh"
+namespace {
+ // convenience for python
+ void set_mat_amb2(GfxObjBase* b, float c) {b->SetMatAmb(Color(c,c,c,1.0));}
+ void set_mat_diff2(GfxObjBase* b, float c) {b->SetMatDiff(Color(c,c,c,1.0));}
+ void set_mat_spec2(GfxObjBase* b, float c) {b->SetMatSpec(Color(c,c,c,1.0));}
+ void set_mat_emm2(GfxObjBase* b, float c) {b->SetMatEmm(Color(c,c,c,1.0));}
+ void set_mat1(GfxObjBase* b, float a, float d, float s, float p)
+ {
+ set_mat_amb2(b,a);
+ set_mat_diff2(b,d);
+ set_mat_spec2(b,s);
+ b->SetMatShin(p);
+ set_mat_emm2(b,0.0);
+ }
+ void set_mat2(GfxObjBase* b, Color a, Color d, Color s, float p)
+ {
+ b->SetMatAmb(a);
+ b->SetMatDiff(d);
+ b->SetMatSpec(s);
+ b->SetMatShin(p);
+ set_mat_emm2(b,0.0);
+ }
+
+ void set_outline(GfxObjBase* b, bool f)
+ {
+ LOGN_MESSAGE("Outline(bool) is deprecated, use SetOutline(bool) instead");
+ b->SetOutline(f);
+ }
+ void set_aalines(GfxObjBase* b, bool f)
+ {
+ LOGN_MESSAGE("AALines(bool) is deprecated, use SetAALines(bool) instead");
+ b->SetAALines(f);
+ }
+}
+
void export_GfxObj()
{
- void (GfxObj::* set_mat_amb1)(const Color&) = &GfxObj::SetMatAmb;
- void (GfxObj::* set_mat_amb2)(float) = &GfxObj::SetMatAmb;
- void (GfxObj::* set_mat_diff1)(const Color&) = &GfxObj::SetMatDiff;
- void (GfxObj::* set_mat_diff2)(float) = &GfxObj::SetMatDiff;
- void (GfxObj::* set_mat_spec1)(const Color&) = &GfxObj::SetMatSpec;
- void (GfxObj::* set_mat_spec2)(float) = &GfxObj::SetMatSpec;
- void (GfxObj::* set_mat_emm1)(const Color&) = &GfxObj::SetMatEmm;
- void (GfxObj::* set_mat_emm2)(float) = &GfxObj::SetMatEmm;
- void (GfxObj::* set_mat1)(const Color&,const Color&,
- const Color&, float) = &GfxObj::SetMat;
- void (GfxObj::* set_mat2)(float,float,float,float) = &GfxObj::SetMat;
-
- class_<GfxObj, bases<GfxNode>, boost::noncopyable>("GfxObj",no_init)
- .def("GetCenter",&GfxObj::GetCenter)
- .def("SetRenderMode", &GfxObj::SetRenderMode)
- .def("GetRenderMode", &GfxObj::GetRenderMode)
- .def("SetLineWidth", &GfxObj::SetLineWidth)
- .def("GetLineWidth", &GfxObj::GetLineWidth)
- .def("SetLineHalo",&GfxObj::SetLineHalo)
- .def("GetLineHalo",&GfxObj::GetLineHalo)
- .def("SetSphereDetail",&GfxObj::SetSphereDetail)
- .def("SetArcDetail",&GfxObj::SetArcDetail)
- .def("SetSplineDetail",&GfxObj::SetSplineDetail)
- .def("SetMatAmb",set_mat_amb1)
+ class_<GfxObjBase, boost::shared_ptr<GfxObjBase>, bases<GfxNode>, boost::noncopyable>("GfxObjBase",no_init)
+ .def("SetMatAmb",&GfxObjBase::SetMatAmb)
.def("SetMatAmb",set_mat_amb2)
- .def("SetMatDiff",set_mat_diff1)
+ .def("SetMatDiff",&GfxObjBase::SetMatDiff)
.def("SetMatDiff",set_mat_diff2)
- .def("GetTF", &GfxObj::GetTF, return_value_policy<copy_const_reference>())
- .def("SetTF", &GfxObj::SetTF)
- .def("SetMatSpec",set_mat_spec1)
+ .def("SetMatSpec",&GfxObjBase::SetMatSpec)
.def("SetMatSpec",set_mat_spec2)
- .def("SetMatEmm",set_mat_emm1)
+ .def("SetMatEmm",&GfxObjBase::SetMatEmm)
.def("SetMatEmm",set_mat_emm2)
- .def("SetMatShin",&GfxObj::SetMatShin)
+ .def("SetMatShin",&GfxObjBase::SetMatShin)
.def("SetMat",set_mat1)
.def("SetMat",set_mat2)
- .def("SetPolyMode",&GfxObj::SetPolyMode)
- .def("SetAALines",&GfxObj::SetAALines)
- .def("SetOpacity",&GfxObj::SetOpacity)
- .def("GetOpacity",&GfxObj::GetOpacity)
+ .def("ContextSwitch", &GfxObjBase::ContextSwitch)
+ .def("SetRenderMode", &GfxObjBase::SetRenderMode)
+ .def("GetRenderMode", &GfxObjBase::GetRenderMode)
+ .def("GetCenter",&GfxObjBase::GetCenter)
+ .def("SetLineWidth", &GfxObjBase::SetLineWidth)
+ .def("SetPolyMode",&GfxObjBase::SetPolyMode)
+ .def("AALines",set_aalines)
+ .def("SetAALines",&GfxObjBase::SetAALines)
+ .def("SetLineHalo",&GfxObjBase::SetLineHalo)
+ .def("Outline",set_outline)
+ .def("SetOutline",&GfxObjBase::SetOutline)
+ .def("SetOutlineMode",&GfxObjBase::SetOutlineMode)
+ .def("SetOutlineWidth",&GfxObjBase::SetOutlineWidth)
+ .def("SetOutlineExpandFactor",&GfxObjBase::SetOutlineExpandFactor)
+ .def("SetOutlineExpandColor",&GfxObjBase::SetOutlineExpandColor)
+ .def("SetOpacity",&GfxObjBase::SetOpacity)
+ .def("GetOpacity",&GfxObjBase::GetOpacity)
+ .add_property("center", &GfxObjBase::GetCenter)
+ COLOR_BY_DEF()
+ ;
+ //register_ptr_to_python<GfxObjBaseP>();
+
+ class_<GfxObj, boost::shared_ptr<GfxObj>, bases<GfxObjBase>, boost::noncopyable>("GfxObj",no_init)
+ .def("GetTF", &GfxObj::GetTF, return_value_policy<copy_const_reference>())
+ .def("SetTF", &GfxObj::SetTF)
.def("FlagRebuild",&GfxObj::FlagRebuild)
.def("FlagRefresh",&GfxObj::FlagRefresh)
.def("SetNormalSmoothFactor",&GfxObj::SetNormalSmoothFactor)
.def("GetNormalSmoothFactor",&GfxObj::GetNormalSmoothFactor)
- .def("SetOutlineMode",&GfxObj::SetOutlineMode)
- .def("SetOutlineExpandFactor",&GfxObj::SetOutlineExpandFactor)
- .def("SetOutlineExpandColor",&GfxObj::SetOutlineExpandColor)
.def("SmoothVertices",&GfxObj::SmoothVertices)
- .def("AmbientOcclusion",&GfxObj::AmbientOcclusion)
.def("Debug",&GfxObj::Debug)
- .add_property("center", &GfxObj::GetCenter)
- COLOR_BY_DEF()
+ .def("GetAALines",&GfxObj::GetAALines)
+ .def("GetLineWidth",&GfxObj::GetLineWidth)
+ .def("GetLineHalo",&GfxObj::GetLineHalo)
;
- register_ptr_to_python<GfxObjP>();
+ //register_ptr_to_python<GfxObjP>();
}
diff --git a/modules/gfx/pymod/export_render_options.cc b/modules/gfx/pymod/export_render_options.cc
index b27e55c46f32ec9ac3fc3c3c166eb74d58cbc1fe..ab4e9425c79f99408533352056227f6c11288dfe 100644
--- a/modules/gfx/pymod/export_render_options.cc
+++ b/modules/gfx/pymod/export_render_options.cc
@@ -63,8 +63,8 @@ void export_RenderOptions()
class_<CPKRenderOptions, boost::shared_ptr<CPKRenderOptions>, bases<RenderOptions>, boost::noncopyable>("CPKRenderOptions")
.def("SetSphereDetail", &CPKRenderOptions::SetSphereDetail)
.def("GetSphereDetail", &CPKRenderOptions::GetSphereDetail)
- .def("SetCPKMode", &CPKRenderOptions::SetCPKMode)
- .def("GetCPKMode", &CPKRenderOptions::GetCPKMode)
+ .def("SetSphereMode", &CPKRenderOptions::SetSphereMode)
+ .def("GetSphereMode", &CPKRenderOptions::GetSphereMode)
;
class_<CustomRenderOptions, boost::shared_ptr<CustomRenderOptions>, bases<RenderOptions>, boost::noncopyable>("CustomRenderOptions")
@@ -102,6 +102,8 @@ void export_RenderOptions()
.def("GetHelixEcc", &CartoonRenderOptions::GetHelixEcc)
.def("SetHelixProfileType", &CartoonRenderOptions::SetHelixProfileType)
.def("GetHelixProfileType", &CartoonRenderOptions::GetHelixProfileType)
+ .def("SetHelixMode", &CartoonRenderOptions::SetHelixMode)
+ .def("GetHelixMode", &CartoonRenderOptions::GetHelixMode)
.def("SetStrandWidth", &CartoonRenderOptions::SetStrandWidth)
.def("GetStrandWidth", &CartoonRenderOptions::GetStrandWidth)
.def("SetStrandThickness", &CartoonRenderOptions::SetStrandThickness)
@@ -110,6 +112,10 @@ void export_RenderOptions()
.def("GetStrandEcc", &CartoonRenderOptions::GetStrandEcc)
.def("SetStrandProfileType", &CartoonRenderOptions::SetStrandProfileType)
.def("GetStrandProfileType", &CartoonRenderOptions::GetStrandProfileType)
+ .def("SetStrandMode", &CartoonRenderOptions::SetStrandMode)
+ .def("GetStrandMode", &CartoonRenderOptions::GetStrandMode)
+ .def("SetColorBlendMode", &CartoonRenderOptions::SetColorBlendMode)
+ .def("GetColorBlendMode", &CartoonRenderOptions::GetColorBlendMode)
;
class_<TraceRenderOptions, boost::shared_ptr<TraceRenderOptions>, bases<RenderOptions>, boost::noncopyable>("TraceRenderOptions")
@@ -119,6 +125,8 @@ void export_RenderOptions()
.def("GetNormalSmoothFactor", &TraceRenderOptions::GetNormalSmoothFactor)
.def("SetTubeRadius", &TraceRenderOptions::SetTubeRadius)
.def("GetTubeRadius", &TraceRenderOptions::GetTubeRadius)
+ .def("SetRadius", &TraceRenderOptions::SetTubeRadius)
+ .def("GetRadius", &TraceRenderOptions::GetTubeRadius)
;
}
diff --git a/modules/gfx/pymod/export_scene.cc b/modules/gfx/pymod/export_scene.cc
index 9cae54473b3dc37cd301c55b1e54d643272fb308..1eb5a8fe2c97d56690552cc35be5d7b7c9dd99f3 100644
--- a/modules/gfx/pymod/export_scene.cc
+++ b/modules/gfx/pymod/export_scene.cc
@@ -33,7 +33,6 @@ BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(scene_autoslab_overloads,
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(scene_export_pov_overloads,
Scene::ExportPov, 1,2)
void (Scene::*apply)(const InputEvent&, bool)=&Scene::Apply;
-namespace {
Scene* get_scene()
{
@@ -49,16 +48,13 @@ GfxObjP scene_getitem(Scene* scene, const String& item)
return scene->operator[](item);
}
-}
+} // anon ns
-}
void export_Scene()
{
def("Scene",get_scene,return_value_policy<reference_existing_object>());
- def("set_offscreen_mode",&Scene::SetOffscreenMode);
-
// will be removed...
def("PickAtom", &pick_atom);
@@ -87,30 +83,26 @@ void export_Scene()
.def("CenterOn",center_on1)
.def("CenterOn",center_on2)
.def("UnProject", &Scene::UnProject, arg("ignore_vp")=false)
+ .def("Project", &Scene::Project, arg("ignore_vp")=false)
.def("InitGL", &Scene::InitGL)
.def("RenderGL", &Scene::RenderGL)
.def("Resize", &Scene::Resize)
.def("SetBackground", &Scene::SetBackground)
- .add_property("center", &Scene::GetCenter, &Scene::SetCenter)
- .add_property("near", &Scene::GetNear, &Scene::SetNear)
- .add_property("far", &Scene::GetFar, &Scene::SetFar)
.def("SetNearFar",&Scene::SetNearFar)
.def("SetFog",&Scene::SetFog)
.def("SetFogColor",&Scene::SetFogColor)
- .add_property("fog_near_offset", &Scene::GetFogNearOffset,
- &Scene::SetFogNearOffset)
- .add_property("fog_far_offset", &Scene::GetFogFarOffset,
- &Scene::SetFogFarOffset)
.def("SetFOV",&Scene::SetFOV)
.def("GetFOV",&Scene::GetFOV)
.def("SetFogOffsets",&Scene::SetFogOffsets)
.def("Stereo",&Scene::Stereo)
.def("SetStereoInverted",&Scene::SetStereoInverted)
- .def("Apply", apply)
- .def("SetStereoEye",&Scene::SetStereoEye)
+ .def("SetStereoView",&Scene::SetStereoView)
+ .def("SetStereoEyeDist",&Scene::SetStereoEyeDist)
+ .def("SetStereoEyeOff",&Scene::SetStereoEyeOff)
.def("SetLightDir",&Scene::SetLightDir)
.def("SetLightProp",set_light_prop1)
.def("SetLightProp",set_light_prop2)
+ .def("Apply", apply)
.def("Export",export1, arg("transparent")=true)
.def("Export",export2, arg("transparent")=true)
.def("ExportPov",&Scene::ExportPov,
@@ -127,9 +119,47 @@ void export_Scene()
.def("BlurSnapshot",&Scene::BlurSnapshot)
.def("SetShadow",&Scene::SetShadow)
.def("SetShadowQuality",&Scene::SetShadowQuality)
+ .def("SetShadowWeight",&Scene::SetShadowWeight)
+ .def("SetDepthDarkening",&Scene::SetDepthDarkening)
+ .def("SetDepthDarkeningWeight",&Scene::SetDepthDarkeningWeight)
+ .def("SetAmbientOcclusion",&Scene::SetAmbientOcclusion)
+ .def("SetAmbientOcclusionWeight",&Scene::SetAmbientOcclusionWeight)
+ .def("SetAmbientOcclusionMode",&Scene::SetAmbientOcclusionMode)
+ .def("SetAmbientOcclusionQuality",&Scene::SetAmbientOcclusionQuality)
.def("AttachObserver",&Scene::AttachObserver)
+ .def("StartOffscreenMode",&Scene::StartOffscreenMode)
+ .def("StopOffscreenMode",&Scene::StopOffscreenMode)
+ .def("SetShadingMode",&Scene::SetShadingMode)
+ .def("SetBeacon",&Scene::SetBeacon)
+ .def("SetBeaconOff",&Scene::SetBeaconOff)
+ .def("__getitem__",scene_getitem)
+ .add_property("bg",
+ &Scene::GetBackground,
+ &Scene::SetBackground)
+ .add_property("center", &Scene::GetCenter, &Scene::SetCenter)
+ .add_property("near", &Scene::GetNear, &Scene::SetNear)
+ .add_property("far", &Scene::GetFar, &Scene::SetFar)
+ .add_property("fov", &Scene::GetFOV, &Scene::SetFOV)
+ .add_property("fog", &Scene::GetFog, &Scene::SetFog)
+ .add_property("fogcol", &Scene::GetFogColor, &Scene::SetFogColor)
+ .add_property("fogno",
+ &Scene::GetFogNearOffset,
+ &Scene::SetFogNearOffset)
+ .add_property("fogfo",
+ &Scene::GetFogFarOffset,
+ &Scene::SetFogFarOffset)
+ .add_property("smode",
+ &Scene::GetSelectionMode,
+ &Scene::SetSelectionMode)
+ // deprecated python properties!
.add_property("selection_mode", &Scene::GetSelectionMode,
&Scene::SetSelectionMode)
- .def("__getitem__",scene_getitem)
+ .add_property("fog_near_offset",
+ &Scene::GetFogNearOffset,
+ &Scene::SetFogNearOffset)
+ .add_property("fog_far_offset",
+ &Scene::GetFogFarOffset,
+ &Scene::SetFogFarOffset)
+
;
}
diff --git a/modules/gfx/pymod/export_surface.cc b/modules/gfx/pymod/export_surface.cc
index 4a4ebc88287f4ea3521a47f998ee9fbeb9b6b266..9a589d077148396f5c93c090ead481cbca2d5f08 100644
--- a/modules/gfx/pymod/export_surface.cc
+++ b/modules/gfx/pymod/export_surface.cc
@@ -122,4 +122,5 @@ void export_Surface()
.def("CleanColorOps", &Surface::CleanColorOps)
.def("ReapplyColorOps", &Surface::ReapplyColorOps)
;
+
}
diff --git a/modules/gfx/pymod/glwin_base_proxy.hh b/modules/gfx/pymod/glwin_base_proxy.hh
index 6c73fd142d7f6fa083e936d2e27a718646afdd0d..b8b47975fb06fc8ad1a61b0468de2e0faaed603c 100644
--- a/modules/gfx/pymod/glwin_base_proxy.hh
+++ b/modules/gfx/pymod/glwin_base_proxy.hh
@@ -22,10 +22,15 @@ public:
virtual void DoRefresh() {
call_method<void>(self, "DoRefresh");
}
- virtual void SetStereo(bool flag) { }
+ virtual bool HasStereo() const {
+ return call_method<bool>(self,"HasStereo");
+ }
virtual void StatusMessage(const String& m) {
call_method<void, const String>(self, "StatusMessage", m);
}
+ virtual bool HasMultisample() const {
+ return call_method<bool>(self,"HasMultisample");
+ }
private:
PyObject* self;
diff --git a/modules/gfx/pymod/wrap_gfx.cc b/modules/gfx/pymod/wrap_gfx.cc
index dd2049702cb4ca0d643517dce0de21917630ae6c..1c8ca00655a03830eaed53a3e6c9f1a407395956 100644
--- a/modules/gfx/pymod/wrap_gfx.cc
+++ b/modules/gfx/pymod/wrap_gfx.cc
@@ -23,7 +23,9 @@ using namespace boost::python;
#include <ost/gfx/prim_list.hh>
#include <ost/gfx/gradient.hh>
#include <ost/gfx/gfx_test_object.hh>
-
+#if OST_SHADER_SUPPORT_ENABLED
+#include <ost/gfx/shader.hh>
+#endif
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
extern void export_Scene();
@@ -170,6 +172,15 @@ BOOST_PYTHON_MODULE(_gfx)
.def("GetRel", &Stop::GetRel)
;
+#if OST_SHADER_SUPPORT_ENABLED
+ class_<Shader, boost::noncopyable>("Shader", no_init)
+ .def("Instance",&Shader::Instance,
+ return_value_policy<reference_existing_object>()).staticmethod("Instance")
+ .def("PushProgram",&Shader::PushProgram)
+ .def("PopProgram",&Shader::PopProgram)
+ .def("Activate",&Shader::Activate)
+ ;
+#endif
export_primitives();
}
diff --git a/modules/gfx/src/CMakeLists.txt b/modules/gfx/src/CMakeLists.txt
index c07798109ce865af880e7d071888cbdac7ae7991..49dd30b678a5d316efdd2205f93ad76d90a463c9 100644
--- a/modules/gfx/src/CMakeLists.txt
+++ b/modules/gfx/src/CMakeLists.txt
@@ -10,6 +10,7 @@ gfx_fw.hh
gfx_node.hh
gfx_node_fw.hh
gfx_node_visitor.hh
+gfx_object_base.hh
gfx_object.hh
gfx_object_fw.hh
gfx_prim.hh
@@ -61,7 +62,6 @@ trace_render_options.hh
set(OST_GFX_IMPL_HEADERS
-calc_ambient.hh
cartoon_renderer.hh
custom_renderer.hh
cpk_renderer.hh
@@ -89,7 +89,6 @@ set(OST_GFX_SOURCES
bitmap_io.cc
color.cc
primitives.cc
-offscreen_buffer.cc
entity.cc
symmetry_node.cc
@@ -116,7 +115,6 @@ color_ops/gradient_color_op.cc
color_ops/entity_view_color_op.cc
color_ops/basic_gradient_color_op.cc
color_ops/gradient_level_color_op.cc
-impl/calc_ambient.cc
impl/entity_renderer.cc
impl/entity_detail.cc
impl/cartoon_renderer.cc
@@ -173,10 +171,27 @@ else()
set(OST_GFX_MAP_SOURCES "")
endif()
+if (UNIX AND NOT APPLE)
+ list(APPEND OST_GFX_SOURCES impl/glx_offscreen_buffer.cc)
+ list(APPEND OST_GFX_IMPL_HEADERS glx_offscreen_buffer.hh)
+endif()
+
+if (APPLE)
+ list(APPEND OST_GFX_SOURCES impl/cgl_offscreen_buffer.cc)
+ list(APPEND OST_GFX_IMPL_HEADERS cgl_offscreen_buffer.hh)
+endif()
+
+if(WIN32)
+ list(APPEND OST_GFX_SOURCES impl/wgl_offscreen_buffer.cc)
+ list(APPEND OST_GFX_IMPL_HEADERS wgl_offscreen_buffer.hh)
+endif()
+
if (USE_SHADER)
message("Compiling with Shader Support")
list(APPEND OST_GFX_SOURCES shader.cc)
list(APPEND OST_GFX_HEADERS shader.hh)
+ list(APPEND OST_GFX_SOURCES impl/scene_fx.cc)
+ list(APPEND OST_GFX_IMPL_HEADERS scene_fx.hh)
if (NOT APPLE)
set(OST_GLEW_HEADERS
glew.h
@@ -208,27 +223,35 @@ target_link_libraries(ost_gfx ${OPENGL_LIBRARIES} ${PNG_LIBRARIES})
if (USE_SHADER)
set(SHADER_FILES
- shader/basic_lf_vs.glsl
+ shader/aaline_fs.glsl
+ shader/amboccl_fs.glsl
+ shader/basic_fs.glsl
+ shader/basic_hf_vs.glsl
shader/basic_lf_fs.glsl
- shader/fraglight_lf_vs.glsl
+ shader/basic_lf_vs.glsl
+ shader/basic_vs.glsl
+ shader/beacon_fs.glsl
+ shader/convolute1_fs.glsl
+ shader/dumpnorm_fs.glsl
+ shader/dumpnorm_vs.glsl
+ shader/fast_sphere_fs.glsl
+ shader/fast_sphere_vs.glsl
+ shader/fraglight_fs.glsl
shader/fraglight_lf_fs.glsl
- shader/basic_lfs_vs.glsl
- shader/basic_lfs_fs.glsl
- shader/fraglight_lfs_vs.glsl
- shader/fraglight_lfs_fs.glsl
- shader/basic_hf_vs.glsl
- shader/selfx_vs.glsl
- shader/selfx_fs.glsl
- shader/toon_vs.glsl
- shader/toon_fs.glsl
- shader/toon2_fs.glsl
- shader/noop_vs.glsl
- shader/aaline_fs.glsl
- shader/iso_vs.glsl
+ shader/fraglight_lf_vs.glsl
+ shader/fraglight_vs.glsl
shader/iso_fs.glsl
- shader/fast_sphere_vs.glsl
- shader/fast_sphere_fs.glsl
+ shader/iso_vs.glsl
+ shader/noop_vs.glsl
shader/outline_vs.glsl
+ shader/quadpp_vs.glsl
+ shader/scenefx_fs.glsl
+ shader/scenefx_vs.glsl
+ shader/selfx_fs.glsl
+ shader/selfx_vs.glsl
+ shader/toon2_fs.glsl
+ shader/toon_fs.glsl
+ shader/toon_vs.glsl
)
copy_if_different("./" "${SHARED_DATA_PATH}/shader" "${SHADER_FILES}"
"SHADER_TARGETS" ost_gfx)
diff --git a/modules/gfx/src/GL/glew.c b/modules/gfx/src/GL/glew.c
index 24c6a726c38153020710e146051590788d76bfc2..987236b7d30f9e55fcaf110a729725d6f0d060d6 100644
--- a/modules/gfx/src/GL/glew.c
+++ b/modules/gfx/src/GL/glew.c
@@ -66,9 +66,26 @@
#endif /* GLEW_MX */
#if defined(__APPLE__)
-#include <mach-o/dyld.h>
#include <stdlib.h>
#include <string.h>
+#include <AvailabilityMacros.h>
+
+#ifdef MAC_OS_X_VERSION_10_3
+
+#include <dlfcn.h>
+
+void* NSGLGetProcAddress (const GLubyte *name)
+{
+ static void* image = NULL;
+ if (NULL == image)
+ {
+ image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
+ }
+ return image ? dlsym(image, (const char*)name) : NULL;
+}
+#else
+
+#include <mach-o/dyld.h>
void* NSGLGetProcAddress (const GLubyte *name)
{
@@ -90,6 +107,7 @@ void* NSGLGetProcAddress (const GLubyte *name)
free(symbolName);
return symbol ? NSAddressOfSymbol(symbol) : NULL;
}
+#endif /* MAC_OS_X_VERSION_10_3 */
#endif /* __APPLE__ */
#if defined(__sgi) || defined (__sun)
@@ -444,8 +462,6 @@ PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;
PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL;
PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL;
-PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;
-PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;
PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL;
PFNGLCLAMPCOLORPROC __glewClampColor = NULL;
PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL;
@@ -459,7 +475,6 @@ PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL;
PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL;
PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL;
PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL;
-PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;
PFNGLGETSTRINGIPROC __glewGetStringi = NULL;
PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL;
PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL;
@@ -501,8 +516,43 @@ PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL;
PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL;
PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL;
+PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL;
+PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL;
+PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL;
+PFNGLTEXBUFFERPROC __glewTexBuffer = NULL;
+
+PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL;
+PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL;
+PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL;
+
+PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL;
+PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL;
+PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL;
+PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL;
+PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL;
+
PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;
+PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL;
+PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL;
+PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL;
+PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL;
+
+PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL;
+PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL;
+PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL;
+PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL;
+PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL;
+PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL;
+PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL;
+PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL;
+PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL;
+PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL;
+PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL;
+
+PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL;
+PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL;
+
PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;
PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;
@@ -521,6 +571,10 @@ PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;
PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;
PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;
+PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL;
+PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL;
+PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL;
+
PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;
PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;
@@ -533,10 +587,36 @@ PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;
PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;
+PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL;
+PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL;
+PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL;
+PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL;
+PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL;
+PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL;
+PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL;
+
+PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL;
+PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL;
+
PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;
+PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL;
+
PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;
+PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL;
+PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL;
+PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL;
+PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL;
+
+PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL;
+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL;
+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL;
+
+PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL;
+PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL;
+
PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL;
PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL;
@@ -547,10 +627,10 @@ PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL;
PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL;
PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL;
PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL;
-PFNGLFRAMEBUFFERTEXTURLAYERPROC __glewFramebufferTexturLayer = NULL;
PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL;
PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL;
PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL;
+PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL;
PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL;
PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL;
PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL;
@@ -659,6 +739,25 @@ PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;
PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;
PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;
+PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL;
+
+PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL;
+
+PFNGLBINDSAMPLERPROC __glewBindSampler = NULL;
+PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL;
+PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL;
+PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL;
+PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL;
+PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL;
+PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL;
+PFNGLISSAMPLERPROC __glewIsSampler = NULL;
+PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL;
+PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL;
+PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL;
+PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL;
+PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL;
+PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL;
+
PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;
PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;
PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;
@@ -699,6 +798,33 @@ PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;
PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;
PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;
+PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL;
+PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL;
+PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL;
+PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL;
+PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL;
+PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL;
+PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL;
+PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL;
+
+PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL;
+PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL;
+PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL;
+PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL;
+PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL;
+PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL;
+
+PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL;
+PFNGLDELETESYNCPROC __glewDeleteSync = NULL;
+PFNGLFENCESYNCPROC __glewFenceSync = NULL;
+PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL;
+PFNGLGETSYNCIVPROC __glewGetSynciv = NULL;
+PFNGLISSYNCPROC __glewIsSync = NULL;
+PFNGLWAITSYNCPROC __glewWaitSync = NULL;
+
+PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL;
+PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL;
+
PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL;
PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;
@@ -709,11 +835,44 @@ PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;
+PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL;
+PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL;
+PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL;
+PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL;
+
+PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL;
+PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL;
+PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL;
+
+PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL;
+PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL;
+PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL;
+PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL;
+PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL;
+PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL;
+PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL;
+
+PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL;
+PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL;
+PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL;
+PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL;
+
PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;
PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;
PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;
PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;
+PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;
+PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;
+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL;
+PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL;
+PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL;
+PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL;
+PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;
+PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL;
+PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL;
+PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL;
+
PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL;
PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL;
PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL;
@@ -809,6 +968,45 @@ PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;
PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;
PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;
+PFNGLCOLORP3UIPROC __glewColorP3ui = NULL;
+PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL;
+PFNGLCOLORP4UIPROC __glewColorP4ui = NULL;
+PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL;
+PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL;
+PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL;
+PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL;
+PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL;
+PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL;
+PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL;
+PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL;
+PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL;
+PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL;
+PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL;
+PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL;
+PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL;
+PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL;
+PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL;
+PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL;
+PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL;
+PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL;
+PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL;
+PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL;
+PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL;
+PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL;
+PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL;
+PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL;
+PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL;
+PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL;
+PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL;
+PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL;
+PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL;
+PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL;
+PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL;
+PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL;
+PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL;
+PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL;
+PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL;
+
PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;
PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;
PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;
@@ -988,7 +1186,14 @@ PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL;
PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL;
PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL;
PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL;
+PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL;
+PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL;
+PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL;
PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL;
+PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL;
+PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL;
+PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL;
+PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL;
PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL;
PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL;
PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL;
@@ -997,7 +1202,9 @@ PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL;
PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL;
PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL;
PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL;
+PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL;
PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL;
+PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL;
PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL;
PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL;
PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL;
@@ -1023,6 +1230,7 @@ PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL;
PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL;
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL;
PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL;
+PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL;
PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL;
PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL;
PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL;
@@ -1030,7 +1238,12 @@ PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL;
PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL;
PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL;
PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL;
+PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL;
+PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL;
+PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL;
+PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL;
PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL;
+PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL;
PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL;
PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL;
PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL;
@@ -1077,6 +1290,7 @@ PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;
PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;
PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;
PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;
+PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL;
PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;
PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL;
PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL;
@@ -1148,6 +1362,17 @@ PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL;
PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL;
PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL;
PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL;
+PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL;
+PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL;
+PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL;
+PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL;
+PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL;
+PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL;
+PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL;
+PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL;
+PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL;
+PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL;
+PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL;
PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;
PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;
@@ -1293,6 +1518,8 @@ PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;
PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;
+PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL;
+
PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;
PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;
@@ -1314,6 +1541,13 @@ PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;
PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;
PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;
+PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL;
+PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL;
+PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL;
+
+PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL;
+PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL;
+
PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;
@@ -1361,6 +1595,18 @@ PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;
PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;
PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;
+PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL;
+PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL;
+PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL;
+PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL;
+PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL;
+PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL;
+PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL;
+PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL;
+PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL;
+PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL;
+PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL;
+
PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;
PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;
PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;
@@ -1475,6 +1721,8 @@ PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;
PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL;
PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL;
+PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL;
+
PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;
PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;
PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;
@@ -1525,6 +1773,41 @@ PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;
+PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL;
+PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL;
+PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL;
+PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL;
+PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL;
+PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL;
+PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL;
+PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL;
+PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL;
+PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL;
+PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL;
+PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL;
+PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL;
+PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL;
+PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL;
+PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL;
+PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL;
+PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL;
+PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL;
+PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL;
+PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL;
+PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL;
+PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL;
+PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL;
+PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL;
+PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL;
+PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL;
+PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL;
+PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL;
+PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL;
+PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL;
+PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL;
+PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL;
+PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL;
+
PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;
PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;
PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;
@@ -1596,7 +1879,6 @@ PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL;
PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL;
PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL;
PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL;
-PFNGLVIDEOPARAMETERIVNVPROC __glewVideoParameterivNV = NULL;
PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;
PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;
@@ -1618,6 +1900,22 @@ PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameter
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;
+PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL;
+PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL;
+PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL;
+PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL;
+PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL;
+PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL;
+PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL;
+PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL;
+PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL;
+PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL;
+PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL;
+PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL;
+PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL;
+
+PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL;
+
PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;
PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;
PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;
@@ -1630,9 +1928,50 @@ PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;
+PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL;
+PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL;
+PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL;
+PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL;
+PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL;
+PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL;
+PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL;
+
PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;
PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;
+PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL;
+PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL;
+PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL;
+PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL;
+PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL;
+PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL;
+PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL;
+PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL;
+PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL;
+PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL;
+PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL;
+PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL;
+PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL;
+PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL;
+PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL;
+PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL;
+PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL;
+PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL;
+PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL;
+
+PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL;
+PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL;
+PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL;
+PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL;
+PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL;
+PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL;
+PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL;
+PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL;
+PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL;
+PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL;
+PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL;
+PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL;
+
PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;
PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;
PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;
@@ -1849,32 +2188,59 @@ GLboolean __GLEW_VERSION_1_5 = GL_FALSE;
GLboolean __GLEW_VERSION_2_0 = GL_FALSE;
GLboolean __GLEW_VERSION_2_1 = GL_FALSE;
GLboolean __GLEW_VERSION_3_0 = GL_FALSE;
+GLboolean __GLEW_VERSION_3_1 = GL_FALSE;
+GLboolean __GLEW_VERSION_3_2 = GL_FALSE;
+GLboolean __GLEW_VERSION_3_3 = GL_FALSE;
+GLboolean __GLEW_VERSION_4_0 = GL_FALSE;
GLboolean __GLEW_3DFX_multisample = GL_FALSE;
GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;
GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;
+GLboolean __GLEW_AMD_conservative_depth = GL_FALSE;
+GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE;
+GLboolean __GLEW_AMD_performance_monitor = GL_FALSE;
+GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE;
+GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE;
+GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE;
+GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE;
+GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE;
GLboolean __GLEW_APPLE_client_storage = GL_FALSE;
GLboolean __GLEW_APPLE_element_array = GL_FALSE;
GLboolean __GLEW_APPLE_fence = GL_FALSE;
GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;
GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;
+GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE;
GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;
+GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE;
+GLboolean __GLEW_APPLE_row_bytes = GL_FALSE;
GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;
GLboolean __GLEW_APPLE_texture_range = GL_FALSE;
GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;
GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;
GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;
+GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE;
GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;
+GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE;
GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;
+GLboolean __GLEW_ARB_compatibility = GL_FALSE;
+GLboolean __GLEW_ARB_copy_buffer = GL_FALSE;
GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE;
+GLboolean __GLEW_ARB_depth_clamp = GL_FALSE;
GLboolean __GLEW_ARB_depth_texture = GL_FALSE;
GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;
+GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE;
+GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE;
+GLboolean __GLEW_ARB_draw_indirect = GL_FALSE;
GLboolean __GLEW_ARB_draw_instanced = GL_FALSE;
+GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE;
+GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE;
GLboolean __GLEW_ARB_fragment_program = GL_FALSE;
GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;
GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;
GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE;
GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE;
GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE;
+GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE;
+GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE;
GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;
GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE;
GLboolean __GLEW_ARB_imaging = GL_FALSE;
@@ -1884,33 +2250,58 @@ GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;
GLboolean __GLEW_ARB_multisample = GL_FALSE;
GLboolean __GLEW_ARB_multitexture = GL_FALSE;
GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;
+GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE;
GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;
GLboolean __GLEW_ARB_point_parameters = GL_FALSE;
GLboolean __GLEW_ARB_point_sprite = GL_FALSE;
+GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE;
+GLboolean __GLEW_ARB_sample_shading = GL_FALSE;
+GLboolean __GLEW_ARB_sampler_objects = GL_FALSE;
+GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE;
+GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE;
GLboolean __GLEW_ARB_shader_objects = GL_FALSE;
+GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE;
+GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE;
GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;
+GLboolean __GLEW_ARB_shading_language_include = GL_FALSE;
GLboolean __GLEW_ARB_shadow = GL_FALSE;
GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;
+GLboolean __GLEW_ARB_sync = GL_FALSE;
+GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE;
GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;
GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE;
+GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE;
GLboolean __GLEW_ARB_texture_compression = GL_FALSE;
+GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE;
GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE;
GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;
+GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE;
GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;
GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;
GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;
GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;
GLboolean __GLEW_ARB_texture_float = GL_FALSE;
+GLboolean __GLEW_ARB_texture_gather = GL_FALSE;
GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;
+GLboolean __GLEW_ARB_texture_multisample = GL_FALSE;
GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;
+GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE;
GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;
GLboolean __GLEW_ARB_texture_rg = GL_FALSE;
+GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE;
+GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE;
+GLboolean __GLEW_ARB_timer_query = GL_FALSE;
+GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE;
+GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE;
GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;
+GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE;
+GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE;
GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE;
GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;
GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;
GLboolean __GLEW_ARB_vertex_program = GL_FALSE;
GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;
+GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE;
GLboolean __GLEW_ARB_window_pos = GL_FALSE;
GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;
GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;
@@ -1921,6 +2312,7 @@ GLboolean __GLEW_ATI_element_array = GL_FALSE;
GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;
GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;
GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;
+GLboolean __GLEW_ATI_meminfo = GL_FALSE;
GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;
GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;
GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;
@@ -1983,10 +2375,13 @@ GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;
GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;
GLboolean __GLEW_EXT_point_parameters = GL_FALSE;
GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;
+GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE;
GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;
GLboolean __GLEW_EXT_scene_marker = GL_FALSE;
GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
+GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE;
GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;
+GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE;
GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;
GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;
GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;
@@ -2016,11 +2411,13 @@ GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;
GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;
GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;
GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;
+GLboolean __GLEW_EXT_texture_snorm = GL_FALSE;
GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;
GLboolean __GLEW_EXT_timer_query = GL_FALSE;
GLboolean __GLEW_EXT_transform_feedback = GL_FALSE;
GLboolean __GLEW_EXT_vertex_array = GL_FALSE;
GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE;
+GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE;
GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;
GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;
GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;
@@ -2048,6 +2445,7 @@ GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;
GLboolean __GLEW_NV_blend_square = GL_FALSE;
GLboolean __GLEW_NV_conditional_render = GL_FALSE;
GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;
+GLboolean __GLEW_NV_copy_image = GL_FALSE;
GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;
GLboolean __GLEW_NV_depth_clamp = GL_FALSE;
GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;
@@ -2064,20 +2462,27 @@ GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;
GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;
GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;
GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;
+GLboolean __GLEW_NV_gpu_program5 = GL_FALSE;
+GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE;
+GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE;
GLboolean __GLEW_NV_half_float = GL_FALSE;
GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;
GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;
GLboolean __GLEW_NV_occlusion_query = GL_FALSE;
GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;
GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;
+GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE;
GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;
GLboolean __GLEW_NV_point_sprite = GL_FALSE;
GLboolean __GLEW_NV_present_video = GL_FALSE;
GLboolean __GLEW_NV_primitive_restart = GL_FALSE;
GLboolean __GLEW_NV_register_combiners = GL_FALSE;
GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;
+GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE;
+GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE;
GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;
GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;
+GLboolean __GLEW_NV_texture_barrier = GL_FALSE;
GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;
GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;
GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;
@@ -2086,8 +2491,11 @@ GLboolean __GLEW_NV_texture_shader = GL_FALSE;
GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;
GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;
GLboolean __GLEW_NV_transform_feedback = GL_FALSE;
+GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE;
GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;
GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;
+GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE;
+GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE;
GLboolean __GLEW_NV_vertex_program = GL_FALSE;
GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;
GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;
@@ -2463,8 +2871,6 @@ static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)
r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r;
r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r;
- r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;
- r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;
r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r;
r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r;
r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r;
@@ -2478,7 +2884,6 @@ static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)
r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r;
r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r;
r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r;
- r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;
r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r;
r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r;
r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r;
@@ -2525,6 +2930,58 @@ static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_VERSION_3_0 */
+#ifdef GL_VERSION_3_1
+
+static GLboolean _glewInit_GL_VERSION_3_1 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r;
+ r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r;
+ r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r;
+ r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_VERSION_3_1 */
+
+#ifdef GL_VERSION_3_2
+
+static GLboolean _glewInit_GL_VERSION_3_2 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r;
+ r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r;
+ r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_VERSION_3_2 */
+
+#ifdef GL_VERSION_3_3
+
+#endif /* GL_VERSION_3_3 */
+
+#ifdef GL_VERSION_4_0
+
+static GLboolean _glewInit_GL_VERSION_4_0 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r;
+ r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r;
+ r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r;
+ r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r;
+ r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_VERSION_4_0 */
+
#ifdef GL_3DFX_multisample
#endif /* GL_3DFX_multisample */
@@ -2546,6 +3003,79 @@ static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_3DFX_texture_compression_FXT1 */
+#ifdef GL_AMD_conservative_depth
+
+#endif /* GL_AMD_conservative_depth */
+
+#ifdef GL_AMD_draw_buffers_blend
+
+static GLboolean _glewInit_GL_AMD_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r;
+ r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r;
+ r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r;
+ r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_AMD_draw_buffers_blend */
+
+#ifdef GL_AMD_performance_monitor
+
+static GLboolean _glewInit_GL_AMD_performance_monitor (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r;
+ r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r;
+ r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r;
+ r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r;
+ r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r;
+ r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r;
+ r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r;
+ r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r;
+ r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r;
+ r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r;
+ r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_AMD_performance_monitor */
+
+#ifdef GL_AMD_seamless_cubemap_per_texture
+
+#endif /* GL_AMD_seamless_cubemap_per_texture */
+
+#ifdef GL_AMD_shader_stencil_export
+
+#endif /* GL_AMD_shader_stencil_export */
+
+#ifdef GL_AMD_texture_texture4
+
+#endif /* GL_AMD_texture_texture4 */
+
+#ifdef GL_AMD_vertex_shader_tessellator
+
+static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r;
+ r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_AMD_vertex_shader_tessellator */
+
+#ifdef GL_APPLE_aux_depth_stencil
+
+#endif /* GL_APPLE_aux_depth_stencil */
+
#ifdef GL_APPLE_client_storage
#endif /* GL_APPLE_client_storage */
@@ -2605,10 +3135,33 @@ static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INI
#endif /* GL_APPLE_flush_buffer_range */
+#ifdef GL_APPLE_object_purgeable
+
+static GLboolean _glewInit_GL_APPLE_object_purgeable (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r;
+ r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r;
+ r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_APPLE_object_purgeable */
+
#ifdef GL_APPLE_pixel_buffer
#endif /* GL_APPLE_pixel_buffer */
+#ifdef GL_APPLE_rgb_422
+
+#endif /* GL_APPLE_rgb_422 */
+
+#ifdef GL_APPLE_row_bytes
+
+#endif /* GL_APPLE_row_bytes */
+
#ifdef GL_APPLE_specular_vector
#endif /* GL_APPLE_specular_vector */
@@ -2662,10 +3215,43 @@ static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INI
#endif /* GL_APPLE_vertex_array_range */
+#ifdef GL_APPLE_vertex_program_evaluators
+
+static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r;
+ r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r;
+ r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r;
+ r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r;
+ r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r;
+ r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r;
+ r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_APPLE_vertex_program_evaluators */
+
#ifdef GL_APPLE_ycbcr_422
#endif /* GL_APPLE_ycbcr_422 */
+#ifdef GL_ARB_blend_func_extended
+
+static GLboolean _glewInit_GL_ARB_blend_func_extended (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r;
+ r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_blend_func_extended */
+
#ifdef GL_ARB_color_buffer_float
static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -2679,10 +3265,31 @@ static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_color_buffer_float */
+#ifdef GL_ARB_compatibility
+
+#endif /* GL_ARB_compatibility */
+
+#ifdef GL_ARB_copy_buffer
+
+static GLboolean _glewInit_GL_ARB_copy_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_copy_buffer */
+
#ifdef GL_ARB_depth_buffer_float
#endif /* GL_ARB_depth_buffer_float */
+#ifdef GL_ARB_depth_clamp
+
+#endif /* GL_ARB_depth_clamp */
+
#ifdef GL_ARB_depth_texture
#endif /* GL_ARB_depth_texture */
@@ -2700,6 +3307,52 @@ static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_draw_buffers */
+#ifdef GL_ARB_draw_buffers_blend
+
+static GLboolean _glewInit_GL_ARB_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r;
+ r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r;
+ r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r;
+ r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_draw_buffers_blend */
+
+#ifdef GL_ARB_draw_elements_base_vertex
+
+static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r;
+ r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r;
+ r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r;
+ r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_draw_elements_base_vertex */
+
+#ifdef GL_ARB_draw_indirect
+
+static GLboolean _glewInit_GL_ARB_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r;
+ r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_draw_indirect */
+
#ifdef GL_ARB_draw_instanced
static GLboolean _glewInit_GL_ARB_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -2714,6 +3367,14 @@ static GLboolean _glewInit_GL_ARB_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_draw_instanced */
+#ifdef GL_ARB_explicit_attrib_location
+
+#endif /* GL_ARB_explicit_attrib_location */
+
+#ifdef GL_ARB_fragment_coord_conventions
+
+#endif /* GL_ARB_fragment_coord_conventions */
+
#ifdef GL_ARB_fragment_program
#endif /* GL_ARB_fragment_program */
@@ -2739,10 +3400,10 @@ static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r;
r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r;
r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r;
- r = ((glFramebufferTexturLayer = (PFNGLFRAMEBUFFERTEXTURLAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexturLayer")) == NULL) || r;
r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r;
r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r;
r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r;
+ r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r;
r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r;
r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r;
r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r;
@@ -2778,6 +3439,14 @@ static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_geometry_shader4 */
+#ifdef GL_ARB_gpu_shader5
+
+#endif /* GL_ARB_gpu_shader5 */
+
+#ifdef GL_ARB_gpu_shader_fp64
+
+#endif /* GL_ARB_gpu_shader_fp64 */
+
#ifdef GL_ARB_half_float_pixel
#endif /* GL_ARB_half_float_pixel */
@@ -2954,6 +3623,10 @@ static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_occlusion_query */
+#ifdef GL_ARB_occlusion_query2
+
+#endif /* GL_ARB_occlusion_query2 */
+
#ifdef GL_ARB_pixel_buffer_object
#endif /* GL_ARB_pixel_buffer_object */
@@ -2976,6 +3649,66 @@ static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_point_sprite */
+#ifdef GL_ARB_provoking_vertex
+
+static GLboolean _glewInit_GL_ARB_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_provoking_vertex */
+
+#ifdef GL_ARB_sample_shading
+
+static GLboolean _glewInit_GL_ARB_sample_shading (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_sample_shading */
+
+#ifdef GL_ARB_sampler_objects
+
+static GLboolean _glewInit_GL_ARB_sampler_objects (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r;
+ r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r;
+ r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r;
+ r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r;
+ r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r;
+ r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r;
+ r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r;
+ r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r;
+ r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r;
+ r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r;
+ r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r;
+ r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r;
+ r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r;
+ r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_sampler_objects */
+
+#ifdef GL_ARB_seamless_cube_map
+
+#endif /* GL_ARB_seamless_cube_map */
+
+#ifdef GL_ARB_shader_bit_encoding
+
+#endif /* GL_ARB_shader_bit_encoding */
+
#ifdef GL_ARB_shader_objects
static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -3027,10 +3760,52 @@ static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_shader_objects */
+#ifdef GL_ARB_shader_subroutine
+
+static GLboolean _glewInit_GL_ARB_shader_subroutine (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r;
+ r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r;
+ r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r;
+ r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r;
+ r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r;
+ r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r;
+ r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r;
+ r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_shader_subroutine */
+
+#ifdef GL_ARB_shader_texture_lod
+
+#endif /* GL_ARB_shader_texture_lod */
+
#ifdef GL_ARB_shading_language_100
#endif /* GL_ARB_shading_language_100 */
+#ifdef GL_ARB_shading_language_include
+
+static GLboolean _glewInit_GL_ARB_shading_language_include (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r;
+ r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r;
+ r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r;
+ r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r;
+ r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r;
+ r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_shading_language_include */
+
#ifdef GL_ARB_shadow
#endif /* GL_ARB_shadow */
@@ -3039,22 +3814,59 @@ static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_shadow_ambient */
-#ifdef GL_ARB_texture_border_clamp
-
-#endif /* GL_ARB_texture_border_clamp */
-
-#ifdef GL_ARB_texture_buffer_object
+#ifdef GL_ARB_sync
-static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
+static GLboolean _glewInit_GL_ARB_sync (GLEW_CONTEXT_ARG_DEF_INIT)
{
GLboolean r = GL_FALSE;
- r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;
+ r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r;
+ r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r;
+ r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r;
+ r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r;
+ r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r;
+ r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r;
+ r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r;
return r;
}
-#endif /* GL_ARB_texture_buffer_object */
+#endif /* GL_ARB_sync */
+
+#ifdef GL_ARB_tessellation_shader
+
+static GLboolean _glewInit_GL_ARB_tessellation_shader (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r;
+ r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_tessellation_shader */
+
+#ifdef GL_ARB_texture_border_clamp
+
+#endif /* GL_ARB_texture_border_clamp */
+
+#ifdef GL_ARB_texture_buffer_object
+
+static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_texture_buffer_object */
+
+#ifdef GL_ARB_texture_buffer_object_rgb32
+
+#endif /* GL_ARB_texture_buffer_object_rgb32 */
#ifdef GL_ARB_texture_compression
@@ -3075,6 +3887,10 @@ static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT
#endif /* GL_ARB_texture_compression */
+#ifdef GL_ARB_texture_compression_bptc
+
+#endif /* GL_ARB_texture_compression_bptc */
+
#ifdef GL_ARB_texture_compression_rgtc
#endif /* GL_ARB_texture_compression_rgtc */
@@ -3083,6 +3899,10 @@ static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT
#endif /* GL_ARB_texture_cube_map */
+#ifdef GL_ARB_texture_cube_map_array
+
+#endif /* GL_ARB_texture_cube_map_array */
+
#ifdef GL_ARB_texture_env_add
#endif /* GL_ARB_texture_env_add */
@@ -3103,14 +3923,38 @@ static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT
#endif /* GL_ARB_texture_float */
+#ifdef GL_ARB_texture_gather
+
+#endif /* GL_ARB_texture_gather */
+
#ifdef GL_ARB_texture_mirrored_repeat
#endif /* GL_ARB_texture_mirrored_repeat */
+#ifdef GL_ARB_texture_multisample
+
+static GLboolean _glewInit_GL_ARB_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r;
+ r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r;
+ r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r;
+ r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_texture_multisample */
+
#ifdef GL_ARB_texture_non_power_of_two
#endif /* GL_ARB_texture_non_power_of_two */
+#ifdef GL_ARB_texture_query_lod
+
+#endif /* GL_ARB_texture_query_lod */
+
#ifdef GL_ARB_texture_rectangle
#endif /* GL_ARB_texture_rectangle */
@@ -3119,6 +3963,64 @@ static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT
#endif /* GL_ARB_texture_rg */
+#ifdef GL_ARB_texture_rgb10_a2ui
+
+#endif /* GL_ARB_texture_rgb10_a2ui */
+
+#ifdef GL_ARB_texture_swizzle
+
+#endif /* GL_ARB_texture_swizzle */
+
+#ifdef GL_ARB_timer_query
+
+static GLboolean _glewInit_GL_ARB_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r;
+ r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r;
+ r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_timer_query */
+
+#ifdef GL_ARB_transform_feedback2
+
+static GLboolean _glewInit_GL_ARB_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r;
+ r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r;
+ r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r;
+ r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r;
+ r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r;
+ r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r;
+ r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_transform_feedback2 */
+
+#ifdef GL_ARB_transform_feedback3
+
+static GLboolean _glewInit_GL_ARB_transform_feedback3 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r;
+ r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r;
+ r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r;
+ r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_transform_feedback3 */
+
#ifdef GL_ARB_transpose_matrix
static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -3135,6 +4037,32 @@ static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_transpose_matrix */
+#ifdef GL_ARB_uniform_buffer_object
+
+static GLboolean _glewInit_GL_ARB_uniform_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;
+ r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;
+ r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r;
+ r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r;
+ r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r;
+ r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r;
+ r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;
+ r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r;
+ r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r;
+ r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_uniform_buffer_object */
+
+#ifdef GL_ARB_vertex_array_bgra
+
+#endif /* GL_ARB_vertex_array_bgra */
+
#ifdef GL_ARB_vertex_array_object
static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -3285,6 +4213,56 @@ static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ARB_vertex_shader */
+#ifdef GL_ARB_vertex_type_2_10_10_10_rev
+
+static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r;
+ r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r;
+ r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r;
+ r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r;
+ r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r;
+ r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r;
+ r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r;
+ r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r;
+ r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r;
+ r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r;
+ r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r;
+ r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r;
+ r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r;
+ r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r;
+ r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r;
+ r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r;
+ r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r;
+ r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r;
+ r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r;
+ r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r;
+ r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r;
+ r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r;
+ r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r;
+ r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r;
+ r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r;
+ r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r;
+ r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r;
+ r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r;
+ r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r;
+ r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r;
+ r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r;
+ r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r;
+ r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r;
+ r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r;
+ r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r;
+ r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r;
+ r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r;
+ r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
+
#ifdef GL_ARB_window_pos
static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -3413,6 +4391,10 @@ static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_ATI_map_object_buffer */
+#ifdef GL_ATI_meminfo
+
+#endif /* GL_ATI_meminfo */
+
#ifdef GL_ATI_pn_triangles
static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -3795,7 +4777,14 @@ static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT
r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r;
r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r;
r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r;
+ r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r;
+ r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r;
+ r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r;
r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r;
+ r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r;
+ r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r;
+ r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r;
+ r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r;
r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r;
r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r;
r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r;
@@ -3804,7 +4793,9 @@ static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT
r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r;
r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r;
r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r;
+ r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r;
r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r;
+ r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r;
r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r;
r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r;
r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r;
@@ -3830,6 +4821,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT
r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r;
r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r;
r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r;
+ r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r;
r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r;
r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r;
r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r;
@@ -3837,7 +4829,12 @@ static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT
r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r;
r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r;
r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r;
+ r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r;
+ r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r;
+ r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r;
+ r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r;
r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r;
+ r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r;
r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r;
r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r;
r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r;
@@ -3884,6 +4881,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT
r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;
r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;
r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;
+ r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r;
r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;
r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r;
r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r;
@@ -3955,6 +4953,17 @@ static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT
r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r;
r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r;
r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r;
+ r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r;
+ r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r;
+ r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r;
return r;
}
@@ -4372,6 +5381,19 @@ static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_EXT_polygon_offset */
+#ifdef GL_EXT_provoking_vertex
+
+static GLboolean _glewInit_GL_EXT_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_EXT_provoking_vertex */
+
#ifdef GL_EXT_rescale_normal
#endif /* GL_EXT_rescale_normal */
@@ -4419,10 +5441,39 @@ static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_EXT_secondary_color */
+#ifdef GL_EXT_separate_shader_objects
+
+static GLboolean _glewInit_GL_EXT_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r;
+ r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r;
+ r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_EXT_separate_shader_objects */
+
#ifdef GL_EXT_separate_specular_color
#endif /* GL_EXT_separate_specular_color */
+#ifdef GL_EXT_shader_image_load_store
+
+static GLboolean _glewInit_GL_EXT_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r;
+ r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_EXT_shader_image_load_store */
+
#ifdef GL_EXT_shadow_funcs
#endif /* GL_EXT_shadow_funcs */
@@ -4614,6 +5665,10 @@ static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_I
#endif /* GL_EXT_texture_shared_exponent */
+#ifdef GL_EXT_texture_snorm
+
+#endif /* GL_EXT_texture_snorm */
+
#ifdef GL_EXT_texture_swizzle
#endif /* GL_EXT_texture_swizzle */
@@ -4676,6 +5731,29 @@ static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_EXT_vertex_array_bgra */
+#ifdef GL_EXT_vertex_attrib_64bit
+
+static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r;
+ r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r;
+ r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r;
+ r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r;
+ r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r;
+ r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r;
+ r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r;
+ r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r;
+ r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r;
+ r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r;
+ r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_EXT_vertex_attrib_64bit */
+
#ifdef GL_EXT_vertex_shader
static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -4989,6 +6067,19 @@ static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_NV_copy_depth_to_color */
+#ifdef GL_NV_copy_image
+
+static GLboolean _glewInit_GL_NV_copy_image (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_copy_image */
+
#ifdef GL_NV_depth_buffer_float
static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -5159,6 +6250,60 @@ static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_NV_gpu_program4 */
+#ifdef GL_NV_gpu_program5
+
+#endif /* GL_NV_gpu_program5 */
+
+#ifdef GL_NV_gpu_program_fp64
+
+#endif /* GL_NV_gpu_program_fp64 */
+
+#ifdef GL_NV_gpu_shader5
+
+static GLboolean _glewInit_GL_NV_gpu_shader5 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r;
+ r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r;
+ r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r;
+ r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r;
+ r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r;
+ r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r;
+ r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r;
+ r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r;
+ r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r;
+ r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r;
+ r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r;
+ r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r;
+ r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r;
+ r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r;
+ r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r;
+ r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r;
+ r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r;
+ r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r;
+ r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r;
+ r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r;
+ r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r;
+ r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r;
+ r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r;
+ r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r;
+ r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r;
+ r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r;
+ r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r;
+ r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r;
+ r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r;
+ r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r;
+ r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r;
+ r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r;
+ r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r;
+ r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_gpu_shader5 */
+
#ifdef GL_NV_half_float
static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -5263,6 +6408,10 @@ static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_I
#endif /* GL_NV_parameter_buffer_object */
+#ifdef GL_NV_parameter_buffer_object2
+
+#endif /* GL_NV_parameter_buffer_object2 */
+
#ifdef GL_NV_pixel_data_range
static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -5303,7 +6452,6 @@ static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT)
r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r;
r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r;
r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r;
- r = ((glVideoParameterivNV = (PFNGLVIDEOPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoParameterivNV")) == NULL) || r;
return r;
}
@@ -5363,6 +6511,35 @@ static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_NV_register_combiners2 */
+#ifdef GL_NV_shader_buffer_load
+
+static GLboolean _glewInit_GL_NV_shader_buffer_load (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r;
+ r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r;
+ r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r;
+ r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r;
+ r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r;
+ r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r;
+ r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r;
+ r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r;
+ r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r;
+ r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r;
+ r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r;
+ r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r;
+ r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_shader_buffer_load */
+
+#ifdef GL_NV_tessellation_program5
+
+#endif /* GL_NV_tessellation_program5 */
+
#ifdef GL_NV_texgen_emboss
#endif /* GL_NV_texgen_emboss */
@@ -5371,6 +6548,19 @@ static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_NV_texgen_reflection */
+#ifdef GL_NV_texture_barrier
+
+static GLboolean _glewInit_GL_NV_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_texture_barrier */
+
#ifdef GL_NV_texture_compression_vtc
#endif /* GL_NV_texture_compression_vtc */
@@ -5422,6 +6612,25 @@ static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_NV_transform_feedback */
+#ifdef GL_NV_transform_feedback2
+
+static GLboolean _glewInit_GL_NV_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r;
+ r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r;
+ r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r;
+ r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r;
+ r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r;
+ r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r;
+ r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_transform_feedback2 */
+
#ifdef GL_NV_vertex_array_range
static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -5440,6 +6649,61 @@ static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
#endif /* GL_NV_vertex_array_range2 */
+#ifdef GL_NV_vertex_attrib_integer_64bit
+
+static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r;
+ r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r;
+ r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r;
+ r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r;
+ r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r;
+ r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r;
+ r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r;
+ r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r;
+ r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r;
+ r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r;
+ r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r;
+ r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r;
+ r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r;
+ r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r;
+ r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r;
+ r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r;
+ r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r;
+ r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r;
+ r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_vertex_attrib_integer_64bit */
+
+#ifdef GL_NV_vertex_buffer_unified_memory
+
+static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (GLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r;
+ r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r;
+ r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r;
+ r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r;
+ r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r;
+ r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r;
+ r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r;
+ r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r;
+ r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r;
+ r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r;
+ r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r;
+ r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GL_NV_vertex_buffer_unified_memory */
+
#ifdef GL_NV_vertex_program
static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
@@ -6153,81 +7417,41 @@ static
GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
{
const GLubyte* s;
- GLuint dot, major, minor;
+ GLuint dot;
+ GLint major, minor;
/* query opengl version */
s = glGetString(GL_VERSION);
dot = _glewStrCLen(s, '.');
- major = dot-1;
- minor = dot+1;
- if (dot == 0 || s[minor] == '\0')
+ if (dot == 0)
+ return GLEW_ERROR_NO_GL_VERSION;
+
+ major = s[dot-1]-'0';
+ minor = s[dot+1]-'0';
+
+ if (minor < 0 || minor > 9)
+ minor = 0;
+ if (major<0 || major>9)
return GLEW_ERROR_NO_GL_VERSION;
- if (s[major] == '1' && s[minor] == '0')
+
+
+ if (major == 1 && minor == 0)
{
- return GLEW_ERROR_GL_VERSION_10_ONLY;
+ return GLEW_ERROR_GL_VERSION_10_ONLY;
}
else
{
- CONST_CAST(GLEW_VERSION_1_1) = GL_TRUE;
- if (s[major] >= '2')
- {
- CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_2_0) = GL_TRUE;
- if (s[minor] >= '1')
- {
- CONST_CAST(GLEW_VERSION_2_1) = GL_TRUE;
- }
- }
- else
- {
- if (s[minor] >= '5')
- {
- CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;
- }
- if (s[minor] == '4')
- {
- CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;
- }
- if (s[minor] == '3')
- {
- CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;
- }
- if (s[minor] == '2')
- {
- CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;
- CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;
- }
- if (s[minor] < '2')
- {
- CONST_CAST(GLEW_VERSION_1_2) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;
- CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;
- }
- }
+ CONST_CAST(GLEW_VERSION_4_0) = ( major > 4 ) || ( major == 4 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_3_3) = GLEW_VERSION_4_0 == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_3_2) = GLEW_VERSION_3_3 == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_3_1) = GLEW_VERSION_3_2 == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_3_0) = GLEW_VERSION_3_1 == GL_TRUE || ( major == 3 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_2_1) = GLEW_VERSION_3_0 == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_2_0) = GLEW_VERSION_2_1 == GL_TRUE || ( major == 2 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_1_5) = GLEW_VERSION_2_0 == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_1_4) = GLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_1_3) = GLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_1_2) = GLEW_VERSION_1_3 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
+ CONST_CAST(GLEW_VERSION_1_1) = GLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
}
/* initialize extensions */
#ifdef GL_VERSION_1_2
@@ -6251,6 +7475,17 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_VERSION_3_0
if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_VERSION_3_0 */
+#ifdef GL_VERSION_3_1
+ if (glewExperimental || GLEW_VERSION_3_1) CONST_CAST(GLEW_VERSION_3_1) = !_glewInit_GL_VERSION_3_1(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_VERSION_3_1 */
+#ifdef GL_VERSION_3_2
+ if (glewExperimental || GLEW_VERSION_3_2) CONST_CAST(GLEW_VERSION_3_2) = !_glewInit_GL_VERSION_3_2(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_VERSION_3_2 */
+#ifdef GL_VERSION_3_3
+#endif /* GL_VERSION_3_3 */
+#ifdef GL_VERSION_4_0
+ if (glewExperimental || GLEW_VERSION_4_0) CONST_CAST(GLEW_VERSION_4_0) = !_glewInit_GL_VERSION_4_0(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_VERSION_4_0 */
#ifdef GL_3DFX_multisample
CONST_CAST(GLEW_3DFX_multisample) = glewGetExtension("GL_3DFX_multisample");
#endif /* GL_3DFX_multisample */
@@ -6261,6 +7496,33 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_3DFX_texture_compression_FXT1
CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = glewGetExtension("GL_3DFX_texture_compression_FXT1");
#endif /* GL_3DFX_texture_compression_FXT1 */
+#ifdef GL_AMD_conservative_depth
+ CONST_CAST(GLEW_AMD_conservative_depth) = glewGetExtension("GL_AMD_conservative_depth");
+#endif /* GL_AMD_conservative_depth */
+#ifdef GL_AMD_draw_buffers_blend
+ CONST_CAST(GLEW_AMD_draw_buffers_blend) = glewGetExtension("GL_AMD_draw_buffers_blend");
+ if (glewExperimental || GLEW_AMD_draw_buffers_blend) CONST_CAST(GLEW_AMD_draw_buffers_blend) = !_glewInit_GL_AMD_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_AMD_draw_buffers_blend */
+#ifdef GL_AMD_performance_monitor
+ CONST_CAST(GLEW_AMD_performance_monitor) = glewGetExtension("GL_AMD_performance_monitor");
+ if (glewExperimental || GLEW_AMD_performance_monitor) CONST_CAST(GLEW_AMD_performance_monitor) = !_glewInit_GL_AMD_performance_monitor(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_AMD_performance_monitor */
+#ifdef GL_AMD_seamless_cubemap_per_texture
+ CONST_CAST(GLEW_AMD_seamless_cubemap_per_texture) = glewGetExtension("GL_AMD_seamless_cubemap_per_texture");
+#endif /* GL_AMD_seamless_cubemap_per_texture */
+#ifdef GL_AMD_shader_stencil_export
+ CONST_CAST(GLEW_AMD_shader_stencil_export) = glewGetExtension("GL_AMD_shader_stencil_export");
+#endif /* GL_AMD_shader_stencil_export */
+#ifdef GL_AMD_texture_texture4
+ CONST_CAST(GLEW_AMD_texture_texture4) = glewGetExtension("GL_AMD_texture_texture4");
+#endif /* GL_AMD_texture_texture4 */
+#ifdef GL_AMD_vertex_shader_tessellator
+ CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = glewGetExtension("GL_AMD_vertex_shader_tessellator");
+ if (glewExperimental || GLEW_AMD_vertex_shader_tessellator) CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = !_glewInit_GL_AMD_vertex_shader_tessellator(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_AMD_vertex_shader_tessellator */
+#ifdef GL_APPLE_aux_depth_stencil
+ CONST_CAST(GLEW_APPLE_aux_depth_stencil) = glewGetExtension("GL_APPLE_aux_depth_stencil");
+#endif /* GL_APPLE_aux_depth_stencil */
#ifdef GL_APPLE_client_storage
CONST_CAST(GLEW_APPLE_client_storage) = glewGetExtension("GL_APPLE_client_storage");
#endif /* GL_APPLE_client_storage */
@@ -6279,9 +7541,19 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_APPLE_flush_buffer_range) = glewGetExtension("GL_APPLE_flush_buffer_range");
if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_APPLE_flush_buffer_range */
+#ifdef GL_APPLE_object_purgeable
+ CONST_CAST(GLEW_APPLE_object_purgeable) = glewGetExtension("GL_APPLE_object_purgeable");
+ if (glewExperimental || GLEW_APPLE_object_purgeable) CONST_CAST(GLEW_APPLE_object_purgeable) = !_glewInit_GL_APPLE_object_purgeable(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_APPLE_object_purgeable */
#ifdef GL_APPLE_pixel_buffer
CONST_CAST(GLEW_APPLE_pixel_buffer) = glewGetExtension("GL_APPLE_pixel_buffer");
#endif /* GL_APPLE_pixel_buffer */
+#ifdef GL_APPLE_rgb_422
+ CONST_CAST(GLEW_APPLE_rgb_422) = glewGetExtension("GL_APPLE_rgb_422");
+#endif /* GL_APPLE_rgb_422 */
+#ifdef GL_APPLE_row_bytes
+ CONST_CAST(GLEW_APPLE_row_bytes) = glewGetExtension("GL_APPLE_row_bytes");
+#endif /* GL_APPLE_row_bytes */
#ifdef GL_APPLE_specular_vector
CONST_CAST(GLEW_APPLE_specular_vector) = glewGetExtension("GL_APPLE_specular_vector");
#endif /* GL_APPLE_specular_vector */
@@ -6300,16 +7572,34 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_APPLE_vertex_array_range) = glewGetExtension("GL_APPLE_vertex_array_range");
if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_APPLE_vertex_array_range */
+#ifdef GL_APPLE_vertex_program_evaluators
+ CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = glewGetExtension("GL_APPLE_vertex_program_evaluators");
+ if (glewExperimental || GLEW_APPLE_vertex_program_evaluators) CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = !_glewInit_GL_APPLE_vertex_program_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_APPLE_vertex_program_evaluators */
#ifdef GL_APPLE_ycbcr_422
CONST_CAST(GLEW_APPLE_ycbcr_422) = glewGetExtension("GL_APPLE_ycbcr_422");
#endif /* GL_APPLE_ycbcr_422 */
+#ifdef GL_ARB_blend_func_extended
+ CONST_CAST(GLEW_ARB_blend_func_extended) = glewGetExtension("GL_ARB_blend_func_extended");
+ if (glewExperimental || GLEW_ARB_blend_func_extended) CONST_CAST(GLEW_ARB_blend_func_extended) = !_glewInit_GL_ARB_blend_func_extended(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_blend_func_extended */
#ifdef GL_ARB_color_buffer_float
CONST_CAST(GLEW_ARB_color_buffer_float) = glewGetExtension("GL_ARB_color_buffer_float");
if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_color_buffer_float */
+#ifdef GL_ARB_compatibility
+ CONST_CAST(GLEW_ARB_compatibility) = glewGetExtension("GL_ARB_compatibility");
+#endif /* GL_ARB_compatibility */
+#ifdef GL_ARB_copy_buffer
+ CONST_CAST(GLEW_ARB_copy_buffer) = glewGetExtension("GL_ARB_copy_buffer");
+ if (glewExperimental || GLEW_ARB_copy_buffer) CONST_CAST(GLEW_ARB_copy_buffer) = !_glewInit_GL_ARB_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_copy_buffer */
#ifdef GL_ARB_depth_buffer_float
CONST_CAST(GLEW_ARB_depth_buffer_float) = glewGetExtension("GL_ARB_depth_buffer_float");
#endif /* GL_ARB_depth_buffer_float */
+#ifdef GL_ARB_depth_clamp
+ CONST_CAST(GLEW_ARB_depth_clamp) = glewGetExtension("GL_ARB_depth_clamp");
+#endif /* GL_ARB_depth_clamp */
#ifdef GL_ARB_depth_texture
CONST_CAST(GLEW_ARB_depth_texture) = glewGetExtension("GL_ARB_depth_texture");
#endif /* GL_ARB_depth_texture */
@@ -6317,10 +7607,28 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_ARB_draw_buffers) = glewGetExtension("GL_ARB_draw_buffers");
if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_draw_buffers */
+#ifdef GL_ARB_draw_buffers_blend
+ CONST_CAST(GLEW_ARB_draw_buffers_blend) = glewGetExtension("GL_ARB_draw_buffers_blend");
+ if (glewExperimental || GLEW_ARB_draw_buffers_blend) CONST_CAST(GLEW_ARB_draw_buffers_blend) = !_glewInit_GL_ARB_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_draw_buffers_blend */
+#ifdef GL_ARB_draw_elements_base_vertex
+ CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = glewGetExtension("GL_ARB_draw_elements_base_vertex");
+ if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = !_glewInit_GL_ARB_draw_elements_base_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_draw_elements_base_vertex */
+#ifdef GL_ARB_draw_indirect
+ CONST_CAST(GLEW_ARB_draw_indirect) = glewGetExtension("GL_ARB_draw_indirect");
+ if (glewExperimental || GLEW_ARB_draw_indirect) CONST_CAST(GLEW_ARB_draw_indirect) = !_glewInit_GL_ARB_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_draw_indirect */
#ifdef GL_ARB_draw_instanced
CONST_CAST(GLEW_ARB_draw_instanced) = glewGetExtension("GL_ARB_draw_instanced");
if (glewExperimental || GLEW_ARB_draw_instanced) CONST_CAST(GLEW_ARB_draw_instanced) = !_glewInit_GL_ARB_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_draw_instanced */
+#ifdef GL_ARB_explicit_attrib_location
+ CONST_CAST(GLEW_ARB_explicit_attrib_location) = glewGetExtension("GL_ARB_explicit_attrib_location");
+#endif /* GL_ARB_explicit_attrib_location */
+#ifdef GL_ARB_fragment_coord_conventions
+ CONST_CAST(GLEW_ARB_fragment_coord_conventions) = glewGetExtension("GL_ARB_fragment_coord_conventions");
+#endif /* GL_ARB_fragment_coord_conventions */
#ifdef GL_ARB_fragment_program
CONST_CAST(GLEW_ARB_fragment_program) = glewGetExtension("GL_ARB_fragment_program");
#endif /* GL_ARB_fragment_program */
@@ -6341,6 +7649,12 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_ARB_geometry_shader4) = glewGetExtension("GL_ARB_geometry_shader4");
if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_geometry_shader4 */
+#ifdef GL_ARB_gpu_shader5
+ CONST_CAST(GLEW_ARB_gpu_shader5) = glewGetExtension("GL_ARB_gpu_shader5");
+#endif /* GL_ARB_gpu_shader5 */
+#ifdef GL_ARB_gpu_shader_fp64
+ CONST_CAST(GLEW_ARB_gpu_shader_fp64) = glewGetExtension("GL_ARB_gpu_shader_fp64");
+#endif /* GL_ARB_gpu_shader_fp64 */
#ifdef GL_ARB_half_float_pixel
CONST_CAST(GLEW_ARB_half_float_pixel) = glewGetExtension("GL_ARB_half_float_pixel");
#endif /* GL_ARB_half_float_pixel */
@@ -6375,6 +7689,9 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_ARB_occlusion_query) = glewGetExtension("GL_ARB_occlusion_query");
if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_occlusion_query */
+#ifdef GL_ARB_occlusion_query2
+ CONST_CAST(GLEW_ARB_occlusion_query2) = glewGetExtension("GL_ARB_occlusion_query2");
+#endif /* GL_ARB_occlusion_query2 */
#ifdef GL_ARB_pixel_buffer_object
CONST_CAST(GLEW_ARB_pixel_buffer_object) = glewGetExtension("GL_ARB_pixel_buffer_object");
#endif /* GL_ARB_pixel_buffer_object */
@@ -6385,19 +7702,56 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_ARB_point_sprite
CONST_CAST(GLEW_ARB_point_sprite) = glewGetExtension("GL_ARB_point_sprite");
#endif /* GL_ARB_point_sprite */
+#ifdef GL_ARB_provoking_vertex
+ CONST_CAST(GLEW_ARB_provoking_vertex) = glewGetExtension("GL_ARB_provoking_vertex");
+ if (glewExperimental || GLEW_ARB_provoking_vertex) CONST_CAST(GLEW_ARB_provoking_vertex) = !_glewInit_GL_ARB_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_provoking_vertex */
+#ifdef GL_ARB_sample_shading
+ CONST_CAST(GLEW_ARB_sample_shading) = glewGetExtension("GL_ARB_sample_shading");
+ if (glewExperimental || GLEW_ARB_sample_shading) CONST_CAST(GLEW_ARB_sample_shading) = !_glewInit_GL_ARB_sample_shading(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_sample_shading */
+#ifdef GL_ARB_sampler_objects
+ CONST_CAST(GLEW_ARB_sampler_objects) = glewGetExtension("GL_ARB_sampler_objects");
+ if (glewExperimental || GLEW_ARB_sampler_objects) CONST_CAST(GLEW_ARB_sampler_objects) = !_glewInit_GL_ARB_sampler_objects(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_sampler_objects */
+#ifdef GL_ARB_seamless_cube_map
+ CONST_CAST(GLEW_ARB_seamless_cube_map) = glewGetExtension("GL_ARB_seamless_cube_map");
+#endif /* GL_ARB_seamless_cube_map */
+#ifdef GL_ARB_shader_bit_encoding
+ CONST_CAST(GLEW_ARB_shader_bit_encoding) = glewGetExtension("GL_ARB_shader_bit_encoding");
+#endif /* GL_ARB_shader_bit_encoding */
#ifdef GL_ARB_shader_objects
CONST_CAST(GLEW_ARB_shader_objects) = glewGetExtension("GL_ARB_shader_objects");
if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_shader_objects */
+#ifdef GL_ARB_shader_subroutine
+ CONST_CAST(GLEW_ARB_shader_subroutine) = glewGetExtension("GL_ARB_shader_subroutine");
+ if (glewExperimental || GLEW_ARB_shader_subroutine) CONST_CAST(GLEW_ARB_shader_subroutine) = !_glewInit_GL_ARB_shader_subroutine(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_shader_subroutine */
+#ifdef GL_ARB_shader_texture_lod
+ CONST_CAST(GLEW_ARB_shader_texture_lod) = glewGetExtension("GL_ARB_shader_texture_lod");
+#endif /* GL_ARB_shader_texture_lod */
#ifdef GL_ARB_shading_language_100
CONST_CAST(GLEW_ARB_shading_language_100) = glewGetExtension("GL_ARB_shading_language_100");
#endif /* GL_ARB_shading_language_100 */
+#ifdef GL_ARB_shading_language_include
+ CONST_CAST(GLEW_ARB_shading_language_include) = glewGetExtension("GL_ARB_shading_language_include");
+ if (glewExperimental || GLEW_ARB_shading_language_include) CONST_CAST(GLEW_ARB_shading_language_include) = !_glewInit_GL_ARB_shading_language_include(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_shading_language_include */
#ifdef GL_ARB_shadow
CONST_CAST(GLEW_ARB_shadow) = glewGetExtension("GL_ARB_shadow");
#endif /* GL_ARB_shadow */
#ifdef GL_ARB_shadow_ambient
CONST_CAST(GLEW_ARB_shadow_ambient) = glewGetExtension("GL_ARB_shadow_ambient");
#endif /* GL_ARB_shadow_ambient */
+#ifdef GL_ARB_sync
+ CONST_CAST(GLEW_ARB_sync) = glewGetExtension("GL_ARB_sync");
+ if (glewExperimental || GLEW_ARB_sync) CONST_CAST(GLEW_ARB_sync) = !_glewInit_GL_ARB_sync(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_sync */
+#ifdef GL_ARB_tessellation_shader
+ CONST_CAST(GLEW_ARB_tessellation_shader) = glewGetExtension("GL_ARB_tessellation_shader");
+ if (glewExperimental || GLEW_ARB_tessellation_shader) CONST_CAST(GLEW_ARB_tessellation_shader) = !_glewInit_GL_ARB_tessellation_shader(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_tessellation_shader */
#ifdef GL_ARB_texture_border_clamp
CONST_CAST(GLEW_ARB_texture_border_clamp) = glewGetExtension("GL_ARB_texture_border_clamp");
#endif /* GL_ARB_texture_border_clamp */
@@ -6405,16 +7759,25 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_ARB_texture_buffer_object) = glewGetExtension("GL_ARB_texture_buffer_object");
if (glewExperimental || GLEW_ARB_texture_buffer_object) CONST_CAST(GLEW_ARB_texture_buffer_object) = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_texture_buffer_object */
+#ifdef GL_ARB_texture_buffer_object_rgb32
+ CONST_CAST(GLEW_ARB_texture_buffer_object_rgb32) = glewGetExtension("GL_ARB_texture_buffer_object_rgb32");
+#endif /* GL_ARB_texture_buffer_object_rgb32 */
#ifdef GL_ARB_texture_compression
CONST_CAST(GLEW_ARB_texture_compression) = glewGetExtension("GL_ARB_texture_compression");
if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_texture_compression */
+#ifdef GL_ARB_texture_compression_bptc
+ CONST_CAST(GLEW_ARB_texture_compression_bptc) = glewGetExtension("GL_ARB_texture_compression_bptc");
+#endif /* GL_ARB_texture_compression_bptc */
#ifdef GL_ARB_texture_compression_rgtc
CONST_CAST(GLEW_ARB_texture_compression_rgtc) = glewGetExtension("GL_ARB_texture_compression_rgtc");
#endif /* GL_ARB_texture_compression_rgtc */
#ifdef GL_ARB_texture_cube_map
CONST_CAST(GLEW_ARB_texture_cube_map) = glewGetExtension("GL_ARB_texture_cube_map");
#endif /* GL_ARB_texture_cube_map */
+#ifdef GL_ARB_texture_cube_map_array
+ CONST_CAST(GLEW_ARB_texture_cube_map_array) = glewGetExtension("GL_ARB_texture_cube_map_array");
+#endif /* GL_ARB_texture_cube_map_array */
#ifdef GL_ARB_texture_env_add
CONST_CAST(GLEW_ARB_texture_env_add) = glewGetExtension("GL_ARB_texture_env_add");
#endif /* GL_ARB_texture_env_add */
@@ -6430,22 +7793,57 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_ARB_texture_float
CONST_CAST(GLEW_ARB_texture_float) = glewGetExtension("GL_ARB_texture_float");
#endif /* GL_ARB_texture_float */
+#ifdef GL_ARB_texture_gather
+ CONST_CAST(GLEW_ARB_texture_gather) = glewGetExtension("GL_ARB_texture_gather");
+#endif /* GL_ARB_texture_gather */
#ifdef GL_ARB_texture_mirrored_repeat
CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = glewGetExtension("GL_ARB_texture_mirrored_repeat");
#endif /* GL_ARB_texture_mirrored_repeat */
+#ifdef GL_ARB_texture_multisample
+ CONST_CAST(GLEW_ARB_texture_multisample) = glewGetExtension("GL_ARB_texture_multisample");
+ if (glewExperimental || GLEW_ARB_texture_multisample) CONST_CAST(GLEW_ARB_texture_multisample) = !_glewInit_GL_ARB_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_texture_multisample */
#ifdef GL_ARB_texture_non_power_of_two
CONST_CAST(GLEW_ARB_texture_non_power_of_two) = glewGetExtension("GL_ARB_texture_non_power_of_two");
#endif /* GL_ARB_texture_non_power_of_two */
+#ifdef GL_ARB_texture_query_lod
+ CONST_CAST(GLEW_ARB_texture_query_lod) = glewGetExtension("GL_ARB_texture_query_lod");
+#endif /* GL_ARB_texture_query_lod */
#ifdef GL_ARB_texture_rectangle
CONST_CAST(GLEW_ARB_texture_rectangle) = glewGetExtension("GL_ARB_texture_rectangle");
#endif /* GL_ARB_texture_rectangle */
#ifdef GL_ARB_texture_rg
CONST_CAST(GLEW_ARB_texture_rg) = glewGetExtension("GL_ARB_texture_rg");
#endif /* GL_ARB_texture_rg */
+#ifdef GL_ARB_texture_rgb10_a2ui
+ CONST_CAST(GLEW_ARB_texture_rgb10_a2ui) = glewGetExtension("GL_ARB_texture_rgb10_a2ui");
+#endif /* GL_ARB_texture_rgb10_a2ui */
+#ifdef GL_ARB_texture_swizzle
+ CONST_CAST(GLEW_ARB_texture_swizzle) = glewGetExtension("GL_ARB_texture_swizzle");
+#endif /* GL_ARB_texture_swizzle */
+#ifdef GL_ARB_timer_query
+ CONST_CAST(GLEW_ARB_timer_query) = glewGetExtension("GL_ARB_timer_query");
+ if (glewExperimental || GLEW_ARB_timer_query) CONST_CAST(GLEW_ARB_timer_query) = !_glewInit_GL_ARB_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_timer_query */
+#ifdef GL_ARB_transform_feedback2
+ CONST_CAST(GLEW_ARB_transform_feedback2) = glewGetExtension("GL_ARB_transform_feedback2");
+ if (glewExperimental || GLEW_ARB_transform_feedback2) CONST_CAST(GLEW_ARB_transform_feedback2) = !_glewInit_GL_ARB_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_transform_feedback2 */
+#ifdef GL_ARB_transform_feedback3
+ CONST_CAST(GLEW_ARB_transform_feedback3) = glewGetExtension("GL_ARB_transform_feedback3");
+ if (glewExperimental || GLEW_ARB_transform_feedback3) CONST_CAST(GLEW_ARB_transform_feedback3) = !_glewInit_GL_ARB_transform_feedback3(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_transform_feedback3 */
#ifdef GL_ARB_transpose_matrix
CONST_CAST(GLEW_ARB_transpose_matrix) = glewGetExtension("GL_ARB_transpose_matrix");
if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_transpose_matrix */
+#ifdef GL_ARB_uniform_buffer_object
+ CONST_CAST(GLEW_ARB_uniform_buffer_object) = glewGetExtension("GL_ARB_uniform_buffer_object");
+ if (glewExperimental || GLEW_ARB_uniform_buffer_object) CONST_CAST(GLEW_ARB_uniform_buffer_object) = !_glewInit_GL_ARB_uniform_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_uniform_buffer_object */
+#ifdef GL_ARB_vertex_array_bgra
+ CONST_CAST(GLEW_ARB_vertex_array_bgra) = glewGetExtension("GL_ARB_vertex_array_bgra");
+#endif /* GL_ARB_vertex_array_bgra */
#ifdef GL_ARB_vertex_array_object
CONST_CAST(GLEW_ARB_vertex_array_object) = glewGetExtension("GL_ARB_vertex_array_object");
if (glewExperimental || GLEW_ARB_vertex_array_object) CONST_CAST(GLEW_ARB_vertex_array_object) = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -6466,6 +7864,10 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_ARB_vertex_shader) = glewGetExtension("GL_ARB_vertex_shader");
if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ARB_vertex_shader */
+#ifdef GL_ARB_vertex_type_2_10_10_10_rev
+ CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = glewGetExtension("GL_ARB_vertex_type_2_10_10_10_rev");
+ if (glewExperimental || GLEW_ARB_vertex_type_2_10_10_10_rev) CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = !_glewInit_GL_ARB_vertex_type_2_10_10_10_rev(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
#ifdef GL_ARB_window_pos
CONST_CAST(GLEW_ARB_window_pos) = glewGetExtension("GL_ARB_window_pos");
if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -6502,6 +7904,9 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_ATI_map_object_buffer) = glewGetExtension("GL_ATI_map_object_buffer");
if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_ATI_map_object_buffer */
+#ifdef GL_ATI_meminfo
+ CONST_CAST(GLEW_ATI_meminfo) = glewGetExtension("GL_ATI_meminfo");
+#endif /* GL_ATI_meminfo */
#ifdef GL_ATI_pn_triangles
CONST_CAST(GLEW_ATI_pn_triangles) = glewGetExtension("GL_ATI_pn_triangles");
if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -6727,6 +8132,10 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_EXT_polygon_offset) = glewGetExtension("GL_EXT_polygon_offset");
if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_EXT_polygon_offset */
+#ifdef GL_EXT_provoking_vertex
+ CONST_CAST(GLEW_EXT_provoking_vertex) = glewGetExtension("GL_EXT_provoking_vertex");
+ if (glewExperimental || GLEW_EXT_provoking_vertex) CONST_CAST(GLEW_EXT_provoking_vertex) = !_glewInit_GL_EXT_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_EXT_provoking_vertex */
#ifdef GL_EXT_rescale_normal
CONST_CAST(GLEW_EXT_rescale_normal) = glewGetExtension("GL_EXT_rescale_normal");
#endif /* GL_EXT_rescale_normal */
@@ -6738,9 +8147,17 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_EXT_secondary_color) = glewGetExtension("GL_EXT_secondary_color");
if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_EXT_secondary_color */
+#ifdef GL_EXT_separate_shader_objects
+ CONST_CAST(GLEW_EXT_separate_shader_objects) = glewGetExtension("GL_EXT_separate_shader_objects");
+ if (glewExperimental || GLEW_EXT_separate_shader_objects) CONST_CAST(GLEW_EXT_separate_shader_objects) = !_glewInit_GL_EXT_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_EXT_separate_shader_objects */
#ifdef GL_EXT_separate_specular_color
CONST_CAST(GLEW_EXT_separate_specular_color) = glewGetExtension("GL_EXT_separate_specular_color");
#endif /* GL_EXT_separate_specular_color */
+#ifdef GL_EXT_shader_image_load_store
+ CONST_CAST(GLEW_EXT_shader_image_load_store) = glewGetExtension("GL_EXT_shader_image_load_store");
+ if (glewExperimental || GLEW_EXT_shader_image_load_store) CONST_CAST(GLEW_EXT_shader_image_load_store) = !_glewInit_GL_EXT_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_EXT_shader_image_load_store */
#ifdef GL_EXT_shadow_funcs
CONST_CAST(GLEW_EXT_shadow_funcs) = glewGetExtension("GL_EXT_shadow_funcs");
#endif /* GL_EXT_shadow_funcs */
@@ -6835,6 +8252,9 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_EXT_texture_shared_exponent
CONST_CAST(GLEW_EXT_texture_shared_exponent) = glewGetExtension("GL_EXT_texture_shared_exponent");
#endif /* GL_EXT_texture_shared_exponent */
+#ifdef GL_EXT_texture_snorm
+ CONST_CAST(GLEW_EXT_texture_snorm) = glewGetExtension("GL_EXT_texture_snorm");
+#endif /* GL_EXT_texture_snorm */
#ifdef GL_EXT_texture_swizzle
CONST_CAST(GLEW_EXT_texture_swizzle) = glewGetExtension("GL_EXT_texture_swizzle");
#endif /* GL_EXT_texture_swizzle */
@@ -6853,6 +8273,10 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_EXT_vertex_array_bgra
CONST_CAST(GLEW_EXT_vertex_array_bgra) = glewGetExtension("GL_EXT_vertex_array_bgra");
#endif /* GL_EXT_vertex_array_bgra */
+#ifdef GL_EXT_vertex_attrib_64bit
+ CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = glewGetExtension("GL_EXT_vertex_attrib_64bit");
+ if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = !_glewInit_GL_EXT_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_EXT_vertex_attrib_64bit */
#ifdef GL_EXT_vertex_shader
CONST_CAST(GLEW_EXT_vertex_shader) = glewGetExtension("GL_EXT_vertex_shader");
if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -6947,6 +8371,10 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_NV_copy_depth_to_color
CONST_CAST(GLEW_NV_copy_depth_to_color) = glewGetExtension("GL_NV_copy_depth_to_color");
#endif /* GL_NV_copy_depth_to_color */
+#ifdef GL_NV_copy_image
+ CONST_CAST(GLEW_NV_copy_image) = glewGetExtension("GL_NV_copy_image");
+ if (glewExperimental || GLEW_NV_copy_image) CONST_CAST(GLEW_NV_copy_image) = !_glewInit_GL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_copy_image */
#ifdef GL_NV_depth_buffer_float
CONST_CAST(GLEW_NV_depth_buffer_float) = glewGetExtension("GL_NV_depth_buffer_float");
if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -6983,7 +8411,7 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_NV_fragment_program2) = glewGetExtension("GL_NV_fragment_program2");
#endif /* GL_NV_fragment_program2 */
#ifdef GL_NV_fragment_program4
- CONST_CAST(GLEW_NV_fragment_program4) = glewGetExtension("GL_NV_fragment_program4");
+ CONST_CAST(GLEW_NV_fragment_program4) = glewGetExtension("GL_NV_gpu_program4");
#endif /* GL_NV_fragment_program4 */
#ifdef GL_NV_fragment_program_option
CONST_CAST(GLEW_NV_fragment_program_option) = glewGetExtension("GL_NV_fragment_program_option");
@@ -6993,7 +8421,7 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_NV_framebuffer_multisample_coverage */
#ifdef GL_NV_geometry_program4
- CONST_CAST(GLEW_NV_geometry_program4) = glewGetExtension("GL_NV_geometry_program4");
+ CONST_CAST(GLEW_NV_geometry_program4) = glewGetExtension("GL_NV_gpu_program4");
if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_NV_geometry_program4 */
#ifdef GL_NV_geometry_shader4
@@ -7003,6 +8431,16 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_NV_gpu_program4) = glewGetExtension("GL_NV_gpu_program4");
if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_NV_gpu_program4 */
+#ifdef GL_NV_gpu_program5
+ CONST_CAST(GLEW_NV_gpu_program5) = glewGetExtension("GL_NV_gpu_program5");
+#endif /* GL_NV_gpu_program5 */
+#ifdef GL_NV_gpu_program_fp64
+ CONST_CAST(GLEW_NV_gpu_program_fp64) = glewGetExtension("GL_NV_gpu_program_fp64");
+#endif /* GL_NV_gpu_program_fp64 */
+#ifdef GL_NV_gpu_shader5
+ CONST_CAST(GLEW_NV_gpu_shader5) = glewGetExtension("GL_NV_gpu_shader5");
+ if (glewExperimental || GLEW_NV_gpu_shader5) CONST_CAST(GLEW_NV_gpu_shader5) = !_glewInit_GL_NV_gpu_shader5(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_gpu_shader5 */
#ifdef GL_NV_half_float
CONST_CAST(GLEW_NV_half_float) = glewGetExtension("GL_NV_half_float");
if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -7024,6 +8462,9 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_NV_parameter_buffer_object) = glewGetExtension("GL_NV_parameter_buffer_object");
if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_NV_parameter_buffer_object */
+#ifdef GL_NV_parameter_buffer_object2
+ CONST_CAST(GLEW_NV_parameter_buffer_object2) = glewGetExtension("GL_NV_parameter_buffer_object2");
+#endif /* GL_NV_parameter_buffer_object2 */
#ifdef GL_NV_pixel_data_range
CONST_CAST(GLEW_NV_pixel_data_range) = glewGetExtension("GL_NV_pixel_data_range");
if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -7048,12 +8489,23 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_NV_register_combiners2) = glewGetExtension("GL_NV_register_combiners2");
if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_NV_register_combiners2 */
+#ifdef GL_NV_shader_buffer_load
+ CONST_CAST(GLEW_NV_shader_buffer_load) = glewGetExtension("GL_NV_shader_buffer_load");
+ if (glewExperimental || GLEW_NV_shader_buffer_load) CONST_CAST(GLEW_NV_shader_buffer_load) = !_glewInit_GL_NV_shader_buffer_load(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_shader_buffer_load */
+#ifdef GL_NV_tessellation_program5
+ CONST_CAST(GLEW_NV_tessellation_program5) = glewGetExtension("GL_NV_gpu_program5");
+#endif /* GL_NV_tessellation_program5 */
#ifdef GL_NV_texgen_emboss
CONST_CAST(GLEW_NV_texgen_emboss) = glewGetExtension("GL_NV_texgen_emboss");
#endif /* GL_NV_texgen_emboss */
#ifdef GL_NV_texgen_reflection
CONST_CAST(GLEW_NV_texgen_reflection) = glewGetExtension("GL_NV_texgen_reflection");
#endif /* GL_NV_texgen_reflection */
+#ifdef GL_NV_texture_barrier
+ CONST_CAST(GLEW_NV_texture_barrier) = glewGetExtension("GL_NV_texture_barrier");
+ if (glewExperimental || GLEW_NV_texture_barrier) CONST_CAST(GLEW_NV_texture_barrier) = !_glewInit_GL_NV_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_texture_barrier */
#ifdef GL_NV_texture_compression_vtc
CONST_CAST(GLEW_NV_texture_compression_vtc) = glewGetExtension("GL_NV_texture_compression_vtc");
#endif /* GL_NV_texture_compression_vtc */
@@ -7079,6 +8531,10 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_NV_transform_feedback) = glewGetExtension("GL_NV_transform_feedback");
if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GL_NV_transform_feedback */
+#ifdef GL_NV_transform_feedback2
+ CONST_CAST(GLEW_NV_transform_feedback2) = glewGetExtension("GL_NV_transform_feedback2");
+ if (glewExperimental || GLEW_NV_transform_feedback2) CONST_CAST(GLEW_NV_transform_feedback2) = !_glewInit_GL_NV_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_transform_feedback2 */
#ifdef GL_NV_vertex_array_range
CONST_CAST(GLEW_NV_vertex_array_range) = glewGetExtension("GL_NV_vertex_array_range");
if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -7086,6 +8542,14 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
#ifdef GL_NV_vertex_array_range2
CONST_CAST(GLEW_NV_vertex_array_range2) = glewGetExtension("GL_NV_vertex_array_range2");
#endif /* GL_NV_vertex_array_range2 */
+#ifdef GL_NV_vertex_attrib_integer_64bit
+ CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = glewGetExtension("GL_NV_vertex_attrib_integer_64bit");
+ if (glewExperimental || GLEW_NV_vertex_attrib_integer_64bit) CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = !_glewInit_GL_NV_vertex_attrib_integer_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_vertex_attrib_integer_64bit */
+#ifdef GL_NV_vertex_buffer_unified_memory
+ CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = glewGetExtension("GL_NV_vertex_buffer_unified_memory");
+ if (glewExperimental || GLEW_NV_vertex_buffer_unified_memory) CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = !_glewInit_GL_NV_vertex_buffer_unified_memory(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GL_NV_vertex_buffer_unified_memory */
#ifdef GL_NV_vertex_program
CONST_CAST(GLEW_NV_vertex_program) = glewGetExtension("GL_NV_vertex_program");
if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -7103,7 +8567,7 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLEW_NV_vertex_program3) = glewGetExtension("GL_NV_vertex_program3");
#endif /* GL_NV_vertex_program3 */
#ifdef GL_NV_vertex_program4
- CONST_CAST(GLEW_NV_vertex_program4) = glewGetExtension("GL_NV_vertex_program4");
+ CONST_CAST(GLEW_NV_vertex_program4) = glewGetExtension("GL_NV_gpu_program4");
#endif /* GL_NV_vertex_program4 */
#ifdef GL_OES_byte_coordinates
CONST_CAST(GLEW_OES_byte_coordinates) = glewGetExtension("GL_OES_byte_coordinates");
@@ -7352,6 +8816,16 @@ GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;
+PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL;
+PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL;
+PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL;
+PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL;
+PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL;
+PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL;
+PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL;
+PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL;
+PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL;
+
PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;
PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;
PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;
@@ -7437,6 +8911,8 @@ PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;
PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;
PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;
+PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL;
+
PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;
PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;
PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;
@@ -7472,8 +8948,10 @@ PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;
PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;
GLboolean __WGLEW_3DFX_multisample = GL_FALSE;
GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;
+GLboolean __WGLEW_AMD_gpu_association = GL_FALSE;
GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;
GLboolean __WGLEW_ARB_create_context = GL_FALSE;
+GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE;
GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;
GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE;
GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;
@@ -7500,6 +8978,7 @@ GLboolean __WGLEW_I3D_genlock = GL_FALSE;
GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;
GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;
GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;
+GLboolean __WGLEW_NV_copy_image = GL_FALSE;
GLboolean __WGLEW_NV_float_buffer = GL_FALSE;
GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;
GLboolean __WGLEW_NV_present_video = GL_FALSE;
@@ -7529,6 +9008,27 @@ static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT)
#endif /* WGL_3DL_stereo_control */
+#ifdef WGL_AMD_gpu_association
+
+static GLboolean _glewInit_WGL_AMD_gpu_association (WGLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r;
+ r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r;
+ r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r;
+ r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r;
+ r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r;
+ r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r;
+ r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r;
+ r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r;
+ r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* WGL_AMD_gpu_association */
+
#ifdef WGL_ARB_buffer_region
static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)
@@ -7558,6 +9058,10 @@ static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT)
#endif /* WGL_ARB_create_context */
+#ifdef WGL_ARB_create_context_profile
+
+#endif /* WGL_ARB_create_context_profile */
+
#ifdef WGL_ARB_extensions_string
static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
@@ -7859,6 +9363,19 @@ static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)
#endif /* WGL_I3D_swap_frame_usage */
+#ifdef WGL_NV_copy_image
+
+static GLboolean _glewInit_WGL_NV_copy_image (WGLEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* WGL_NV_copy_image */
+
#ifdef WGL_NV_float_buffer
#endif /* WGL_NV_float_buffer */
@@ -8014,6 +9531,10 @@ GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(WGLEW_3DL_stereo_control) = wglewGetExtension("WGL_3DL_stereo_control");
if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* WGL_3DL_stereo_control */
+#ifdef WGL_AMD_gpu_association
+ CONST_CAST(WGLEW_AMD_gpu_association) = wglewGetExtension("WGL_AMD_gpu_association");
+ if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) CONST_CAST(WGLEW_AMD_gpu_association)= !_glewInit_WGL_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* WGL_AMD_gpu_association */
#ifdef WGL_ARB_buffer_region
CONST_CAST(WGLEW_ARB_buffer_region) = wglewGetExtension("WGL_ARB_buffer_region");
if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -8022,6 +9543,9 @@ GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(WGLEW_ARB_create_context) = wglewGetExtension("WGL_ARB_create_context");
if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* WGL_ARB_create_context */
+#ifdef WGL_ARB_create_context_profile
+ CONST_CAST(WGLEW_ARB_create_context_profile) = wglewGetExtension("WGL_ARB_create_context_profile");
+#endif /* WGL_ARB_create_context_profile */
#ifdef WGL_ARB_extensions_string
CONST_CAST(WGLEW_ARB_extensions_string) = wglewGetExtension("WGL_ARB_extensions_string");
if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -8117,6 +9641,10 @@ GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(WGLEW_I3D_swap_frame_usage) = wglewGetExtension("WGL_I3D_swap_frame_usage");
if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* WGL_I3D_swap_frame_usage */
+#ifdef WGL_NV_copy_image
+ CONST_CAST(WGLEW_NV_copy_image) = wglewGetExtension("WGL_NV_copy_image");
+ if (glewExperimental || WGLEW_NV_copy_image|| crippled) CONST_CAST(WGLEW_NV_copy_image)= !_glewInit_WGL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* WGL_NV_copy_image */
#ifdef WGL_NV_float_buffer
CONST_CAST(WGLEW_NV_float_buffer) = wglewGetExtension("WGL_NV_float_buffer");
#endif /* WGL_NV_float_buffer */
@@ -8187,6 +9715,8 @@ PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;
PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;
PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;
+PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL;
+
PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;
PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;
@@ -8200,6 +9730,8 @@ PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;
PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;
+PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL;
+
PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL;
PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL;
@@ -8285,24 +9817,29 @@ GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;
GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;
GLboolean __GLXEW_3DFX_multisample = GL_FALSE;
GLboolean __GLXEW_ARB_create_context = GL_FALSE;
+GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE;
GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;
GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE;
GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;
GLboolean __GLXEW_ARB_multisample = GL_FALSE;
+GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE;
GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;
GLboolean __GLXEW_ATI_render_texture = GL_FALSE;
GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;
GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;
GLboolean __GLXEW_EXT_import_context = GL_FALSE;
GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;
+GLboolean __GLXEW_EXT_swap_control = GL_FALSE;
GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;
GLboolean __GLXEW_EXT_visual_info = GL_FALSE;
GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;
+GLboolean __GLXEW_INTEL_swap_event = GL_FALSE;
GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;
GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;
GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;
GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;
GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;
+GLboolean __GLXEW_NV_copy_image = GL_FALSE;
GLboolean __GLXEW_NV_float_buffer = GL_FALSE;
GLboolean __GLXEW_NV_present_video = GL_FALSE;
GLboolean __GLXEW_NV_swap_group = GL_FALSE;
@@ -8395,6 +9932,10 @@ static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT)
#endif /* GLX_ARB_create_context */
+#ifdef GLX_ARB_create_context_profile
+
+#endif /* GLX_ARB_create_context_profile */
+
#ifdef GLX_ARB_fbconfig_float
#endif /* GLX_ARB_fbconfig_float */
@@ -8411,6 +9952,10 @@ static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT)
#endif /* GLX_ARB_multisample */
+#ifdef GLX_ARB_vertex_buffer_object
+
+#endif /* GLX_ARB_vertex_buffer_object */
+
#ifdef GLX_ATI_pixel_format_float
#endif /* GLX_ATI_pixel_format_float */
@@ -8458,6 +10003,19 @@ static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)
#endif /* GLX_EXT_scene_marker */
+#ifdef GLX_EXT_swap_control
+
+static GLboolean _glewInit_GLX_EXT_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GLX_EXT_swap_control */
+
#ifdef GLX_EXT_texture_from_pixmap
static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT)
@@ -8480,6 +10038,10 @@ static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_IN
#endif /* GLX_EXT_visual_rating */
+#ifdef GLX_INTEL_swap_event
+
+#endif /* GLX_INTEL_swap_event */
+
#ifdef GLX_MESA_agp_offset
static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)
@@ -8545,17 +10107,30 @@ static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)
#endif /* GLX_MESA_set_3dfx_mode */
-#ifdef GLX_NV_float_buffer
-
-#endif /* GLX_NV_float_buffer */
-
-#ifdef GLX_NV_present_video
+#ifdef GLX_NV_copy_image
-static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT)
+static GLboolean _glewInit_GLX_NV_copy_image (GLXEW_CONTEXT_ARG_DEF_INIT)
{
GLboolean r = GL_FALSE;
- r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;
+ r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r;
+
+ return r;
+}
+
+#endif /* GLX_NV_copy_image */
+
+#ifdef GLX_NV_float_buffer
+
+#endif /* GLX_NV_float_buffer */
+
+#ifdef GLX_NV_present_video
+
+static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT)
+{
+ GLboolean r = GL_FALSE;
+
+ r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;
r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r;
return r;
@@ -8841,10 +10416,10 @@ GLboolean glxewGetExtension (const char* name)
{
GLubyte* p;
GLubyte* end;
- GLuint len = _glewStrLen((const GLubyte*)name);
-/* if (glXQueryExtensionsString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE; */
-/* p = (GLubyte*)glXQueryExtensionsString(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay())); */
- if (glXGetClientString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE;
+ GLuint len;
+
+ if (glXGetCurrentDisplay == NULL) return GL_FALSE;
+ len = _glewStrLen((const GLubyte*)name);
p = (GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
if (0 == p) return GL_FALSE;
end = p + _glewStrLen(p);
@@ -8897,6 +10472,9 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLXEW_ARB_create_context) = glxewGetExtension("GLX_ARB_create_context");
if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GLX_ARB_create_context */
+#ifdef GLX_ARB_create_context_profile
+ CONST_CAST(GLXEW_ARB_create_context_profile) = glxewGetExtension("GLX_ARB_create_context_profile");
+#endif /* GLX_ARB_create_context_profile */
#ifdef GLX_ARB_fbconfig_float
CONST_CAST(GLXEW_ARB_fbconfig_float) = glxewGetExtension("GLX_ARB_fbconfig_float");
#endif /* GLX_ARB_fbconfig_float */
@@ -8909,6 +10487,9 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
#ifdef GLX_ARB_multisample
CONST_CAST(GLXEW_ARB_multisample) = glxewGetExtension("GLX_ARB_multisample");
#endif /* GLX_ARB_multisample */
+#ifdef GLX_ARB_vertex_buffer_object
+ CONST_CAST(GLXEW_ARB_vertex_buffer_object) = glxewGetExtension("GLX_ARB_vertex_buffer_object");
+#endif /* GLX_ARB_vertex_buffer_object */
#ifdef GLX_ATI_pixel_format_float
CONST_CAST(GLXEW_ATI_pixel_format_float) = glxewGetExtension("GLX_ATI_pixel_format_float");
#endif /* GLX_ATI_pixel_format_float */
@@ -8929,6 +10510,10 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
#ifdef GLX_EXT_scene_marker
CONST_CAST(GLXEW_EXT_scene_marker) = glxewGetExtension("GLX_EXT_scene_marker");
#endif /* GLX_EXT_scene_marker */
+#ifdef GLX_EXT_swap_control
+ CONST_CAST(GLXEW_EXT_swap_control) = glxewGetExtension("GLX_EXT_swap_control");
+ if (glewExperimental || GLXEW_EXT_swap_control) CONST_CAST(GLXEW_EXT_swap_control) = !_glewInit_GLX_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GLX_EXT_swap_control */
#ifdef GLX_EXT_texture_from_pixmap
CONST_CAST(GLXEW_EXT_texture_from_pixmap) = glxewGetExtension("GLX_EXT_texture_from_pixmap");
if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -8939,6 +10524,9 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
#ifdef GLX_EXT_visual_rating
CONST_CAST(GLXEW_EXT_visual_rating) = glxewGetExtension("GLX_EXT_visual_rating");
#endif /* GLX_EXT_visual_rating */
+#ifdef GLX_INTEL_swap_event
+ CONST_CAST(GLXEW_INTEL_swap_event) = glxewGetExtension("GLX_INTEL_swap_event");
+#endif /* GLX_INTEL_swap_event */
#ifdef GLX_MESA_agp_offset
CONST_CAST(GLXEW_MESA_agp_offset) = glxewGetExtension("GLX_MESA_agp_offset");
if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);
@@ -8959,6 +10547,10 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
CONST_CAST(GLXEW_MESA_set_3dfx_mode) = glxewGetExtension("GLX_MESA_set_3dfx_mode");
if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT);
#endif /* GLX_MESA_set_3dfx_mode */
+#ifdef GLX_NV_copy_image
+ CONST_CAST(GLXEW_NV_copy_image) = glxewGetExtension("GLX_NV_copy_image");
+ if (glewExperimental || GLXEW_NV_copy_image) CONST_CAST(GLXEW_NV_copy_image) = !_glewInit_GLX_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
+#endif /* GLX_NV_copy_image */
#ifdef GLX_NV_float_buffer
CONST_CAST(GLXEW_NV_float_buffer) = glxewGetExtension("GLX_NV_float_buffer");
#endif /* GLX_NV_float_buffer */
@@ -9076,10 +10668,10 @@ const GLubyte* glewGetString (GLenum name)
static const GLubyte* _glewString[] =
{
(const GLubyte*)NULL,
- (const GLubyte*)"1.5.1",
+ (const GLubyte*)"1.5.4",
(const GLubyte*)"1",
(const GLubyte*)"5",
- (const GLubyte*)"1"
+ (const GLubyte*)"4"
};
const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;
return _glewString[(int)name > max_string ? 0 : (int)name];
@@ -9174,6 +10766,34 @@ GLboolean glewIsSupported (const char* name)
ret = GLEW_VERSION_3_0;
continue;
}
+#endif
+#ifdef GL_VERSION_3_1
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3))
+ {
+ ret = GLEW_VERSION_3_1;
+ continue;
+ }
+#endif
+#ifdef GL_VERSION_3_2
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3))
+ {
+ ret = GLEW_VERSION_3_2;
+ continue;
+ }
+#endif
+#ifdef GL_VERSION_3_3
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3))
+ {
+ ret = GLEW_VERSION_3_3;
+ continue;
+ }
+#endif
+#ifdef GL_VERSION_4_0
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3))
+ {
+ ret = GLEW_VERSION_4_0;
+ continue;
+ }
#endif
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
@@ -9198,10 +10818,69 @@ GLboolean glewIsSupported (const char* name)
ret = GLEW_3DFX_texture_compression_FXT1;
continue;
}
+#endif
+ }
+ if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
+ {
+#ifdef GL_AMD_conservative_depth
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
+ {
+ ret = GLEW_AMD_conservative_depth;
+ continue;
+ }
+#endif
+#ifdef GL_AMD_draw_buffers_blend
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
+ {
+ ret = GLEW_AMD_draw_buffers_blend;
+ continue;
+ }
+#endif
+#ifdef GL_AMD_performance_monitor
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19))
+ {
+ ret = GLEW_AMD_performance_monitor;
+ continue;
+ }
+#endif
+#ifdef GL_AMD_seamless_cubemap_per_texture
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))
+ {
+ ret = GLEW_AMD_seamless_cubemap_per_texture;
+ continue;
+ }
+#endif
+#ifdef GL_AMD_shader_stencil_export
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
+ {
+ ret = GLEW_AMD_shader_stencil_export;
+ continue;
+ }
+#endif
+#ifdef GL_AMD_texture_texture4
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16))
+ {
+ ret = GLEW_AMD_texture_texture4;
+ continue;
+ }
+#endif
+#ifdef GL_AMD_vertex_shader_tessellator
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25))
+ {
+ ret = GLEW_AMD_vertex_shader_tessellator;
+ continue;
+ }
#endif
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))
{
+#ifdef GL_APPLE_aux_depth_stencil
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17))
+ {
+ ret = GLEW_APPLE_aux_depth_stencil;
+ continue;
+ }
+#endif
#ifdef GL_APPLE_client_storage
if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))
{
@@ -9237,6 +10916,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_APPLE_object_purgeable
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16))
+ {
+ ret = GLEW_APPLE_object_purgeable;
+ continue;
+ }
+#endif
#ifdef GL_APPLE_pixel_buffer
if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))
{
@@ -9244,6 +10930,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_APPLE_rgb_422
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7))
+ {
+ ret = GLEW_APPLE_rgb_422;
+ continue;
+ }
+#endif
+#ifdef GL_APPLE_row_bytes
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9))
+ {
+ ret = GLEW_APPLE_row_bytes;
+ continue;
+ }
+#endif
#ifdef GL_APPLE_specular_vector
if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))
{
@@ -9279,6 +10979,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_APPLE_vertex_program_evaluators
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25))
+ {
+ ret = GLEW_APPLE_vertex_program_evaluators;
+ continue;
+ }
+#endif
#ifdef GL_APPLE_ycbcr_422
if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))
{
@@ -9289,6 +10996,13 @@ GLboolean glewIsSupported (const char* name)
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
{
+#ifdef GL_ARB_blend_func_extended
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19))
+ {
+ ret = GLEW_ARB_blend_func_extended;
+ continue;
+ }
+#endif
#ifdef GL_ARB_color_buffer_float
if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))
{
@@ -9296,6 +11010,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_compatibility
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13))
+ {
+ ret = GLEW_ARB_compatibility;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_copy_buffer
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))
+ {
+ ret = GLEW_ARB_copy_buffer;
+ continue;
+ }
+#endif
#ifdef GL_ARB_depth_buffer_float
if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
{
@@ -9303,6 +11031,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_depth_clamp
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
+ {
+ ret = GLEW_ARB_depth_clamp;
+ continue;
+ }
+#endif
#ifdef GL_ARB_depth_texture
if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
{
@@ -9317,6 +11052,27 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_draw_buffers_blend
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
+ {
+ ret = GLEW_ARB_draw_buffers_blend;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_draw_elements_base_vertex
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25))
+ {
+ ret = GLEW_ARB_draw_elements_base_vertex;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_draw_indirect
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13))
+ {
+ ret = GLEW_ARB_draw_indirect;
+ continue;
+ }
+#endif
#ifdef GL_ARB_draw_instanced
if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
{
@@ -9324,6 +11080,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_explicit_attrib_location
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24))
+ {
+ ret = GLEW_ARB_explicit_attrib_location;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_fragment_coord_conventions
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26))
+ {
+ ret = GLEW_ARB_fragment_coord_conventions;
+ continue;
+ }
+#endif
#ifdef GL_ARB_fragment_program
if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
{
@@ -9366,6 +11136,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_gpu_shader5
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
+ {
+ ret = GLEW_ARB_gpu_shader5;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_gpu_shader_fp64
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15))
+ {
+ ret = GLEW_ARB_gpu_shader_fp64;
+ continue;
+ }
+#endif
#ifdef GL_ARB_half_float_pixel
if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))
{
@@ -9429,6 +11213,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_occlusion_query2
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16))
+ {
+ ret = GLEW_ARB_occlusion_query2;
+ continue;
+ }
+#endif
#ifdef GL_ARB_pixel_buffer_object
if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
{
@@ -9450,6 +11241,41 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_provoking_vertex
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
+ {
+ ret = GLEW_ARB_provoking_vertex;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_sample_shading
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14))
+ {
+ ret = GLEW_ARB_sample_shading;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_sampler_objects
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15))
+ {
+ ret = GLEW_ARB_sampler_objects;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_seamless_cube_map
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17))
+ {
+ ret = GLEW_ARB_seamless_cube_map;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_shader_bit_encoding
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19))
+ {
+ ret = GLEW_ARB_shader_bit_encoding;
+ continue;
+ }
+#endif
#ifdef GL_ARB_shader_objects
if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))
{
@@ -9457,6 +11283,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_shader_subroutine
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17))
+ {
+ ret = GLEW_ARB_shader_subroutine;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_shader_texture_lod
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
+ {
+ ret = GLEW_ARB_shader_texture_lod;
+ continue;
+ }
+#endif
#ifdef GL_ARB_shading_language_100
if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))
{
@@ -9464,6 +11304,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_shading_language_include
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24))
+ {
+ ret = GLEW_ARB_shading_language_include;
+ continue;
+ }
+#endif
#ifdef GL_ARB_shadow
if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
{
@@ -9478,6 +11325,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_sync
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))
+ {
+ ret = GLEW_ARB_sync;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_tessellation_shader
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19))
+ {
+ ret = GLEW_ARB_tessellation_shader;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_border_clamp
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
{
@@ -9492,6 +11353,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_buffer_object_rgb32
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27))
+ {
+ ret = GLEW_ARB_texture_buffer_object_rgb32;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_compression
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))
{
@@ -9499,6 +11367,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_compression_bptc
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24))
+ {
+ ret = GLEW_ARB_texture_compression_bptc;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_compression_rgtc
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
{
@@ -9513,6 +11388,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_cube_map_array
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22))
+ {
+ ret = GLEW_ARB_texture_cube_map_array;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_env_add
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
{
@@ -9548,6 +11430,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_gather
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14))
+ {
+ ret = GLEW_ARB_texture_gather;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_mirrored_repeat
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
{
@@ -9555,6 +11444,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_multisample
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
+ {
+ ret = GLEW_ARB_texture_multisample;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_non_power_of_two
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))
{
@@ -9562,6 +11458,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_query_lod
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17))
+ {
+ ret = GLEW_ARB_texture_query_lod;
+ continue;
+ }
+#endif
#ifdef GL_ARB_texture_rectangle
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
{
@@ -9576,6 +11479,41 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_texture_rgb10_a2ui
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18))
+ {
+ ret = GLEW_ARB_texture_rgb10_a2ui;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_texture_swizzle
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
+ {
+ ret = GLEW_ARB_texture_swizzle;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_timer_query
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
+ {
+ ret = GLEW_ARB_timer_query;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_transform_feedback2
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
+ {
+ ret = GLEW_ARB_transform_feedback2;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_transform_feedback3
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19))
+ {
+ ret = GLEW_ARB_transform_feedback3;
+ continue;
+ }
+#endif
#ifdef GL_ARB_transpose_matrix
if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))
{
@@ -9583,6 +11521,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_uniform_buffer_object
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21))
+ {
+ ret = GLEW_ARB_uniform_buffer_object;
+ continue;
+ }
+#endif
+#ifdef GL_ARB_vertex_array_bgra
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
+ {
+ ret = GLEW_ARB_vertex_array_bgra;
+ continue;
+ }
+#endif
#ifdef GL_ARB_vertex_array_object
if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
{
@@ -9618,6 +11570,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ARB_vertex_type_2_10_10_10_rev
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26))
+ {
+ ret = GLEW_ARB_vertex_type_2_10_10_10_rev;
+ continue;
+ }
+#endif
#ifdef GL_ARB_window_pos
if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
{
@@ -9694,6 +11653,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_ATI_meminfo
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7))
+ {
+ ret = GLEW_ATI_meminfo;
+ continue;
+ }
+#endif
#ifdef GL_ATI_pn_triangles
if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))
{
@@ -10131,6 +12097,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_EXT_provoking_vertex
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
+ {
+ ret = GLEW_EXT_provoking_vertex;
+ continue;
+ }
+#endif
#ifdef GL_EXT_rescale_normal
if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))
{
@@ -10152,6 +12125,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_EXT_separate_shader_objects
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
+ {
+ ret = GLEW_EXT_separate_shader_objects;
+ continue;
+ }
+#endif
#ifdef GL_EXT_separate_specular_color
if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))
{
@@ -10159,6 +12139,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_EXT_shader_image_load_store
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
+ {
+ ret = GLEW_EXT_shader_image_load_store;
+ continue;
+ }
+#endif
#ifdef GL_EXT_shadow_funcs
if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))
{
@@ -10362,6 +12349,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_EXT_texture_snorm
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13))
+ {
+ ret = GLEW_EXT_texture_snorm;
+ continue;
+ }
+#endif
#ifdef GL_EXT_texture_swizzle
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
{
@@ -10397,6 +12391,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_EXT_vertex_attrib_64bit
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
+ {
+ ret = GLEW_EXT_vertex_attrib_64bit;
+ continue;
+ }
+#endif
#ifdef GL_EXT_vertex_shader
if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
{
@@ -10613,6 +12614,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_copy_image
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
+ {
+ ret = GLEW_NV_copy_image;
+ continue;
+ }
+#endif
#ifdef GL_NV_depth_buffer_float
if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
{
@@ -10725,6 +12733,27 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_gpu_program5
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12))
+ {
+ ret = GLEW_NV_gpu_program5;
+ continue;
+ }
+#endif
+#ifdef GL_NV_gpu_program_fp64
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16))
+ {
+ ret = GLEW_NV_gpu_program_fp64;
+ continue;
+ }
+#endif
+#ifdef GL_NV_gpu_shader5
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
+ {
+ ret = GLEW_NV_gpu_shader5;
+ continue;
+ }
+#endif
#ifdef GL_NV_half_float
if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))
{
@@ -10767,6 +12796,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_parameter_buffer_object2
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24))
+ {
+ ret = GLEW_NV_parameter_buffer_object2;
+ continue;
+ }
+#endif
#ifdef GL_NV_pixel_data_range
if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))
{
@@ -10809,6 +12845,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_shader_buffer_load
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18))
+ {
+ ret = GLEW_NV_shader_buffer_load;
+ continue;
+ }
+#endif
+#ifdef GL_NV_tessellation_program5
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21))
+ {
+ ret = GLEW_NV_tessellation_program5;
+ continue;
+ }
+#endif
#ifdef GL_NV_texgen_emboss
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))
{
@@ -10823,6 +12873,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_texture_barrier
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15))
+ {
+ ret = GLEW_NV_texture_barrier;
+ continue;
+ }
+#endif
#ifdef GL_NV_texture_compression_vtc
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))
{
@@ -10879,6 +12936,13 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_transform_feedback2
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
+ {
+ ret = GLEW_NV_transform_feedback2;
+ continue;
+ }
+#endif
#ifdef GL_NV_vertex_array_range
if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
{
@@ -10893,6 +12957,20 @@ GLboolean glewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GL_NV_vertex_attrib_integer_64bit
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27))
+ {
+ ret = GLEW_NV_vertex_attrib_integer_64bit;
+ continue;
+ }
+#endif
+#ifdef GL_NV_vertex_buffer_unified_memory
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28))
+ {
+ ret = GLEW_NV_vertex_buffer_unified_memory;
+ continue;
+ }
+#endif
#ifdef GL_NV_vertex_program
if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
{
@@ -11505,6 +13583,16 @@ GLboolean wglewIsSupported (const char* name)
ret = WGLEW_3DL_stereo_control;
continue;
}
+#endif
+ }
+ if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
+ {
+#ifdef WGL_AMD_gpu_association
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
+ {
+ ret = WGLEW_AMD_gpu_association;
+ continue;
+ }
#endif
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
@@ -11523,6 +13611,13 @@ GLboolean wglewIsSupported (const char* name)
continue;
}
#endif
+#ifdef WGL_ARB_create_context_profile
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
+ {
+ ret = WGLEW_ARB_create_context_profile;
+ continue;
+ }
+#endif
#ifdef WGL_ARB_extensions_string
if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
{
@@ -11717,6 +13812,13 @@ GLboolean wglewIsSupported (const char* name)
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
{
+#ifdef WGL_NV_copy_image
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
+ {
+ ret = WGLEW_NV_copy_image;
+ continue;
+ }
+#endif
#ifdef WGL_NV_float_buffer
if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
{
@@ -11848,6 +13950,13 @@ GLboolean glxewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GLX_ARB_create_context_profile
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
+ {
+ ret = GLXEW_ARB_create_context_profile;
+ continue;
+ }
+#endif
#ifdef GLX_ARB_fbconfig_float
if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))
{
@@ -11875,6 +13984,13 @@ GLboolean glxewIsSupported (const char* name)
ret = GLXEW_ARB_multisample;
continue;
}
+#endif
+#ifdef GLX_ARB_vertex_buffer_object
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
+ {
+ ret = GLXEW_ARB_vertex_buffer_object;
+ continue;
+ }
#endif
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
@@ -11924,6 +14040,13 @@ GLboolean glxewIsSupported (const char* name)
continue;
}
#endif
+#ifdef GLX_EXT_swap_control
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
+ {
+ ret = GLXEW_EXT_swap_control;
+ continue;
+ }
+#endif
#ifdef GLX_EXT_texture_from_pixmap
if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))
{
@@ -11944,6 +14067,16 @@ GLboolean glxewIsSupported (const char* name)
ret = GLXEW_EXT_visual_rating;
continue;
}
+#endif
+ }
+ if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
+ {
+#ifdef GLX_INTEL_swap_event
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10))
+ {
+ ret = GLXEW_INTEL_swap_event;
+ continue;
+ }
#endif
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
@@ -11986,6 +14119,13 @@ GLboolean glxewIsSupported (const char* name)
}
if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
{
+#ifdef GLX_NV_copy_image
+ if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
+ {
+ ret = GLXEW_NV_copy_image;
+ continue;
+ }
+#endif
#ifdef GLX_NV_float_buffer
if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
{
diff --git a/modules/gfx/src/GL/glew.h b/modules/gfx/src/GL/glew.h
index 2014092e8771498ba8bf6ad47d61c94c2e3cab97..189270e64d866719604ce57f0eabd89162d21626 100644
--- a/modules/gfx/src/GL/glew.h
+++ b/modules/gfx/src/GL/glew.h
@@ -80,7 +80,7 @@
#define __glew_h__
#define __GLEW_H__
-#if defined(__gl_h_) || defined(__GL_H__)
+#if defined(__gl_h_) || defined(__GL_H__) || defined(__X_GL_H)
#error gl.h included before glew.h
#endif
#if defined(__glext_h_) || defined(__GLEXT_H_)
@@ -92,6 +92,7 @@
#define __gl_h_
#define __GL_H__
+#define __X_GL_H
#define __glext_h_
#define __GLEXT_H_
#define __gl_ATI_h_
@@ -106,7 +107,7 @@
/* <windef.h> */
#ifndef APIENTRY
#define GLEW_APIENTRY_DEFINED
-# if defined(__MINGW32__)
+# if defined(__MINGW32__) || defined(__CYGWIN__)
# define APIENTRY __stdcall
# elif (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__)
# define APIENTRY __stdcall
@@ -115,14 +116,14 @@
# endif
#endif
#ifndef GLAPI
-# if defined(__MINGW32__)
+# if defined(__MINGW32__) || defined(__CYGWIN__)
# define GLAPI extern
# endif
#endif
/* <winnt.h> */
#ifndef CALLBACK
#define GLEW_CALLBACK_DEFINED
-# if defined(__MINGW32__)
+# if defined(__MINGW32__) || defined(__CYGWIN__)
# define CALLBACK __attribute__ ((__stdcall__))
# elif (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
# define CALLBACK __stdcall
@@ -159,7 +160,7 @@ typedef _W64 int ptrdiff_t;
#endif
#ifndef GLAPI
-# if defined(__MINGW32__)
+# if defined(__MINGW32__) || defined(__CYGWIN__)
# define GLAPI extern
# else
# define GLAPI WINGDIAPI
@@ -196,7 +197,14 @@ typedef _W64 int ptrdiff_t;
*/
#include <stddef.h>
+
+/* SGI MIPSPro doesn't like stdint.h in C++ mode */
+
+#if defined(__sgi) && !defined(__GNUC__)
+#include <inttypes.h>
+#else
#include <stdint.h>
+#endif
#define GLEW_APIENTRY_DEFINED
#define APIENTRY
@@ -246,12 +254,15 @@ typedef signed long long GLint64EXT;
typedef unsigned long long GLuint64EXT;
# endif
#else
-# if defined(__MINGW32__)
+# if defined(__MINGW32__) || defined(__CYGWIN__)
#include <inttypes.h>
# endif
typedef int64_t GLint64EXT;
typedef uint64_t GLuint64EXT;
#endif
+typedef GLint64EXT GLint64;
+typedef GLuint64EXT GLuint64;
+typedef struct __GLsync *GLsync;
#define GL_ACCUM 0x0100
#define GL_LOAD 0x0101
@@ -1455,9 +1466,9 @@ typedef void (GLAPIENTRY * PFNGLFOGCOORDFVPROC) (const GLfloat *coord);
typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param);
-typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVPROC) (GLenum pname, GLfloat *params);
+typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params);
typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param);
-typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, GLint *params);
+typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params);
typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue);
typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v);
typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue);
@@ -2094,8 +2105,6 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLsizei
typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERPROC) (GLuint, GLenum);
typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKPROC) (GLenum);
-typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEPROC) (GLenum, GLuint, GLuint);
-typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEPROC) (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr);
typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONPROC) (GLuint, GLuint, const GLchar*);
typedef void (GLAPIENTRY * PFNGLCLAMPCOLORPROC) (GLenum, GLenum);
typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFIPROC) (GLenum, GLint, GLfloat, GLint);
@@ -2109,7 +2118,6 @@ typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERPROC) (void);
typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKPROC) (void);
typedef void (GLAPIENTRY * PFNGLGETBOOLEANI_VPROC) (GLenum, GLuint, GLboolean*);
typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONPROC) (GLuint, const GLchar*);
-typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VPROC) (GLenum, GLuint, GLint*);
typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGIPROC) (GLenum, GLuint);
typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVPROC) (GLenum, GLenum, GLint*);
typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVPROC) (GLenum, GLenum, GLuint*);
@@ -2120,7 +2128,7 @@ typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVPROC) (GLuint, GLenum, GLuint
typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIPROC) (GLenum, GLuint);
typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVPROC) (GLenum, GLenum, const GLint*);
typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVPROC) (GLenum, GLenum, const GLuint*);
-typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint, GLsizei, const GLint*, GLenum);
+typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint, GLsizei, const GLchar **, GLenum);
typedef void (GLAPIENTRY * PFNGLUNIFORM1UIPROC) (GLint, GLuint);
typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVPROC) (GLint, GLsizei, const GLuint*);
typedef void (GLAPIENTRY * PFNGLUNIFORM2UIPROC) (GLint, GLuint, GLuint);
@@ -2153,8 +2161,6 @@ typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint, GLint, GLenum
#define glBeginConditionalRender GLEW_GET_FUN(__glewBeginConditionalRender)
#define glBeginTransformFeedback GLEW_GET_FUN(__glewBeginTransformFeedback)
-#define glBindBufferBase GLEW_GET_FUN(__glewBindBufferBase)
-#define glBindBufferRange GLEW_GET_FUN(__glewBindBufferRange)
#define glBindFragDataLocation GLEW_GET_FUN(__glewBindFragDataLocation)
#define glClampColor GLEW_GET_FUN(__glewClampColor)
#define glClearBufferfi GLEW_GET_FUN(__glewClearBufferfi)
@@ -2168,7 +2174,6 @@ typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint, GLint, GLenum
#define glEndTransformFeedback GLEW_GET_FUN(__glewEndTransformFeedback)
#define glGetBooleani_v GLEW_GET_FUN(__glewGetBooleani_v)
#define glGetFragDataLocation GLEW_GET_FUN(__glewGetFragDataLocation)
-#define glGetIntegeri_v GLEW_GET_FUN(__glewGetIntegeri_v)
#define glGetStringi GLEW_GET_FUN(__glewGetStringi)
#define glGetTexParameterIiv GLEW_GET_FUN(__glewGetTexParameterIiv)
#define glGetTexParameterIuiv GLEW_GET_FUN(__glewGetTexParameterIuiv)
@@ -2214,6 +2219,157 @@ typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint, GLint, GLenum
#endif /* GL_VERSION_3_0 */
+/* ----------------------------- GL_VERSION_3_1 ---------------------------- */
+
+#ifndef GL_VERSION_3_1
+#define GL_VERSION_3_1 1
+
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
+#define GL_SAMPLER_2D_RECT 0x8B63
+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
+#define GL_TEXTURE_BUFFER 0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_TEXTURE_BUFFER_FORMAT 0x8C2E
+#define GL_SAMPLER_BUFFER 0x8DC2
+#define GL_INT_SAMPLER_2D_RECT 0x8DCD
+#define GL_INT_SAMPLER_BUFFER 0x8DD0
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
+#define GL_RED_SNORM 0x8F90
+#define GL_RG_SNORM 0x8F91
+#define GL_RGB_SNORM 0x8F92
+#define GL_RGBA_SNORM 0x8F93
+#define GL_R8_SNORM 0x8F94
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_R16_SNORM 0x8F98
+#define GL_RG16_SNORM 0x8F99
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_PRIMITIVE_RESTART 0x8F9D
+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BUFFER_MAP_OFFSET 0x9121
+
+typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDPROC) (GLenum, GLint, GLsizei, GLsizei);
+typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDPROC) (GLenum, GLsizei, GLenum, const GLvoid*, GLsizei);
+typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTINDEXPROC) (GLuint);
+typedef void (GLAPIENTRY * PFNGLTEXBUFFERPROC) (GLenum, GLenum, GLuint);
+
+#define glDrawArraysInstanced GLEW_GET_FUN(__glewDrawArraysInstanced)
+#define glDrawElementsInstanced GLEW_GET_FUN(__glewDrawElementsInstanced)
+#define glPrimitiveRestartIndex GLEW_GET_FUN(__glewPrimitiveRestartIndex)
+#define glTexBuffer GLEW_GET_FUN(__glewTexBuffer)
+
+#define GLEW_VERSION_3_1 GLEW_GET_VAR(__GLEW_VERSION_3_1)
+
+#endif /* GL_VERSION_3_1 */
+
+/* ----------------------------- GL_VERSION_3_2 ---------------------------- */
+
+#ifndef GL_VERSION_3_2
+#define GL_VERSION_3_2 1
+
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_LINES_ADJACENCY 0x000A
+#define GL_LINE_STRIP_ADJACENCY 0x000B
+#define GL_TRIANGLES_ADJACENCY 0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
+#define GL_PROGRAM_POINT_SIZE 0x8642
+#define GL_GEOMETRY_VERTICES_OUT 0x8916
+#define GL_GEOMETRY_INPUT_TYPE 0x8917
+#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_GEOMETRY_SHADER 0x8DD9
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+
+typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREPROC) (GLenum, GLenum, GLuint, GLint);
+typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERI64VPROC) (GLenum, GLenum, GLint64 *);
+typedef void (GLAPIENTRY * PFNGLGETINTEGER64I_VPROC) (GLenum, GLuint, GLint64 *);
+
+#define glFramebufferTexture GLEW_GET_FUN(__glewFramebufferTexture)
+#define glGetBufferParameteri64v GLEW_GET_FUN(__glewGetBufferParameteri64v)
+#define glGetInteger64i_v GLEW_GET_FUN(__glewGetInteger64i_v)
+
+#define GLEW_VERSION_3_2 GLEW_GET_VAR(__GLEW_VERSION_3_2)
+
+#endif /* GL_VERSION_3_2 */
+
+/* ----------------------------- GL_VERSION_3_3 ---------------------------- */
+
+#ifndef GL_VERSION_3_3
+#define GL_VERSION_3_3 1
+
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+#define GL_RGB10_A2UI 0x906F
+
+#define GLEW_VERSION_3_3 GLEW_GET_VAR(__GLEW_VERSION_3_3)
+
+#endif /* GL_VERSION_3_3 */
+
+/* ----------------------------- GL_VERSION_4_0 ---------------------------- */
+
+#ifndef GL_VERSION_4_0
+#define GL_VERSION_4_0 1
+
+#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F
+#define GL_SAMPLE_SHADING 0x8C36
+#define GL_MIN_SAMPLE_SHADING_VALUE 0x8C37
+#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C
+#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS 0x8F9F
+#define GL_TEXTURE_CUBE_MAP_ARRAY 0x9009
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY 0x900B
+#define GL_SAMPLER_CUBE_MAP_ARRAY 0x900C
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F
+
+typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIPROC) (GLuint buf, GLenum mode);
+typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+typedef void (GLAPIENTRY * PFNGLBLENDFUNCIPROC) (GLuint buf, GLenum src, GLenum dst);
+typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGPROC) (GLclampf value);
+
+#define glBlendEquationSeparatei GLEW_GET_FUN(__glewBlendEquationSeparatei)
+#define glBlendEquationi GLEW_GET_FUN(__glewBlendEquationi)
+#define glBlendFuncSeparatei GLEW_GET_FUN(__glewBlendFuncSeparatei)
+#define glBlendFunci GLEW_GET_FUN(__glewBlendFunci)
+#define glMinSampleShading GLEW_GET_FUN(__glewMinSampleShading)
+
+#define GLEW_VERSION_4_0 GLEW_GET_VAR(__GLEW_VERSION_4_0)
+
+#endif /* GL_VERSION_4_0 */
+
/* -------------------------- GL_3DFX_multisample -------------------------- */
#ifndef GL_3DFX_multisample
@@ -2253,6 +2409,140 @@ typedef void (GLAPIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
#endif /* GL_3DFX_texture_compression_FXT1 */
+/* ----------------------- GL_AMD_conservative_depth ----------------------- */
+
+#ifndef GL_AMD_conservative_depth
+#define GL_AMD_conservative_depth 1
+
+#define GLEW_AMD_conservative_depth GLEW_GET_VAR(__GLEW_AMD_conservative_depth)
+
+#endif /* GL_AMD_conservative_depth */
+
+/* ----------------------- GL_AMD_draw_buffers_blend ----------------------- */
+
+#ifndef GL_AMD_draw_buffers_blend
+#define GL_AMD_draw_buffers_blend 1
+
+typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONINDEXEDAMDPROC) (GLuint buf, GLenum mode);
+typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+typedef void (GLAPIENTRY * PFNGLBLENDFUNCINDEXEDAMDPROC) (GLuint buf, GLenum src, GLenum dst);
+typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+
+#define glBlendEquationIndexedAMD GLEW_GET_FUN(__glewBlendEquationIndexedAMD)
+#define glBlendEquationSeparateIndexedAMD GLEW_GET_FUN(__glewBlendEquationSeparateIndexedAMD)
+#define glBlendFuncIndexedAMD GLEW_GET_FUN(__glewBlendFuncIndexedAMD)
+#define glBlendFuncSeparateIndexedAMD GLEW_GET_FUN(__glewBlendFuncSeparateIndexedAMD)
+
+#define GLEW_AMD_draw_buffers_blend GLEW_GET_VAR(__GLEW_AMD_draw_buffers_blend)
+
+#endif /* GL_AMD_draw_buffers_blend */
+
+/* ----------------------- GL_AMD_performance_monitor ---------------------- */
+
+#ifndef GL_AMD_performance_monitor
+#define GL_AMD_performance_monitor 1
+
+#define GL_UNSIGNED_INT 0x1405
+#define GL_FLOAT 0x1406
+#define GL_COUNTER_TYPE_AMD 0x8BC0
+#define GL_COUNTER_RANGE_AMD 0x8BC1
+#define GL_UNSIGNED_INT64_AMD 0x8BC2
+#define GL_PERCENTAGE_AMD 0x8BC3
+#define GL_PERFMON_RESULT_AVAILABLE_AMD 0x8BC4
+#define GL_PERFMON_RESULT_SIZE_AMD 0x8BC5
+#define GL_PERFMON_RESULT_AMD 0x8BC6
+
+typedef void (GLAPIENTRY * PFNGLBEGINPERFMONITORAMDPROC) (GLuint monitor);
+typedef void (GLAPIENTRY * PFNGLDELETEPERFMONITORSAMDPROC) (GLsizei n, GLuint* monitors);
+typedef void (GLAPIENTRY * PFNGLENDPERFMONITORAMDPROC) (GLuint monitor);
+typedef void (GLAPIENTRY * PFNGLGENPERFMONITORSAMDPROC) (GLsizei n, GLuint* monitors);
+typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERDATAAMDPROC) (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint *bytesWritten);
+typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERINFOAMDPROC) (GLuint group, GLuint counter, GLenum pname, void* data);
+typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC) (GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, char *counterString);
+typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERSAMDPROC) (GLuint group, GLint* numCounters, GLint *maxActiveCounters, GLsizei countersSize, GLuint *counters);
+typedef void (GLAPIENTRY * PFNGLGETPERFMONITORGROUPSTRINGAMDPROC) (GLuint group, GLsizei bufSize, GLsizei* length, char *groupString);
+typedef void (GLAPIENTRY * PFNGLGETPERFMONITORGROUPSAMDPROC) (GLint* numGroups, GLsizei groupsSize, GLuint *groups);
+typedef void (GLAPIENTRY * PFNGLSELECTPERFMONITORCOUNTERSAMDPROC) (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList);
+
+#define glBeginPerfMonitorAMD GLEW_GET_FUN(__glewBeginPerfMonitorAMD)
+#define glDeletePerfMonitorsAMD GLEW_GET_FUN(__glewDeletePerfMonitorsAMD)
+#define glEndPerfMonitorAMD GLEW_GET_FUN(__glewEndPerfMonitorAMD)
+#define glGenPerfMonitorsAMD GLEW_GET_FUN(__glewGenPerfMonitorsAMD)
+#define glGetPerfMonitorCounterDataAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterDataAMD)
+#define glGetPerfMonitorCounterInfoAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterInfoAMD)
+#define glGetPerfMonitorCounterStringAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterStringAMD)
+#define glGetPerfMonitorCountersAMD GLEW_GET_FUN(__glewGetPerfMonitorCountersAMD)
+#define glGetPerfMonitorGroupStringAMD GLEW_GET_FUN(__glewGetPerfMonitorGroupStringAMD)
+#define glGetPerfMonitorGroupsAMD GLEW_GET_FUN(__glewGetPerfMonitorGroupsAMD)
+#define glSelectPerfMonitorCountersAMD GLEW_GET_FUN(__glewSelectPerfMonitorCountersAMD)
+
+#define GLEW_AMD_performance_monitor GLEW_GET_VAR(__GLEW_AMD_performance_monitor)
+
+#endif /* GL_AMD_performance_monitor */
+
+/* ------------------ GL_AMD_seamless_cubemap_per_texture ------------------ */
+
+#ifndef GL_AMD_seamless_cubemap_per_texture
+#define GL_AMD_seamless_cubemap_per_texture 1
+
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS_ARB 0x884F
+
+#define GLEW_AMD_seamless_cubemap_per_texture GLEW_GET_VAR(__GLEW_AMD_seamless_cubemap_per_texture)
+
+#endif /* GL_AMD_seamless_cubemap_per_texture */
+
+/* ---------------------- GL_AMD_shader_stencil_export --------------------- */
+
+#ifndef GL_AMD_shader_stencil_export
+#define GL_AMD_shader_stencil_export 1
+
+#define GLEW_AMD_shader_stencil_export GLEW_GET_VAR(__GLEW_AMD_shader_stencil_export)
+
+#endif /* GL_AMD_shader_stencil_export */
+
+/* ------------------------ GL_AMD_texture_texture4 ------------------------ */
+
+#ifndef GL_AMD_texture_texture4
+#define GL_AMD_texture_texture4 1
+
+#define GLEW_AMD_texture_texture4 GLEW_GET_VAR(__GLEW_AMD_texture_texture4)
+
+#endif /* GL_AMD_texture_texture4 */
+
+/* -------------------- GL_AMD_vertex_shader_tessellator ------------------- */
+
+#ifndef GL_AMD_vertex_shader_tessellator
+#define GL_AMD_vertex_shader_tessellator 1
+
+#define GL_SAMPLER_BUFFER_AMD 0x9001
+#define GL_INT_SAMPLER_BUFFER_AMD 0x9002
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD 0x9003
+#define GL_TESSELLATION_MODE_AMD 0x9004
+#define GL_TESSELLATION_FACTOR_AMD 0x9005
+#define GL_DISCRETE_AMD 0x9006
+#define GL_CONTINUOUS_AMD 0x9007
+
+typedef void (GLAPIENTRY * PFNGLTESSELLATIONFACTORAMDPROC) (GLfloat factor);
+typedef void (GLAPIENTRY * PFNGLTESSELLATIONMODEAMDPROC) (GLenum mode);
+
+#define glTessellationFactorAMD GLEW_GET_FUN(__glewTessellationFactorAMD)
+#define glTessellationModeAMD GLEW_GET_FUN(__glewTessellationModeAMD)
+
+#define GLEW_AMD_vertex_shader_tessellator GLEW_GET_VAR(__GLEW_AMD_vertex_shader_tessellator)
+
+#endif /* GL_AMD_vertex_shader_tessellator */
+
+/* ----------------------- GL_APPLE_aux_depth_stencil ---------------------- */
+
+#ifndef GL_APPLE_aux_depth_stencil
+#define GL_APPLE_aux_depth_stencil 1
+
+#define GL_AUX_DEPTH_STENCIL_APPLE 0x8A14
+
+#define GLEW_APPLE_aux_depth_stencil GLEW_GET_VAR(__GLEW_APPLE_aux_depth_stencil)
+
+#endif /* GL_APPLE_aux_depth_stencil */
+
/* ------------------------ GL_APPLE_client_storage ------------------------ */
#ifndef GL_APPLE_client_storage
@@ -2269,9 +2559,9 @@ typedef void (GLAPIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
#ifndef GL_APPLE_element_array
#define GL_APPLE_element_array 1
-#define GL_ELEMENT_ARRAY_APPLE 0x8768
-#define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8769
-#define GL_ELEMENT_ARRAY_POINTER_APPLE 0x876A
+#define GL_ELEMENT_ARRAY_APPLE 0x8A0C
+#define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8A0D
+#define GL_ELEMENT_ARRAY_POINTER_APPLE 0x8A0E
typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count);
typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count);
@@ -2361,6 +2651,30 @@ typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target,
#endif /* GL_APPLE_flush_buffer_range */
+/* ----------------------- GL_APPLE_object_purgeable ----------------------- */
+
+#ifndef GL_APPLE_object_purgeable
+#define GL_APPLE_object_purgeable 1
+
+#define GL_BUFFER_OBJECT_APPLE 0x85B3
+#define GL_RELEASED_APPLE 0x8A19
+#define GL_VOLATILE_APPLE 0x8A1A
+#define GL_RETAINED_APPLE 0x8A1B
+#define GL_UNDEFINED_APPLE 0x8A1C
+#define GL_PURGEABLE_APPLE 0x8A1D
+
+typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVAPPLEPROC) (GLenum objectType, GLuint name, GLenum pname, GLint* params);
+typedef GLenum (GLAPIENTRY * PFNGLOBJECTPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option);
+typedef GLenum (GLAPIENTRY * PFNGLOBJECTUNPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option);
+
+#define glGetObjectParameterivAPPLE GLEW_GET_FUN(__glewGetObjectParameterivAPPLE)
+#define glObjectPurgeableAPPLE GLEW_GET_FUN(__glewObjectPurgeableAPPLE)
+#define glObjectUnpurgeableAPPLE GLEW_GET_FUN(__glewObjectUnpurgeableAPPLE)
+
+#define GLEW_APPLE_object_purgeable GLEW_GET_VAR(__GLEW_APPLE_object_purgeable)
+
+#endif /* GL_APPLE_object_purgeable */
+
/* ------------------------- GL_APPLE_pixel_buffer ------------------------- */
#ifndef GL_APPLE_pixel_buffer
@@ -2372,6 +2686,31 @@ typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target,
#endif /* GL_APPLE_pixel_buffer */
+/* ---------------------------- GL_APPLE_rgb_422 --------------------------- */
+
+#ifndef GL_APPLE_rgb_422
+#define GL_APPLE_rgb_422 1
+
+#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA
+#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB
+#define GL_RGB_422_APPLE 0x8A1F
+
+#define GLEW_APPLE_rgb_422 GLEW_GET_VAR(__GLEW_APPLE_rgb_422)
+
+#endif /* GL_APPLE_rgb_422 */
+
+/* --------------------------- GL_APPLE_row_bytes -------------------------- */
+
+#ifndef GL_APPLE_row_bytes
+#define GL_APPLE_row_bytes 1
+
+#define GL_PACK_ROW_BYTES_APPLE 0x8A15
+#define GL_UNPACK_ROW_BYTES_APPLE 0x8A16
+
+#define GLEW_APPLE_row_bytes GLEW_GET_VAR(__GLEW_APPLE_row_bytes)
+
+#endif /* GL_APPLE_row_bytes */
+
/* ------------------------ GL_APPLE_specular_vector ----------------------- */
#ifndef GL_APPLE_specular_vector
@@ -2447,6 +2786,7 @@ typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array);
#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F
#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_APPLE 0x8520
#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521
+#define GL_STORAGE_CLIENT_APPLE 0x85B4
#define GL_STORAGE_CACHED_APPLE 0x85BE
#define GL_STORAGE_SHARED_APPLE 0x85BF
@@ -2462,6 +2802,42 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void
#endif /* GL_APPLE_vertex_array_range */
+/* ------------------- GL_APPLE_vertex_program_evaluators ------------------ */
+
+#ifndef GL_APPLE_vertex_program_evaluators
+#define GL_APPLE_vertex_program_evaluators 1
+
+#define GL_VERTEX_ATTRIB_MAP1_APPLE 0x8A00
+#define GL_VERTEX_ATTRIB_MAP2_APPLE 0x8A01
+#define GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE 0x8A02
+#define GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE 0x8A03
+#define GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE 0x8A04
+#define GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE 0x8A05
+#define GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE 0x8A06
+#define GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE 0x8A07
+#define GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE 0x8A08
+#define GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE 0x8A09
+
+typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname);
+typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname);
+typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXATTRIBENABLEDAPPLEPROC) (GLuint index, GLenum pname);
+typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB1DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points);
+typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB1FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points);
+typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB2DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points);
+typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB2FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points);
+
+#define glDisableVertexAttribAPPLE GLEW_GET_FUN(__glewDisableVertexAttribAPPLE)
+#define glEnableVertexAttribAPPLE GLEW_GET_FUN(__glewEnableVertexAttribAPPLE)
+#define glIsVertexAttribEnabledAPPLE GLEW_GET_FUN(__glewIsVertexAttribEnabledAPPLE)
+#define glMapVertexAttrib1dAPPLE GLEW_GET_FUN(__glewMapVertexAttrib1dAPPLE)
+#define glMapVertexAttrib1fAPPLE GLEW_GET_FUN(__glewMapVertexAttrib1fAPPLE)
+#define glMapVertexAttrib2dAPPLE GLEW_GET_FUN(__glewMapVertexAttrib2dAPPLE)
+#define glMapVertexAttrib2fAPPLE GLEW_GET_FUN(__glewMapVertexAttrib2fAPPLE)
+
+#define GLEW_APPLE_vertex_program_evaluators GLEW_GET_VAR(__GLEW_APPLE_vertex_program_evaluators)
+
+#endif /* GL_APPLE_vertex_program_evaluators */
+
/* --------------------------- GL_APPLE_ycbcr_422 -------------------------- */
#ifndef GL_APPLE_ycbcr_422
@@ -2475,6 +2851,26 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void
#endif /* GL_APPLE_ycbcr_422 */
+/* ----------------------- GL_ARB_blend_func_extended ---------------------- */
+
+#ifndef GL_ARB_blend_func_extended
+#define GL_ARB_blend_func_extended 1
+
+#define GL_SRC1_COLOR 0x88F9
+#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
+#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
+#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
+
+typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) (GLuint program, GLuint colorNumber, GLuint index, const char * name);
+typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATAINDEXPROC) (GLuint program, const char * name);
+
+#define glBindFragDataLocationIndexed GLEW_GET_FUN(__glewBindFragDataLocationIndexed)
+#define glGetFragDataIndex GLEW_GET_FUN(__glewGetFragDataIndex)
+
+#define GLEW_ARB_blend_func_extended GLEW_GET_VAR(__GLEW_ARB_blend_func_extended)
+
+#endif /* GL_ARB_blend_func_extended */
+
/* ----------------------- GL_ARB_color_buffer_float ----------------------- */
#ifndef GL_ARB_color_buffer_float
@@ -2494,6 +2890,31 @@ typedef void (GLAPIENTRY * PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp)
#endif /* GL_ARB_color_buffer_float */
+/* -------------------------- GL_ARB_compatibility ------------------------- */
+
+#ifndef GL_ARB_compatibility
+#define GL_ARB_compatibility 1
+
+#define GLEW_ARB_compatibility GLEW_GET_VAR(__GLEW_ARB_compatibility)
+
+#endif /* GL_ARB_compatibility */
+
+/* --------------------------- GL_ARB_copy_buffer -------------------------- */
+
+#ifndef GL_ARB_copy_buffer
+#define GL_ARB_copy_buffer 1
+
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COPY_WRITE_BUFFER 0x8F37
+
+typedef void (GLAPIENTRY * PFNGLCOPYBUFFERSUBDATAPROC) (GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size);
+
+#define glCopyBufferSubData GLEW_GET_FUN(__glewCopyBufferSubData)
+
+#define GLEW_ARB_copy_buffer GLEW_GET_VAR(__GLEW_ARB_copy_buffer)
+
+#endif /* GL_ARB_copy_buffer */
+
/* ----------------------- GL_ARB_depth_buffer_float ----------------------- */
#ifndef GL_ARB_depth_buffer_float
@@ -2507,6 +2928,17 @@ typedef void (GLAPIENTRY * PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp)
#endif /* GL_ARB_depth_buffer_float */
+/* --------------------------- GL_ARB_depth_clamp -------------------------- */
+
+#ifndef GL_ARB_depth_clamp
+#define GL_ARB_depth_clamp 1
+
+#define GL_DEPTH_CLAMP 0x864F
+
+#define GLEW_ARB_depth_clamp GLEW_GET_VAR(__GLEW_ARB_depth_clamp)
+
+#endif /* GL_ARB_depth_clamp */
+
/* -------------------------- GL_ARB_depth_texture ------------------------- */
#ifndef GL_ARB_depth_texture
@@ -2553,6 +2985,62 @@ typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum* bu
#endif /* GL_ARB_draw_buffers */
+/* ----------------------- GL_ARB_draw_buffers_blend ----------------------- */
+
+#ifndef GL_ARB_draw_buffers_blend
+#define GL_ARB_draw_buffers_blend 1
+
+typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIARBPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIARBPROC) (GLuint buf, GLenum mode);
+typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIARBPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+typedef void (GLAPIENTRY * PFNGLBLENDFUNCIARBPROC) (GLuint buf, GLenum src, GLenum dst);
+
+#define glBlendEquationSeparateiARB GLEW_GET_FUN(__glewBlendEquationSeparateiARB)
+#define glBlendEquationiARB GLEW_GET_FUN(__glewBlendEquationiARB)
+#define glBlendFuncSeparateiARB GLEW_GET_FUN(__glewBlendFuncSeparateiARB)
+#define glBlendFunciARB GLEW_GET_FUN(__glewBlendFunciARB)
+
+#define GLEW_ARB_draw_buffers_blend GLEW_GET_VAR(__GLEW_ARB_draw_buffers_blend)
+
+#endif /* GL_ARB_draw_buffers_blend */
+
+/* -------------------- GL_ARB_draw_elements_base_vertex ------------------- */
+
+#ifndef GL_ARB_draw_elements_base_vertex
+#define GL_ARB_draw_elements_base_vertex 1
+
+typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, void* indices, GLint basevertex);
+typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLint basevertex);
+typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void* indices, GLint basevertex);
+typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei* count, GLenum type, GLvoid**indices, GLsizei primcount, GLint *basevertex);
+
+#define glDrawElementsBaseVertex GLEW_GET_FUN(__glewDrawElementsBaseVertex)
+#define glDrawElementsInstancedBaseVertex GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertex)
+#define glDrawRangeElementsBaseVertex GLEW_GET_FUN(__glewDrawRangeElementsBaseVertex)
+#define glMultiDrawElementsBaseVertex GLEW_GET_FUN(__glewMultiDrawElementsBaseVertex)
+
+#define GLEW_ARB_draw_elements_base_vertex GLEW_GET_VAR(__GLEW_ARB_draw_elements_base_vertex)
+
+#endif /* GL_ARB_draw_elements_base_vertex */
+
+/* -------------------------- GL_ARB_draw_indirect ------------------------- */
+
+#ifndef GL_ARB_draw_indirect
+#define GL_ARB_draw_indirect 1
+
+#define GL_DRAW_INDIRECT_BUFFER 0x8F3F
+#define GL_DRAW_INDIRECT_BUFFER_BINDING 0x8F43
+
+typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINDIRECTPROC) (GLenum mode, const void* indirect);
+typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINDIRECTPROC) (GLenum mode, GLenum type, const void* indirect);
+
+#define glDrawArraysIndirect GLEW_GET_FUN(__glewDrawArraysIndirect)
+#define glDrawElementsIndirect GLEW_GET_FUN(__glewDrawElementsIndirect)
+
+#define GLEW_ARB_draw_indirect GLEW_GET_VAR(__GLEW_ARB_draw_indirect)
+
+#endif /* GL_ARB_draw_indirect */
+
/* ------------------------- GL_ARB_draw_instanced ------------------------- */
#ifndef GL_ARB_draw_instanced
@@ -2568,6 +3056,24 @@ typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDARBPROC) (GLenum mode, GLsi
#endif /* GL_ARB_draw_instanced */
+/* -------------------- GL_ARB_explicit_attrib_location -------------------- */
+
+#ifndef GL_ARB_explicit_attrib_location
+#define GL_ARB_explicit_attrib_location 1
+
+#define GLEW_ARB_explicit_attrib_location GLEW_GET_VAR(__GLEW_ARB_explicit_attrib_location)
+
+#endif /* GL_ARB_explicit_attrib_location */
+
+/* ------------------- GL_ARB_fragment_coord_conventions ------------------- */
+
+#ifndef GL_ARB_fragment_coord_conventions
+#define GL_ARB_fragment_coord_conventions 1
+
+#define GLEW_ARB_fragment_coord_conventions GLEW_GET_VAR(__GLEW_ARB_fragment_coord_conventions)
+
+#endif /* GL_ARB_fragment_coord_conventions */
+
/* ------------------------ GL_ARB_fragment_program ------------------------ */
#ifndef GL_ARB_fragment_program
@@ -2702,10 +3208,10 @@ typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target);
typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint* framebuffers);
typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint* renderbuffers);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURLAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer);
+typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer);
typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint* framebuffers);
typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint* renderbuffers);
typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPPROC) (GLenum target);
@@ -2723,10 +3229,10 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum targ
#define glDeleteFramebuffers GLEW_GET_FUN(__glewDeleteFramebuffers)
#define glDeleteRenderbuffers GLEW_GET_FUN(__glewDeleteRenderbuffers)
#define glFramebufferRenderbuffer GLEW_GET_FUN(__glewFramebufferRenderbuffer)
-#define glFramebufferTexturLayer GLEW_GET_FUN(__glewFramebufferTexturLayer)
#define glFramebufferTexture1D GLEW_GET_FUN(__glewFramebufferTexture1D)
#define glFramebufferTexture2D GLEW_GET_FUN(__glewFramebufferTexture2D)
#define glFramebufferTexture3D GLEW_GET_FUN(__glewFramebufferTexture3D)
+#define glFramebufferTextureLayer GLEW_GET_FUN(__glewFramebufferTextureLayer)
#define glGenFramebuffers GLEW_GET_FUN(__glewGenFramebuffers)
#define glGenRenderbuffers GLEW_GET_FUN(__glewGenRenderbuffers)
#define glGenerateMipmap GLEW_GET_FUN(__glewGenerateMipmap)
@@ -2791,6 +3297,31 @@ typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIARBPROC) (GLuint program, GLenu
#endif /* GL_ARB_geometry_shader4 */
+/* --------------------------- GL_ARB_gpu_shader5 -------------------------- */
+
+#ifndef GL_ARB_gpu_shader5
+#define GL_ARB_gpu_shader5 1
+
+#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F
+#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C
+#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D
+#define GL_MAX_VERTEX_STREAMS 0x8E71
+
+#define GLEW_ARB_gpu_shader5 GLEW_GET_VAR(__GLEW_ARB_gpu_shader5)
+
+#endif /* GL_ARB_gpu_shader5 */
+
+/* ------------------------- GL_ARB_gpu_shader_fp64 ------------------------ */
+
+#ifndef GL_ARB_gpu_shader_fp64
+#define GL_ARB_gpu_shader_fp64 1
+
+#define GLEW_ARB_gpu_shader_fp64 GLEW_GET_VAR(__GLEW_ARB_gpu_shader_fp64)
+
+#endif /* GL_ARB_gpu_shader_fp64 */
+
/* ------------------------ GL_ARB_half_float_pixel ------------------------ */
#ifndef GL_ARB_half_float_pixel
@@ -3206,6 +3737,17 @@ typedef GLboolean (GLAPIENTRY * PFNGLISQUERYARBPROC) (GLuint id);
#endif /* GL_ARB_occlusion_query */
+/* ------------------------ GL_ARB_occlusion_query2 ------------------------ */
+
+#ifndef GL_ARB_occlusion_query2
+#define GL_ARB_occlusion_query2 1
+
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+
+#define GLEW_ARB_occlusion_query2 GLEW_GET_VAR(__GLEW_ARB_occlusion_query2)
+
+#endif /* GL_ARB_occlusion_query2 */
+
/* ----------------------- GL_ARB_pixel_buffer_object ---------------------- */
#ifndef GL_ARB_pixel_buffer_object
@@ -3252,6 +3794,101 @@ typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, GLfloat*
#endif /* GL_ARB_point_sprite */
+/* ------------------------ GL_ARB_provoking_vertex ------------------------ */
+
+#ifndef GL_ARB_provoking_vertex
+#define GL_ARB_provoking_vertex 1
+
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
+#define GL_LAST_VERTEX_CONVENTION 0x8E4E
+#define GL_PROVOKING_VERTEX 0x8E4F
+
+typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXPROC) (GLenum mode);
+
+#define glProvokingVertex GLEW_GET_FUN(__glewProvokingVertex)
+
+#define GLEW_ARB_provoking_vertex GLEW_GET_VAR(__GLEW_ARB_provoking_vertex)
+
+#endif /* GL_ARB_provoking_vertex */
+
+/* ------------------------- GL_ARB_sample_shading ------------------------- */
+
+#ifndef GL_ARB_sample_shading
+#define GL_ARB_sample_shading 1
+
+#define GL_SAMPLE_SHADING_ARB 0x8C36
+#define GL_MIN_SAMPLE_SHADING_VALUE_ARB 0x8C37
+
+typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGARBPROC) (GLclampf value);
+
+#define glMinSampleShadingARB GLEW_GET_FUN(__glewMinSampleShadingARB)
+
+#define GLEW_ARB_sample_shading GLEW_GET_VAR(__GLEW_ARB_sample_shading)
+
+#endif /* GL_ARB_sample_shading */
+
+/* ------------------------- GL_ARB_sampler_objects ------------------------ */
+
+#ifndef GL_ARB_sampler_objects
+#define GL_ARB_sampler_objects 1
+
+#define GL_SAMPLER_BINDING 0x8919
+
+typedef void (GLAPIENTRY * PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler);
+typedef void (GLAPIENTRY * PFNGLDELETESAMPLERSPROC) (GLsizei count, const GLuint * samplers);
+typedef void (GLAPIENTRY * PFNGLGENSAMPLERSPROC) (GLsizei count, GLuint* samplers);
+typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, GLint* params);
+typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, GLuint* params);
+typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, GLfloat* params);
+typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, GLint* params);
+typedef GLboolean (GLAPIENTRY * PFNGLISSAMPLERPROC) (GLuint sampler);
+typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, const GLint* params);
+typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, const GLuint* params);
+typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFPROC) (GLuint sampler, GLenum pname, GLfloat param);
+typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, const GLfloat* params);
+typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIPROC) (GLuint sampler, GLenum pname, GLint param);
+typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, const GLint* params);
+
+#define glBindSampler GLEW_GET_FUN(__glewBindSampler)
+#define glDeleteSamplers GLEW_GET_FUN(__glewDeleteSamplers)
+#define glGenSamplers GLEW_GET_FUN(__glewGenSamplers)
+#define glGetSamplerParameterIiv GLEW_GET_FUN(__glewGetSamplerParameterIiv)
+#define glGetSamplerParameterIuiv GLEW_GET_FUN(__glewGetSamplerParameterIuiv)
+#define glGetSamplerParameterfv GLEW_GET_FUN(__glewGetSamplerParameterfv)
+#define glGetSamplerParameteriv GLEW_GET_FUN(__glewGetSamplerParameteriv)
+#define glIsSampler GLEW_GET_FUN(__glewIsSampler)
+#define glSamplerParameterIiv GLEW_GET_FUN(__glewSamplerParameterIiv)
+#define glSamplerParameterIuiv GLEW_GET_FUN(__glewSamplerParameterIuiv)
+#define glSamplerParameterf GLEW_GET_FUN(__glewSamplerParameterf)
+#define glSamplerParameterfv GLEW_GET_FUN(__glewSamplerParameterfv)
+#define glSamplerParameteri GLEW_GET_FUN(__glewSamplerParameteri)
+#define glSamplerParameteriv GLEW_GET_FUN(__glewSamplerParameteriv)
+
+#define GLEW_ARB_sampler_objects GLEW_GET_VAR(__GLEW_ARB_sampler_objects)
+
+#endif /* GL_ARB_sampler_objects */
+
+/* ------------------------ GL_ARB_seamless_cube_map ----------------------- */
+
+#ifndef GL_ARB_seamless_cube_map
+#define GL_ARB_seamless_cube_map 1
+
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+
+#define GLEW_ARB_seamless_cube_map GLEW_GET_VAR(__GLEW_ARB_seamless_cube_map)
+
+#endif /* GL_ARB_seamless_cube_map */
+
+/* ----------------------- GL_ARB_shader_bit_encoding ---------------------- */
+
+#ifndef GL_ARB_shader_bit_encoding
+#define GL_ARB_shader_bit_encoding 1
+
+#define GLEW_ARB_shader_bit_encoding GLEW_GET_VAR(__GLEW_ARB_shader_bit_encoding)
+
+#endif /* GL_ARB_shader_bit_encoding */
+
/* ------------------------- GL_ARB_shader_objects ------------------------- */
#ifndef GL_ARB_shader_objects
@@ -3379,6 +4016,52 @@ typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj)
#endif /* GL_ARB_shader_objects */
+/* ------------------------ GL_ARB_shader_subroutine ----------------------- */
+
+#ifndef GL_ARB_shader_subroutine
+#define GL_ARB_shader_subroutine 1
+
+#define GL_ACTIVE_SUBROUTINES 0x8DE5
+#define GL_ACTIVE_SUBROUTINE_UNIFORMS 0x8DE6
+#define GL_MAX_SUBROUTINES 0x8DE7
+#define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS 0x8DE8
+#define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS 0x8E47
+#define GL_ACTIVE_SUBROUTINE_MAX_LENGTH 0x8E48
+#define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH 0x8E49
+#define GL_NUM_COMPATIBLE_SUBROUTINES 0x8E4A
+#define GL_COMPATIBLE_SUBROUTINES 0x8E4B
+
+typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINENAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, char *name);
+typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, char *name);
+typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC) (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values);
+typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTAGEIVPROC) (GLuint program, GLenum shadertype, GLenum pname, GLint* values);
+typedef GLuint (GLAPIENTRY * PFNGLGETSUBROUTINEINDEXPROC) (GLuint program, GLenum shadertype, const char* name);
+typedef GLint (GLAPIENTRY * PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC) (GLuint program, GLenum shadertype, const char* name);
+typedef void (GLAPIENTRY * PFNGLGETUNIFORMSUBROUTINEUIVPROC) (GLenum shadertype, GLint location, GLuint* params);
+typedef void (GLAPIENTRY * PFNGLUNIFORMSUBROUTINESUIVPROC) (GLenum shadertype, GLsizei count, const GLuint* indices);
+
+#define glGetActiveSubroutineName GLEW_GET_FUN(__glewGetActiveSubroutineName)
+#define glGetActiveSubroutineUniformName GLEW_GET_FUN(__glewGetActiveSubroutineUniformName)
+#define glGetActiveSubroutineUniformiv GLEW_GET_FUN(__glewGetActiveSubroutineUniformiv)
+#define glGetProgramStageiv GLEW_GET_FUN(__glewGetProgramStageiv)
+#define glGetSubroutineIndex GLEW_GET_FUN(__glewGetSubroutineIndex)
+#define glGetSubroutineUniformLocation GLEW_GET_FUN(__glewGetSubroutineUniformLocation)
+#define glGetUniformSubroutineuiv GLEW_GET_FUN(__glewGetUniformSubroutineuiv)
+#define glUniformSubroutinesuiv GLEW_GET_FUN(__glewUniformSubroutinesuiv)
+
+#define GLEW_ARB_shader_subroutine GLEW_GET_VAR(__GLEW_ARB_shader_subroutine)
+
+#endif /* GL_ARB_shader_subroutine */
+
+/* ----------------------- GL_ARB_shader_texture_lod ----------------------- */
+
+#ifndef GL_ARB_shader_texture_lod
+#define GL_ARB_shader_texture_lod 1
+
+#define GLEW_ARB_shader_texture_lod GLEW_GET_VAR(__GLEW_ARB_shader_texture_lod)
+
+#endif /* GL_ARB_shader_texture_lod */
+
/* ---------------------- GL_ARB_shading_language_100 ---------------------- */
#ifndef GL_ARB_shading_language_100
@@ -3390,6 +4073,33 @@ typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj)
#endif /* GL_ARB_shading_language_100 */
+/* -------------------- GL_ARB_shading_language_include -------------------- */
+
+#ifndef GL_ARB_shading_language_include
+#define GL_ARB_shading_language_include 1
+
+#define GL_SHADER_INCLUDE_ARB 0x8DAE
+#define GL_NAMED_STRING_LENGTH_ARB 0x8DE9
+#define GL_NAMED_STRING_TYPE_ARB 0x8DEA
+
+typedef void (GLAPIENTRY * PFNGLCOMPILESHADERINCLUDEARBPROC) (GLuint shader, GLsizei count, const char ** path, const GLint *length);
+typedef void (GLAPIENTRY * PFNGLDELETENAMEDSTRINGARBPROC) (GLint namelen, const char* name);
+typedef void (GLAPIENTRY * PFNGLGETNAMEDSTRINGARBPROC) (GLint namelen, const char* name, GLsizei bufSize, GLint *stringlen, char *string);
+typedef void (GLAPIENTRY * PFNGLGETNAMEDSTRINGIVARBPROC) (GLint namelen, const char* name, GLenum pname, GLint *params);
+typedef GLboolean (GLAPIENTRY * PFNGLISNAMEDSTRINGARBPROC) (GLint namelen, const char* name);
+typedef void (GLAPIENTRY * PFNGLNAMEDSTRINGARBPROC) (GLenum type, GLint namelen, const char* name, GLint stringlen, const char *string);
+
+#define glCompileShaderIncludeARB GLEW_GET_FUN(__glewCompileShaderIncludeARB)
+#define glDeleteNamedStringARB GLEW_GET_FUN(__glewDeleteNamedStringARB)
+#define glGetNamedStringARB GLEW_GET_FUN(__glewGetNamedStringARB)
+#define glGetNamedStringivARB GLEW_GET_FUN(__glewGetNamedStringivARB)
+#define glIsNamedStringARB GLEW_GET_FUN(__glewIsNamedStringARB)
+#define glNamedStringARB GLEW_GET_FUN(__glewNamedStringARB)
+
+#define GLEW_ARB_shading_language_include GLEW_GET_VAR(__GLEW_ARB_shading_language_include)
+
+#endif /* GL_ARB_shading_language_include */
+
/* ----------------------------- GL_ARB_shadow ----------------------------- */
#ifndef GL_ARB_shadow
@@ -3414,6 +4124,95 @@ typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj)
#endif /* GL_ARB_shadow_ambient */
+/* ------------------------------ GL_ARB_sync ------------------------------ */
+
+#ifndef GL_ARB_sync
+#define GL_ARB_sync 1
+
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_OBJECT_TYPE 0x9112
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SYNC_STATUS 0x9114
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_UNSIGNALED 0x9118
+#define GL_SIGNALED 0x9119
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_WAIT_FAILED 0x911D
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF
+
+typedef GLenum (GLAPIENTRY * PFNGLCLIENTWAITSYNCPROC) (GLsync GLsync,GLbitfield flags,GLuint64 timeout);
+typedef void (GLAPIENTRY * PFNGLDELETESYNCPROC) (GLsync GLsync);
+typedef GLsync (GLAPIENTRY * PFNGLFENCESYNCPROC) (GLenum condition,GLbitfield flags);
+typedef void (GLAPIENTRY * PFNGLGETINTEGER64VPROC) (GLenum pname, GLint64* params);
+typedef void (GLAPIENTRY * PFNGLGETSYNCIVPROC) (GLsync GLsync,GLenum pname,GLsizei bufSize,GLsizei* length, GLint *values);
+typedef GLboolean (GLAPIENTRY * PFNGLISSYNCPROC) (GLsync GLsync);
+typedef void (GLAPIENTRY * PFNGLWAITSYNCPROC) (GLsync GLsync,GLbitfield flags,GLuint64 timeout);
+
+#define glClientWaitSync GLEW_GET_FUN(__glewClientWaitSync)
+#define glDeleteSync GLEW_GET_FUN(__glewDeleteSync)
+#define glFenceSync GLEW_GET_FUN(__glewFenceSync)
+#define glGetInteger64v GLEW_GET_FUN(__glewGetInteger64v)
+#define glGetSynciv GLEW_GET_FUN(__glewGetSynciv)
+#define glIsSync GLEW_GET_FUN(__glewIsSync)
+#define glWaitSync GLEW_GET_FUN(__glewWaitSync)
+
+#define GLEW_ARB_sync GLEW_GET_VAR(__GLEW_ARB_sync)
+
+#endif /* GL_ARB_sync */
+
+/* ----------------------- GL_ARB_tessellation_shader ---------------------- */
+
+#ifndef GL_ARB_tessellation_shader
+#define GL_ARB_tessellation_shader 1
+
+#define GL_PATCHES 0xE
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER 0x84F0
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER 0x84F1
+#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C
+#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D
+#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E
+#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F
+#define GL_PATCH_VERTICES 0x8E72
+#define GL_PATCH_DEFAULT_INNER_LEVEL 0x8E73
+#define GL_PATCH_DEFAULT_OUTER_LEVEL 0x8E74
+#define GL_TESS_CONTROL_OUTPUT_VERTICES 0x8E75
+#define GL_TESS_GEN_MODE 0x8E76
+#define GL_TESS_GEN_SPACING 0x8E77
+#define GL_TESS_GEN_VERTEX_ORDER 0x8E78
+#define GL_TESS_GEN_POINT_MODE 0x8E79
+#define GL_ISOLINES 0x8E7A
+#define GL_FRACTIONAL_ODD 0x8E7B
+#define GL_FRACTIONAL_EVEN 0x8E7C
+#define GL_MAX_PATCH_VERTICES 0x8E7D
+#define GL_MAX_TESS_GEN_LEVEL 0x8E7E
+#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F
+#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80
+#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
+#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
+#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83
+#define GL_MAX_TESS_PATCH_COMPONENTS 0x8E84
+#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85
+#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86
+#define GL_TESS_EVALUATION_SHADER 0x8E87
+#define GL_TESS_CONTROL_SHADER 0x8E88
+#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89
+#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A
+
+typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERFVPROC) (GLenum pname, const GLfloat* values);
+typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERIPROC) (GLenum pname, GLint value);
+
+#define glPatchParameterfv GLEW_GET_FUN(__glewPatchParameterfv)
+#define glPatchParameteri GLEW_GET_FUN(__glewPatchParameteri)
+
+#define GLEW_ARB_tessellation_shader GLEW_GET_VAR(__GLEW_ARB_tessellation_shader)
+
+#endif /* GL_ARB_tessellation_shader */
+
/* ---------------------- GL_ARB_texture_border_clamp ---------------------- */
#ifndef GL_ARB_texture_border_clamp
@@ -3444,6 +4243,15 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFERARBPROC) (GLenum target, GLenum interna
#endif /* GL_ARB_texture_buffer_object */
+/* ------------------- GL_ARB_texture_buffer_object_rgb32 ------------------ */
+
+#ifndef GL_ARB_texture_buffer_object_rgb32
+#define GL_ARB_texture_buffer_object_rgb32 1
+
+#define GLEW_ARB_texture_buffer_object_rgb32 GLEW_GET_VAR(__GLEW_ARB_texture_buffer_object_rgb32)
+
+#endif /* GL_ARB_texture_buffer_object_rgb32 */
+
/* ----------------------- GL_ARB_texture_compression ---------------------- */
#ifndef GL_ARB_texture_compression
@@ -3481,6 +4289,20 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#endif /* GL_ARB_texture_compression */
+/* -------------------- GL_ARB_texture_compression_bptc -------------------- */
+
+#ifndef GL_ARB_texture_compression_bptc
+#define GL_ARB_texture_compression_bptc 1
+
+#define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C
+#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D
+#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E
+#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F
+
+#define GLEW_ARB_texture_compression_bptc GLEW_GET_VAR(__GLEW_ARB_texture_compression_bptc)
+
+#endif /* GL_ARB_texture_compression_bptc */
+
/* -------------------- GL_ARB_texture_compression_rgtc -------------------- */
#ifndef GL_ARB_texture_compression_rgtc
@@ -3517,6 +4339,23 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#endif /* GL_ARB_texture_cube_map */
+/* --------------------- GL_ARB_texture_cube_map_array --------------------- */
+
+#ifndef GL_ARB_texture_cube_map_array
+#define GL_ARB_texture_cube_map_array 1
+
+#define GL_TEXTURE_CUBE_MAP_ARRAY_ARB 0x9009
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB 0x900A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB 0x900B
+#define GL_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900C
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB 0x900D
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900E
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900F
+
+#define GLEW_ARB_texture_cube_map_array GLEW_GET_VAR(__GLEW_ARB_texture_cube_map_array)
+
+#endif /* GL_ARB_texture_cube_map_array */
+
/* ------------------------- GL_ARB_texture_env_add ------------------------ */
#ifndef GL_ARB_texture_env_add
@@ -3609,6 +4448,19 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#endif /* GL_ARB_texture_float */
+/* ------------------------- GL_ARB_texture_gather ------------------------- */
+
+#ifndef GL_ARB_texture_gather
+#define GL_ARB_texture_gather 1
+
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5E
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5F
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB 0x8F9F
+
+#define GLEW_ARB_texture_gather GLEW_GET_VAR(__GLEW_ARB_texture_gather)
+
+#endif /* GL_ARB_texture_gather */
+
/* --------------------- GL_ARB_texture_mirrored_repeat -------------------- */
#ifndef GL_ARB_texture_mirrored_repeat
@@ -3620,6 +4472,47 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#endif /* GL_ARB_texture_mirrored_repeat */
+/* ----------------------- GL_ARB_texture_multisample ---------------------- */
+
+#ifndef GL_ARB_texture_multisample
+#define GL_ARB_texture_multisample 1
+
+#define GL_SAMPLE_POSITION 0x8E50
+#define GL_SAMPLE_MASK 0x8E51
+#define GL_SAMPLE_MASK_VALUE 0x8E52
+#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TEXTURE_SAMPLES 0x9106
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
+#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
+#define GL_MAX_INTEGER_SAMPLES 0x9110
+
+typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVPROC) (GLenum pname, GLuint index, GLfloat* val);
+typedef void (GLAPIENTRY * PFNGLSAMPLEMASKIPROC) (GLuint index, GLbitfield mask);
+typedef void (GLAPIENTRY * PFNGLTEXIMAGE2DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+
+#define glGetMultisamplefv GLEW_GET_FUN(__glewGetMultisamplefv)
+#define glSampleMaski GLEW_GET_FUN(__glewSampleMaski)
+#define glTexImage2DMultisample GLEW_GET_FUN(__glewTexImage2DMultisample)
+#define glTexImage3DMultisample GLEW_GET_FUN(__glewTexImage3DMultisample)
+
+#define GLEW_ARB_texture_multisample GLEW_GET_VAR(__GLEW_ARB_texture_multisample)
+
+#endif /* GL_ARB_texture_multisample */
+
/* -------------------- GL_ARB_texture_non_power_of_two -------------------- */
#ifndef GL_ARB_texture_non_power_of_two
@@ -3629,6 +4522,15 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#endif /* GL_ARB_texture_non_power_of_two */
+/* ------------------------ GL_ARB_texture_query_lod ----------------------- */
+
+#ifndef GL_ARB_texture_query_lod
+#define GL_ARB_texture_query_lod 1
+
+#define GLEW_ARB_texture_query_lod GLEW_GET_VAR(__GLEW_ARB_texture_query_lod)
+
+#endif /* GL_ARB_texture_query_lod */
+
/* ------------------------ GL_ARB_texture_rectangle ----------------------- */
#ifndef GL_ARB_texture_rectangle
@@ -3651,6 +4553,8 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#define GL_ARB_texture_rg 1
#define GL_RED 0x1903
+#define GL_COMPRESSED_RED 0x8225
+#define GL_COMPRESSED_RG 0x8226
#define GL_RG 0x8227
#define GL_RG_INTEGER 0x8228
#define GL_R8 0x8229
@@ -3678,6 +4582,104 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL
#endif /* GL_ARB_texture_rg */
+/* ----------------------- GL_ARB_texture_rgb10_a2ui ----------------------- */
+
+#ifndef GL_ARB_texture_rgb10_a2ui
+#define GL_ARB_texture_rgb10_a2ui 1
+
+#define GL_RGB10_A2UI 0x906F
+
+#define GLEW_ARB_texture_rgb10_a2ui GLEW_GET_VAR(__GLEW_ARB_texture_rgb10_a2ui)
+
+#endif /* GL_ARB_texture_rgb10_a2ui */
+
+/* ------------------------- GL_ARB_texture_swizzle ------------------------ */
+
+#ifndef GL_ARB_texture_swizzle
+#define GL_ARB_texture_swizzle 1
+
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+
+#define GLEW_ARB_texture_swizzle GLEW_GET_VAR(__GLEW_ARB_texture_swizzle)
+
+#endif /* GL_ARB_texture_swizzle */
+
+/* --------------------------- GL_ARB_timer_query -------------------------- */
+
+#ifndef GL_ARB_timer_query
+#define GL_ARB_timer_query 1
+
+#define GL_TIME_ELAPSED 0x88BF
+#define GL_TIMESTAMP 0x8E28
+
+typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VPROC) (GLuint id, GLenum pname, GLint64* params);
+typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VPROC) (GLuint id, GLenum pname, GLuint64* params);
+typedef void (GLAPIENTRY * PFNGLQUERYCOUNTERPROC) (GLuint id, GLenum target);
+
+#define glGetQueryObjecti64v GLEW_GET_FUN(__glewGetQueryObjecti64v)
+#define glGetQueryObjectui64v GLEW_GET_FUN(__glewGetQueryObjectui64v)
+#define glQueryCounter GLEW_GET_FUN(__glewQueryCounter)
+
+#define GLEW_ARB_timer_query GLEW_GET_VAR(__GLEW_ARB_timer_query)
+
+#endif /* GL_ARB_timer_query */
+
+/* ----------------------- GL_ARB_transform_feedback2 ---------------------- */
+
+#ifndef GL_ARB_transform_feedback2
+#define GL_ARB_transform_feedback2 1
+
+#define GL_TRANSFORM_FEEDBACK 0x8E22
+#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23
+#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
+
+typedef void (GLAPIENTRY * PFNGLBINDTRANSFORMFEEDBACKPROC) (GLenum target, GLuint id);
+typedef void (GLAPIENTRY * PFNGLDELETETRANSFORMFEEDBACKSPROC) (GLsizei n, const GLuint* ids);
+typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKPROC) (GLenum mode, GLuint id);
+typedef void (GLAPIENTRY * PFNGLGENTRANSFORMFEEDBACKSPROC) (GLsizei n, GLuint* ids);
+typedef GLboolean (GLAPIENTRY * PFNGLISTRANSFORMFEEDBACKPROC) (GLuint id);
+typedef void (GLAPIENTRY * PFNGLPAUSETRANSFORMFEEDBACKPROC) (void);
+typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKPROC) (void);
+
+#define glBindTransformFeedback GLEW_GET_FUN(__glewBindTransformFeedback)
+#define glDeleteTransformFeedbacks GLEW_GET_FUN(__glewDeleteTransformFeedbacks)
+#define glDrawTransformFeedback GLEW_GET_FUN(__glewDrawTransformFeedback)
+#define glGenTransformFeedbacks GLEW_GET_FUN(__glewGenTransformFeedbacks)
+#define glIsTransformFeedback GLEW_GET_FUN(__glewIsTransformFeedback)
+#define glPauseTransformFeedback GLEW_GET_FUN(__glewPauseTransformFeedback)
+#define glResumeTransformFeedback GLEW_GET_FUN(__glewResumeTransformFeedback)
+
+#define GLEW_ARB_transform_feedback2 GLEW_GET_VAR(__GLEW_ARB_transform_feedback2)
+
+#endif /* GL_ARB_transform_feedback2 */
+
+/* ----------------------- GL_ARB_transform_feedback3 ---------------------- */
+
+#ifndef GL_ARB_transform_feedback3
+#define GL_ARB_transform_feedback3 1
+
+#define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS 0x8E70
+#define GL_MAX_VERTEX_STREAMS 0x8E71
+
+typedef void (GLAPIENTRY * PFNGLBEGINQUERYINDEXEDPROC) (GLenum target, GLuint index, GLuint id);
+typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC) (GLenum mode, GLuint id, GLuint stream);
+typedef void (GLAPIENTRY * PFNGLENDQUERYINDEXEDPROC) (GLenum target, GLuint index);
+typedef void (GLAPIENTRY * PFNGLGETQUERYINDEXEDIVPROC) (GLenum target, GLuint index, GLenum pname, GLint* params);
+
+#define glBeginQueryIndexed GLEW_GET_FUN(__glewBeginQueryIndexed)
+#define glDrawTransformFeedbackStream GLEW_GET_FUN(__glewDrawTransformFeedbackStream)
+#define glEndQueryIndexed GLEW_GET_FUN(__glewEndQueryIndexed)
+#define glGetQueryIndexediv GLEW_GET_FUN(__glewGetQueryIndexediv)
+
+#define GLEW_ARB_transform_feedback3 GLEW_GET_VAR(__GLEW_ARB_transform_feedback3)
+
+#endif /* GL_ARB_transform_feedback3 */
+
/* ------------------------ GL_ARB_transpose_matrix ------------------------ */
#ifndef GL_ARB_transpose_matrix
@@ -3702,6 +4704,82 @@ typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]);
#endif /* GL_ARB_transpose_matrix */
+/* ---------------------- GL_ARB_uniform_buffer_object --------------------- */
+
+#ifndef GL_ARB_uniform_buffer_object
+#define GL_ARB_uniform_buffer_object 1
+
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX 0xFFFFFFFF
+
+typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer);
+typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, char* uniformBlockName);
+typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMBLOCKIVPROC) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
+typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMNAMEPROC) (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, char* uniformName);
+typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMSIVPROC) (GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params);
+typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint* data);
+typedef GLuint (GLAPIENTRY * PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const char* uniformBlockName);
+typedef void (GLAPIENTRY * PFNGLGETUNIFORMINDICESPROC) (GLuint program, GLsizei uniformCount, const char** uniformNames, GLuint* uniformIndices);
+typedef void (GLAPIENTRY * PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+
+#define glBindBufferBase GLEW_GET_FUN(__glewBindBufferBase)
+#define glBindBufferRange GLEW_GET_FUN(__glewBindBufferRange)
+#define glGetActiveUniformBlockName GLEW_GET_FUN(__glewGetActiveUniformBlockName)
+#define glGetActiveUniformBlockiv GLEW_GET_FUN(__glewGetActiveUniformBlockiv)
+#define glGetActiveUniformName GLEW_GET_FUN(__glewGetActiveUniformName)
+#define glGetActiveUniformsiv GLEW_GET_FUN(__glewGetActiveUniformsiv)
+#define glGetIntegeri_v GLEW_GET_FUN(__glewGetIntegeri_v)
+#define glGetUniformBlockIndex GLEW_GET_FUN(__glewGetUniformBlockIndex)
+#define glGetUniformIndices GLEW_GET_FUN(__glewGetUniformIndices)
+#define glUniformBlockBinding GLEW_GET_FUN(__glewUniformBlockBinding)
+
+#define GLEW_ARB_uniform_buffer_object GLEW_GET_VAR(__GLEW_ARB_uniform_buffer_object)
+
+#endif /* GL_ARB_uniform_buffer_object */
+
+/* ------------------------ GL_ARB_vertex_array_bgra ----------------------- */
+
+#ifndef GL_ARB_vertex_array_bgra
+#define GL_ARB_vertex_array_bgra 1
+
+#define GL_BGRA 0x80E1
+
+#define GLEW_ARB_vertex_array_bgra GLEW_GET_VAR(__GLEW_ARB_vertex_array_bgra)
+
+#endif /* GL_ARB_vertex_array_bgra */
+
/* ----------------------- GL_ARB_vertex_array_object ---------------------- */
#ifndef GL_ARB_vertex_array_object
@@ -4105,6 +5183,96 @@ typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programO
#endif /* GL_ARB_vertex_shader */
+/* ------------------- GL_ARB_vertex_type_2_10_10_10_rev ------------------- */
+
+#ifndef GL_ARB_vertex_type_2_10_10_10_rev
+#define GL_ARB_vertex_type_2_10_10_10_rev 1
+
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_INT_2_10_10_10_REV 0x8D9F
+
+typedef void (GLAPIENTRY * PFNGLCOLORP3UIPROC) (GLenum type, GLuint color);
+typedef void (GLAPIENTRY * PFNGLCOLORP3UIVPROC) (GLenum type, const GLuint* color);
+typedef void (GLAPIENTRY * PFNGLCOLORP4UIPROC) (GLenum type, GLuint color);
+typedef void (GLAPIENTRY * PFNGLCOLORP4UIVPROC) (GLenum type, const GLuint* color);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP1UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP1UIVPROC) (GLenum texture, GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP2UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP2UIVPROC) (GLenum texture, GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP3UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP3UIVPROC) (GLenum texture, GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP4UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP4UIVPROC) (GLenum texture, GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLNORMALP3UIPROC) (GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLNORMALP3UIVPROC) (GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORP3UIPROC) (GLenum type, GLuint color);
+typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORP3UIVPROC) (GLenum type, const GLuint* color);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP1UIPROC) (GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP1UIVPROC) (GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP2UIPROC) (GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP2UIVPROC) (GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP3UIPROC) (GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP3UIVPROC) (GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP4UIPROC) (GLenum type, GLuint coords);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDP4UIVPROC) (GLenum type, const GLuint* coords);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP1UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP1UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP2UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP2UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP3UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP3UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP4UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP4UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value);
+typedef void (GLAPIENTRY * PFNGLVERTEXP2UIPROC) (GLenum type, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXP2UIVPROC) (GLenum type, const GLuint* value);
+typedef void (GLAPIENTRY * PFNGLVERTEXP3UIPROC) (GLenum type, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXP3UIVPROC) (GLenum type, const GLuint* value);
+typedef void (GLAPIENTRY * PFNGLVERTEXP4UIPROC) (GLenum type, GLuint value);
+typedef void (GLAPIENTRY * PFNGLVERTEXP4UIVPROC) (GLenum type, const GLuint* value);
+
+#define glColorP3ui GLEW_GET_FUN(__glewColorP3ui)
+#define glColorP3uiv GLEW_GET_FUN(__glewColorP3uiv)
+#define glColorP4ui GLEW_GET_FUN(__glewColorP4ui)
+#define glColorP4uiv GLEW_GET_FUN(__glewColorP4uiv)
+#define glMultiTexCoordP1ui GLEW_GET_FUN(__glewMultiTexCoordP1ui)
+#define glMultiTexCoordP1uiv GLEW_GET_FUN(__glewMultiTexCoordP1uiv)
+#define glMultiTexCoordP2ui GLEW_GET_FUN(__glewMultiTexCoordP2ui)
+#define glMultiTexCoordP2uiv GLEW_GET_FUN(__glewMultiTexCoordP2uiv)
+#define glMultiTexCoordP3ui GLEW_GET_FUN(__glewMultiTexCoordP3ui)
+#define glMultiTexCoordP3uiv GLEW_GET_FUN(__glewMultiTexCoordP3uiv)
+#define glMultiTexCoordP4ui GLEW_GET_FUN(__glewMultiTexCoordP4ui)
+#define glMultiTexCoordP4uiv GLEW_GET_FUN(__glewMultiTexCoordP4uiv)
+#define glNormalP3ui GLEW_GET_FUN(__glewNormalP3ui)
+#define glNormalP3uiv GLEW_GET_FUN(__glewNormalP3uiv)
+#define glSecondaryColorP3ui GLEW_GET_FUN(__glewSecondaryColorP3ui)
+#define glSecondaryColorP3uiv GLEW_GET_FUN(__glewSecondaryColorP3uiv)
+#define glTexCoordP1ui GLEW_GET_FUN(__glewTexCoordP1ui)
+#define glTexCoordP1uiv GLEW_GET_FUN(__glewTexCoordP1uiv)
+#define glTexCoordP2ui GLEW_GET_FUN(__glewTexCoordP2ui)
+#define glTexCoordP2uiv GLEW_GET_FUN(__glewTexCoordP2uiv)
+#define glTexCoordP3ui GLEW_GET_FUN(__glewTexCoordP3ui)
+#define glTexCoordP3uiv GLEW_GET_FUN(__glewTexCoordP3uiv)
+#define glTexCoordP4ui GLEW_GET_FUN(__glewTexCoordP4ui)
+#define glTexCoordP4uiv GLEW_GET_FUN(__glewTexCoordP4uiv)
+#define glVertexAttribP1ui GLEW_GET_FUN(__glewVertexAttribP1ui)
+#define glVertexAttribP1uiv GLEW_GET_FUN(__glewVertexAttribP1uiv)
+#define glVertexAttribP2ui GLEW_GET_FUN(__glewVertexAttribP2ui)
+#define glVertexAttribP2uiv GLEW_GET_FUN(__glewVertexAttribP2uiv)
+#define glVertexAttribP3ui GLEW_GET_FUN(__glewVertexAttribP3ui)
+#define glVertexAttribP3uiv GLEW_GET_FUN(__glewVertexAttribP3uiv)
+#define glVertexAttribP4ui GLEW_GET_FUN(__glewVertexAttribP4ui)
+#define glVertexAttribP4uiv GLEW_GET_FUN(__glewVertexAttribP4uiv)
+#define glVertexP2ui GLEW_GET_FUN(__glewVertexP2ui)
+#define glVertexP2uiv GLEW_GET_FUN(__glewVertexP2uiv)
+#define glVertexP3ui GLEW_GET_FUN(__glewVertexP3ui)
+#define glVertexP3uiv GLEW_GET_FUN(__glewVertexP3uiv)
+#define glVertexP4ui GLEW_GET_FUN(__glewVertexP4ui)
+#define glVertexP4uiv GLEW_GET_FUN(__glewVertexP4uiv)
+
+#define GLEW_ARB_vertex_type_2_10_10_10_rev GLEW_GET_VAR(__GLEW_ARB_vertex_type_2_10_10_10_rev)
+
+#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
+
/* --------------------------- GL_ARB_window_pos --------------------------- */
#ifndef GL_ARB_window_pos
@@ -4390,6 +5558,19 @@ typedef void (GLAPIENTRY * PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer);
#endif /* GL_ATI_map_object_buffer */
+/* ----------------------------- GL_ATI_meminfo ---------------------------- */
+
+#ifndef GL_ATI_meminfo
+#define GL_ATI_meminfo 1
+
+#define GL_VBO_FREE_MEMORY_ATI 0x87FB
+#define GL_TEXTURE_FREE_MEMORY_ATI 0x87FC
+#define GL_RENDERBUFFER_FREE_MEMORY_ATI 0x87FD
+
+#define GLEW_ATI_meminfo GLEW_GET_VAR(__GLEW_ATI_meminfo)
+
+#endif /* GL_ATI_meminfo */
+
/* -------------------------- GL_ATI_pn_triangles -------------------------- */
#ifndef GL_ATI_pn_triangles
@@ -5007,6 +6188,10 @@ typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint
#ifndef GL_EXT_cull_vertex
#define GL_EXT_cull_vertex 1
+#define GL_CULL_VERTEX_EXT 0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT 0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC
+
typedef void (GLAPIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble* params);
typedef void (GLAPIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat* params);
@@ -5068,7 +6253,14 @@ typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, G
typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index);
+typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEIEXTPROC) (GLenum array, GLuint index);
+typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC) (GLuint vaobj, GLuint index);
+typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYEXTPROC) (GLuint vaobj, GLenum array);
typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index);
+typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEIEXTPROC) (GLenum array, GLuint index);
+typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYATTRIBEXTPROC) (GLuint vaobj, GLuint index);
+typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYEXTPROC) (GLuint vaobj, GLenum array);
+typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) (GLuint framebuffer, GLenum mode);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) (GLuint framebuffer, GLsizei n, const GLenum* bufs);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERREADBUFFEREXTPROC) (GLuint framebuffer, GLenum mode);
@@ -5076,8 +6268,10 @@ typedef void (GLAPIENTRY * PFNGLGENERATEMULTITEXMIPMAPEXTPROC) (GLenum texunit,
typedef void (GLAPIENTRY * PFNGLGENERATETEXTUREMIPMAPEXTPROC) (GLuint texture, GLenum target);
typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, void* img);
typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, void* img);
-typedef void (GLAPIENTRY * PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum pname, GLuint index, GLdouble* params);
-typedef void (GLAPIENTRY * PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum pname, GLuint index, GLfloat* params);
+typedef void (GLAPIENTRY * PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum target, GLuint index, GLdouble* params);
+typedef void (GLAPIENTRY * PFNGLGETDOUBLEI_VEXTPROC) (GLenum pname, GLuint index, GLdouble* params);
+typedef void (GLAPIENTRY * PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum target, GLuint index, GLfloat* params);
+typedef void (GLAPIENTRY * PFNGLGETFLOATI_VEXTPROC) (GLenum pname, GLuint index, GLfloat* params);
typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint* param);
typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params);
typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params);
@@ -5102,7 +6296,8 @@ typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) (GLuint
typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum pname, void* string);
typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMIVEXTPROC) (GLuint program, GLenum target, GLenum pname, GLint* params);
typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) (GLuint renderbuffer, GLenum pname, GLint* params);
-typedef void (GLAPIENTRY * PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum pname, GLuint index, GLvoid** params);
+typedef void (GLAPIENTRY * PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum target, GLuint index, GLvoid** params);
+typedef void (GLAPIENTRY * PFNGLGETPOINTERI_VEXTPROC) (GLenum pname, GLuint index, GLvoid** params);
typedef void (GLAPIENTRY * PFNGLGETTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void* pixels);
typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params);
typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params);
@@ -5110,7 +6305,12 @@ typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIIVEXTPROC) (GLuint texture,
typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint* params);
typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat* params);
typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params);
+typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint* param);
+typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINTEGERVEXTPROC) (GLuint vaobj, GLenum pname, GLint* param);
+typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLvoid** param);
+typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYPOINTERVEXTPROC) (GLuint vaobj, GLenum pname, GLvoid** param);
typedef GLvoid * (GLAPIENTRY * PFNGLMAPNAMEDBUFFEREXTPROC) (GLuint buffer, GLenum access);
+typedef GLvoid * (GLAPIENTRY * PFNGLMAPNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
typedef void (GLAPIENTRY * PFNGLMATRIXFRUSTUMEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f);
typedef void (GLAPIENTRY * PFNGLMATRIXLOADIDENTITYEXTPROC) (GLenum matrixMode);
typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m);
@@ -5157,6 +6357,7 @@ typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLen
typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels);
typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLsizeiptr size, const void* data, GLenum usage);
typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data);
+typedef void (GLAPIENTRY * PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
@@ -5228,6 +6429,17 @@ typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenu
typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels);
typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels);
typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYCOLOROFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYINDEXOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYNORMALOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
#define glBindMultiTextureEXT GLEW_GET_FUN(__glewBindMultiTextureEXT)
#define glCheckNamedFramebufferStatusEXT GLEW_GET_FUN(__glewCheckNamedFramebufferStatusEXT)
@@ -5255,7 +6467,14 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
#define glCopyTextureSubImage2DEXT GLEW_GET_FUN(__glewCopyTextureSubImage2DEXT)
#define glCopyTextureSubImage3DEXT GLEW_GET_FUN(__glewCopyTextureSubImage3DEXT)
#define glDisableClientStateIndexedEXT GLEW_GET_FUN(__glewDisableClientStateIndexedEXT)
+#define glDisableClientStateiEXT GLEW_GET_FUN(__glewDisableClientStateiEXT)
+#define glDisableVertexArrayAttribEXT GLEW_GET_FUN(__glewDisableVertexArrayAttribEXT)
+#define glDisableVertexArrayEXT GLEW_GET_FUN(__glewDisableVertexArrayEXT)
#define glEnableClientStateIndexedEXT GLEW_GET_FUN(__glewEnableClientStateIndexedEXT)
+#define glEnableClientStateiEXT GLEW_GET_FUN(__glewEnableClientStateiEXT)
+#define glEnableVertexArrayAttribEXT GLEW_GET_FUN(__glewEnableVertexArrayAttribEXT)
+#define glEnableVertexArrayEXT GLEW_GET_FUN(__glewEnableVertexArrayEXT)
+#define glFlushMappedNamedBufferRangeEXT GLEW_GET_FUN(__glewFlushMappedNamedBufferRangeEXT)
#define glFramebufferDrawBufferEXT GLEW_GET_FUN(__glewFramebufferDrawBufferEXT)
#define glFramebufferDrawBuffersEXT GLEW_GET_FUN(__glewFramebufferDrawBuffersEXT)
#define glFramebufferReadBufferEXT GLEW_GET_FUN(__glewFramebufferReadBufferEXT)
@@ -5264,7 +6483,9 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
#define glGetCompressedMultiTexImageEXT GLEW_GET_FUN(__glewGetCompressedMultiTexImageEXT)
#define glGetCompressedTextureImageEXT GLEW_GET_FUN(__glewGetCompressedTextureImageEXT)
#define glGetDoubleIndexedvEXT GLEW_GET_FUN(__glewGetDoubleIndexedvEXT)
+#define glGetDoublei_vEXT GLEW_GET_FUN(__glewGetDoublei_vEXT)
#define glGetFloatIndexedvEXT GLEW_GET_FUN(__glewGetFloatIndexedvEXT)
+#define glGetFloati_vEXT GLEW_GET_FUN(__glewGetFloati_vEXT)
#define glGetFramebufferParameterivEXT GLEW_GET_FUN(__glewGetFramebufferParameterivEXT)
#define glGetMultiTexEnvfvEXT GLEW_GET_FUN(__glewGetMultiTexEnvfvEXT)
#define glGetMultiTexEnvivEXT GLEW_GET_FUN(__glewGetMultiTexEnvivEXT)
@@ -5290,6 +6511,7 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
#define glGetNamedProgramivEXT GLEW_GET_FUN(__glewGetNamedProgramivEXT)
#define glGetNamedRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetNamedRenderbufferParameterivEXT)
#define glGetPointerIndexedvEXT GLEW_GET_FUN(__glewGetPointerIndexedvEXT)
+#define glGetPointeri_vEXT GLEW_GET_FUN(__glewGetPointeri_vEXT)
#define glGetTextureImageEXT GLEW_GET_FUN(__glewGetTextureImageEXT)
#define glGetTextureLevelParameterfvEXT GLEW_GET_FUN(__glewGetTextureLevelParameterfvEXT)
#define glGetTextureLevelParameterivEXT GLEW_GET_FUN(__glewGetTextureLevelParameterivEXT)
@@ -5297,7 +6519,12 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
#define glGetTextureParameterIuivEXT GLEW_GET_FUN(__glewGetTextureParameterIuivEXT)
#define glGetTextureParameterfvEXT GLEW_GET_FUN(__glewGetTextureParameterfvEXT)
#define glGetTextureParameterivEXT GLEW_GET_FUN(__glewGetTextureParameterivEXT)
+#define glGetVertexArrayIntegeri_vEXT GLEW_GET_FUN(__glewGetVertexArrayIntegeri_vEXT)
+#define glGetVertexArrayIntegervEXT GLEW_GET_FUN(__glewGetVertexArrayIntegervEXT)
+#define glGetVertexArrayPointeri_vEXT GLEW_GET_FUN(__glewGetVertexArrayPointeri_vEXT)
+#define glGetVertexArrayPointervEXT GLEW_GET_FUN(__glewGetVertexArrayPointervEXT)
#define glMapNamedBufferEXT GLEW_GET_FUN(__glewMapNamedBufferEXT)
+#define glMapNamedBufferRangeEXT GLEW_GET_FUN(__glewMapNamedBufferRangeEXT)
#define glMatrixFrustumEXT GLEW_GET_FUN(__glewMatrixFrustumEXT)
#define glMatrixLoadIdentityEXT GLEW_GET_FUN(__glewMatrixLoadIdentityEXT)
#define glMatrixLoadTransposedEXT GLEW_GET_FUN(__glewMatrixLoadTransposedEXT)
@@ -5344,6 +6571,7 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
#define glMultiTexSubImage3DEXT GLEW_GET_FUN(__glewMultiTexSubImage3DEXT)
#define glNamedBufferDataEXT GLEW_GET_FUN(__glewNamedBufferDataEXT)
#define glNamedBufferSubDataEXT GLEW_GET_FUN(__glewNamedBufferSubDataEXT)
+#define glNamedCopyBufferSubDataEXT GLEW_GET_FUN(__glewNamedCopyBufferSubDataEXT)
#define glNamedFramebufferRenderbufferEXT GLEW_GET_FUN(__glewNamedFramebufferRenderbufferEXT)
#define glNamedFramebufferTexture1DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture1DEXT)
#define glNamedFramebufferTexture2DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture2DEXT)
@@ -5415,6 +6643,17 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
#define glTextureSubImage2DEXT GLEW_GET_FUN(__glewTextureSubImage2DEXT)
#define glTextureSubImage3DEXT GLEW_GET_FUN(__glewTextureSubImage3DEXT)
#define glUnmapNamedBufferEXT GLEW_GET_FUN(__glewUnmapNamedBufferEXT)
+#define glVertexArrayColorOffsetEXT GLEW_GET_FUN(__glewVertexArrayColorOffsetEXT)
+#define glVertexArrayEdgeFlagOffsetEXT GLEW_GET_FUN(__glewVertexArrayEdgeFlagOffsetEXT)
+#define glVertexArrayFogCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayFogCoordOffsetEXT)
+#define glVertexArrayIndexOffsetEXT GLEW_GET_FUN(__glewVertexArrayIndexOffsetEXT)
+#define glVertexArrayMultiTexCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayMultiTexCoordOffsetEXT)
+#define glVertexArrayNormalOffsetEXT GLEW_GET_FUN(__glewVertexArrayNormalOffsetEXT)
+#define glVertexArraySecondaryColorOffsetEXT GLEW_GET_FUN(__glewVertexArraySecondaryColorOffsetEXT)
+#define glVertexArrayTexCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayTexCoordOffsetEXT)
+#define glVertexArrayVertexAttribIOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribIOffsetEXT)
+#define glVertexArrayVertexAttribOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribOffsetEXT)
+#define glVertexArrayVertexOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexOffsetEXT)
#define GLEW_EXT_direct_state_access GLEW_GET_VAR(__GLEW_EXT_direct_state_access)
@@ -6223,6 +7462,24 @@ typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat b
#endif /* GL_EXT_polygon_offset */
+/* ------------------------ GL_EXT_provoking_vertex ------------------------ */
+
+#ifndef GL_EXT_provoking_vertex
+#define GL_EXT_provoking_vertex 1
+
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT 0x8E4C
+#define GL_FIRST_VERTEX_CONVENTION_EXT 0x8E4D
+#define GL_LAST_VERTEX_CONVENTION_EXT 0x8E4E
+#define GL_PROVOKING_VERTEX_EXT 0x8E4F
+
+typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXEXTPROC) (GLenum mode);
+
+#define glProvokingVertexEXT GLEW_GET_FUN(__glewProvokingVertexEXT)
+
+#define GLEW_EXT_provoking_vertex GLEW_GET_VAR(__GLEW_EXT_provoking_vertex)
+
+#endif /* GL_EXT_provoking_vertex */
+
/* ------------------------- GL_EXT_rescale_normal ------------------------- */
#ifndef GL_EXT_rescale_normal
@@ -6302,6 +7559,25 @@ typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenu
#endif /* GL_EXT_secondary_color */
+/* --------------------- GL_EXT_separate_shader_objects -------------------- */
+
+#ifndef GL_EXT_separate_shader_objects
+#define GL_EXT_separate_shader_objects 1
+
+#define GL_ACTIVE_PROGRAM_EXT 0x8B8D
+
+typedef void (GLAPIENTRY * PFNGLACTIVEPROGRAMEXTPROC) (GLuint program);
+typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROGRAMEXTPROC) (GLenum type, const char* string);
+typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint program);
+
+#define glActiveProgramEXT GLEW_GET_FUN(__glewActiveProgramEXT)
+#define glCreateShaderProgramEXT GLEW_GET_FUN(__glewCreateShaderProgramEXT)
+#define glUseShaderProgramEXT GLEW_GET_FUN(__glewUseShaderProgramEXT)
+
+#define GLEW_EXT_separate_shader_objects GLEW_GET_VAR(__GLEW_EXT_separate_shader_objects)
+
+#endif /* GL_EXT_separate_shader_objects */
+
/* --------------------- GL_EXT_separate_specular_color -------------------- */
#ifndef GL_EXT_separate_specular_color
@@ -6315,6 +7591,77 @@ typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenu
#endif /* GL_EXT_separate_specular_color */
+/* --------------------- GL_EXT_shader_image_load_store -------------------- */
+
+#ifndef GL_EXT_shader_image_load_store
+#define GL_EXT_shader_image_load_store 1
+
+#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT 0x00000001
+#define GL_ELEMENT_ARRAY_BARRIER_BIT_EXT 0x00000002
+#define GL_UNIFORM_BARRIER_BIT_EXT 0x00000004
+#define GL_TEXTURE_FETCH_BARRIER_BIT_EXT 0x00000008
+#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT 0x00000020
+#define GL_COMMAND_BARRIER_BIT_EXT 0x00000040
+#define GL_PIXEL_BUFFER_BARRIER_BIT_EXT 0x00000080
+#define GL_TEXTURE_UPDATE_BARRIER_BIT_EXT 0x00000100
+#define GL_BUFFER_UPDATE_BARRIER_BIT_EXT 0x00000200
+#define GL_FRAMEBUFFER_BARRIER_BIT_EXT 0x00000400
+#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT 0x00000800
+#define GL_ATOMIC_COUNTER_BARRIER_BIT_EXT 0x00001000
+#define GL_MAX_IMAGE_UNITS_EXT 0x8F38
+#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT 0x8F39
+#define GL_IMAGE_BINDING_NAME_EXT 0x8F3A
+#define GL_IMAGE_BINDING_LEVEL_EXT 0x8F3B
+#define GL_IMAGE_BINDING_LAYERED_EXT 0x8F3C
+#define GL_IMAGE_BINDING_LAYER_EXT 0x8F3D
+#define GL_IMAGE_BINDING_ACCESS_EXT 0x8F3E
+#define GL_IMAGE_1D_EXT 0x904C
+#define GL_IMAGE_2D_EXT 0x904D
+#define GL_IMAGE_3D_EXT 0x904E
+#define GL_IMAGE_2D_RECT_EXT 0x904F
+#define GL_IMAGE_CUBE_EXT 0x9050
+#define GL_IMAGE_BUFFER_EXT 0x9051
+#define GL_IMAGE_1D_ARRAY_EXT 0x9052
+#define GL_IMAGE_2D_ARRAY_EXT 0x9053
+#define GL_IMAGE_CUBE_MAP_ARRAY_EXT 0x9054
+#define GL_IMAGE_2D_MULTISAMPLE_EXT 0x9055
+#define GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9056
+#define GL_INT_IMAGE_1D_EXT 0x9057
+#define GL_INT_IMAGE_2D_EXT 0x9058
+#define GL_INT_IMAGE_3D_EXT 0x9059
+#define GL_INT_IMAGE_2D_RECT_EXT 0x905A
+#define GL_INT_IMAGE_CUBE_EXT 0x905B
+#define GL_INT_IMAGE_BUFFER_EXT 0x905C
+#define GL_INT_IMAGE_1D_ARRAY_EXT 0x905D
+#define GL_INT_IMAGE_2D_ARRAY_EXT 0x905E
+#define GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x905F
+#define GL_INT_IMAGE_2D_MULTISAMPLE_EXT 0x9060
+#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9061
+#define GL_UNSIGNED_INT_IMAGE_1D_EXT 0x9062
+#define GL_UNSIGNED_INT_IMAGE_2D_EXT 0x9063
+#define GL_UNSIGNED_INT_IMAGE_3D_EXT 0x9064
+#define GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT 0x9065
+#define GL_UNSIGNED_INT_IMAGE_CUBE_EXT 0x9066
+#define GL_UNSIGNED_INT_IMAGE_BUFFER_EXT 0x9067
+#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT 0x9068
+#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT 0x9069
+#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x906A
+#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT 0x906B
+#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x906C
+#define GL_MAX_IMAGE_SAMPLES_EXT 0x906D
+#define GL_IMAGE_BINDING_FORMAT_EXT 0x906E
+#define GL_ALL_BARRIER_BITS_EXT 0xFFFFFFFF
+
+typedef void (GLAPIENTRY * PFNGLBINDIMAGETEXTUREEXTPROC) (GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format);
+typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers);
+
+#define glBindImageTextureEXT GLEW_GET_FUN(__glewBindImageTextureEXT)
+#define glMemoryBarrierEXT GLEW_GET_FUN(__glewMemoryBarrierEXT)
+
+#define GLEW_EXT_shader_image_load_store GLEW_GET_VAR(__GLEW_EXT_shader_image_load_store)
+
+#endif /* GL_EXT_shader_image_load_store */
+
/* -------------------------- GL_EXT_shadow_funcs -------------------------- */
#ifndef GL_EXT_shadow_funcs
@@ -6871,6 +8218,41 @@ typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode);
#endif /* GL_EXT_texture_shared_exponent */
+/* -------------------------- GL_EXT_texture_snorm ------------------------- */
+
+#ifndef GL_EXT_texture_snorm
+#define GL_EXT_texture_snorm 1
+
+#define GL_RED_SNORM 0x8F90
+#define GL_RG_SNORM 0x8F91
+#define GL_RGB_SNORM 0x8F92
+#define GL_RGBA_SNORM 0x8F93
+#define GL_R8_SNORM 0x8F94
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_R16_SNORM 0x8F98
+#define GL_RG16_SNORM 0x8F99
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_ALPHA_SNORM 0x9010
+#define GL_LUMINANCE_SNORM 0x9011
+#define GL_LUMINANCE_ALPHA_SNORM 0x9012
+#define GL_INTENSITY_SNORM 0x9013
+#define GL_ALPHA8_SNORM 0x9014
+#define GL_LUMINANCE8_SNORM 0x9015
+#define GL_LUMINANCE8_ALPHA8_SNORM 0x9016
+#define GL_INTENSITY8_SNORM 0x9017
+#define GL_ALPHA16_SNORM 0x9018
+#define GL_LUMINANCE16_SNORM 0x9019
+#define GL_LUMINANCE16_ALPHA16_SNORM 0x901A
+#define GL_INTENSITY16_SNORM 0x901B
+
+#define GLEW_EXT_texture_snorm GLEW_GET_VAR(__GLEW_EXT_texture_snorm)
+
+#endif /* GL_EXT_texture_snorm */
+
/* ------------------------- GL_EXT_texture_swizzle ------------------------ */
#ifndef GL_EXT_texture_swizzle
@@ -7018,6 +8400,46 @@ typedef void (GLAPIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type,
#endif /* GL_EXT_vertex_array_bgra */
+/* ----------------------- GL_EXT_vertex_attrib_64bit ---------------------- */
+
+#ifndef GL_EXT_vertex_attrib_64bit
+#define GL_EXT_vertex_attrib_64bit 1
+
+#define GL_DOUBLE_MAT2_EXT 0x8F46
+#define GL_DOUBLE_MAT3_EXT 0x8F47
+#define GL_DOUBLE_MAT4_EXT 0x8F48
+#define GL_DOUBLE_VEC2_EXT 0x8FFC
+#define GL_DOUBLE_VEC3_EXT 0x8FFD
+#define GL_DOUBLE_VEC4_EXT 0x8FFE
+
+typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLDVEXTPROC) (GLuint index, GLenum pname, GLdouble* params);
+typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DEXTPROC) (GLuint index, GLdouble x);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DVEXTPROC) (GLuint index, const GLdouble* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DEXTPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DVEXTPROC) (GLuint index, const GLdouble* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DVEXTPROC) (GLuint index, const GLdouble* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DVEXTPROC) (GLuint index, const GLdouble* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer);
+
+#define glGetVertexAttribLdvEXT GLEW_GET_FUN(__glewGetVertexAttribLdvEXT)
+#define glVertexArrayVertexAttribLOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribLOffsetEXT)
+#define glVertexAttribL1dEXT GLEW_GET_FUN(__glewVertexAttribL1dEXT)
+#define glVertexAttribL1dvEXT GLEW_GET_FUN(__glewVertexAttribL1dvEXT)
+#define glVertexAttribL2dEXT GLEW_GET_FUN(__glewVertexAttribL2dEXT)
+#define glVertexAttribL2dvEXT GLEW_GET_FUN(__glewVertexAttribL2dvEXT)
+#define glVertexAttribL3dEXT GLEW_GET_FUN(__glewVertexAttribL3dEXT)
+#define glVertexAttribL3dvEXT GLEW_GET_FUN(__glewVertexAttribL3dvEXT)
+#define glVertexAttribL4dEXT GLEW_GET_FUN(__glewVertexAttribL4dEXT)
+#define glVertexAttribL4dvEXT GLEW_GET_FUN(__glewVertexAttribL4dvEXT)
+#define glVertexAttribLPointerEXT GLEW_GET_FUN(__glewVertexAttribLPointerEXT)
+
+#define GLEW_EXT_vertex_attrib_64bit GLEW_GET_VAR(__GLEW_EXT_vertex_attrib_64bit)
+
+#endif /* GL_EXT_vertex_attrib_64bit */
+
/* -------------------------- GL_EXT_vertex_shader ------------------------- */
#ifndef GL_EXT_vertex_shader
@@ -7686,6 +9108,19 @@ typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERNVPROC) (void);
#endif /* GL_NV_copy_depth_to_color */
+/* ---------------------------- GL_NV_copy_image --------------------------- */
+
+#ifndef GL_NV_copy_image
+#define GL_NV_copy_image 1
+
+typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATANVPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+
+#define glCopyImageSubDataNV GLEW_GET_FUN(__glewCopyImageSubDataNV)
+
+#define GLEW_NV_copy_image GLEW_GET_VAR(__GLEW_NV_copy_image)
+
+#endif /* GL_NV_copy_image */
+
/* ------------------------ GL_NV_depth_buffer_float ----------------------- */
#ifndef GL_NV_depth_buffer_float
@@ -8034,6 +9469,137 @@ typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum targe
#endif /* GL_NV_gpu_program4 */
+/* --------------------------- GL_NV_gpu_program5 -------------------------- */
+
+#ifndef GL_NV_gpu_program5
+#define GL_NV_gpu_program5 1
+
+#define GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV 0x8E5A
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5B
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5C
+#define GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV 0x8E5D
+
+#define GLEW_NV_gpu_program5 GLEW_GET_VAR(__GLEW_NV_gpu_program5)
+
+#endif /* GL_NV_gpu_program5 */
+
+/* ------------------------- GL_NV_gpu_program_fp64 ------------------------ */
+
+#ifndef GL_NV_gpu_program_fp64
+#define GL_NV_gpu_program_fp64 1
+
+#define GLEW_NV_gpu_program_fp64 GLEW_GET_VAR(__GLEW_NV_gpu_program_fp64)
+
+#endif /* GL_NV_gpu_program_fp64 */
+
+/* --------------------------- GL_NV_gpu_shader5 --------------------------- */
+
+#ifndef GL_NV_gpu_shader5
+#define GL_NV_gpu_shader5 1
+
+#define GL_INT64_NV 0x140E
+#define GL_UNSIGNED_INT64_NV 0x140F
+#define GL_INT8_NV 0x8FE0
+#define GL_INT8_VEC2_NV 0x8FE1
+#define GL_INT8_VEC3_NV 0x8FE2
+#define GL_INT8_VEC4_NV 0x8FE3
+#define GL_INT16_NV 0x8FE4
+#define GL_INT16_VEC2_NV 0x8FE5
+#define GL_INT16_VEC3_NV 0x8FE6
+#define GL_INT16_VEC4_NV 0x8FE7
+#define GL_INT64_VEC2_NV 0x8FE9
+#define GL_INT64_VEC3_NV 0x8FEA
+#define GL_INT64_VEC4_NV 0x8FEB
+#define GL_UNSIGNED_INT8_NV 0x8FEC
+#define GL_UNSIGNED_INT8_VEC2_NV 0x8FED
+#define GL_UNSIGNED_INT8_VEC3_NV 0x8FEE
+#define GL_UNSIGNED_INT8_VEC4_NV 0x8FEF
+#define GL_UNSIGNED_INT16_NV 0x8FF0
+#define GL_UNSIGNED_INT16_VEC2_NV 0x8FF1
+#define GL_UNSIGNED_INT16_VEC3_NV 0x8FF2
+#define GL_UNSIGNED_INT16_VEC4_NV 0x8FF3
+#define GL_UNSIGNED_INT64_VEC2_NV 0x8FF5
+#define GL_UNSIGNED_INT64_VEC3_NV 0x8FF6
+#define GL_UNSIGNED_INT64_VEC4_NV 0x8FF7
+#define GL_FLOAT16_NV 0x8FF8
+#define GL_FLOAT16_VEC2_NV 0x8FF9
+#define GL_FLOAT16_VEC3_NV 0x8FFA
+#define GL_FLOAT16_VEC4_NV 0x8FFB
+
+typedef void (GLAPIENTRY * PFNGLGETUNIFORMI64VNVPROC) (GLuint program, GLint location, GLint64EXT* params);
+typedef void (GLAPIENTRY * PFNGLGETUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLuint64EXT* params);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64NVPROC) (GLuint program, GLint location, GLint64EXT x);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM1I64NVPROC) (GLint location, GLint64EXT x);
+typedef void (GLAPIENTRY * PFNGLUNIFORM1I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64NVPROC) (GLint location, GLuint64EXT x);
+typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM2I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y);
+typedef void (GLAPIENTRY * PFNGLUNIFORM2I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y);
+typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM3I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+typedef void (GLAPIENTRY * PFNGLUNIFORM3I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM4I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+typedef void (GLAPIENTRY * PFNGLUNIFORM4I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value);
+
+#define glGetUniformi64vNV GLEW_GET_FUN(__glewGetUniformi64vNV)
+#define glGetUniformui64vNV GLEW_GET_FUN(__glewGetUniformui64vNV)
+#define glProgramUniform1i64NV GLEW_GET_FUN(__glewProgramUniform1i64NV)
+#define glProgramUniform1i64vNV GLEW_GET_FUN(__glewProgramUniform1i64vNV)
+#define glProgramUniform1ui64NV GLEW_GET_FUN(__glewProgramUniform1ui64NV)
+#define glProgramUniform1ui64vNV GLEW_GET_FUN(__glewProgramUniform1ui64vNV)
+#define glProgramUniform2i64NV GLEW_GET_FUN(__glewProgramUniform2i64NV)
+#define glProgramUniform2i64vNV GLEW_GET_FUN(__glewProgramUniform2i64vNV)
+#define glProgramUniform2ui64NV GLEW_GET_FUN(__glewProgramUniform2ui64NV)
+#define glProgramUniform2ui64vNV GLEW_GET_FUN(__glewProgramUniform2ui64vNV)
+#define glProgramUniform3i64NV GLEW_GET_FUN(__glewProgramUniform3i64NV)
+#define glProgramUniform3i64vNV GLEW_GET_FUN(__glewProgramUniform3i64vNV)
+#define glProgramUniform3ui64NV GLEW_GET_FUN(__glewProgramUniform3ui64NV)
+#define glProgramUniform3ui64vNV GLEW_GET_FUN(__glewProgramUniform3ui64vNV)
+#define glProgramUniform4i64NV GLEW_GET_FUN(__glewProgramUniform4i64NV)
+#define glProgramUniform4i64vNV GLEW_GET_FUN(__glewProgramUniform4i64vNV)
+#define glProgramUniform4ui64NV GLEW_GET_FUN(__glewProgramUniform4ui64NV)
+#define glProgramUniform4ui64vNV GLEW_GET_FUN(__glewProgramUniform4ui64vNV)
+#define glUniform1i64NV GLEW_GET_FUN(__glewUniform1i64NV)
+#define glUniform1i64vNV GLEW_GET_FUN(__glewUniform1i64vNV)
+#define glUniform1ui64NV GLEW_GET_FUN(__glewUniform1ui64NV)
+#define glUniform1ui64vNV GLEW_GET_FUN(__glewUniform1ui64vNV)
+#define glUniform2i64NV GLEW_GET_FUN(__glewUniform2i64NV)
+#define glUniform2i64vNV GLEW_GET_FUN(__glewUniform2i64vNV)
+#define glUniform2ui64NV GLEW_GET_FUN(__glewUniform2ui64NV)
+#define glUniform2ui64vNV GLEW_GET_FUN(__glewUniform2ui64vNV)
+#define glUniform3i64NV GLEW_GET_FUN(__glewUniform3i64NV)
+#define glUniform3i64vNV GLEW_GET_FUN(__glewUniform3i64vNV)
+#define glUniform3ui64NV GLEW_GET_FUN(__glewUniform3ui64NV)
+#define glUniform3ui64vNV GLEW_GET_FUN(__glewUniform3ui64vNV)
+#define glUniform4i64NV GLEW_GET_FUN(__glewUniform4i64NV)
+#define glUniform4i64vNV GLEW_GET_FUN(__glewUniform4i64vNV)
+#define glUniform4ui64NV GLEW_GET_FUN(__glewUniform4ui64NV)
+#define glUniform4ui64vNV GLEW_GET_FUN(__glewUniform4ui64vNV)
+
+#define GLEW_NV_gpu_shader5 GLEW_GET_VAR(__GLEW_NV_gpu_shader5)
+
+#endif /* GL_NV_gpu_shader5 */
+
/* ---------------------------- GL_NV_half_float --------------------------- */
#ifndef GL_NV_half_float
@@ -8229,6 +9795,15 @@ typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) (GLenum target,
#endif /* GL_NV_parameter_buffer_object */
+/* --------------------- GL_NV_parameter_buffer_object2 -------------------- */
+
+#ifndef GL_NV_parameter_buffer_object2
+#define GL_NV_parameter_buffer_object2 1
+
+#define GLEW_NV_parameter_buffer_object2 GLEW_GET_VAR(__GLEW_NV_parameter_buffer_object2)
+
+#endif /* GL_NV_parameter_buffer_object2 */
+
/* ------------------------- GL_NV_pixel_data_range ------------------------ */
#ifndef GL_NV_pixel_data_range
@@ -8288,7 +9863,6 @@ typedef void (GLAPIENTRY * PFNGLGETVIDEOUI64VNVPROC) (GLuint video_slot, GLenum
typedef void (GLAPIENTRY * PFNGLGETVIDEOUIVNVPROC) (GLuint video_slot, GLenum pname, GLuint* params);
typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEDUALFILLNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3);
typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEKEYEDNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1);
-typedef void (GLAPIENTRY * PFNGLVIDEOPARAMETERIVNVPROC) (GLuint video_slot, GLenum pname, const GLint* params);
#define glGetVideoi64vNV GLEW_GET_FUN(__glewGetVideoi64vNV)
#define glGetVideoivNV GLEW_GET_FUN(__glewGetVideoivNV)
@@ -8296,7 +9870,6 @@ typedef void (GLAPIENTRY * PFNGLVIDEOPARAMETERIVNVPROC) (GLuint video_slot, GLen
#define glGetVideouivNV GLEW_GET_FUN(__glewGetVideouivNV)
#define glPresentFrameDualFillNV GLEW_GET_FUN(__glewPresentFrameDualFillNV)
#define glPresentFrameKeyedNV GLEW_GET_FUN(__glewPresentFrameKeyedNV)
-#define glVideoParameterivNV GLEW_GET_FUN(__glewVideoParameterivNV)
#define GLEW_NV_present_video GLEW_GET_VAR(__GLEW_NV_present_video)
@@ -8426,6 +9999,62 @@ typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage
#endif /* GL_NV_register_combiners2 */
+/* ------------------------ GL_NV_shader_buffer_load ----------------------- */
+
+#ifndef GL_NV_shader_buffer_load
+#define GL_NV_shader_buffer_load 1
+
+#define GL_BUFFER_GPU_ADDRESS_NV 0x8F1D
+#define GL_GPU_ADDRESS_NV 0x8F34
+#define GL_MAX_SHADER_BUFFER_ADDRESS_NV 0x8F35
+
+typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERUI64VNVPROC) (GLenum target, GLenum pname, GLuint64EXT* params);
+typedef void (GLAPIENTRY * PFNGLGETINTEGERUI64VNVPROC) (GLenum value, GLuint64EXT* result);
+typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC) (GLuint buffer, GLenum pname, GLuint64EXT* params);
+typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERRESIDENTNVPROC) (GLenum target);
+typedef GLboolean (GLAPIENTRY * PFNGLISNAMEDBUFFERRESIDENTNVPROC) (GLuint buffer);
+typedef void (GLAPIENTRY * PFNGLMAKEBUFFERNONRESIDENTNVPROC) (GLenum target);
+typedef void (GLAPIENTRY * PFNGLMAKEBUFFERRESIDENTNVPROC) (GLenum target, GLenum access);
+typedef void (GLAPIENTRY * PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC) (GLuint buffer);
+typedef void (GLAPIENTRY * PFNGLMAKENAMEDBUFFERRESIDENTNVPROC) (GLuint buffer, GLenum access);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMUI64NVPROC) (GLuint program, GLint location, GLuint64EXT value);
+typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value);
+typedef void (GLAPIENTRY * PFNGLUNIFORMUI64NVPROC) (GLint location, GLuint64EXT value);
+typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value);
+
+#define glGetBufferParameterui64vNV GLEW_GET_FUN(__glewGetBufferParameterui64vNV)
+#define glGetIntegerui64vNV GLEW_GET_FUN(__glewGetIntegerui64vNV)
+#define glGetNamedBufferParameterui64vNV GLEW_GET_FUN(__glewGetNamedBufferParameterui64vNV)
+#define glIsBufferResidentNV GLEW_GET_FUN(__glewIsBufferResidentNV)
+#define glIsNamedBufferResidentNV GLEW_GET_FUN(__glewIsNamedBufferResidentNV)
+#define glMakeBufferNonResidentNV GLEW_GET_FUN(__glewMakeBufferNonResidentNV)
+#define glMakeBufferResidentNV GLEW_GET_FUN(__glewMakeBufferResidentNV)
+#define glMakeNamedBufferNonResidentNV GLEW_GET_FUN(__glewMakeNamedBufferNonResidentNV)
+#define glMakeNamedBufferResidentNV GLEW_GET_FUN(__glewMakeNamedBufferResidentNV)
+#define glProgramUniformui64NV GLEW_GET_FUN(__glewProgramUniformui64NV)
+#define glProgramUniformui64vNV GLEW_GET_FUN(__glewProgramUniformui64vNV)
+#define glUniformui64NV GLEW_GET_FUN(__glewUniformui64NV)
+#define glUniformui64vNV GLEW_GET_FUN(__glewUniformui64vNV)
+
+#define GLEW_NV_shader_buffer_load GLEW_GET_VAR(__GLEW_NV_shader_buffer_load)
+
+#endif /* GL_NV_shader_buffer_load */
+
+/* ---------------------- GL_NV_tessellation_program5 ---------------------- */
+
+#ifndef GL_NV_tessellation_program5
+#define GL_NV_tessellation_program5 1
+
+#define GL_MAX_PROGRAM_PATCH_ATTRIBS_NV 0x86D8
+#define GL_TESS_CONTROL_PROGRAM_NV 0x891E
+#define GL_TESS_EVALUATION_PROGRAM_NV 0x891F
+#define GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV 0x8C74
+#define GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV 0x8C75
+
+#define GLEW_NV_tessellation_program5 GLEW_GET_VAR(__GLEW_NV_tessellation_program5)
+
+#endif /* GL_NV_tessellation_program5 */
+
/* -------------------------- GL_NV_texgen_emboss -------------------------- */
#ifndef GL_NV_texgen_emboss
@@ -8451,6 +10080,19 @@ typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage
#endif /* GL_NV_texgen_reflection */
+/* ------------------------- GL_NV_texture_barrier ------------------------- */
+
+#ifndef GL_NV_texture_barrier
+#define GL_NV_texture_barrier 1
+
+typedef void (GLAPIENTRY * PFNGLTEXTUREBARRIERNVPROC) (void);
+
+#define glTextureBarrierNV GLEW_GET_FUN(__glewTextureBarrierNV)
+
+#define GLEW_NV_texture_barrier GLEW_GET_VAR(__GLEW_NV_texture_barrier)
+
+#endif /* GL_NV_texture_barrier */
+
/* --------------------- GL_NV_texture_compression_vtc --------------------- */
#ifndef GL_NV_texture_compression_vtc
@@ -8707,6 +10349,36 @@ typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint program
#endif /* GL_NV_transform_feedback */
+/* ----------------------- GL_NV_transform_feedback2 ----------------------- */
+
+#ifndef GL_NV_transform_feedback2
+#define GL_NV_transform_feedback2 1
+
+#define GL_TRANSFORM_FEEDBACK_NV 0x8E22
+#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV 0x8E23
+#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING_NV 0x8E25
+
+typedef void (GLAPIENTRY * PFNGLBINDTRANSFORMFEEDBACKNVPROC) (GLenum target, GLuint id);
+typedef void (GLAPIENTRY * PFNGLDELETETRANSFORMFEEDBACKSNVPROC) (GLsizei n, const GLuint* ids);
+typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKNVPROC) (GLenum mode, GLuint id);
+typedef void (GLAPIENTRY * PFNGLGENTRANSFORMFEEDBACKSNVPROC) (GLsizei n, GLuint* ids);
+typedef GLboolean (GLAPIENTRY * PFNGLISTRANSFORMFEEDBACKNVPROC) (GLuint id);
+typedef void (GLAPIENTRY * PFNGLPAUSETRANSFORMFEEDBACKNVPROC) (void);
+typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKNVPROC) (void);
+
+#define glBindTransformFeedbackNV GLEW_GET_FUN(__glewBindTransformFeedbackNV)
+#define glDeleteTransformFeedbacksNV GLEW_GET_FUN(__glewDeleteTransformFeedbacksNV)
+#define glDrawTransformFeedbackNV GLEW_GET_FUN(__glewDrawTransformFeedbackNV)
+#define glGenTransformFeedbacksNV GLEW_GET_FUN(__glewGenTransformFeedbacksNV)
+#define glIsTransformFeedbackNV GLEW_GET_FUN(__glewIsTransformFeedbackNV)
+#define glPauseTransformFeedbackNV GLEW_GET_FUN(__glewPauseTransformFeedbackNV)
+#define glResumeTransformFeedbackNV GLEW_GET_FUN(__glewResumeTransformFeedbackNV)
+
+#define GLEW_NV_transform_feedback2 GLEW_GET_VAR(__GLEW_NV_transform_feedback2)
+
+#endif /* GL_NV_transform_feedback2 */
+
/* ------------------------ GL_NV_vertex_array_range ----------------------- */
#ifndef GL_NV_vertex_array_range
@@ -8739,6 +10411,116 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, void* p
#endif /* GL_NV_vertex_array_range2 */
+/* ------------------- GL_NV_vertex_attrib_integer_64bit ------------------- */
+
+#ifndef GL_NV_vertex_attrib_integer_64bit
+#define GL_NV_vertex_attrib_integer_64bit 1
+
+#define GL_INT64_NV 0x140E
+#define GL_UNSIGNED_INT64_NV 0x140F
+
+typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLI64VNVPROC) (GLuint index, GLenum pname, GLint64EXT* params);
+typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLUI64VNVPROC) (GLuint index, GLenum pname, GLuint64EXT* params);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1I64NVPROC) (GLuint index, GLint64EXT x);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1I64VNVPROC) (GLuint index, const GLint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64NVPROC) (GLuint index, GLuint64EXT x);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64VNVPROC) (GLuint index, const GLuint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2I64VNVPROC) (GLuint index, const GLint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2UI64VNVPROC) (GLuint index, const GLuint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3I64VNVPROC) (GLuint index, const GLint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3UI64VNVPROC) (GLuint index, const GLuint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4I64VNVPROC) (GLuint index, const GLint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4UI64VNVPROC) (GLuint index, const GLuint64EXT* v);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride);
+
+#define glGetVertexAttribLi64vNV GLEW_GET_FUN(__glewGetVertexAttribLi64vNV)
+#define glGetVertexAttribLui64vNV GLEW_GET_FUN(__glewGetVertexAttribLui64vNV)
+#define glVertexAttribL1i64NV GLEW_GET_FUN(__glewVertexAttribL1i64NV)
+#define glVertexAttribL1i64vNV GLEW_GET_FUN(__glewVertexAttribL1i64vNV)
+#define glVertexAttribL1ui64NV GLEW_GET_FUN(__glewVertexAttribL1ui64NV)
+#define glVertexAttribL1ui64vNV GLEW_GET_FUN(__glewVertexAttribL1ui64vNV)
+#define glVertexAttribL2i64NV GLEW_GET_FUN(__glewVertexAttribL2i64NV)
+#define glVertexAttribL2i64vNV GLEW_GET_FUN(__glewVertexAttribL2i64vNV)
+#define glVertexAttribL2ui64NV GLEW_GET_FUN(__glewVertexAttribL2ui64NV)
+#define glVertexAttribL2ui64vNV GLEW_GET_FUN(__glewVertexAttribL2ui64vNV)
+#define glVertexAttribL3i64NV GLEW_GET_FUN(__glewVertexAttribL3i64NV)
+#define glVertexAttribL3i64vNV GLEW_GET_FUN(__glewVertexAttribL3i64vNV)
+#define glVertexAttribL3ui64NV GLEW_GET_FUN(__glewVertexAttribL3ui64NV)
+#define glVertexAttribL3ui64vNV GLEW_GET_FUN(__glewVertexAttribL3ui64vNV)
+#define glVertexAttribL4i64NV GLEW_GET_FUN(__glewVertexAttribL4i64NV)
+#define glVertexAttribL4i64vNV GLEW_GET_FUN(__glewVertexAttribL4i64vNV)
+#define glVertexAttribL4ui64NV GLEW_GET_FUN(__glewVertexAttribL4ui64NV)
+#define glVertexAttribL4ui64vNV GLEW_GET_FUN(__glewVertexAttribL4ui64vNV)
+#define glVertexAttribLFormatNV GLEW_GET_FUN(__glewVertexAttribLFormatNV)
+
+#define GLEW_NV_vertex_attrib_integer_64bit GLEW_GET_VAR(__GLEW_NV_vertex_attrib_integer_64bit)
+
+#endif /* GL_NV_vertex_attrib_integer_64bit */
+
+/* ------------------- GL_NV_vertex_buffer_unified_memory ------------------ */
+
+#ifndef GL_NV_vertex_buffer_unified_memory
+#define GL_NV_vertex_buffer_unified_memory 1
+
+#define GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV 0x8F1E
+#define GL_ELEMENT_ARRAY_UNIFIED_NV 0x8F1F
+#define GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV 0x8F20
+#define GL_VERTEX_ARRAY_ADDRESS_NV 0x8F21
+#define GL_NORMAL_ARRAY_ADDRESS_NV 0x8F22
+#define GL_COLOR_ARRAY_ADDRESS_NV 0x8F23
+#define GL_INDEX_ARRAY_ADDRESS_NV 0x8F24
+#define GL_TEXTURE_COORD_ARRAY_ADDRESS_NV 0x8F25
+#define GL_EDGE_FLAG_ARRAY_ADDRESS_NV 0x8F26
+#define GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV 0x8F27
+#define GL_FOG_COORD_ARRAY_ADDRESS_NV 0x8F28
+#define GL_ELEMENT_ARRAY_ADDRESS_NV 0x8F29
+#define GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV 0x8F2A
+#define GL_VERTEX_ARRAY_LENGTH_NV 0x8F2B
+#define GL_NORMAL_ARRAY_LENGTH_NV 0x8F2C
+#define GL_COLOR_ARRAY_LENGTH_NV 0x8F2D
+#define GL_INDEX_ARRAY_LENGTH_NV 0x8F2E
+#define GL_TEXTURE_COORD_ARRAY_LENGTH_NV 0x8F2F
+#define GL_EDGE_FLAG_ARRAY_LENGTH_NV 0x8F30
+#define GL_SECONDARY_COLOR_ARRAY_LENGTH_NV 0x8F31
+#define GL_FOG_COORD_ARRAY_LENGTH_NV 0x8F32
+#define GL_ELEMENT_ARRAY_LENGTH_NV 0x8F33
+
+typedef void (GLAPIENTRY * PFNGLBUFFERADDRESSRANGENVPROC) (GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length);
+typedef void (GLAPIENTRY * PFNGLCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLEDGEFLAGFORMATNVPROC) (GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLFOGCOORDFORMATNVPROC) (GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT result[]);
+typedef void (GLAPIENTRY * PFNGLINDEXFORMATNVPROC) (GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLNORMALFORMATNVPROC) (GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLTEXCOORDFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLVERTEXFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+
+#define glBufferAddressRangeNV GLEW_GET_FUN(__glewBufferAddressRangeNV)
+#define glColorFormatNV GLEW_GET_FUN(__glewColorFormatNV)
+#define glEdgeFlagFormatNV GLEW_GET_FUN(__glewEdgeFlagFormatNV)
+#define glFogCoordFormatNV GLEW_GET_FUN(__glewFogCoordFormatNV)
+#define glGetIntegerui64i_vNV GLEW_GET_FUN(__glewGetIntegerui64i_vNV)
+#define glIndexFormatNV GLEW_GET_FUN(__glewIndexFormatNV)
+#define glNormalFormatNV GLEW_GET_FUN(__glewNormalFormatNV)
+#define glSecondaryColorFormatNV GLEW_GET_FUN(__glewSecondaryColorFormatNV)
+#define glTexCoordFormatNV GLEW_GET_FUN(__glewTexCoordFormatNV)
+#define glVertexAttribFormatNV GLEW_GET_FUN(__glewVertexAttribFormatNV)
+#define glVertexAttribIFormatNV GLEW_GET_FUN(__glewVertexAttribIFormatNV)
+#define glVertexFormatNV GLEW_GET_FUN(__glewVertexFormatNV)
+
+#define GLEW_NV_vertex_buffer_unified_memory GLEW_GET_VAR(__GLEW_NV_vertex_buffer_unified_memory)
+
+#endif /* GL_NV_vertex_buffer_unified_memory */
+
/* -------------------------- GL_NV_vertex_program ------------------------- */
#ifndef GL_NV_vertex_program
@@ -10460,8 +12242,6 @@ GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv;
GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender;
GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback;
-GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEPROC __glewBindBufferBase;
-GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange;
GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation;
GLEW_FUN_EXPORT PFNGLCLAMPCOLORPROC __glewClampColor;
GLEW_FUN_EXPORT PFNGLCLEARBUFFERFIPROC __glewClearBufferfi;
@@ -10475,7 +12255,6 @@ GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender;
GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback;
GLEW_FUN_EXPORT PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v;
GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation;
-GLEW_FUN_EXPORT PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v;
GLEW_FUN_EXPORT PFNGLGETSTRINGIPROC __glewGetStringi;
GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv;
GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv;
@@ -10517,8 +12296,43 @@ GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv;
GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv;
GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer;
+GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced;
+GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced;
+GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex;
+GLEW_FUN_EXPORT PFNGLTEXBUFFERPROC __glewTexBuffer;
+
+GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture;
+GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v;
+GLEW_FUN_EXPORT PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v;
+
+GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei;
+GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIPROC __glewBlendEquationi;
+GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei;
+GLEW_FUN_EXPORT PFNGLBLENDFUNCIPROC __glewBlendFunci;
+GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading;
+
GLEW_FUN_EXPORT PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX;
+GLEW_FUN_EXPORT PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD;
+GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD;
+GLEW_FUN_EXPORT PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD;
+GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD;
+
+GLEW_FUN_EXPORT PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD;
+GLEW_FUN_EXPORT PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD;
+GLEW_FUN_EXPORT PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD;
+GLEW_FUN_EXPORT PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD;
+GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD;
+GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD;
+GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD;
+GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD;
+GLEW_FUN_EXPORT PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD;
+GLEW_FUN_EXPORT PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD;
+GLEW_FUN_EXPORT PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD;
+
+GLEW_FUN_EXPORT PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD;
+GLEW_FUN_EXPORT PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD;
+
GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE;
GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE;
GLEW_FUN_EXPORT PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE;
@@ -10537,6 +12351,10 @@ GLEW_FUN_EXPORT PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE;
GLEW_FUN_EXPORT PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE;
GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE;
+GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE;
+GLEW_FUN_EXPORT PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE;
+GLEW_FUN_EXPORT PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE;
+
GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE;
GLEW_FUN_EXPORT PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE;
@@ -10549,10 +12367,36 @@ GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeA
GLEW_FUN_EXPORT PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE;
GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE;
+GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE;
+GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE;
+GLEW_FUN_EXPORT PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE;
+GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE;
+GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE;
+GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE;
+GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE;
+
+GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed;
+GLEW_FUN_EXPORT PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex;
+
GLEW_FUN_EXPORT PFNGLCLAMPCOLORARBPROC __glewClampColorARB;
+GLEW_FUN_EXPORT PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData;
+
GLEW_FUN_EXPORT PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB;
+GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB;
+GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB;
+GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB;
+GLEW_FUN_EXPORT PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB;
+
+GLEW_FUN_EXPORT PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex;
+GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex;
+GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex;
+GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex;
+
+GLEW_FUN_EXPORT PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect;
+GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect;
+
GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB;
GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB;
@@ -10563,10 +12407,10 @@ GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus;
GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers;
GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer;
-GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURLAYERPROC __glewFramebufferTexturLayer;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D;
+GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer;
GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers;
GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers;
GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap;
@@ -10675,6 +12519,25 @@ GLEW_FUN_EXPORT PFNGLISQUERYARBPROC __glewIsQueryARB;
GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB;
GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB;
+GLEW_FUN_EXPORT PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex;
+
+GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB;
+
+GLEW_FUN_EXPORT PFNGLBINDSAMPLERPROC __glewBindSampler;
+GLEW_FUN_EXPORT PFNGLDELETESAMPLERSPROC __glewDeleteSamplers;
+GLEW_FUN_EXPORT PFNGLGENSAMPLERSPROC __glewGenSamplers;
+GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv;
+GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv;
+GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv;
+GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv;
+GLEW_FUN_EXPORT PFNGLISSAMPLERPROC __glewIsSampler;
+GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv;
+GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv;
+GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf;
+GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv;
+GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri;
+GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv;
+
GLEW_FUN_EXPORT PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB;
GLEW_FUN_EXPORT PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB;
GLEW_FUN_EXPORT PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB;
@@ -10715,6 +12578,33 @@ GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB;
GLEW_FUN_EXPORT PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB;
GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB;
+GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName;
+GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName;
+GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv;
+GLEW_FUN_EXPORT PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv;
+GLEW_FUN_EXPORT PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex;
+GLEW_FUN_EXPORT PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation;
+GLEW_FUN_EXPORT PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv;
+GLEW_FUN_EXPORT PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv;
+
+GLEW_FUN_EXPORT PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB;
+GLEW_FUN_EXPORT PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB;
+GLEW_FUN_EXPORT PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB;
+GLEW_FUN_EXPORT PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB;
+GLEW_FUN_EXPORT PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB;
+GLEW_FUN_EXPORT PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB;
+
+GLEW_FUN_EXPORT PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync;
+GLEW_FUN_EXPORT PFNGLDELETESYNCPROC __glewDeleteSync;
+GLEW_FUN_EXPORT PFNGLFENCESYNCPROC __glewFenceSync;
+GLEW_FUN_EXPORT PFNGLGETINTEGER64VPROC __glewGetInteger64v;
+GLEW_FUN_EXPORT PFNGLGETSYNCIVPROC __glewGetSynciv;
+GLEW_FUN_EXPORT PFNGLISSYNCPROC __glewIsSync;
+GLEW_FUN_EXPORT PFNGLWAITSYNCPROC __glewWaitSync;
+
+GLEW_FUN_EXPORT PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv;
+GLEW_FUN_EXPORT PFNGLPATCHPARAMETERIPROC __glewPatchParameteri;
+
GLEW_FUN_EXPORT PFNGLTEXBUFFERARBPROC __glewTexBufferARB;
GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB;
@@ -10725,11 +12615,44 @@ GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2
GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB;
GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB;
+GLEW_FUN_EXPORT PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv;
+GLEW_FUN_EXPORT PFNGLSAMPLEMASKIPROC __glewSampleMaski;
+GLEW_FUN_EXPORT PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample;
+GLEW_FUN_EXPORT PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample;
+
+GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v;
+GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v;
+GLEW_FUN_EXPORT PFNGLQUERYCOUNTERPROC __glewQueryCounter;
+
+GLEW_FUN_EXPORT PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback;
+GLEW_FUN_EXPORT PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks;
+GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback;
+GLEW_FUN_EXPORT PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks;
+GLEW_FUN_EXPORT PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback;
+GLEW_FUN_EXPORT PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback;
+GLEW_FUN_EXPORT PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback;
+
+GLEW_FUN_EXPORT PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed;
+GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream;
+GLEW_FUN_EXPORT PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed;
+GLEW_FUN_EXPORT PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv;
+
GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB;
GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB;
GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB;
GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB;
+GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEPROC __glewBindBufferBase;
+GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange;
+GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName;
+GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv;
+GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName;
+GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv;
+GLEW_FUN_EXPORT PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v;
+GLEW_FUN_EXPORT PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex;
+GLEW_FUN_EXPORT PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices;
+GLEW_FUN_EXPORT PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding;
+
GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray;
GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays;
GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays;
@@ -10825,6 +12748,45 @@ GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB;
GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB;
GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB;
+GLEW_FUN_EXPORT PFNGLCOLORP3UIPROC __glewColorP3ui;
+GLEW_FUN_EXPORT PFNGLCOLORP3UIVPROC __glewColorP3uiv;
+GLEW_FUN_EXPORT PFNGLCOLORP4UIPROC __glewColorP4ui;
+GLEW_FUN_EXPORT PFNGLCOLORP4UIVPROC __glewColorP4uiv;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui;
+GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv;
+GLEW_FUN_EXPORT PFNGLNORMALP3UIPROC __glewNormalP3ui;
+GLEW_FUN_EXPORT PFNGLNORMALP3UIVPROC __glewNormalP3uiv;
+GLEW_FUN_EXPORT PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui;
+GLEW_FUN_EXPORT PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui;
+GLEW_FUN_EXPORT PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXP2UIPROC __glewVertexP2ui;
+GLEW_FUN_EXPORT PFNGLVERTEXP2UIVPROC __glewVertexP2uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXP3UIPROC __glewVertexP3ui;
+GLEW_FUN_EXPORT PFNGLVERTEXP3UIVPROC __glewVertexP3uiv;
+GLEW_FUN_EXPORT PFNGLVERTEXP4UIPROC __glewVertexP4ui;
+GLEW_FUN_EXPORT PFNGLVERTEXP4UIVPROC __glewVertexP4uiv;
+
GLEW_FUN_EXPORT PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB;
GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB;
GLEW_FUN_EXPORT PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB;
@@ -11004,7 +12966,14 @@ GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT
GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT;
GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT;
GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT;
+GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT;
+GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT;
+GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT;
GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT;
+GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT;
+GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT;
+GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT;
+GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT;
@@ -11013,7 +12982,9 @@ GLEW_FUN_EXPORT PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT
GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT;
GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT;
GLEW_FUN_EXPORT PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT;
+GLEW_FUN_EXPORT PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT;
GLEW_FUN_EXPORT PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT;
+GLEW_FUN_EXPORT PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT;
GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT;
GLEW_FUN_EXPORT PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT;
GLEW_FUN_EXPORT PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT;
@@ -11039,6 +13010,7 @@ GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT
GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT;
GLEW_FUN_EXPORT PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT;
GLEW_FUN_EXPORT PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT;
+GLEW_FUN_EXPORT PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT;
GLEW_FUN_EXPORT PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT;
GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT;
GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT;
@@ -11046,7 +13018,12 @@ GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivE
GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT;
GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT;
GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT;
+GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT;
+GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT;
+GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT;
+GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT;
GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT;
+GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT;
GLEW_FUN_EXPORT PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT;
GLEW_FUN_EXPORT PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT;
GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT;
@@ -11093,6 +13070,7 @@ GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT;
GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT;
GLEW_FUN_EXPORT PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT;
GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT;
+GLEW_FUN_EXPORT PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT;
GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT;
GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT;
GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT;
@@ -11164,6 +13142,17 @@ GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT;
GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT;
GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT;
GLEW_FUN_EXPORT PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT;
GLEW_FUN_EXPORT PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT;
GLEW_FUN_EXPORT PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT;
@@ -11309,6 +13298,8 @@ GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT;
GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT;
+GLEW_FUN_EXPORT PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT;
+
GLEW_FUN_EXPORT PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT;
GLEW_FUN_EXPORT PFNGLENDSCENEEXTPROC __glewEndSceneEXT;
@@ -11330,6 +13321,13 @@ GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT;
GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT;
GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT;
+GLEW_FUN_EXPORT PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT;
+GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT;
+GLEW_FUN_EXPORT PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT;
+
+GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT;
+GLEW_FUN_EXPORT PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT;
+
GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT;
GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT;
@@ -11377,6 +13375,18 @@ GLEW_FUN_EXPORT PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT;
GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT;
GLEW_FUN_EXPORT PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT;
+GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT;
+
GLEW_FUN_EXPORT PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT;
GLEW_FUN_EXPORT PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT;
GLEW_FUN_EXPORT PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT;
@@ -11491,6 +13501,8 @@ GLEW_FUN_EXPORT PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA;
GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV;
GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV;
+GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV;
+
GLEW_FUN_EXPORT PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV;
GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV;
GLEW_FUN_EXPORT PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV;
@@ -11541,6 +13553,41 @@ GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParamete
GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV;
GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV;
+GLEW_FUN_EXPORT PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV;
+GLEW_FUN_EXPORT PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV;
+
GLEW_FUN_EXPORT PFNGLCOLOR3HNVPROC __glewColor3hNV;
GLEW_FUN_EXPORT PFNGLCOLOR3HVNVPROC __glewColor3hvNV;
GLEW_FUN_EXPORT PFNGLCOLOR4HNVPROC __glewColor4hNV;
@@ -11612,7 +13659,6 @@ GLEW_FUN_EXPORT PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV;
GLEW_FUN_EXPORT PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV;
GLEW_FUN_EXPORT PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV;
GLEW_FUN_EXPORT PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV;
-GLEW_FUN_EXPORT PFNGLVIDEOPARAMETERIVNVPROC __glewVideoParameterivNV;
GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV;
GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV;
@@ -11634,6 +13680,22 @@ GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombin
GLEW_FUN_EXPORT PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV;
GLEW_FUN_EXPORT PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV;
+GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV;
+GLEW_FUN_EXPORT PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV;
+GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV;
+GLEW_FUN_EXPORT PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV;
+GLEW_FUN_EXPORT PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV;
+GLEW_FUN_EXPORT PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV;
+GLEW_FUN_EXPORT PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV;
+GLEW_FUN_EXPORT PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV;
+GLEW_FUN_EXPORT PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV;
+GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV;
+GLEW_FUN_EXPORT PFNGLUNIFORMUI64NVPROC __glewUniformui64NV;
+GLEW_FUN_EXPORT PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV;
+
+GLEW_FUN_EXPORT PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV;
+
GLEW_FUN_EXPORT PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV;
GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV;
GLEW_FUN_EXPORT PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV;
@@ -11646,9 +13708,50 @@ GLEW_FUN_EXPORT PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV;
GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV;
GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV;
+GLEW_FUN_EXPORT PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV;
+GLEW_FUN_EXPORT PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV;
+GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV;
+GLEW_FUN_EXPORT PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV;
+GLEW_FUN_EXPORT PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV;
+GLEW_FUN_EXPORT PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV;
+GLEW_FUN_EXPORT PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV;
+
GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV;
GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV;
+GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV;
+GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV;
+
+GLEW_FUN_EXPORT PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV;
+GLEW_FUN_EXPORT PFNGLCOLORFORMATNVPROC __glewColorFormatNV;
+GLEW_FUN_EXPORT PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV;
+GLEW_FUN_EXPORT PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV;
+GLEW_FUN_EXPORT PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV;
+GLEW_FUN_EXPORT PFNGLINDEXFORMATNVPROC __glewIndexFormatNV;
+GLEW_FUN_EXPORT PFNGLNORMALFORMATNVPROC __glewNormalFormatNV;
+GLEW_FUN_EXPORT PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV;
+GLEW_FUN_EXPORT PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV;
+GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV;
+GLEW_FUN_EXPORT PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV;
+
GLEW_FUN_EXPORT PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV;
GLEW_FUN_EXPORT PFNGLBINDPROGRAMNVPROC __glewBindProgramNV;
GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV;
@@ -11866,32 +13969,59 @@ GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_5;
GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_0;
GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_1;
GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_0;
+GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_1;
+GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_2;
+GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_3;
+GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_0;
GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_multisample;
GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_tbuffer;
GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_texture_compression_FXT1;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_conservative_depth;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_draw_buffers_blend;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_performance_monitor;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_seamless_cubemap_per_texture;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_export;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_texture_texture4;
+GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_tessellator;
+GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_aux_depth_stencil;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_client_storage;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_element_array;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_fence;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_float_pixels;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_flush_buffer_range;
+GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_object_purgeable;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_pixel_buffer;
+GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_rgb_422;
+GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_row_bytes;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_specular_vector;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_range;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_transform_hint;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_object;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_range;
+GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_program_evaluators;
GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_ycbcr_422;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_blend_func_extended;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_color_buffer_float;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compatibility;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_copy_buffer;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_buffer_float;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_clamp;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_texture;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers_blend;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_elements_base_vertex;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_indirect;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_instanced;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_explicit_attrib_location;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_coord_conventions;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program_shadow;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_shader;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_object;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_sRGB;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_geometry_shader4;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader5;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader_fp64;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_pixel;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_vertex;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_imaging;
@@ -11901,33 +14031,58 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_matrix_palette;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multisample;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multitexture;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query2;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pixel_buffer_object;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_parameters;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_sprite;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_provoking_vertex;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sample_shading;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sampler_objects;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_seamless_cube_map;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_bit_encoding;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_objects;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_subroutine;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_texture_lod;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_100;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_include;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow_ambient;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sync;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_tessellation_shader;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_border_clamp;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object_rgb32;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_bptc;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_rgtc;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map_array;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_add;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_combine;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_crossbar;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_dot3;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_float;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_gather;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_mirrored_repeat;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_multisample;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_non_power_of_two;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_query_lod;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rectangle;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rg;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rgb10_a2ui;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_swizzle;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_timer_query;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback2;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback3;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transpose_matrix;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_uniform_buffer_object;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_bgra;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_object;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_blend;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_buffer_object;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_program;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_shader;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev;
GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos;
GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_point_sprites;
GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_combine3;
@@ -11938,6 +14093,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ATI_element_array;
GLEW_VAR_EXPORT GLboolean __GLEW_ATI_envmap_bumpmap;
GLEW_VAR_EXPORT GLboolean __GLEW_ATI_fragment_shader;
GLEW_VAR_EXPORT GLboolean __GLEW_ATI_map_object_buffer;
+GLEW_VAR_EXPORT GLboolean __GLEW_ATI_meminfo;
GLEW_VAR_EXPORT GLboolean __GLEW_ATI_pn_triangles;
GLEW_VAR_EXPORT GLboolean __GLEW_ATI_separate_stencil;
GLEW_VAR_EXPORT GLboolean __GLEW_ATI_shader_texture_lod;
@@ -12000,10 +14156,13 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform_color_table;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_point_parameters;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_provoking_vertex;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_rescale_normal;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_scene_marker;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_shader_objects;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_store;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_clear_tag;
@@ -12033,11 +14192,13 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_perturb_normal;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_rectangle;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_snorm;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_timer_query;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_transform_feedback;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array_bgra;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_attrib_64bit;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_shader;
GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_weighting;
GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_frame_terminator;
@@ -12065,6 +14226,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_square;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_conditional_render;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_depth_to_color;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_image;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_buffer_float;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_clamp;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_range_unclamped;
@@ -12081,20 +14243,27 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_multisample_coverage;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_program4;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader4;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program4;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program5;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program_fp64;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_shader5;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_half_float;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_occlusion_query;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_depth_stencil;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object2;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_pixel_data_range;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners2;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_buffer_load;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_tessellation_program5;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_emboss;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_reflection;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_barrier;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_vtc;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_env_combine4;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_expand_normal;
@@ -12103,8 +14272,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback2;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range2;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_attrib_integer_64bit;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_buffer_unified_memory;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program1_1;
GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2;
@@ -12244,6 +14416,7 @@ GLEWAPI const GLubyte* glewGetString (GLenum name);
#undef GLEW_APIENTRY_DEFINED
#undef APIENTRY
#undef GLAPIENTRY
+#define GLAPIENTRY
#endif
#ifdef GLEW_CALLBACK_DEFINED
diff --git a/modules/gfx/src/GL/glxew.h b/modules/gfx/src/GL/glxew.h
index a29030da3cbeb435ceb66f488315621a74913954..637ef1eaab7757446f25ffc7473ea386b96fff1a 100644
--- a/modules/gfx/src/GL/glxew.h
+++ b/modules/gfx/src/GL/glxew.h
@@ -83,13 +83,16 @@
#ifdef __glxext_h_
#error glxext.h included before glxew.h
#endif
-#ifdef GLX_H
+
+#if defined(GLX_H) || defined(__GLX_glx_h__) || defined(__glx_h__)
#error glx.h included before glxew.h
#endif
#define __glxext_h_
-#define __GLX_glx_h__
+
#define GLX_H
+#define __GLX_glx_h__
+#define __glx_h__
#include <X11/Xlib.h>
#include <X11/Xutil.h>
@@ -362,6 +365,19 @@ typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display* dpy, GLXFBCo
#endif /* GLX_ARB_create_context */
+/* --------------------- GLX_ARB_create_context_profile -------------------- */
+
+#ifndef GLX_ARB_create_context_profile
+#define GLX_ARB_create_context_profile 1
+
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+
+#define GLXEW_ARB_create_context_profile GLXEW_GET_VAR(__GLXEW_ARB_create_context_profile)
+
+#endif /* GLX_ARB_create_context_profile */
+
/* ------------------------- GLX_ARB_fbconfig_float ------------------------ */
#ifndef GLX_ARB_fbconfig_float
@@ -408,6 +424,17 @@ extern void ( * glXGetProcAddressARB (const GLubyte *procName)) (void);
#endif /* GLX_ARB_multisample */
+/* ---------------------- GLX_ARB_vertex_buffer_object --------------------- */
+
+#ifndef GLX_ARB_vertex_buffer_object
+#define GLX_ARB_vertex_buffer_object 1
+
+#define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095
+
+#define GLXEW_ARB_vertex_buffer_object GLXEW_GET_VAR(__GLXEW_ARB_vertex_buffer_object)
+
+#endif /* GLX_ARB_vertex_buffer_object */
+
/* ----------------------- GLX_ATI_pixel_format_float ---------------------- */
#ifndef GLX_ATI_pixel_format_float
@@ -529,6 +556,22 @@ typedef int ( * PFNGLXQUERYCONTEXTINFOEXTPROC) (Display* dpy, GLXContext context
#endif /* GLX_EXT_scene_marker */
+/* -------------------------- GLX_EXT_swap_control ------------------------- */
+
+#ifndef GLX_EXT_swap_control
+#define GLX_EXT_swap_control 1
+
+#define GLX_SWAP_INTERVAL_EXT 0x20F1
+#define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2
+
+typedef void ( * PFNGLXSWAPINTERVALEXTPROC) (Display* dpy, GLXDrawable drawable, int interval);
+
+#define glXSwapIntervalEXT GLXEW_GET_FUN(__glewXSwapIntervalEXT)
+
+#define GLXEW_EXT_swap_control GLXEW_GET_VAR(__GLXEW_EXT_swap_control)
+
+#endif /* GLX_EXT_swap_control */
+
/* ---------------------- GLX_EXT_texture_from_pixmap ---------------------- */
#ifndef GLX_EXT_texture_from_pixmap
@@ -615,6 +658,20 @@ typedef void ( * PFNGLXRELEASETEXIMAGEEXTPROC) (Display* display, GLXDrawable dr
#endif /* GLX_EXT_visual_rating */
+/* -------------------------- GLX_INTEL_swap_event ------------------------- */
+
+#ifndef GLX_INTEL_swap_event
+#define GLX_INTEL_swap_event 1
+
+#define GLX_EXCHANGE_COMPLETE_INTEL 0x8180
+#define GLX_COPY_COMPLETE_INTEL 0x8181
+#define GLX_FLIP_COMPLETE_INTEL 0x8182
+#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000
+
+#define GLXEW_INTEL_swap_event GLXEW_GET_VAR(__GLXEW_INTEL_swap_event)
+
+#endif /* GLX_INTEL_swap_event */
+
/* -------------------------- GLX_MESA_agp_offset -------------------------- */
#ifndef GLX_MESA_agp_offset
@@ -683,6 +740,19 @@ typedef GLboolean ( * PFNGLXSET3DFXMODEMESAPROC) (GLint mode);
#endif /* GLX_MESA_set_3dfx_mode */
+/* --------------------------- GLX_NV_copy_image --------------------------- */
+
+#ifndef GLX_NV_copy_image
+#define GLX_NV_copy_image 1
+
+typedef void ( * PFNGLXCOPYIMAGESUBDATANVPROC) (Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+
+#define glXCopyImageSubDataNV GLXEW_GET_FUN(__glewXCopyImageSubDataNV)
+
+#define GLXEW_NV_copy_image GLXEW_GET_VAR(__GLXEW_NV_copy_image)
+
+#endif /* GLX_NV_copy_image */
+
/* -------------------------- GLX_NV_float_buffer -------------------------- */
#ifndef GLX_NV_float_buffer
@@ -1217,6 +1287,8 @@ extern PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT;
extern PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT;
extern PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT;
+extern PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT;
+
extern PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT;
extern PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT;
@@ -1230,6 +1302,8 @@ extern PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA;
extern PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA;
+extern PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV;
+
extern PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV;
extern PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV;
@@ -1318,24 +1392,29 @@ GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_3;
GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_4;
GLXEW_EXPORT GLboolean __GLXEW_3DFX_multisample;
GLXEW_EXPORT GLboolean __GLXEW_ARB_create_context;
+GLXEW_EXPORT GLboolean __GLXEW_ARB_create_context_profile;
GLXEW_EXPORT GLboolean __GLXEW_ARB_fbconfig_float;
GLXEW_EXPORT GLboolean __GLXEW_ARB_framebuffer_sRGB;
GLXEW_EXPORT GLboolean __GLXEW_ARB_get_proc_address;
GLXEW_EXPORT GLboolean __GLXEW_ARB_multisample;
+GLXEW_EXPORT GLboolean __GLXEW_ARB_vertex_buffer_object;
GLXEW_EXPORT GLboolean __GLXEW_ATI_pixel_format_float;
GLXEW_EXPORT GLboolean __GLXEW_ATI_render_texture;
GLXEW_EXPORT GLboolean __GLXEW_EXT_fbconfig_packed_float;
GLXEW_EXPORT GLboolean __GLXEW_EXT_framebuffer_sRGB;
GLXEW_EXPORT GLboolean __GLXEW_EXT_import_context;
GLXEW_EXPORT GLboolean __GLXEW_EXT_scene_marker;
+GLXEW_EXPORT GLboolean __GLXEW_EXT_swap_control;
GLXEW_EXPORT GLboolean __GLXEW_EXT_texture_from_pixmap;
GLXEW_EXPORT GLboolean __GLXEW_EXT_visual_info;
GLXEW_EXPORT GLboolean __GLXEW_EXT_visual_rating;
+GLXEW_EXPORT GLboolean __GLXEW_INTEL_swap_event;
GLXEW_EXPORT GLboolean __GLXEW_MESA_agp_offset;
GLXEW_EXPORT GLboolean __GLXEW_MESA_copy_sub_buffer;
GLXEW_EXPORT GLboolean __GLXEW_MESA_pixmap_colormap;
GLXEW_EXPORT GLboolean __GLXEW_MESA_release_buffers;
GLXEW_EXPORT GLboolean __GLXEW_MESA_set_3dfx_mode;
+GLXEW_EXPORT GLboolean __GLXEW_NV_copy_image;
GLXEW_EXPORT GLboolean __GLXEW_NV_float_buffer;
GLXEW_EXPORT GLboolean __GLXEW_NV_present_video;
GLXEW_EXPORT GLboolean __GLXEW_NV_swap_group;
diff --git a/modules/gfx/src/GL/wglew.h b/modules/gfx/src/GL/wglew.h
index e35cd04b72a17e73b9470d18b894e04b00eada67..7c7a3804794cbe861bbaefe67a2d01a4f965c14a 100644
--- a/modules/gfx/src/GL/wglew.h
+++ b/modules/gfx/src/GL/wglew.h
@@ -62,11 +62,12 @@
#define __wglext_h_
-#if !defined(APIENTRY) && !defined(__CYGWIN__)
-# ifndef _MSC_VER_LEAN_AND_MEAN
-# define _MSC_VER_LEAN_AND_MEAN 1
+#if !defined(WINAPI)
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN 1
# endif
#include <windows.h>
+# undef WIN32_LEAN_AND_MEAN
#endif
/*
@@ -117,6 +118,46 @@ typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState
#endif /* WGL_3DL_stereo_control */
+/* ------------------------ WGL_AMD_gpu_association ------------------------ */
+
+#ifndef WGL_AMD_gpu_association
+#define WGL_AMD_gpu_association 1
+
+#define WGL_GPU_VENDOR_AMD 0x1F00
+#define WGL_GPU_RENDERER_STRING_AMD 0x1F01
+#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define WGL_GPU_RAM_AMD 0x21A3
+#define WGL_GPU_CLOCK_AMD 0x21A4
+#define WGL_GPU_NUM_PIPES_AMD 0x21A5
+#define WGL_GPU_NUM_SIMD_AMD 0x21A6
+#define WGL_GPU_NUM_RB_AMD 0x21A7
+#define WGL_GPU_NUM_SPI_AMD 0x21A8
+
+typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id);
+typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int* attribList);
+typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc);
+typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc);
+typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void);
+typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT* ids);
+typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, INT property, GLenum dataType, UINT size, void* data);
+typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc);
+
+#define wglBlitContextFramebufferAMD WGLEW_GET_FUN(__wglewBlitContextFramebufferAMD)
+#define wglCreateAssociatedContextAMD WGLEW_GET_FUN(__wglewCreateAssociatedContextAMD)
+#define wglCreateAssociatedContextAttribsAMD WGLEW_GET_FUN(__wglewCreateAssociatedContextAttribsAMD)
+#define wglDeleteAssociatedContextAMD WGLEW_GET_FUN(__wglewDeleteAssociatedContextAMD)
+#define wglGetContextGPUIDAMD WGLEW_GET_FUN(__wglewGetContextGPUIDAMD)
+#define wglGetCurrentAssociatedContextAMD WGLEW_GET_FUN(__wglewGetCurrentAssociatedContextAMD)
+#define wglGetGPUIDsAMD WGLEW_GET_FUN(__wglewGetGPUIDsAMD)
+#define wglGetGPUInfoAMD WGLEW_GET_FUN(__wglewGetGPUInfoAMD)
+#define wglMakeAssociatedContextCurrentAMD WGLEW_GET_FUN(__wglewMakeAssociatedContextCurrentAMD)
+
+#define WGLEW_AMD_gpu_association WGLEW_GET_VAR(__WGLEW_AMD_gpu_association)
+
+#endif /* WGL_AMD_gpu_association */
+
/* ------------------------- WGL_ARB_buffer_region ------------------------- */
#ifndef WGL_ARB_buffer_region
@@ -161,6 +202,19 @@ typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShar
#endif /* WGL_ARB_create_context */
+/* --------------------- WGL_ARB_create_context_profile -------------------- */
+
+#ifndef WGL_ARB_create_context_profile
+#define WGL_ARB_create_context_profile 1
+
+#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
+
+#define WGLEW_ARB_create_context_profile WGLEW_GET_VAR(__WGLEW_ARB_create_context_profile)
+
+#endif /* WGL_ARB_create_context_profile */
+
/* ----------------------- WGL_ARB_extensions_string ----------------------- */
#ifndef WGL_ARB_extensions_string
@@ -752,6 +806,19 @@ typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD* pFrameCount, DWO
#endif /* WGL_I3D_swap_frame_usage */
+/* --------------------------- WGL_NV_copy_image --------------------------- */
+
+#ifndef WGL_NV_copy_image
+#define WGL_NV_copy_image 1
+
+typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+
+#define wglCopyImageSubDataNV WGLEW_GET_FUN(__wglewCopyImageSubDataNV)
+
+#define WGLEW_NV_copy_image WGLEW_GET_VAR(__WGLEW_NV_copy_image)
+
+#endif /* WGL_NV_copy_image */
+
/* -------------------------- WGL_NV_float_buffer -------------------------- */
#ifndef WGL_NV_float_buffer
@@ -863,7 +930,7 @@ typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrie
typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group);
typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint* count);
typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint* maxGroups, GLuint *maxBarriers);
-typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint* group);
+typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint* group, GLuint *barrier);
typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC);
#define wglBindSwapBarrierNV WGLEW_GET_FUN(__wglewBindSwapBarrierNV)
@@ -969,6 +1036,16 @@ struct WGLEWContextStruct
WGLEW_EXPORT PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL;
+WGLEW_EXPORT PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD;
+WGLEW_EXPORT PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD;
+WGLEW_EXPORT PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD;
+WGLEW_EXPORT PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD;
+WGLEW_EXPORT PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD;
+WGLEW_EXPORT PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD;
+WGLEW_EXPORT PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD;
+WGLEW_EXPORT PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD;
+WGLEW_EXPORT PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD;
+
WGLEW_EXPORT PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB;
WGLEW_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB;
WGLEW_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB;
@@ -1054,6 +1131,8 @@ WGLEW_EXPORT PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D;
WGLEW_EXPORT PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D;
WGLEW_EXPORT PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D;
+WGLEW_EXPORT PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV;
+
WGLEW_EXPORT PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV;
WGLEW_EXPORT PFNWGLDELETEDCNVPROC __wglewDeleteDCNV;
WGLEW_EXPORT PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV;
@@ -1089,8 +1168,10 @@ WGLEW_EXPORT PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML;
WGLEW_EXPORT PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML;
WGLEW_EXPORT GLboolean __WGLEW_3DFX_multisample;
WGLEW_EXPORT GLboolean __WGLEW_3DL_stereo_control;
+WGLEW_EXPORT GLboolean __WGLEW_AMD_gpu_association;
WGLEW_EXPORT GLboolean __WGLEW_ARB_buffer_region;
WGLEW_EXPORT GLboolean __WGLEW_ARB_create_context;
+WGLEW_EXPORT GLboolean __WGLEW_ARB_create_context_profile;
WGLEW_EXPORT GLboolean __WGLEW_ARB_extensions_string;
WGLEW_EXPORT GLboolean __WGLEW_ARB_framebuffer_sRGB;
WGLEW_EXPORT GLboolean __WGLEW_ARB_make_current_read;
@@ -1117,6 +1198,7 @@ WGLEW_EXPORT GLboolean __WGLEW_I3D_genlock;
WGLEW_EXPORT GLboolean __WGLEW_I3D_image_buffer;
WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_lock;
WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_usage;
+WGLEW_EXPORT GLboolean __WGLEW_NV_copy_image;
WGLEW_EXPORT GLboolean __WGLEW_NV_float_buffer;
WGLEW_EXPORT GLboolean __WGLEW_NV_gpu_affinity;
WGLEW_EXPORT GLboolean __WGLEW_NV_present_video;
diff --git a/modules/gfx/src/bitmap_io.cc b/modules/gfx/src/bitmap_io.cc
index 8de3d7ea0ac13c19a1c8a8d70ae3e9ef854f6932..7c8fdf71b2b10f9225f74d6db8e1f6c22372a00f 100644
--- a/modules/gfx/src/bitmap_io.cc
+++ b/modules/gfx/src/bitmap_io.cc
@@ -38,7 +38,8 @@ void export_png(const String& filename, unsigned int width, unsigned int height,
LOGN_ERROR("error opening" << filename << " for exporting");
return;
}
-
+
+ LOGN_DEBUG("creating png write struct");
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL);
if (png_ptr == NULL) {
@@ -47,6 +48,7 @@ void export_png(const String& filename, unsigned int width, unsigned int height,
return;
}
+ LOGN_DEBUG("creating png info struct");
png_infop info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
fclose(fp);
@@ -72,20 +74,24 @@ void export_png(const String& filename, unsigned int width, unsigned int height,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+ LOGN_DEBUG("writing png info");
png_write_info(png_ptr, info_ptr);
png_bytep* row_pointers = new png_bytep[height];
png_byte* png_data = data;
+ LOGN_DEBUG("assigning png row pointers");
for(uint i=0;i<height;++i){
row_pointers[height-i-1]=&png_data[i*4*width];
}
+ LOGN_DEBUG("writing png image");
png_write_image(png_ptr, row_pointers);
delete []row_pointers;
+ LOGN_DEBUG("finalizing png write");
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
@@ -162,7 +168,7 @@ Bitmap import_png(const String& filename)
}
}
- LOGN_VERBOSE("loaded " << width << "x" << height << ":" << channels << " bitmap");
+ LOGN_DEBUG("loaded " << width << "x" << height << ":" << channels << " bitmap");
bm.channels=channels;
bm.width=width;
diff --git a/modules/gfx/src/entity.cc b/modules/gfx/src/entity.cc
index 8d639a33665cddc437adb568d27b1f8c56f89723..84d0a1bb7ed1f1207f75c7dab3454c0861bc4b22 100644
--- a/modules/gfx/src/entity.cc
+++ b/modules/gfx/src/entity.cc
@@ -67,7 +67,14 @@ Entity::Entity(const String& name,
const Query& q):
GfxObj(name),
qv_(q, h),
- bbox_(geom::Vec3(), geom::Vec3())
+ bbox_(geom::Vec3(), geom::Vec3()),
+ sel_(),
+ sel_update_(),
+ trace_(),
+ opacity_(1.0),
+ blur_(false),
+ blurf1_(1.0),
+ blurf2_(0.8)
{
init(RenderMode::SIMPLE);
}
@@ -78,7 +85,14 @@ Entity::Entity(const String& name,
const Query& q):
GfxObj(name),
qv_(q, h),
- bbox_(geom::Vec3(), geom::Vec3())
+ bbox_(geom::Vec3(), geom::Vec3()),
+ sel_(),
+ sel_update_(),
+ trace_(),
+ opacity_(1.0),
+ blur_(false),
+ blurf1_(1.0),
+ blurf2_(0.8)
{
init(m);
}
@@ -87,7 +101,14 @@ Entity::Entity(const String& name,
const EntityView& v):
GfxObj(name),
qv_(v),
- bbox_(geom::Vec3(), geom::Vec3())
+ bbox_(geom::Vec3(), geom::Vec3()),
+ sel_(),
+ sel_update_(),
+ trace_(),
+ opacity_(1.0),
+ blur_(false),
+ blurf1_(1.0),
+ blurf2_(0.8)
{
init(RenderMode::SIMPLE);
}
@@ -97,7 +118,14 @@ Entity::Entity(const String& name,
const EntityView& v):
GfxObj(name),
qv_(v),
- bbox_(geom::Vec3(), geom::Vec3())
+ bbox_(geom::Vec3(), geom::Vec3()),
+ sel_(),
+ sel_update_(),
+ trace_(),
+ opacity_(1.0),
+ blur_(false),
+ blurf1_(1.0),
+ blurf2_(0.8)
{
init(m);
}
@@ -105,8 +133,9 @@ Entity::Entity(const String& name,
impl::EntityRenderer* Entity::GetOrCreateRenderer(RenderMode::Type rm)
{
- if (renderer_.find(rm)!=renderer_.end()) {
- return renderer_.find(rm)->second;
+ RendererMap::iterator rit = renderer_.find(rm);
+ if(rit!=renderer_.end()) {
+ return rit->second;
}
impl::EntityRenderer* r=NULL;
switch (rm) {
@@ -117,22 +146,22 @@ impl::EntityRenderer* Entity::GetOrCreateRenderer(RenderMode::Type rm)
r=new impl::CustomRenderer();
break;
case RenderMode::SLINE:
- r=new impl::SlineRenderer(trace_);
+ r=new impl::SlineRenderer(&trace_);
break;
case RenderMode::LINE_TRACE:
- r=new impl::LineTraceRenderer(trace_);
+ r=new impl::LineTraceRenderer(&trace_);
break;
case RenderMode::TRACE:
- r=new impl::TraceRenderer(trace_);
+ r=new impl::TraceRenderer(&trace_);
break;
case RenderMode::HSC:
- r=new impl::CartoonRenderer(trace_);
+ r=new impl::CartoonRenderer(&trace_,false);
break;
case RenderMode::CPK:
r=new impl::CPKRenderer();
break;
case RenderMode::TUBE:
- r=new impl::CartoonRenderer(trace_, true);
+ r=new impl::CartoonRenderer(&trace_, true);
break;
default:
return 0;
@@ -144,11 +173,14 @@ impl::EntityRenderer* Entity::GetOrCreateRenderer(RenderMode::Type rm)
void Entity::init(RenderMode::Type rm)
{
// TODO replace with def mat for this gfx obj type
- SetMat(0.0,1.0,0.8,96.0);
+ SetMatAmb(Color(0,0,0));
+ SetMatDiff(Color(1,1,1));
+ SetMatSpec(Color(0.7,0.7,0.7));
+ SetMatShin(96);
update_view_=true;
render_mode_=rm;
- trace_.SetView(this->GetView());
+ trace_.ResetView(this->GetView());
sel_=this->GetView().CreateEmptyView();
impl::EntityRenderer* r=this->GetOrCreateRenderer(rm);
if(!r) return;
@@ -160,43 +192,46 @@ void Entity::init(RenderMode::Type rm)
Rebuild();
}
-namespace {
-
-SimpleRenderOptionsPtr get_sro(impl::EntityRenderer* renderer)
-{
- impl::SimpleRenderer* sr=dynamic_cast<SimpleRenderer*>(renderer);
- assert(sr);
- return dyn_cast<SimpleRenderOptions>(sr->GetOptions());
-}
-}
void Entity::SetBlur(bool f)
{
- impl::EntityRenderer* renderer=this->GetOrCreateRenderer(RenderMode::SIMPLE);
- if(!renderer) return;
- SimpleRenderOptionsPtr sro=get_sro(renderer);
- sro->SetBlurFlag(f);
+ blur_=f;
}
void Entity::BlurSnapshot()
{
- impl::EntityRenderer* renderer=this->GetOrCreateRenderer(RenderMode::SIMPLE);
- if(!renderer) return;
- impl::SimpleRenderer* sr=dynamic_cast<SimpleRenderer*>(renderer);
- assert(sr);
- sr->BlurSnapshot();
+ for (RendererMap::iterator i=renderer_.begin(),e=renderer_.end(); i!=e; ++i) {
+ impl::SimpleRenderer* sr = dynamic_cast<impl::SimpleRenderer*>(i->second);
+ if(sr) {
+ DoBlurSnapshot(sr->GetBondEntryList());
+ }
+ impl::LineTraceRenderer* lr = dynamic_cast<impl::LineTraceRenderer*>(i->second);
+ if(lr) {
+ DoBlurSnapshot(lr->GetBondEntryList());
+ }
+ }
}
void Entity::SetBlurFactors(float bf1,float bf2)
{
- impl::EntityRenderer* renderer=this->GetOrCreateRenderer(RenderMode::SIMPLE);
- if(!renderer) return;
- SimpleRenderOptionsPtr sro=get_sro(renderer);
- sro->SetBlurFactors(bf1, bf2);
+ blurf1_=bf1;
+ blurf2_=bf2;
}
void Entity::Rebuild()
{
geom::Vec3 delta=GetTF().GetTrans()-GetTF().GetCenter();
+
+ if(update_view_) {
+ EntityView nv=this->GetView();
+ for (RendererMap::iterator i=renderer_.begin(),
+ e=renderer_.end(); i!=e; ++i) {
+ i->second->ClearViews();
+ i->second->AddView(nv);
+ i->second->UpdateViews();
+ i->second->PrepareRendering();
+ }
+ }
+
this->ReapplyColorOps();
FlagRebuild();
geom::Vec3 center=this->GetCenter();
@@ -249,7 +284,7 @@ void Entity::ProcessLimits(geom::Vec3& minc, geom::Vec3& maxc,
maxc = geom::Max(maxc, geom::Max(t1, geom::Max(t2, geom::Max(t3,
geom::Max(t4, geom::Max(t5, geom::Max(t6,
geom::Max(t7, t8))))))));
- } catch(Error&) {
+ } catch(Error& e) {
// in case the object is empty...
}
}
@@ -296,6 +331,7 @@ bool Entity::UpdateIfNeeded() const
renderer->PrepareRendering();
updated=true;
}
+ renderer->VA().SetOpacity(opacity_);
}
if (updated) {
this->CacheBoundingBox();
@@ -324,66 +360,29 @@ void Entity::CustomRenderGL(RenderPass pass)
for (RendererMap::iterator i=renderer_.begin(),
e=renderer_.end(); i!=e; ++i) {
impl::EntityRenderer* r=i->second;
- if(r->IsEnabled()){
- switch(pass) {
- case STANDARD_RENDER_PASS:
- case OPAQUE_RENDER_PASS:
- r->Render(pass);
- break;
- case GLOW_RENDER_PASS:
- if (r->HasSelection()) {
- r->Render(pass);
- }
- break;
+ if(r->IsEnabled()) {
+ if(pass==STANDARD_RENDER_PASS) {
+ r->Render(pass);
+ if(outline_flag_) {
+ r->VA().SetOutlineMode(outline_mode_);
+ r->Render(STANDARD_RENDER_PASS);
+ r->VA().SetOutlineMode(0);
+ }
+ } else if(pass==GLOW_RENDER_PASS) {
+ r->Render(GLOW_RENDER_PASS);
+ }
+ if(blur_) {
+ impl::SimpleRenderer* sr = dynamic_cast<impl::SimpleRenderer*>(r);
+ if(sr) {
+ DoRenderBlur(sr->GetBondEntryList(),blurf1_,blurf2_);
+ }
+ impl::LineTraceRenderer* lr = dynamic_cast<impl::LineTraceRenderer*>(r);
+ if(lr) {
+ DoRenderBlur(lr->GetBondEntryList(),blurf1_,blurf2_);
+ }
}
}
}
- geom::AlignedCuboid bbox=this->GetBoundingBox();
- geom::Vec3 mmin=bbox.GetMin();
- geom::Vec3 mmax=bbox.GetMax();
-#if 0
- glDisable(GL_LIGHTING);
- glLineWidth(1.0);
- glColor3f(1.0, 1.0, 1.0);
- glBegin(GL_LINES);
- glVertex3(geom::Vec3(mmin[0], mmin[1], mmin[2]));
- glVertex3(geom::Vec3(mmin[0], mmax[1], mmin[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmax[1], mmin[2]));
- glVertex3(geom::Vec3(mmin[0], mmax[1], mmax[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmax[1], mmax[2]));
- glVertex3(geom::Vec3(mmin[0], mmin[1], mmax[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmin[1], mmax[2]));
- glVertex3(geom::Vec3(mmin[0], mmin[1], mmin[2]));
-
-
- glVertex3(geom::Vec3(mmax[0], mmin[1], mmin[2]));
- glVertex3(geom::Vec3(mmax[0], mmax[1], mmin[2]));
-
- glVertex3(geom::Vec3(mmax[0], mmax[1], mmin[2]));
- glVertex3(geom::Vec3(mmax[0], mmax[1], mmax[2]));
-
- glVertex3(geom::Vec3(mmax[0], mmax[1], mmax[2]));
- glVertex3(geom::Vec3(mmax[0], mmin[1], mmax[2]));
-
- glVertex3(geom::Vec3(mmax[0], mmin[1], mmax[2]));
- glVertex3(geom::Vec3(mmax[0], mmin[1], mmin[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmin[1], mmin[2]));
- glVertex3(geom::Vec3(mmax[0], mmin[1], mmin[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmax[1], mmin[2]));
- glVertex3(geom::Vec3(mmax[0], mmax[1], mmin[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmax[1], mmax[2]));
- glVertex3(geom::Vec3(mmax[0], mmax[1], mmax[2]));
-
- glVertex3(geom::Vec3(mmin[0], mmin[1], mmax[2]));
- glVertex3(geom::Vec3(mmax[0], mmin[1], mmax[2]));
- glEnd();
-#endif
}
void Entity::CustomRenderPov(PovState& pov)
@@ -567,6 +566,43 @@ void Entity::OptionsChanged(RenderMode::Type render_mode)
Scene::Instance().ObjectChanged(this->GetName());
}
+void Entity::SetOpacity(float f)
+{
+ opacity_=f;
+ this->UpdateIfNeeded();
+ Scene::Instance().RequestRedraw();
+}
+
+void Entity::SetOutlineWidth(float f)
+{
+ for (RendererMap::iterator it=renderer_.begin(); it!=renderer_.end(); ++it) {
+ if(it->second->IsEnabled()){
+ it->second->VA().SetOutlineWidth(f);
+ }
+ }
+ Scene::Instance().RequestRedraw();
+}
+
+void Entity::SetOutlineExpandFactor(float f)
+{
+ for (RendererMap::iterator it=renderer_.begin(); it!=renderer_.end(); ++it) {
+ if(it->second->IsEnabled()){
+ it->second->VA().SetOutlineExpandFactor(f);
+ }
+ }
+ Scene::Instance().RequestRedraw();
+}
+
+void Entity::SetOutlineExpandColor(const Color& c)
+{
+ for (RendererMap::iterator it=renderer_.begin(); it!=renderer_.end(); ++it) {
+ if(it->second->IsEnabled()){
+ it->second->VA().SetOutlineExpandColor(c);
+ }
+ }
+ Scene::Instance().RequestRedraw();
+}
+
void Entity::OnRenderModeChange()
{
for (RendererMap::iterator i=renderer_.begin(),
@@ -652,7 +688,7 @@ void Entity::SetRenderMode(RenderMode::Type mode,
}
renderer->UpdateViews();
}
- this->ReapplyColorOps();
+ this->ReapplyColorOps(); // done in rebuild?
this->FlagRebuild();
Scene::Instance().RenderModeChanged(GetName());
}
@@ -676,7 +712,7 @@ void Entity::SetVisible(const mol::EntityView& view, bool visible){
renderer->SetVisible(view, visible);
renderer->UpdateViews();
}
- this->ReapplyColorOps();
+ this->ReapplyColorOps(); // done in rebuild?
this->FlagRebuild();
}
@@ -765,6 +801,16 @@ void Entity::ColorBy(const String& prop,
this->Apply(glop);
}
+void Entity::DetailColorBy(const String& prop,
+ const Gradient& gradient,
+ float minv,float maxv,
+ mol::Prop::Level level)
+{
+ GradientLevelColorOp glop = GradientLevelColorOp("",prop, gradient,minv,maxv,level);
+ glop.SetMask(DETAIL_COLOR);
+ this->Apply(glop);
+}
+
void Entity::ColorBy(const String& prop,
const Color& c1, const Color& c2,
float minv, float maxv,
@@ -948,4 +994,11 @@ void Entity::ReapplyColorOps()
GfxObj::ReapplyColorOps();
}
+void Entity::UpdateView()
+{
+ update_view_=true;
+ Rebuild();
+ UpdatePositions();
+}
+
}} // ns
diff --git a/modules/gfx/src/entity.hh b/modules/gfx/src/entity.hh
index 368445df056732e6ad47777a1a36fea0b72deea8..d8896375428ffec7f95e3922b073e40a532be064 100644
--- a/modules/gfx/src/entity.hh
+++ b/modules/gfx/src/entity.hh
@@ -140,7 +140,16 @@ public:
virtual void OptionsChanged(RenderMode::Type mode);
+ virtual void SetOpacity(float f);
+ virtual float GetOpacity() const {return opacity_;}
+ virtual void SetOutlineWidth(float f);
+ virtual void SetOutlineExpandFactor(float f);
+ virtual void SetOutlineExpandColor(const Color& c);
+
/// \brief rebuild graphical object (see ctor comments)
+ /*
+ the naming here is misleading - this method WON'T be called upon FlagRebuild
+ */
void Rebuild();
/// \brief only grab updated positions, dont rebuild the whole thing
@@ -199,6 +208,12 @@ public:
float minv,float maxv,
mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
+ // temporary, should be incorporated with ColorBy
+ void DetailColorBy(const String& prop,
+ const Gradient& gradient,
+ float minv,float maxv,
+ mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
+
// convenience
void ColorBy(const String& prop,
const Gradient& gradient,
@@ -257,6 +272,9 @@ public:
void ApplyOptions(RenderMode::Type render_mode,
RenderOptionsPtr& render_options);
bool HasSelection() const;
+
+ void UpdateView();
+
protected:
virtual void CustomPreRenderGL(bool flag);
@@ -282,6 +300,11 @@ private:
typedef boost::ptr_map<RenderMode::Type, impl::EntityRenderer> RendererMap;
mutable RendererMap renderer_;
+
+ float opacity_;
+ bool blur_;
+ float blurf1_;
+ float blurf2_;
};
diff --git a/modules/gfx/src/gfx_node.cc b/modules/gfx/src/gfx_node.cc
index f3a61c11ebf8da0eb9fcacc39cd154d611c6f20d..395658e960b3e6226edbdbfe2e346192d0b4ad4f 100644
--- a/modules/gfx/src/gfx_node.cc
+++ b/modules/gfx/src/gfx_node.cc
@@ -160,5 +160,11 @@ bool GfxNode::IsVisible() const
return show_;
}
+void GfxNode::ContextSwitch()
+{
+ for(GfxNodeVector::iterator it =node_vector_.begin();it!=node_vector_.end();++it) {
+ (*it)->ContextSwitch();
+ }
+}
}} // ns
diff --git a/modules/gfx/src/gfx_node.hh b/modules/gfx/src/gfx_node.hh
index 0f7ecc2d009e7071766d7e08a84141a722f2c9cd..eb4fcc2bb85b8243e87ced85c056c260c0fdb900 100644
--- a/modules/gfx/src/gfx_node.hh
+++ b/modules/gfx/src/gfx_node.hh
@@ -95,6 +95,7 @@ class DLLEXPORT_OST_GFX GfxNode: public boost::enable_shared_from_this<GfxNode>
// return visibility state
bool IsVisible() const;
+ virtual void ContextSwitch();
private:
GfxNode(const GfxNode& o);
diff --git a/modules/gfx/src/gfx_object.cc b/modules/gfx/src/gfx_object.cc
index c0d24ff0e1729f3dd5e7964248a9ada6f5f66a99..8e992a0f7d763da5197e4c1f0395aaa24991836a 100644
--- a/modules/gfx/src/gfx_object.cc
+++ b/modules/gfx/src/gfx_object.cc
@@ -41,7 +41,7 @@
namespace ost { namespace gfx {
GfxObj::GfxObj(const String& name):
- GfxNode(name),
+ GfxObjBase(name),
va_(),
render_mode_(RenderMode::SIMPLE),
debug_flags_(0),
@@ -49,9 +49,6 @@ GfxObj::GfxObj(const String& name):
rebuild_(true),
refresh_(false),
line_width_(2.0),
- sphere_detail_(4),
- arc_detail_(4),
- spline_detail_(8),
poly_mode_(2),
aalines_flag_(false),
line_halo_(0.0),
@@ -60,64 +57,22 @@ GfxObj::GfxObj(const String& name):
mat_update_(true),
opacity_(1.0),
smoothf_(0.0),
- omode_(0),
+ outline_flag_(false),
+ outline_mode_(1),
c_ops_(),
labels_(),
use_occlusion_(false)
{
}
-GfxObj::~GfxObj()
-{}
-
-GfxObj::GfxObj(const GfxObj& o):
- GfxNode("") // to make the compiler happy
+GfxObj::GfxObj(const GfxObj&):
+ GfxObjBase("") // to make the compiler happy
{}
GfxObj& GfxObj::operator=(const GfxObj&) {return *this;}
-void GfxObj::Apply(GfxNodeVisitor& v, GfxNodeVisitor::Stack st)
-{
- v.VisitObject(this,st);
-}
-
-int GfxObj::GetType() const
-{
- return 1;
-}
-
-geom::AlignedCuboid GfxObj::GetBoundingBox() const
-{
- return geom::AlignedCuboid(geom::Vec3(),geom::Vec3());
-}
-
-void GfxObj::ProcessLimits(geom::Vec3& minc, geom::Vec3& maxc,
- const mol::Transform& tf) const
-{
- try {
- geom::AlignedCuboid coord_limits=this->GetBoundingBox();
- // update min/max by transforming all 8 corners of the bounding box and
- // comparing it against the current min/max
- geom::Vec3 mmin=coord_limits.GetMin();
- geom::Vec3 mmax=coord_limits.GetMax();
- geom::Vec3 t1=tf.Apply(geom::Vec3(mmin[0], mmin[1], mmin[2]));
- geom::Vec3 t2=tf.Apply(geom::Vec3(mmin[0], mmax[1], mmin[2]));
- geom::Vec3 t3=tf.Apply(geom::Vec3(mmax[0], mmax[1], mmin[2]));
- geom::Vec3 t4=tf.Apply(geom::Vec3(mmax[0], mmin[1], mmin[2]));
- geom::Vec3 t5=tf.Apply(geom::Vec3(mmin[0], mmin[1], mmax[2]));
- geom::Vec3 t6=tf.Apply(geom::Vec3(mmin[0], mmax[1], mmax[2]));
- geom::Vec3 t7=tf.Apply(geom::Vec3(mmax[0], mmax[1], mmax[2]));
- geom::Vec3 t8=tf.Apply(geom::Vec3(mmax[0], mmin[1], mmax[2]));
- minc = geom::Min(minc, geom::Min(t1, geom::Min(t2, geom::Min(t3,
- geom::Min(t4, geom::Min(t5, geom::Min(t6,
- geom::Min(t7, t8))))))));
- maxc = geom::Max(maxc, geom::Max(t1, geom::Max(t2, geom::Max(t3,
- geom::Max(t4, geom::Max(t5, geom::Max(t6,
- geom::Max(t7, t8))))))));
- } catch(Error&) {
- // in case the object is empty...
- }
-}
+////////////////////////////////////////
+// the GfxNode interface
GfxNodeP GfxObj::Copy() const
{
@@ -130,9 +85,6 @@ void GfxObj::DeepSwap(GfxObj& go)
std::swap(transform_,go.transform_);
std::swap(rebuild_,go.rebuild_);
std::swap(refresh_,go.refresh_);
- std::swap(sphere_detail_,go.sphere_detail_);
- std::swap(arc_detail_,go.arc_detail_);
- std::swap(spline_detail_,go.spline_detail_);
std::swap(poly_mode_,go.poly_mode_);
std::swap(aalines_flag_,go.aalines_flag_);
std::swap(line_halo_,go.line_halo_);
@@ -141,95 +93,150 @@ void GfxObj::DeepSwap(GfxObj& go)
std::swap(mat_update_,go.mat_update_);
std::swap(opacity_,go.opacity_);
std::swap(smoothf_,go.smoothf_);
+ std::swap(outline_flag_,go.outline_flag_);
+ std::swap(outline_mode_,go.outline_mode_);
+ std::swap(c_ops_,go.c_ops_);
+ std::swap(labels_,go.labels_);
+ std::swap(use_occlusion_,go.use_occlusion_);
}
-void GfxObj::CustomRenderGL(RenderPass pass) {}
-void GfxObj::CustomPreRenderGL(bool flag) {}
+void GfxObj::RenderGL(RenderPass pass)
+{
+ LOGN_TRACE("object " << GetName() << ": RenderGL()");
-void GfxObj::CustomRenderPov(PovState& pov) {}
+ if(pass==0) {
+ if(mat_update_) {
+ LOGN_TRACE("updating material display list");
+ if(mat_dlist_==0) {
+ mat_dlist_=glGenLists(1);
+ }
+ glNewList(mat_dlist_,GL_COMPILE);
+ mat_.RenderGL();
+ glEndList();
+ mat_update_=false;
+ }
+
+ if(rebuild_ || refresh_) {
+ PreRenderGL(rebuild_);
+ rebuild_=false;
+ refresh_=false;
+ // there really needs to be a central place
+ // where the va attributes are re-applied
+ va_.SetOpacity(opacity_);
+ }
+ }
+ if(IsVisible()) {
+ LOGN_TRACE("applying local transformation");
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glMultMatrix(transform_.GetTransposedMatrix().Data());
+ if(Scene::Instance().InOffscreenMode()) {
+ LOGN_TRACE("applying material");
+ mat_.RenderGL();
+ } else {
+ LOGN_TRACE("applying material display list");
+ glCallList(mat_dlist_);
+ }
+ LOGN_TRACE("calling custom render gl pass " << pass);
-void GfxObj::RefreshVA(IndexedVertexArray& va)
-{
- va.SetLineWidth(GetLineWidth());
- va.SetPolyMode(GetPolyMode());
- va.SetAALines(GetAALines());
- va.SetLineHalo(GetLineHalo());
- va.DrawNormals(debug_flags_&0x1);
- va.SetPolyMode(debug_flags_&0x2 ? 1 : 2);
- va.UseAmbient(use_occlusion_);
- va.FlagRefresh();
+ /*
+ only STANDARD_RENDER_PASS and GLOW_RENDER_PASS are
+ passed down to the custom rendering routines
+ */
+
+ if(pass==DEPTH_RENDER_PASS) {
+ render_depth_only();
+ } else if(pass==TRANSPARENT_RENDER_PASS) {
+ if(GetOpacity()<1.0) {
+ render_depth_only();
+ CustomRenderGL(STANDARD_RENDER_PASS);
+ }
+ } else if(pass==STANDARD_RENDER_PASS) {
+ if(GetOpacity()>=1.0) {
+ CustomRenderGL(STANDARD_RENDER_PASS);
+ }
+ if(outline_flag_) {
+ va_.SetOutlineMode(outline_mode_);
+ CustomRenderGL(pass);
+ va_.SetOutlineMode(0);
+ }
+ } else if(pass==GLOW_RENDER_PASS) {
+ CustomRenderGL(GLOW_RENDER_PASS);
+ } else if(pass==OVERLAY_RENDER_PASS) {
+ LOGN_TRACE("drawing labels");
+ render_labels();
+ }
+
+ glPopMatrix();
+ }
}
-void GfxObj::OnInput(const InputEvent& e)
-{
- geom::Mat3 rot=gfx::Scene::Instance().GetTransform().GetRot();
- geom::Vec3 cam_trans=gfx::Scene::Instance().GetTransform().GetTrans();
- float x=e.GetDelta()*M_PI/180.0;
- bool transformed=false;
- if (e.GetCommand()==INPUT_COMMAND_ROTX) {
- transformed=true;
- transform_.SetRot(AxisRotation(geom::Vec3(1,0,0)*rot,x)*transform_.GetRot());
- } else if(e.GetCommand()==INPUT_COMMAND_ROTY) {
- transformed=true;
- transform_.SetRot(AxisRotation(geom::Vec3(0,1,0)*rot,x)*transform_.GetRot());
- } else if(e.GetCommand()==INPUT_COMMAND_ROTZ) {
- transformed=true;
- transform_.SetRot(AxisRotation(geom::Vec3(0,0,1)*rot,x)*transform_.GetRot());
- } else if(e.GetCommand()==INPUT_COMMAND_TRANSX ||
- e.GetCommand()==INPUT_COMMAND_TRANSY) {
-
- double mm[]={1,0,0,0,
- 0,1,0,0,
- 0,0,1,0,
- transform_.GetTrans()[0]-cam_trans[0],
- transform_.GetTrans()[1]-cam_trans[1],
- transform_.GetTrans()[2]-cam_trans[2], 1};
- double pm[16];
- glGetDoublev(GL_PROJECTION_MATRIX,pm);
- GLint vp[4];
- glGetIntegerv(GL_VIEWPORT,vp);
- double wx,wy,wz;
- gluProject(0.0,0.0,0.0,mm,pm,vp,&wx,&wy,&wz);
- double ox,oy,oz;
- gluUnProject(wx+1.0,wy+1.0,wz,mm,pm,vp,&ox,&oy,&oz);
- float fx=ox;
- float fy=oy;
- geom::Vec3 trans=transform_.GetTrans();
- transformed=true;
- if (e.GetCommand()==INPUT_COMMAND_TRANSX) {
- trans+=geom::Vec3(-fx*e.GetDelta(), 0.0, 0.0)*rot;
- } else {
- trans+=geom::Vec3(0.0, -fy*e.GetDelta(), 0.0)*rot;
+void GfxObj::RenderPov(PovState& pov)
+{
+ if(IsVisible()) {
+ pov.start_obj(GetName(),1.0,1.0,1.0);
+ // apply local transformation
+ // using transform_
+ if(rebuild_ || refresh_) {
+ PreRenderGL(true);
}
- transform_.SetTrans(trans);
- }
- if (transformed) {
- GfxObjP obj=dyn_cast<GfxObj>(this->shared_from_this());
- Scene::Instance().NodeTransformed(obj);
+ CustomRenderPov(pov);
+ pov.end_obj();
}
}
-const mol::Transform& GfxObj::GetTF() const
+void GfxObj::Apply(GfxNodeVisitor& v, GfxNodeVisitor::Stack st)
{
- return transform_;
+ v.VisitObject(this,st);
}
+int GfxObj::GetType() const
+{
+ return 1;
+}
-void GfxObj::SetTF(const mol::Transform& tf)
+////////////////////////////////////////
+// now for the GfxObjBase interface
+void GfxObj::SetMatAmb(const Color& c)
{
- transform_=tf;
+ mat_.SetAmb(c);
+ mat_update_=true;
+ Scene::Instance().RequestRedraw();
}
-geom::Vec3 GfxObj::GetCenter() const
+void GfxObj::SetMatDiff(const Color& c)
{
- return this->GetBoundingBox().GetCenter();
+ mat_.SetDiff(c);
+ mat_update_=true;
+ Scene::Instance().RequestRedraw();
}
-bool GfxObj::OnSelect(const geom::Line3& l, geom::Vec3& result,
- float zlim, bool pick_flag)
+void GfxObj::SetMatSpec(const Color& c)
{
- return false;
+ mat_.SetSpec(c);
+ mat_update_=true;
+ Scene::Instance().RequestRedraw();
+}
+
+void GfxObj::SetMatShin(float s)
+{
+ mat_.SetShin(s);
+ mat_update_=true;
+ Scene::Instance().RequestRedraw();
+}
+
+void GfxObj::SetMatEmm(const Color& c)
+{
+ mat_.SetEmm(c);
+ mat_update_=true;
+ Scene::Instance().RequestRedraw();
+}
+
+void GfxObj::ContextSwitch()
+{
+ FlagRebuild();
+ GfxNode::ContextSwitch();
}
void GfxObj::SetRenderMode(RenderMode::Type m)
@@ -245,197 +252,240 @@ RenderMode::Type GfxObj::GetRenderMode() const
return render_mode_;
}
-void GfxObj::FlagRebuild()
+geom::Vec3 GfxObj::GetCenter() const
{
- rebuild_=true;
- Scene::Instance().RequestRedraw();
+ return this->GetBoundingBox().GetCenter();
}
-void GfxObj::FlagRefresh()
+void GfxObj::SetLineWidth(float w)
{
- refresh_=true;
- Scene::Instance().RequestRedraw();
+ va_.SetLineWidth(w);
+ line_width_=std::max(float(0.01),w);
+ FlagRefresh();
+ Scene::Instance().RenderModeChanged(GetName());
}
-void GfxObj::SetNormalSmoothFactor(float smoothf)
+void GfxObj::SetPolyMode(unsigned int m)
{
- smoothf_=smoothf;
- FlagRebuild();
+ if(m==poly_mode_) return;
+ poly_mode_=std::min((unsigned int)2,m);
+ va_.SetPolyMode(poly_mode_);
+ FlagRefresh();
}
-float GfxObj::GetNormalSmoothFactor() const
+void GfxObj::SetAALines(bool f)
{
- return smoothf_;
+ if(f==aalines_flag_) return;
+ va_.SetAALines(f);
+ aalines_flag_=f;
+ FlagRefresh();
}
-void GfxObj::OnRenderModeChange()
+void GfxObj::SetLineHalo(float f)
{
- Scene::Instance().ObjectChanged(GetName());
- Scene::Instance().RenderModeChanged(GetName());
+ va_.SetLineHalo(f);
+ line_halo_=f;
+ FlagRefresh();
}
-void GfxObj::SetLineWidth(float w)
+void GfxObj::SetOutline(bool f)
{
- line_width_=std::max(float(0.01),w);
+ outline_flag_=f;
FlagRefresh();
- Scene::Instance().RenderModeChanged(GetName());
+ if(f) {
+ outline_mode_=std::min(3,std::max(1,outline_mode_));
+ }
+ Scene::Instance().RequestRedraw();
}
-float GfxObj::GetLineWidth() const
+void GfxObj::SetOutlineMode(int m)
{
- return line_width_;
+ outline_mode_=m;
+ if(outline_flag_) {
+ FlagRefresh();
+ Scene::Instance().RequestRedraw();
+ }
}
-void GfxObj::SetSphereDetail(unsigned int d)
+void GfxObj::SetOutlineWidth(float f)
{
- if(d==sphere_detail_) return;
- sphere_detail_=d;
- FlagRebuild();
+ va_.SetOutlineWidth(f);
+ Scene::Instance().RequestRedraw();
}
-unsigned int GfxObj::GetSphereDetail() const
+void GfxObj::SetOutlineExpandFactor(float f)
{
- return sphere_detail_;
+ va_.SetOutlineExpandFactor(f);
+ Scene::Instance().RequestRedraw();
}
-void GfxObj::SetArcDetail(unsigned int d)
+void GfxObj::SetOutlineExpandColor(const Color& c)
{
- if(d==arc_detail_) return;
- arc_detail_=d;
- FlagRebuild();
+ va_.SetOutlineExpandColor(c);
+ Scene::Instance().RequestRedraw();
}
-unsigned int GfxObj::GetArcDetail() const
+void GfxObj::SetOpacity(float o)
{
- return arc_detail_;
+ opacity_=o;
+ va_.SetOpacity(opacity_);
+ FlagRefresh();
+ Scene::Instance().RequestRedraw();
}
-void GfxObj::SetSplineDetail(unsigned int d)
+void GfxObj::ColorBy(const mol::EntityView& ev,
+ const String& prop,
+ const Gradient& g, float minv, float maxv)
{
- if(d==spline_detail_) return;
- spline_detail_=d;
- FlagRebuild();
+ LOGN_VERBOSE("ColorBy not implemented for this gfx object");
}
-unsigned int GfxObj::GetSplineDetail() const
+#if OST_IMG_ENABLED
+void GfxObj::ColorBy(const img::MapHandle& mh,
+ const String& prop,
+ const Gradient& g, float minv, float maxv)
{
- return spline_detail_;
+ LOGN_VERBOSE("ColorBy not implemented for this gfx object");
}
+#endif
-void GfxObj::SetPolyMode(unsigned int m)
+//////////////////////////////////////////////////
+// and now for the rest of the GfxObj interface
+
+geom::AlignedCuboid GfxObj::GetBoundingBox() const
{
- if(m==poly_mode_) return;
- poly_mode_=std::min((unsigned int)2,m);
- FlagRefresh();
+ return geom::AlignedCuboid(geom::Vec3(),geom::Vec3());
}
-unsigned int GfxObj::GetPolyMode() const
+void GfxObj::ProcessLimits(geom::Vec3& minc, geom::Vec3& maxc,
+ const mol::Transform& tf) const
{
- return poly_mode_;
+ try {
+ geom::AlignedCuboid coord_limits=this->GetBoundingBox();
+ // update min/max by transforming all 8 corners of the bounding box and
+ // comparing it against the current min/max
+ geom::Vec3 mmin=coord_limits.GetMin();
+ geom::Vec3 mmax=coord_limits.GetMax();
+ geom::Vec3 t1=tf.Apply(geom::Vec3(mmin[0], mmin[1], mmin[2]));
+ geom::Vec3 t2=tf.Apply(geom::Vec3(mmin[0], mmax[1], mmin[2]));
+ geom::Vec3 t3=tf.Apply(geom::Vec3(mmax[0], mmax[1], mmin[2]));
+ geom::Vec3 t4=tf.Apply(geom::Vec3(mmax[0], mmin[1], mmin[2]));
+ geom::Vec3 t5=tf.Apply(geom::Vec3(mmin[0], mmin[1], mmax[2]));
+ geom::Vec3 t6=tf.Apply(geom::Vec3(mmin[0], mmax[1], mmax[2]));
+ geom::Vec3 t7=tf.Apply(geom::Vec3(mmax[0], mmax[1], mmax[2]));
+ geom::Vec3 t8=tf.Apply(geom::Vec3(mmax[0], mmin[1], mmax[2]));
+ minc = geom::Min(minc, geom::Min(t1, geom::Min(t2, geom::Min(t3,
+ geom::Min(t4, geom::Min(t5, geom::Min(t6,
+ geom::Min(t7, t8))))))));
+ maxc = geom::Max(maxc, geom::Max(t1, geom::Max(t2, geom::Max(t3,
+ geom::Max(t4, geom::Max(t5, geom::Max(t6,
+ geom::Max(t7, t8))))))));
+ } catch(Error& e) {
+ // in case the object is empty...
+ }
}
-void GfxObj::SetAALines(bool f)
-{
- if(f==aalines_flag_) return;
- aalines_flag_=f;
- FlagRefresh();
+
+void GfxObj::CustomRenderGL(RenderPass pass) {}
+
+void GfxObj::CustomPreRenderGL(bool flag) {}
+
+void GfxObj::CustomRenderPov(PovState& pov) {}
+
+bool GfxObj::OnSelect(const geom::Line3& l, geom::Vec3& result,
+ float zlim, bool pick_flag)
+{
+ return false;
+}
+
+void GfxObj::OnInput(const InputEvent& e)
+{
+ geom::Mat3 rot=gfx::Scene::Instance().GetTransform().GetRot();
+ geom::Vec3 cam_trans=gfx::Scene::Instance().GetTransform().GetTrans();
+ float x=e.GetDelta()*M_PI/180.0;
+ bool transformed=false;
+ if (e.GetCommand()==INPUT_COMMAND_ROTX) {
+ transformed=true;
+ transform_.SetRot(AxisRotation(geom::Vec3(1,0,0)*rot,x)*transform_.GetRot());
+ } else if(e.GetCommand()==INPUT_COMMAND_ROTY) {
+ transformed=true;
+ transform_.SetRot(AxisRotation(geom::Vec3(0,1,0)*rot,x)*transform_.GetRot());
+ } else if(e.GetCommand()==INPUT_COMMAND_ROTZ) {
+ transformed=true;
+ transform_.SetRot(AxisRotation(geom::Vec3(0,0,1)*rot,x)*transform_.GetRot());
+ } else if(e.GetCommand()==INPUT_COMMAND_TRANSX ||
+ e.GetCommand()==INPUT_COMMAND_TRANSY) {
+
+ double mm[]={1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ transform_.GetTrans()[0]-cam_trans[0],
+ transform_.GetTrans()[1]-cam_trans[1],
+ transform_.GetTrans()[2]-cam_trans[2], 1};
+ double pm[16];
+ glGetDoublev(GL_PROJECTION_MATRIX,pm);
+ GLint vp[4];
+ glGetIntegerv(GL_VIEWPORT,vp);
+ double wx,wy,wz;
+ gluProject(0.0,0.0,0.0,mm,pm,vp,&wx,&wy,&wz);
+ double ox,oy,oz;
+ gluUnProject(wx+1.0,wy+1.0,wz,mm,pm,vp,&ox,&oy,&oz);
+
+ float fx=ox;
+ float fy=oy;
+ geom::Vec3 trans=transform_.GetTrans();
+ transformed=true;
+ if (e.GetCommand()==INPUT_COMMAND_TRANSX) {
+ trans+=geom::Vec3(-fx*e.GetDelta(), 0.0, 0.0)*rot;
+ } else {
+ trans+=geom::Vec3(0.0, -fy*e.GetDelta(), 0.0)*rot;
+ }
+ transform_.SetTrans(trans);
+ }
+ if (transformed) {
+ GfxObjP obj=dyn_cast<GfxObj>(this->shared_from_this());
+ Scene::Instance().NodeTransformed(obj);
+ }
}
-bool GfxObj::GetAALines() const
+const mol::Transform& GfxObj::GetTF() const
{
- return aalines_flag_;
+ return transform_;
}
-void GfxObj::SetLineHalo(float f)
-{
- line_halo_=f;
- FlagRefresh();
-}
-float GfxObj::GetLineHalo() const
+void GfxObj::SetTF(const mol::Transform& tf)
{
- return line_halo_;
+ transform_=tf;
}
-void GfxObj::SetOutlineMode(int m)
+void GfxObj::FlagRebuild()
{
- omode_=m;
- FlagRefresh();
+ rebuild_=true;
+ Scene::Instance().RequestRedraw();
}
-void GfxObj::SetOutlineExpandFactor(float f)
+void GfxObj::FlagRefresh()
{
- va_.SetOutlineExpandFactor(f);
+ refresh_=true;
+ Scene::Instance().RequestRedraw();
}
-void GfxObj::SetOutlineExpandColor(const Color& c)
+void GfxObj::SetNormalSmoothFactor(float smoothf)
{
- va_.SetOutlineExpandColor(c);
+ smoothf_=smoothf;
+ FlagRebuild();
}
-void GfxObj::RenderGL(RenderPass pass)
+float GfxObj::GetNormalSmoothFactor() const
{
- LOGN_TRACE("object " << GetName() << ": RenderGL()");
-
- if(pass==0) {
- if(mat_update_) {
- LOGN_TRACE("updating material display list");
- if(mat_dlist_==0) {
- mat_dlist_=glGenLists(1);
- }
- glNewList(mat_dlist_,GL_COMPILE);
- mat_.RenderGL();
- glEndList();
- mat_update_=false;
- }
-
- if(rebuild_ || refresh_) {
- PreRenderGL(rebuild_);
- rebuild_=false;
- refresh_=false;
- }
- }
- if(IsVisible()) {
- LOGN_TRACE("applying local transformation");
- glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- glMultMatrix(transform_.GetTransposedMatrix().Data());
- if(Scene::Instance().InOffscreenMode()) {
- LOGN_TRACE("applying material");
- mat_.RenderGL();
- } else {
- LOGN_TRACE("applying material display list");
- glCallList(mat_dlist_);
- }
- LOGN_TRACE("calling custom render gl pass " << pass);
-
- CustomRenderGL(pass);
-
- if(pass==0 && omode_>0) {
- va_.SetOutlineMode(omode_);
- CustomRenderGL(pass);
- va_.SetOutlineMode(0);
- }
-
- if(pass==1) {
- LOGN_TRACE("drawing labels");
- render_labels();
- }
-
- glPopMatrix();
- }
+ return smoothf_;
}
-
-void GfxObj::RenderPov(PovState& pov)
+void GfxObj::OnRenderModeChange()
{
- if(IsVisible()) {
- pov.start_obj(GetName(),1.0,1.0,1.0);
- // apply local transformation
- // using transform_
- CustomRenderPov(pov);
- pov.end_obj();
- }
+ Scene::Instance().ObjectChanged(GetName());
+ Scene::Instance().RenderModeChanged(GetName());
}
void GfxObj::PreRenderGL(bool f)
@@ -446,6 +496,7 @@ void GfxObj::PreRenderGL(bool f)
void GfxObj::Clear()
{
+ va_.Clear();
}
Color GfxObj::Ele2Color(const String& ele)
@@ -487,90 +538,6 @@ void GfxObj::ClearLabels()
labels_.clear();
}
-void GfxObj::SetMatAmb(const Color& c)
-{
- mat_.SetAmb(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatAmb(float c)
-{
- mat_.SetAmb(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatDiff(const Color& c)
-{
- mat_.SetDiff(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatDiff(float c)
-{
- mat_.SetDiff(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatSpec(const Color& c)
-{
- mat_.SetSpec(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatSpec(float c)
-{
- mat_.SetSpec(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatShin(float s)
-{
- mat_.SetShin(s);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatEmm(const Color& c)
-{
- mat_.SetEmm(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMatEmm(float c)
-{
- mat_.SetEmm(c);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMat(const Color& amb, const Color& diff, const Color& spec, float shin)
-{
- SetMatAmb(amb);
- SetMatDiff(diff);
- SetMatSpec(spec);
- SetMatShin(shin);
- SetMatEmm(0.0);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::SetMat(float amb, float diff, float spec, float shin)
-{
- SetMatAmb(amb);
- SetMatDiff(diff);
- SetMatSpec(spec);
- SetMatShin(shin);
- SetMatEmm(0.0);
- mat_update_=true;
- Scene::Instance().RequestRedraw();
-}
Material GfxObj::GetMaterial() const
{
@@ -594,139 +561,12 @@ void GfxObj::GLCleanup()
void GfxObj::OnGLCleanup()
{}
-void GfxObj::SetOpacity(float o)
-{
- opacity_=o;
- FlagRebuild();
-}
-
-float GfxObj::GetOpacity() const
-{
- return opacity_;
-}
-
void GfxObj::SmoothVertices(float smoothf)
{
va_.SmoothVertices(smoothf);
FlagRefresh();
}
-void GfxObj::AmbientOcclusion(bool f)
-{
- use_occlusion_=f;
- va_.UseAmbient(f);
- Scene::Instance().RequestRedraw();
-}
-
-void GfxObj::ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Gradient& g, float minv, float maxv)
-{
- LOGN_VERBOSE("ColorBy not implemented for this gfx object");
-}
-
-
-void GfxObj::ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv)
-{
- Gradient g;
- g.SetColorAt(0.0,c1);
- g.SetColorAt(1.0,c2);
- this->ColorBy(ev,prop,g,minv,maxv);
-}
-
-#if OST_IMG_ENABLED
-void GfxObj::ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Gradient& g, float minv, float maxv)
-{
- LOGN_VERBOSE("ColorBy not implemented for this gfx object");
-}
-
-void GfxObj::ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv)
-{
- Gradient g;
- g.SetColorAt(0.0,c1);
- g.SetColorAt(1.0,c2);
- this->ColorBy(mh,prop,g,minv,maxv);
-}
-
-void GfxObj::ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Gradient& g)
-{
- ost::img::alg::Stat stat;
- mh.Apply(stat);
- float min = static_cast<float>(stat.GetMinimum());
- float max = static_cast<float>(stat.GetMaximum());
- std::pair<float,float> minmax = std::make_pair(min,max);
- this->ColorBy(mh,prop,g,minmax.first, minmax.second);
-}
-
-void GfxObj::ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Color& c1, const Color& c2)
-{
- ost::img::alg::Stat stat;
- mh.Apply(stat);
- float min = static_cast<float>(stat.GetMinimum());
- float max = static_cast<float>(stat.GetMaximum());
- std::pair<float,float> minmax = std::make_pair(min,max);
- this->ColorBy(mh,prop,c1,c2,minmax.first, minmax.second);
-}
-
-#endif //OST_IMG_ENABLED
-
-void GfxObj::ColorBy(const mol::EntityHandle& eh,
- const String& prop,
- const Gradient& g, float minv, float maxv)
-{
- this->ColorBy(eh.CreateFullView(),prop,g,minv,maxv);
-}
-
-void GfxObj::ColorBy(const mol::EntityHandle& eh,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv)
-{
- Gradient g;
- g.SetColorAt(0.0,c1);
- g.SetColorAt(1.0,c2);
- this->ColorBy(eh,prop,g,minv,maxv);
-}
-
-void GfxObj::ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Gradient& g)
-{
- std::pair<float,float> minmax = ev.GetMinMax(prop);
- this->ColorBy(ev,prop,g,minmax.first, minmax.second);
-}
-
-void GfxObj::ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Color& c1, const Color& c2)
-{
- std::pair<float,float> minmax = ev.GetMinMax(prop);
- this->ColorBy(ev,prop,c1,c2,minmax.first, minmax.second);
-}
-
-void GfxObj::ColorBy(const mol::EntityHandle& eh,
- const String& prop,
- const Gradient& g)
-{
- this->ColorBy(eh.CreateFullView(),prop,g);
-}
-
-void GfxObj::ColorBy(const mol::EntityHandle& eh,
- const String& prop,
- const Color& c1, const Color& c2)
-{
- this->ColorBy(eh.CreateFullView(),prop,c1,c2);
-}
-
namespace {
float normalize(float v, float min_v, float max_v)
@@ -748,7 +588,7 @@ void GfxObj::ReapplyColorOps(){
GfxObjP o=dyn_cast<GfxObj>(shared_from_this());
for(boost::ptr_vector<gfx::ColorOp>::iterator it=c_ops_.begin();
it!=c_ops_.end();++it) {
- it->ApplyTo(o);
+ it->ApplyTo(o);
}
}
}
@@ -761,4 +601,31 @@ void GfxObj::CleanColorOps(){
c_ops_.release();
}
+void GfxObj::Debug(unsigned int flags)
+{
+ va_.DrawNormals(flags & 0x1);
+}
+
+void GfxObj::render_depth_only()
+{
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+ glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+ glDisable(GL_LIGHTING);
+ glDisable(GL_COLOR_MATERIAL);
+ glDisable(GL_BLEND);
+ glDisable(GL_FOG);
+ glShadeModel(GL_FLAT);
+ glDisable(GL_LINE_SMOOTH);
+ glDisable(GL_POINT_SMOOTH);
+ glDisable(GL_POLYGON_SMOOTH);
+ glDisable(GL_DITHER);
+ glDisable(GL_NORMALIZE);
+ glEnable(GL_DEPTH_TEST);
+ CustomRenderGL(STANDARD_RENDER_PASS);
+ CustomRenderGL(TRANSPARENT_RENDER_PASS);
+ glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
+ glPopAttrib();
+}
+
+
}} // ns
diff --git a/modules/gfx/src/gfx_object.hh b/modules/gfx/src/gfx_object.hh
index 5a4bd4877dec27e434a1cdce1fe7ade9abf58adc..42f9fbbfecca4636f2742edb573d468b5f0cf1d9 100644
--- a/modules/gfx/src/gfx_object.hh
+++ b/modules/gfx/src/gfx_object.hh
@@ -33,58 +33,66 @@
#include <ost/config.hh>
#include <ost/gfx/module_config.hh>
-#include <ost/gfx/color_ops/color_op.hh>
-
-#include <ost/geom/geom.hh>
-#include <ost/mol/entity_handle.hh>
-#include <ost/mol/entity_view.hh>
#include <ost/mol/transform.hh>
-
-#if OST_IMG_ENABLED
-# include <ost/img/map.hh>
-#endif
-
#include "gfx_object_fw.hh"
-#include "gfx_node.hh"
+#include "gfx_object_base.hh"
#include "gfx_prim.hh"
#include "vertex_array.hh"
#include "input.hh"
-#include "render_mode.hh"
-#include "material.hh"
-#include "gradient.hh"
-
namespace ost { namespace gfx {
class Scene; // fw decl
-/// \brief Base class for all graphical rendering objects
-class DLLEXPORT_OST_GFX GfxObj: public GfxNode
+/// \brief main class for all graphic objects
+class DLLEXPORT_OST_GFX GfxObj: public GfxObjBase
{
-
public:
GfxObj(const String& name);
- virtual ~GfxObj();
+ // gfx node interface
virtual GfxNodeP Copy() const;
-
+ virtual void DeepSwap(GfxObj& go);
+ virtual void RenderGL(RenderPass pass);
+ virtual void RenderPov(PovState& pov);
virtual void Apply(GfxNodeVisitor& v,GfxNodeVisitor::Stack st);
-
virtual int GetType() const;
+ //
+
+ // gfx obj base interface
+ virtual void SetMatAmb(const Color& c);
+ virtual void SetMatDiff(const Color& c);
+ virtual void SetMatSpec(const Color& c);
+ virtual void SetMatShin(float s);
+ virtual void SetMatEmm(const Color& c);
+ virtual void ContextSwitch();
+ virtual void SetRenderMode(RenderMode::Type m);
+ virtual RenderMode::Type GetRenderMode() const;
+ virtual geom::Vec3 GetCenter() const;
+ virtual void SetLineWidth(float w);
+ virtual void SetPolyMode(unsigned int m);
+ virtual void SetAALines(bool f);
+ virtual void SetLineHalo(float f);
+ virtual void SetOutline(bool f);
+ virtual void SetOutlineMode(int m);
+ virtual void SetOutlineWidth(float f);
+ virtual void SetOutlineExpandFactor(float f);
+ virtual void SetOutlineExpandColor(const Color& c);
+ virtual void SetOpacity(float f);
+ virtual float GetOpacity() const {return opacity_;}
+ virtual void ColorBy(const mol::EntityView& ev,
+ const String& prop,
+ const Gradient& g, float minv, float maxv);
+#if OST_IMG_ENABLED
+ virtual void ColorBy(const img::MapHandle& mh,
+ const String& prop,
+ const Gradient& g,float minv, float maxv);
+#endif
- virtual void RenderGL(RenderPass pass);
-
- virtual void RenderPov(PovState& pov);
+ // end of gfx obj base interface
- void Clear();
-
- /// \brief get transform
- const mol::Transform& GetTF() const;
- /// \brief set transform
- void SetTF(const mol::Transform& tf);
-
- virtual geom::Vec3 GetCenter() const;
+ // new gfx obj virtual interface starts here
/// \brief returns the left-bottom-front and the right-top-back corner
/// that encompasses all graphical elements in this object
@@ -98,8 +106,14 @@ public:
virtual void ProcessLimits(geom::Vec3& minc, geom::Vec3& maxc,
const mol::Transform& tf) const;
+ // implemented in derived classes for the actual GL rendering
+ /*
+ note: only STANDARD_RENDER_PASS and GLOW_RENDER_PASS need to
+ be implemented, the rest is taken care of by GfxObj::RenderGL
+ */
virtual void CustomRenderGL(RenderPass pass);
+ // implemented in derived classes for the actual POVray export
virtual void CustomRenderPov(PovState& pov);
// handle pick (select) event
@@ -116,43 +130,20 @@ public:
// input event entry point
virtual void OnInput(const InputEvent& e);
-
- virtual void DeepSwap(GfxObj& go);
-
+
+ // informs derived class that render mode has changes
virtual void OnRenderModeChange();
virtual void OnGLCleanup();
+ //
- /// \brief change render mode
- virtual void SetRenderMode(RenderMode::Type m);
- /// \brief current render mode
- RenderMode::Type GetRenderMode() const;
-
- /// \brief set line width
- void SetLineWidth(float w);
+ /// \brief removes all graphical elements
+ void Clear();
+
+ /// \brief get transform
+ const mol::Transform& GetTF() const;
+ /// \brief set transform
+ void SetTF(const mol::Transform& tf);
- /// \brief get line width
- float GetLineWidth() const;
-
- void SetSphereDetail(unsigned int d);
- unsigned int GetSphereDetail() const;
-
- // subdivions per 90deg
- void SetArcDetail(unsigned int d);
- unsigned int GetArcDetail() const;
-
- void SetSplineDetail(unsigned int d);
- unsigned int GetSplineDetail() const;
-
- void SetPolyMode(unsigned int m);
- unsigned int GetPolyMode() const;
-
- // sophisticated line anti-aliasing, requires shader
- void SetAALines(bool f);
- bool GetAALines() const;
-
- void SetLineHalo(float f);
- float GetLineHalo() const;
-
// add a label at the given position
void AddLabel(const String& s, const geom::Vec3& pos, const Color& col, float psize);
// convenience method
@@ -161,112 +152,37 @@ public:
void AddLabel(const String& s, const geom::Vec3& pos, float psize);
// convenience method
void AddLabel(const String& s, const geom::Vec3& pos);
-
// remove all labels
void ClearLabels();
- void SetMatAmb(const Color& c);
- void SetMatAmb(float c);
- void SetMatDiff(const Color& c);
- void SetMatDiff(float c);
- void SetMatSpec(const Color& c);
- void SetMatSpec(float c);
- void SetMatShin(float s);
- void SetMatEmm(const Color& c);
- void SetMatEmm(float c);
- void SetMat(const Color& amb, const Color& diff, const Color& spec, float shin);
- void SetMat(float amb, float diff, float spec, float shin);
-
- void SetOpacity(float o);
- float GetOpacity() const;
-
- static Color Ele2Color(const String& ele);
-
void FlagRebuild();
void FlagRefresh();
+ bool GetAALines() const {return aalines_flag_;}
+ float GetLineWidth() const {return line_width_;}
+ float GetLineHalo() const {return line_halo_;}
+
void SetNormalSmoothFactor(float smoothf);
float GetNormalSmoothFactor() const;
Material GetMaterial() const;
void SetMaterial(const Material& m);
- void SetOutlineMode(int m);
- void SetOutlineExpandFactor(float f);
- void SetOutlineExpandColor(const Color& c);
-
// experimental, don't use
void SmoothVertices(float smoothf);
- // experimental, don't use
- void AmbientOcclusion(bool f);
void GLCleanup();
- /// \brief color each component based on the gradient-mapped property of
- /// the given entity
- virtual void ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Gradient& g, float minv, float maxv);
-
- /// \brief convenience method
- void ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv);
-
- /// \brief convenience method
- void ColorBy(const mol::EntityHandle& eh,
- const String& prop,
- const Gradient& g, float minv, float maxv);
- /// \brief convenience method
- void ColorBy(const mol::EntityHandle& eh,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv);
- // convenience method
- void ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Gradient& g);
- // convenience method
- void ColorBy(const mol::EntityView& ev,
- const String& prop,
- const Color& c1, const Color& c2);
- // convenience method
- void ColorBy(const mol::EntityHandle& ev,
- const String& prop,
- const Gradient& g);
- // convenience method
- void ColorBy(const mol::EntityHandle& ev,
- const String& prop,
- const Color& c1, const Color& c2);
-#if OST_IMG_ENABLED
- // convenience method
- void ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Gradient& g);
- // convenience method
- void ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Color& c1, const Color& c2);
- // dito for maps
- virtual void ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Gradient& g,float minv, float maxv);
- // convenience method
- void ColorBy(const img::MapHandle& mh,
- const String& prop,
- const Color& c1, const Color& c2, float minv, float maxv);
-#endif
+ // this really should not be here
+ static Color Ele2Color(const String& ele);
- void Debug(unsigned int flags) {debug_flags_=flags; RefreshVA();}
+ void Debug(unsigned int flags);
protected:
void PreRenderGL(bool flag);
virtual void CustomPreRenderGL(bool flag);
- void RefreshVA(IndexedVertexArray& va);
-
- virtual void RefreshVA() {RefreshVA(va_);}
-
private:
GfxObj(const GfxObj& o);
GfxObj& operator=(const GfxObj&);
@@ -275,19 +191,17 @@ public:
void AppendColorOp(gfx::ColorOp* op);
void CleanColorOps();
void ReapplyColorOps();
+ void render_labels() const;
+ void render_depth_only();
IndexedVertexArray va_;
RenderMode::Type render_mode_;
unsigned int debug_flags_;
- private:
mol::Transform transform_;
bool rebuild_;
bool refresh_;
float line_width_;
- unsigned int sphere_detail_;
- unsigned int arc_detail_;
- unsigned int spline_detail_;
unsigned int poly_mode_;
bool aalines_flag_;
float line_halo_;
@@ -298,12 +212,12 @@ public:
float opacity_;
float smoothf_;
- int omode_;
+ bool outline_flag_;
+ int outline_mode_;
boost::ptr_vector<gfx::ColorOp> c_ops_;
TextPrimList labels_;
- void render_labels() const;
bool use_occlusion_;
};
diff --git a/modules/gfx/src/gfx_object_base.hh b/modules/gfx/src/gfx_object_base.hh
index bcbf4613f8e1c7216988845e1f93ccf72e229685..24b331a4134e87479dc2e5411affdb2f1477ddf3 100644
--- a/modules/gfx/src/gfx_object_base.hh
+++ b/modules/gfx/src/gfx_object_base.hh
@@ -84,33 +84,26 @@ class DLLEXPORT_OST_GFX GfxObjBase: public GfxNode
virtual void SetPolyMode(unsigned int m) = 0;
/// \brief turn on sophisticated line anti-aliasing, requires shader
- virtual void AALines(bool f) = 0;
+ virtual void SetAALines(bool f) = 0;
/// \brief turn on line halo of given strength
virtual void SetLineHalo(float f) = 0;
/// \brief turn outline rendering on or off
- virtual void Outline(bool f) = 0;
-
+ virtual void SetOutline(bool f) = 0;
/// \brief set outline mode
virtual void SetOutlineMode(int m) = 0;
- /// \brief set outline tweak factor
+ /// \brief set outline width (modes 1 + 2)
+ virtual void SetOutlineWidth(float f) = 0;
+ /// \brief set outline tweak factor (mode 3)
virtual void SetOutlineExpandFactor(float f) = 0;
- /// \brief set outline color
+ /// \brief set outline color (mode 3)
virtual void SetOutlineExpandColor(const Color& c) = 0;
- /// \brief ambient occlusion rendering
- /// results are cached, but may be very slow on first call
- virtual void AmbientOcclusion(bool f) = 0;
-
- /// \brief blending weight of local color to fragment color
- virtual void SetAmbientLocalWeight(float w) = 0;
-
- /// \brief blending weight of occlusion factor
- virtual void SetAmbientOcclusionWeight(float w) = 0;
-
/// \brief set opacity (1 = no transparency)
virtual void SetOpacity(float f) = 0;
+ /// \brief returns a value smaller than 1.0 if transparency is used in this object
+ virtual float GetOpacity() const = 0;
/// \brief color each component based on the gradient-mapped property of
/// the given entity
diff --git a/modules/gfx/src/gfx_object_fw.hh b/modules/gfx/src/gfx_object_fw.hh
index 7e54f3599b25dfc33776f4ffda0c2120258e33d0..56c9d1906b9cbef4ef7ad2d67f3627d183f60739 100644
--- a/modules/gfx/src/gfx_object_fw.hh
+++ b/modules/gfx/src/gfx_object_fw.hh
@@ -27,8 +27,9 @@
namespace ost { namespace gfx {
+class GfxObjBase;
+typedef boost::shared_ptr<GfxObjBase> GfxObjBaseP;
class GfxObj;
-
typedef boost::shared_ptr<GfxObj> GfxObjP;
}} // ns
diff --git a/modules/gfx/src/gfx_prim.hh b/modules/gfx/src/gfx_prim.hh
index 1ec2bc25a55c382af86d52087a56b5c900e069d5..aead546538e44fe83dab8c948b65b976cf2eb6d7 100644
--- a/modules/gfx/src/gfx_prim.hh
+++ b/modules/gfx/src/gfx_prim.hh
@@ -48,13 +48,19 @@ typedef std::vector<SpherePrim> SpherePrimList;
struct CylinderPrim {
CylinderPrim():
- start(),end(),radius(1.0),color(),length(1.0),rotmat(),rotmat_t()
+ start(),end(),radius(1.0),color1(),color2(),length(1.0),rotmat(),rotmat_t()
{
calc_rotmat();
}
CylinderPrim(const geom::Vec3& st, const geom::Vec3& en, float rad, const Color& col):
- start(st),end(en),radius(rad),color(col),length(geom::Length(end-start)),rotmat(),rotmat_t()
+ start(st),end(en),radius(rad),color1(col),color2(col),length(geom::Length(end-start)),rotmat(),rotmat_t()
+ {
+ calc_rotmat();
+ }
+
+ CylinderPrim(const geom::Vec3& st, const geom::Vec3& en, float rad, const Color& col1, const Color& col2):
+ start(st),end(en),radius(rad),color1(col1),color2(col2),length(geom::Length(end-start)),rotmat(),rotmat_t()
{
calc_rotmat();
}
@@ -63,7 +69,7 @@ struct CylinderPrim {
geom::Vec3 start,end;
float radius;
- Color color;
+ Color color1, color2;
float length;
geom::Mat3 rotmat;
geom::Mat3 rotmat_t;
diff --git a/modules/gfx/src/gl_helper.hh b/modules/gfx/src/gl_helper.hh
index 1c955212cd7e228ad9ef54939b82e1ab9a6d6b8d..db9c07d9f3dd82d8b806de2bed149ac29a925594 100644
--- a/modules/gfx/src/gl_helper.hh
+++ b/modules/gfx/src/gl_helper.hh
@@ -38,18 +38,24 @@ Author: Juergen Haas
#include "glext_include.hh"
#include "gl_include.hh"
+#include <ost/log.hh>
+
+inline void check_gl_error()
+{
+ GLenum error_code;
+ if((error_code=glGetError())!=GL_NO_ERROR) {
+ LOGN_VERBOSE("GL error: " << gluErrorString(error_code));
+ }
+}
+
inline void glVertex3v(double* v){
glVertex3dv(v);
}
-
-
inline void glVertex3v(const double* v){
glVertex3dv(v);
}
-
-
inline void glVertex3v(float* v){
glVertex3fv(v);
}
diff --git a/modules/gfx/src/glwin_base.hh b/modules/gfx/src/glwin_base.hh
index 69ce405252c271a4ba32f57467a5e0b0df484e58..1be6d819f78fb15eba23eb82c440f59d8654ae09 100644
--- a/modules/gfx/src/glwin_base.hh
+++ b/modules/gfx/src/glwin_base.hh
@@ -33,11 +33,15 @@ class DLLEXPORT_OST_GFX GLWinBase {
public:
virtual ~GLWinBase() {}
+ virtual void MakeActive() {}
+
virtual void DoRefresh() = 0;
virtual void StatusMessage(const String& m) = 0;
- virtual void SetStereo(bool s) = 0;
+ virtual bool HasStereo() const = 0;
+
+ virtual bool HasMultisample() const = 0;
};
}}
diff --git a/modules/gfx/src/impl/backbone_trace.cc b/modules/gfx/src/impl/backbone_trace.cc
index c61fd23a5dc991025cad4c1de9a0400662e1d898..32fef42cde9ffb8ae17e306fe9510b934fc00b35 100644
--- a/modules/gfx/src/impl/backbone_trace.cc
+++ b/modules/gfx/src/impl/backbone_trace.cc
@@ -32,14 +32,15 @@ public:
TraceBuilder(BackboneTrace* bb_trace):
backbone_trace_(bb_trace),
last_residue_(),
- list_()
+ list_(),
+ id_counter_(0)
{}
virtual bool VisitChain(const mol::ChainHandle& chain)
{
if(last_chain_ && chain!=last_chain_) {
if(!list_.empty()) {
- backbone_trace_->AddNodeList(list_);
+ backbone_trace_->AddNodeEntryList(list_);
list_.clear();
}
last_chain_=chain;
@@ -51,20 +52,20 @@ public:
{
if(!mol::InSequence(last_residue_,res)) {
if(!list_.empty()) {
- backbone_trace_->AddNodeList(list_);
+ backbone_trace_->AddNodeEntryList(list_);
list_.clear();
}
}
// determine atom to add to list
mol::AtomHandle ca = res.GetCentralAtom();
if (ca) {
- NodeEntry entry={ca, GfxObj::Ele2Color(ca.GetElement()),
- GfxObj::Ele2Color(ca.GetElement()),
- geom::Vec3(0.0,0.0,0.0), // this will be set by the gfx trace obj
+ NodeEntry entry={ca, GfxObj::Ele2Color(ca.GetAtomProps().element),
+ GfxObj::Ele2Color(ca.GetAtomProps().element),
+ geom::Vec3(), // this will be set by the gfx trace obj
res.GetCentralNormal(),
1.0,
- geom::Vec3(),geom::Vec3(),geom::Vec3(),
- false};
+ geom::Vec3(),geom::Vec3(),geom::Vec3(), // for later use in NA rendering
+ false,id_counter_++};
list_.push_back(entry);
}
@@ -76,7 +77,7 @@ public:
virtual void OnExit()
{
if (!list_.empty()) {
- backbone_trace_->AddNodeList(list_);
+ backbone_trace_->AddNodeEntryList(list_);
list_.clear();
}
}
@@ -85,97 +86,22 @@ private:
mol::ResidueHandle last_residue_;
mol::ChainHandle last_chain_;
NodeEntryList list_;
+ int id_counter_;
};
-BackboneTrace::BackboneTrace(const mol::EntityView& ent)
-{
- view_=ent;
- TraceBuilder trace(this);
- if (view_) {
- view_.Apply(trace);
- }
-}
-
BackboneTrace::BackboneTrace()
-{
-
-}
+{}
-void BackboneTrace::SetView(const mol::EntityView& ent)
+BackboneTrace::BackboneTrace(const mol::EntityView& ent)
{
view_=ent;
- if (view_) {
- node_list_list_.clear();
- TraceBuilder trace(this);
- view_.Apply(trace);
- }
+ Rebuild();
}
-void BackboneTrace::AddNodeList(const NodeEntryList& l)
+void BackboneTrace::ResetView(const mol::EntityView& ent)
{
- if(l.size()>=3) {
- node_list_list_.push_back(l);
- // assign direction and normal vectors for each entry
- // they are composed of the i-1 -> i and i->i+1 directions
- //
- // this same algorithm is used in the spline generation, so
- // perhaps all of this here is not necessary ?!
- //
- NodeEntry* e0=&node_list_list_.back()[0];
- NodeEntry* e1=&node_list_list_.back()[1];
- NodeEntry* e2=&node_list_list_.back()[2];
- geom::Vec3 p0 = e0->atom.GetPos();
- geom::Vec3 p1 = e1->atom.GetPos();
- geom::Vec3 p2 = e2->atom.GetPos();
-
- e0->direction=geom::Normalize(p1-p0);
- // e0->normal is set afterwards to normal of second one
- // backup residue normal
- e0->v1 = e0->normal;
-
- //reference normal to avoid twisting
- geom::Vec3 nref=geom::Normalize(geom::Cross(p0-p1,p2-p1));
-
- // start loop with the second
- unsigned int i=1;
- for(;i<node_list_list_.back().size()-1;++i) {
- geom::Vec3 p10 = p0-p1;
- geom::Vec3 p12 = p2-p1;
- if(p10==-p12 || p10==p12) p12+=geom::Vec3(0.001,0.001,0.001);
- e1->v1=e1->normal;
- // twist avoidance
- if(geom::Dot(e0->v1,e1->v1)<0.0) {
- e1->v1=-e1->v1;
- }
- e1->normal=geom::Normalize(geom::Cross(p10,p12));
- float omega=0.5*acos(geom::Dot(geom::Normalize(p10),geom::Normalize(p12)));
- geom::Vec3 orth=geom::AxisRotation(e1->normal, -omega)*p12;
- e1->direction=geom::Normalize(geom::Cross(e1->normal,orth));
-
- // align normals to avoid twisting
- //if(geom::Dot(e1->normal,nref)<0.0) e1->normal=-e1->normal;
- //nref=e1->normal;
- // skip over shift for the last iteration
- if(i==node_list_list_.back().size()-2) break;
- // shift to i+1 for next iteration
- e0=&node_list_list_.back()[i];
- e1=&node_list_list_.back()[i+1];
- e2=&node_list_list_.back()[i+2];
- p0 = e0->atom.GetPos();
- p1 = e1->atom.GetPos();
- p2 = e2->atom.GetPos();
- }
- // finish remaining values
- // i is at size-2 due to break statement above
- node_list_list_.back()[0].normal=node_list_list_.back()[1].normal;
- node_list_list_.back()[i+1].direction=geom::Normalize(p2-p1);
- node_list_list_.back()[i+1].v1=node_list_list_.back()[i+1].normal;
- if (geom::Dot(node_list_list_.back()[i].v1,
- node_list_list_.back()[i+1].v1)<0.0) {
- node_list_list_.back()[i+1].v1=-node_list_list_.back()[i+1].v1;
- }
- node_list_list_.back()[i+1].normal=node_list_list_.back()[i].normal;
- }
+ view_=ent;
+ Rebuild();
}
int BackboneTrace::GetListCount() const
@@ -195,97 +121,104 @@ NodeEntryList& BackboneTrace::GetList(int index)
void BackboneTrace::Rebuild()
{
- TraceBuilder trace(this);
- view_.Apply(trace);
-}
-
-NodeListSubset::NodeListSubset(BackboneTrace& trace, int index):
- trace_(trace), list_index_(index), at_start_(0), at_end_(0)
-{
+ if (view_) {
+ node_list_list_.clear();
+ TraceBuilder trace(this);
+ view_.Apply(trace);
+ }
}
-TraceSubset::TraceSubset(BackboneTrace& trace,
- const mol::EntityView& view, int n):
- trace_(trace), overshoot_(n)
+void BackboneTrace::AddNodeEntryList(const NodeEntryList& l)
{
- this->Update(view);
+ if(l.size()>=3) {
+ node_list_list_.push_back(l);
+ PrepList(node_list_list_.back());
+ }
}
-TraceSubset::TraceSubset(BackboneTrace& trace, int n):
- trace_(trace), overshoot_(n)
-{
+void BackboneTrace::PrepList(NodeEntryList& nelist)
+{
+ // assign direction and normal vectors for each entry
+ // they are composed of the i-1 -> i and i->i+1 directions
+ //
+ // this same algorithm is used in the spline generation, so
+ // perhaps all of this here is not necessary ?!
+ //
+ NodeEntry* e0=&nelist[0];
+ NodeEntry* e1=&nelist[1];
+ NodeEntry* e2=&nelist[2];
+ geom::Vec3 p0 = e0->atom.GetPos();
+ geom::Vec3 p1 = e1->atom.GetPos();
+ geom::Vec3 p2 = e2->atom.GetPos();
-}
-
-
-void TraceSubset::NodeListEnd(NodeListSubset& nl, int c, int s)
-{
- if (nl.GetSize()>0) {
- int n=std::min(s-(nl.indices_.back()+1), overshoot_);
- nl.at_end_=n;
- while (n>0) {
- nl.indices_.push_back(nl.indices_.back()+1);
- --n;
+ e0->direction=geom::Normalize(p1-p0);
+ // e0->normal is set afterwards to normal of second one
+ // backup residue normal
+ e0->v1 = e0->normal;
+
+ //reference normal to avoid twisting
+ geom::Vec3 nref=geom::Normalize(geom::Cross(p0-p1,p2-p1));
+
+ // start loop with the second
+ unsigned int i=1;
+ for(;i<nelist.size()-1;++i) {
+ geom::Vec3 p10 = p0-p1;
+ geom::Vec3 p12 = p2-p1;
+ if(p10==-p12 || p10==p12) p12+=geom::Vec3(0.001,0.001,0.001);
+ e1->v1=e1->normal;
+ // twist avoidance
+ if(geom::Dot(e0->v1,e1->v1)<0.0) {
+ e1->v1=-e1->v1;
}
+ e1->normal=geom::Normalize(geom::Cross(p10,p12));
+ float omega=0.5*acos(geom::Dot(geom::Normalize(p10),geom::Normalize(p12)));
+ geom::Vec3 orth=geom::AxisRotation(e1->normal, -omega)*p12;
+ e1->direction=geom::Normalize(geom::Cross(e1->normal,orth));
+
+ // align normals to avoid twisting
+ //if(geom::Dot(e1->normal,nref)<0.0) e1->normal=-e1->normal;
+ //nref=e1->normal;
+ // skip over shift for the last iteration
+ if(i==nelist.size()-2) break;
+ // shift to i+1 for next iteration
+ e0=&nelist[i];
+ e1=&nelist[i+1];
+ e2=&nelist[i+2];
+ p0 = e0->atom.GetPos();
+ p1 = e1->atom.GetPos();
+ p2 = e2->atom.GetPos();
}
-}
-
-void TraceSubset::NodeListStart(NodeListSubset& nl, int c)
-{
- if (nl.GetSize()==0 && c>0) {
- for (int i=std::max(0,c-overshoot_); i<c; ++i) {
- nl.indices_.push_back(i);
- }
- nl.at_start_=nl.indices_.size();
+ // finish remaining values
+ // i is at size-2 due to break statement above
+ nelist[0].normal=nelist[1].normal;
+ nelist[i+1].direction=geom::Normalize(p2-p1);
+ nelist[i+1].v1=nelist[i+1].normal;
+ if (geom::Dot(nelist[i].v1,
+ nelist[i+1].v1)<0.0) {
+ nelist[i+1].v1=-nelist[i+1].v1;
}
+ nelist[i+1].normal=nelist[i].normal;
}
-
-void TraceSubset::Update(const mol::EntityView& view)
+BackboneTrace BackboneTrace::CreateSubset(const mol::EntityView& subview)
{
-
- lists_.clear();
- if (!view.IsValid()) {
- return;
- }
- for (int i=0; i<trace_.GetListCount(); ++i) {
- const NodeEntryList& l=trace_.GetList(i);
- int c=0;
- NodeEntryList::const_iterator j=l.begin(),e=l.end();
- NodeListSubset curr(trace_, i);
- while (j!=e) {
- while (j!=e && view.FindAtom(j->atom)) {
- if (curr.indices_.empty()) {
- this->NodeListStart(curr, c);
- }
- curr.indices_.push_back(c);
- ++j; ++c;
- }
- if (curr.GetSize()) {
- this->NodeListEnd(curr, curr.indices_.back(), l.size());
- lists_.push_back(curr);
- curr=NodeListSubset(trace_, i);
- } else {
- ++c; ++j;
+ BackboneTrace nrvo;
+ nrvo.view_=subview;
+ nrvo.node_list_list_.clear();
+ for(NodeEntryListList::const_iterator nitnit=node_list_list_.begin();nitnit!=node_list_list_.end();++nitnit) {
+ NodeEntryList new_nlist;
+ const NodeEntryList& nlist=*nitnit;
+ for(NodeEntryList::const_iterator nit=nlist.begin();nit!=nlist.end();++nit) {
+ if(subview.FindAtom(nit->atom).IsValid()) {
+ new_nlist.push_back(*nit);
}
}
+ if(!new_nlist.empty()) {
+ nrvo.node_list_list_.push_back(new_nlist);
+ }
}
+ return nrvo;
}
-NodeListSubset& NodeListSubset::operator=(const NodeListSubset& rhs)
-{
- trace_=rhs.trace_;
- list_index_=rhs.list_index_;
- indices_=rhs.indices_;
- return *this;
-}
-
-TraceSubset& TraceSubset::operator=(const TraceSubset& rhs)
-{
- trace_=rhs.trace_;
- lists_=rhs.lists_;
- overshoot_=rhs.overshoot_;
- return *this;
-}
+}}} // ns
-}}}
diff --git a/modules/gfx/src/impl/backbone_trace.hh b/modules/gfx/src/impl/backbone_trace.hh
index c6663f12c336b9b87470bf8cce4c3540ef711d4e..debcc54b59b653e5370f3dbe581d46fd3fac87b6 100644
--- a/modules/gfx/src/impl/backbone_trace.hh
+++ b/modules/gfx/src/impl/backbone_trace.hh
@@ -40,99 +40,41 @@ class BackboneTraceBuilder;
class DLLEXPORT_OST_GFX BackboneTrace {
public:
- BackboneTrace(const mol::EntityView& ent);
+ // empty trace
BackboneTrace();
-
+
+ // initialize with a view, and build
+ BackboneTrace(const mol::EntityView& ent);
+
+ // number of node-lists
int GetListCount() const;
-
+
+ // grab a list
const NodeEntryList& GetList(int index) const;
+ // grab a list
NodeEntryList& GetList(int index);
+
+ // reset the view and rebuild
+ void ResetView(const mol::EntityView& ent);
+
+ // used internally - adds a finished nodelist
+ void AddNodeEntryList(const NodeEntryList& entries);
- void SetView(const mol::EntityView& ent);
-
- // used internally
- void AddNodeList(const NodeEntryList& entries);
-
+ // used internally - calculates some derived values for a nodelist
+ static void PrepList(NodeEntryList& nelist);
+
+ // re-creates internal nodelist-list based on view
void Rebuild();
+ // extract portions of this backbone trace for a subview
+ // this is faster then re-generating a trace
+ BackboneTrace CreateSubset(const mol::EntityView& subview);
+
private:
mol::EntityView view_;
NodeEntryListList node_list_list_;
};
-/// \internal
-/// \brief a subset of a node list
-class DLLEXPORT_OST_GFX NodeListSubset {
-public:
- friend class TraceSubset;
-
- NodeListSubset(BackboneTrace& trace, int index);
-
- int GetSize() const
- {
- return indices_.size();
- }
- int AtStart() const
- {
- return at_start_;
- }
-
- int AtEnd() const
- {
- return at_end_;
- }
- const NodeEntry& operator [](int index) const
- {
- assert(index>=0 && index<static_cast<int>(indices_.size()));
- return trace_.GetList(list_index_)[indices_[index]];
- }
- NodeEntry& operator [](int index)
- {
- assert(index>=0 && index<static_cast<int>(indices_.size()));
- return trace_.GetList(list_index_)[indices_[index]];
- }
- NodeListSubset& operator=(const NodeListSubset& rhs);
-private:
- BackboneTrace& trace_;
- int list_index_;
-protected:
- std::vector<int> indices_;
- int at_start_;
- int at_end_;
-};
-
-/// \brief a subset of the trace
-class DLLEXPORT_OST_GFX TraceSubset {
-public:
- TraceSubset(BackboneTrace& trace, const mol::EntityView& view, int n);
- TraceSubset(BackboneTrace& trace, int n);
-
- const NodeListSubset& operator[](int index) const
- {
- return lists_[index];
- }
-
- NodeListSubset& operator[](int index)
- {
- return lists_[index];
- }
-
- int GetSize() const
- {
- return lists_.size();
- }
- void SetOvershoot(int n) { overshoot_=n; }
- int GetOvershoot() const { return overshoot_; }
- TraceSubset& operator=(const TraceSubset& rhs);
- void Update(const mol::EntityView& view);
-private:
- void NodeListStart(NodeListSubset& nl, int c);
- void NodeListEnd(NodeListSubset& nl, int c, int s);
- BackboneTrace& trace_;
- std::vector<NodeListSubset> lists_;
- int overshoot_;
-};
-
}}}
#endif
diff --git a/modules/gfx/src/impl/calc_ambient.cc b/modules/gfx/src/impl/calc_ambient.cc
deleted file mode 100644
index cfbbdacc183db740b9156b214a791693d74eca3d..0000000000000000000000000000000000000000
--- a/modules/gfx/src/impl/calc_ambient.cc
+++ /dev/null
@@ -1,360 +0,0 @@
-//------------------------------------------------------------------------------
-// This file is part of the OpenStructure project <www.openstructure.org>
-//
-// Copyright (C) 2008-2010 by the OpenStructure authors
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License as published by the Free
-// Software Foundation; either version 3.0 of the License, or (at your option)
-// any later version.
-// This library is distributed in the hope that it will be useful, but WITHOUT
-// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-// details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with this library; if not, write to the Free Software Foundation, Inc.,
-// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-//------------------------------------------------------------------------------
-
-/*
- Author: Ansgar Philippsen
-*/
-
-#include <map>
-#include <vector>
-#include <limits>
-
-#include <ost/geom/geom.hh>
-#include <ost/gfx/vertex_array.hh>
-
-#include "calc_ambient.hh"
-
-using namespace ost;
-using namespace ost::gfx;
-
-namespace {
-
- typedef IndexedVertexArray::EntryList EntryList;
- typedef IndexedVertexArray::IndexList IndexList;
-
- geom::Vec3 abs(const geom::Vec3& v) {
- geom::Vec3 nrvo(std::abs(v[0]),std::abs(v[1]),std::abs(v[2]));
- return nrvo;
- }
-
- std::pair<geom::Vec3, geom::Vec3> calc_limits(const EntryList& elist)
- {
- geom::Vec3 minc(std::numeric_limits<float>::max(),
- std::numeric_limits<float>::max(),
- std::numeric_limits<float>::max());
- geom::Vec3 maxc(-std::numeric_limits<float>::max(),
- -std::numeric_limits<float>::max(),
- -std::numeric_limits<float>::max());
-
- for(EntryList::const_iterator it=elist.begin();it!=elist.end();++it) {
-#if OST_DOUBLE_PRECISION
- minc[0]=std::min(static_cast<double>(it->v[0]),minc[0]);
- minc[1]=std::min(static_cast<double>(it->v[1]),minc[1]);
- minc[2]=std::min(static_cast<double>(it->v[2]),minc[2]);
- maxc[0]=std::max(static_cast<double>(it->v[0]),maxc[0]);
- maxc[1]=std::max(static_cast<double>(it->v[1]),maxc[1]);
- maxc[2]=std::max(static_cast<double>(it->v[2]),maxc[2]);
-#else
- minc[0]=std::min(it->v[0],minc[0]);
- minc[1]=std::min(it->v[1],minc[1]);
- minc[2]=std::min(it->v[2],minc[2]);
- maxc[0]=std::max(it->v[0],maxc[0]);
- maxc[1]=std::max(it->v[1],maxc[1]);
- maxc[2]=std::max(it->v[2],maxc[2]);
-#endif
- }
- return std::make_pair(minc,maxc);
- }
-
- struct CIndex {
- CIndex(): u(0),v(0),w(0) {}
- CIndex(long uu, long vv, long ww): u(uu), v(vv), w(ww) {}
- long u,v,w;
- bool operator<(const CIndex& rhs) const {
- return u==rhs.u ? (v==rhs.v ? w<rhs.w : v<rhs.v) : u<rhs.u;
- }
- };
-
- struct CEntry {
- CEntry(): id(0), type(0) {}
- CEntry(unsigned int ii, const geom::Vec3& vv1, const geom::Vec3& vv2, const geom::Vec3& vv3, const geom::Vec4& cc):
- id(ii), type(3),
- v0(1.0f/3.0f*(vv1+vv2+vv3)),
- v1(vv1), v2(vv2), v3(vv3), v4(),
- n(geom::Normalize(geom::Cross(v1-v2,v1-v3))),
- c(cc) {}
- CEntry(unsigned int ii, const geom::Vec3& vv1, const geom::Vec3& vv2, const geom::Vec3& vv3, const geom::Vec3& vv4, const geom::Vec4& cc):
- id(ii), type(3),
- v0(1.0f/4.0f*(vv1+vv2+vv3+vv4)),
- v1(vv1), v2(vv2), v3(vv3), v4(vv4),
- n(geom::Normalize(geom::Cross(v1-v2,v1-v3))),
- c(cc) {}
-
- unsigned int id; // original entry id
- unsigned int type; // type
- geom::Vec3 v0; // center position
- geom::Vec3 v1; // edge positions
- geom::Vec3 v2; // edge positions
- geom::Vec3 v3; // edge positions
- geom::Vec3 v4; // edge positions
- geom::Vec3 n; // face normal
- geom::Vec4 c; // average color
- };
-
- struct RayEntry {
- RayEntry(): v(), d2(0.0), c() {}
- RayEntry(const geom::Vec3& vv, float dd): v(vv), d2(dd), c() {}
- geom::Vec3 v;
- float d2;
- geom::Vec4 c;
- bool hit;
- bool back;
- };
-
- typedef std::vector<CEntry> CList;
- typedef std::map<CIndex,CList > CMap;
-
- class AmbientOcclusionBuilder {
- public:
- AmbientOcclusionBuilder(IndexedVertexArray& va):
- va_(va), cmap_(), bsize_(5.0), weight_(0.5), cutoff_(bsize_), rays_(), density_(20)
- {
- float delta=2.0*M_PI/static_cast<float>(density_);
- for(unsigned int s=0;s<density_/2;++s) {
- float a=s*delta;
- float z=std::cos(a);
- float x=std::sin(a);
- unsigned int tmp_subdiv=static_cast<unsigned int>(round(2.0*M_PI*std::abs(x)/delta));
- if(tmp_subdiv==0) {
- rays_.push_back(RayEntry(geom::Vec3(0.0,0.0,z/std::abs(z)),cutoff_*cutoff_));
- } else {
- float tmp_delta=2.0*M_PI/static_cast<float>(tmp_subdiv);
- for(unsigned int t=0;t<tmp_subdiv;++t) {
- float b=t*tmp_delta;
- rays_.push_back(RayEntry(geom::Normalize(geom::Vec3(x*std::cos(b),x*std::sin(b),z)),cutoff_*cutoff_));
- }
- }
- }
- }
-
- CIndex coord_to_index(const geom::Vec3& v)
- {
- return CIndex(static_cast<int>(floor(v[0]/bsize_)),
- static_cast<int>(floor(v[1]/bsize_)),
- static_cast<int>(floor(v[2]/bsize_)));
- }
-
- void build_cmap() {
- const EntryList& elist = va_.GetEntries();
- const IndexList& tlist = va_.GetTriIndices();
- const IndexList& qlist = va_.GetQuadIndices();
-
- cmap_.clear();
- float inv3 = 1.0f/3.0;
- for(unsigned int c=0;c<tlist.size();c+=3) {
- geom::Vec4 c0(elist[tlist[c+0]].c);
- geom::Vec4 c1(elist[tlist[c+1]].c);
- geom::Vec4 c2(elist[tlist[c+2]].c);
- CEntry ce = add_to_cmap(c,geom::Vec3(elist[tlist[c+0]].v),geom::Vec3(elist[tlist[c+1]].v),geom::Vec3(elist[tlist[c+2]].v),inv3*(c0+c1+c2));
- //std::cerr << c << " " << ce.n << " ";
- //std::cerr << geom::Vec3(elist[tlist[c+0]].n) << " ";
- //std::cerr << geom::Vec3(elist[tlist[c+1]].n) << " ";
- //std::cerr << geom::Vec3(elist[tlist[c+2]].n) << std::endl;
- }
- float inv4 = 1.0f/4.0;
- for(unsigned int c=0;c<qlist.size();c+=4) {
- geom::Vec4 c0(elist[qlist[c+0]].c);
- geom::Vec4 c1(elist[qlist[c+1]].c);
- geom::Vec4 c2(elist[qlist[c+2]].c);
- geom::Vec4 c3(elist[qlist[c+3]].c);
- add_to_cmap(c,geom::Vec3(elist[qlist[c+0]].v),geom::Vec3(elist[qlist[c+1]].v),geom::Vec3(elist[qlist[c+2]].v),geom::Vec3(elist[qlist[c+3]].v),inv4*(c0+c1+c2+c3));
- }
- }
-
- CEntry add_to_cmap(unsigned int id, const geom::Vec3& v1, const geom::Vec3& v2, const geom::Vec3& v3, const geom::Vec4& c)
- {
- CEntry ce(id,v1,v2,v3,c);
- CIndex cindex=coord_to_index(ce.v0);
- CMap::iterator it=cmap_.find(cindex);
- if(it==cmap_.end()) {
- std::vector<CEntry> tmplist(1);
- tmplist[0]=ce;
- cmap_[cindex]=tmplist;
- } else {
- it->second.push_back(ce);
- }
- return ce;
- }
-
- CEntry add_to_cmap(unsigned int id, const geom::Vec3& v1, const geom::Vec3& v2, const geom::Vec3& v3, const geom::Vec3& v4, const geom::Vec4& c)
- {
- CEntry ce(id,v1,v2,v3,v4,c);
- CIndex cindex=coord_to_index(ce.v0);
- CMap::iterator it=cmap_.find(cindex);
- if(it==cmap_.end()) {
- std::vector<CEntry> tmplist(1);
- tmplist[0]=ce;
- cmap_[cindex]=tmplist;
- } else {
- it->second.push_back(ce);
- }
- return ce;
- }
-
- void accumulate(const CIndex& cindex, const CEntry& ce)
- {
- float cutoff2=cutoff_*cutoff_;
- CMap::iterator mit=cmap_.find(cindex);
- if(mit==cmap_.end()) return;
- for(std::vector<CEntry>::const_iterator eit=mit->second.begin();eit!=mit->second.end();++eit) {
- geom::Vec3 dir0=(eit->v0-ce.v0); // vector from reference entry to current entry
- float l2=geom::Length2(dir0);
- if(l2>cutoff2 || l2<0.01) continue;
-
- dir0=geom::Normalize(dir0);
-
- if(geom::Dot(dir0,ce.n)<1e-6) continue;
-
- // largest opening angle from reference entry to corners
- float a0=1.0;
- if(eit->type==3) {
- a0 = (geom::Dot(dir0,geom::Normalize(eit->v1-ce.v0))+
- geom::Dot(dir0,geom::Normalize(eit->v2-ce.v0))+
- geom::Dot(dir0,geom::Normalize(eit->v3-ce.v0)))/3.0;
- } else if(eit->type==4) {
- a0 = (geom::Dot(dir0,geom::Normalize(eit->v1-ce.v0))+
- geom::Dot(dir0,geom::Normalize(eit->v2-ce.v0))+
- geom::Dot(dir0,geom::Normalize(eit->v3-ce.v0))+
- geom::Dot(dir0,geom::Normalize(eit->v4-ce.v0)))/4.0;
- }
-
- for(std::vector<RayEntry>::iterator rit=rays_.begin();rit!=rays_.end();++rit) {
- if(rit->back) continue;
- if(geom::Dot(ce.n,rit->v)<1e-6) {
- rit->back=true;
- continue;
- }
- if(geom::Dot(dir0,rit->v)<a0) continue;
- if(rit->d2<l2) continue;
- rit->d2=l2;
- rit->c=eit->c;
- rit->hit=true;
- }
- }
- }
-
- void calc_all() {
- const EntryList& elist = va_.GetEntries();
- const IndexList& tlist = va_.GetTriIndices();
- const IndexList& qlist = va_.GetQuadIndices();
- float cutoff2=cutoff_*cutoff_;
- float isig2 = 1.0/(2.0*2.0*cutoff_/3.0*cutoff_/3.0);
-
- std::vector<std::pair<geom::Vec4, int> > entry_accum(elist.size());
-
- for(CMap::iterator mit=cmap_.begin();mit!=cmap_.end();++mit) {
- for(CList::iterator lit=mit->second.begin();lit!=mit->second.end();++lit) {
- // reset rays
- for(std::vector<RayEntry>::iterator rit=rays_.begin();rit!=rays_.end();++rit) {
- rit->d2=cutoff2;
- rit->hit=false;
- rit->back=false;
- }
- // visit all 27 quadrants
- for(int w=-1;w<=1;++w) {
- for(int v=-1;v<=1;++v) {
- for(int u=-1;u<=1;++u) {
- accumulate(CIndex(mit->first.u+u,mit->first.v+v,mit->first.w+w),*lit);
- }
- }
- }
-
- // sum up ray contributions
- float occl=0.0;
- float occl_sum=0.0;
- geom::Vec4 col(0.0,0.0,0.0,0.0);
- float col_weight_sum=0.0;
- for(std::vector<RayEntry>::iterator rit=rays_.begin();rit!=rays_.end();++rit) {
- if(!rit->back) {
- float ca=std::max(Real(0.0),geom::Dot(rit->v,lit->n));
- occl_sum += ca;
- if(!rit->hit) {
- occl += ca;
- float col_weight=exp(-rit->d2*isig2);
- col[0] += col_weight*rit->c[0];
- col[1] += col_weight*rit->c[1];
- col[2] += col_weight*rit->c[2];
- col_weight_sum+=col_weight;
- }
- }
- }
- if(occl_sum>0.0) occl/=occl_sum;
- if(col_weight_sum>0.0) col/=col_weight_sum;
-
- col[3]=occl;
- if(lit->type==3) {
- unsigned int litid=lit->id;
- /*
- entry_accum[tlist[litid+0]].first+=col;
- entry_accum[tlist[litid+0]].second+=1;
- entry_accum[tlist[litid+1]].first+=col;
- entry_accum[tlist[litid+1]].second+=1;
- entry_accum[tlist[litid+2]].first+=col;
- entry_accum[tlist[litid+2]].second+=1;
- */
- std::pair<geom::Vec4,int>* e=&entry_accum[tlist[litid++]];
- e->first+=col; ++e->second;
- e=&entry_accum[tlist[litid++]];
- e->first+=col; ++e->second;
- e=&entry_accum[tlist[litid++]];
- e->first+=col; ++e->second;
- } else if(lit->type==4) {
- unsigned int litid=lit->id;
- std::pair<geom::Vec4,int>* e=&entry_accum[qlist[litid++]];
- e->first+=col; ++e->second;
- e=&entry_accum[qlist[litid++]];
- e->first+=col; ++e->second;
- e=&entry_accum[qlist[litid++]];
- e->first+=col; ++e->second;
- e=&entry_accum[qlist[litid++]];
- e->first+=col; ++e->second;
- }
- }
- }
- for(unsigned int i=0;i<elist.size();++i) {
- float fact = entry_accum[i].second==0 ? 1.0f : 1.0f/static_cast<float>(entry_accum[i].second);
- va_.SetAmbientColor(i,Color(entry_accum[i].first[0]*fact,
- entry_accum[i].first[1]*fact,
- entry_accum[i].first[2]*fact,
- entry_accum[i].first[3]*fact));
- }
- }
-
- private:
- IndexedVertexArray& va_;
- CMap cmap_;
- float bsize_;
- float weight_;
- float cutoff_;
- std::vector<RayEntry> rays_;
- unsigned int density_;
- };
-
-} // ns
-
-
-
-void ost::gfx::CalcAmbientTerms(IndexedVertexArray& va)
-{
- AmbientOcclusionBuilder aob(va);
- LOGN_VERBOSE("building component map");
- aob.build_cmap();
- LOGN_VERBOSE("calculating ambient terms");
- aob.calc_all();
-}
diff --git a/modules/gfx/src/impl/calc_ambient.hh b/modules/gfx/src/impl/calc_ambient.hh
deleted file mode 100644
index 6064f84c9aabf4344734254461e91a2b67683788..0000000000000000000000000000000000000000
--- a/modules/gfx/src/impl/calc_ambient.hh
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// This file is part of the OpenStructure project <www.openstructure.org>
-//
-// Copyright (C) 2008-2010 by the OpenStructure authors
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License as published by the Free
-// Software Foundation; either version 3.0 of the License, or (at your option)
-// any later version.
-// This library is distributed in the hope that it will be useful, but WITHOUT
-// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-// details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with this library; if not, write to the Free Software Foundation, Inc.,
-// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-//------------------------------------------------------------------------------
-#ifndef OST_CALC_AMBIENT_HH
-#define OST_CALC_AMBIENT_HH
-
-/*
- calculate ambient contributions per VA entry
-
- Author: Ansgar Philippsen
-*/
-
-namespace ost { namespace gfx {
-
- class IndexedVertexArray;
- void CalcAmbientTerms(IndexedVertexArray& va);
-
-}} // ns
-
-#endif
diff --git a/modules/gfx/src/impl/cartoon_renderer.cc b/modules/gfx/src/impl/cartoon_renderer.cc
index 08f0a0c3e5a1167a35d35a9712afc2f677505cc5..5a10e13fa56bf79c6568ea62785947236db82f4f 100644
--- a/modules/gfx/src/impl/cartoon_renderer.cc
+++ b/modules/gfx/src/impl/cartoon_renderer.cc
@@ -16,8 +16,17 @@
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+
+/*
+ Author: Ansgar Philippsen
+*/
+
#include "cartoon_renderer.hh"
+#include <Eigen/Core>
+#include <Eigen/Array>
+#include <Eigen/SVD>
+#include <Eigen/LU>
#include <ost/gfx/entity.hh>
#include <ost/gfx/impl/tabulated_trig.hh>
@@ -30,16 +39,11 @@ static const unsigned int MAX_ARC_DETAIL=12;
using namespace impl;
-CartoonRenderer::CartoonRenderer(BackboneTrace& trace, bool force_tube):
+CartoonRenderer::CartoonRenderer(BackboneTrace* trace, bool force_tube):
TraceRendererBase(trace, 3), force_tube_(force_tube),
options_(new CartoonRenderOptions(force_tube))
{
-if(force_tube){
- this->SetName("Smooth Tube");
-}
-else{
- this->SetName("Helix & Strand Cartoon");
-}
+ this->SetName(force_tube ? "Smooth Tube" : "Helix & Strand Cartoon");
}
void CartoonRenderer::SetForceTube(bool force_tube)
@@ -47,75 +51,135 @@ void CartoonRenderer::SetForceTube(bool force_tube)
force_tube_ = force_tube;
}
-void CartoonRenderer::PrepareRendering(TraceSubset& subset,
+void CartoonRenderer::PrepareRendering(const BackboneTrace& subset,
IndexedVertexArray& va,
SplineEntryListList& spline_list_list,
- bool is_sel)
+ bool)
{
+ if(options_==NULL) {
+ LOGN_DEBUG("CartoonRenderer: NULL options, not creating objects");
+ }
+
+ va.Clear();
+ va.SetLighting(true);
+ va.SetCullFace(true);
+ va.SetColorMaterial(true);
+ va.SetMode(0x4);
+ va.SetPolyMode(options_->GetPolyMode());
+
+ LOGN_DEBUG("CartoonRenderer: starting object build");
int spline_detail=std::max((unsigned int) 1, options_->GetSplineDetail());
- const Color& sel_clr=this->GetSelectionColor();
- if(options_!=NULL){
- va.Clear();
- va.SetLighting(true);
- va.SetCullFace(true);
- va.SetColorMaterial(true);
- va.SetMode(0x4);
- va.SetPolyMode(options_->GetPolyMode());
- spline_list_list.clear();
- for (int node_list=0; node_list<subset.GetSize(); ++node_list) {
- // first build the spline
- Spline spl;
- const NodeListSubset& nl=subset[node_list];
- for (int i=0; i<nl.GetSize();++i) {
- int type=0;
- const NodeEntry& entry=nl[i];
- if(!force_tube_) {
- mol::ResidueHandle resh = entry.atom.GetResidue();
- mol::SecStructure sst=resh.GetSecStructure();
- mol::ResidueHandle resh2 = resh.GetNext();
- mol::SecStructure sst2=mol::SecStructure(mol::SecStructure::COIL);
- if (resh2.IsValid()) {
- sst2=resh2.GetSecStructure();
- }
- if(sst.IsHelical()) {
- type=1;
- } else if(sst.IsExtended()) {
- if(!sst2.IsExtended()) {
- type=3; // end of strand
- } else {
- type=2;
- }
- }
- }
- SplineEntry& ee = spl.AddEntry(entry.atom.GetPos(),entry.direction,
- entry.normal, entry.rad,
- is_sel ? sel_clr : entry.color1,
- is_sel ? sel_clr : entry.color2, type);
- ee.v1 = entry.v1;
+ SplineEntryListList tmp_sll;
+ for (int node_list=0; node_list<subset.GetListCount(); ++node_list) {
+ LOGN_DEBUG("CartoonRenderer: collecting spline entries for node list " << node_list);
+ // first build the spline
+ SplineEntryList spl;
+ const NodeEntryList& nl=subset.GetList(node_list);
+ for (unsigned int i=0; i<nl.size();++i) {
+ int type=0;
+ const NodeEntry& entry=nl[i];
+ if(!force_tube_) {
+ mol::ResidueHandle resh = entry.atom.GetResidue();
+ mol::SecStructure sst=resh.GetSecStructure();
+ if(sst.IsHelical()) {
+ type=1;
+ } else if(sst.IsExtended()) {
+ type=2;
+ }
}
- spline_list_list.push_back(spl.Generate(spline_detail));
- // now create the shape around the interpolated pathway
+ SplineEntry ee(entry.atom.GetPos(),entry.direction,
+ entry.normal, entry.rad,
+ entry.color1,
+ entry.color2,
+ type, entry.id);
+ ee.v1 = entry.v1;
+ spl.push_back(ee);
+ }
+ LOGN_DEBUG("CartoonRenderer: found " << spl.size() << " entries");
+ if(!spl.empty()) {
+ tmp_sll.push_back(spl);
+ }
+ }
+ if(!force_tube_) {
+ LOGN_DEBUG("CartoonRenderer: adjusting spline-entry-list lists for various modes");
+ FudgeSplineObj(tmp_sll);
+ }
+ spline_list_list.clear();
+ unsigned int tmp_count=0;
+ for(SplineEntryListList::const_iterator sit=tmp_sll.begin();sit!=tmp_sll.end();++sit) {
+ if(sit->size()==2 and sit->at(0).type==6) {
+ // don't intpol cylinders
+ spline_list_list.push_back(*sit);
+ } else {
+ LOGN_DEBUG("CartoonRenderer: generating full spline for spline-entry-list " << tmp_count++);
+ spline_list_list.push_back(Spline::Generate(*sit,spline_detail,options_->GetColorBlendMode()));
}
- RebuildSplineObj(spline_list_list.back(), va, spline_list_list, subset, is_sel);
- va.SmoothNormals(options_->GetNormalSmoothFactor());
- }
+ }
}
+
void CartoonRenderer::PrepareRendering()
{
TraceRendererBase::PrepareRendering();
- va_.Clear();
- this->PrepareRendering(trace_subset_, va_, spline_list_list_, false);
- if (this->HasSelection()) {
- this->PrepareRendering(sel_subset_, sel_va_, sel_spline_list_list_, true);
- sel_va_.SetColorMaterial(false);
+ if(state_>0) {
+ va_.Clear();
+ this->PrepareRendering(trace_subset_, va_, spline_list_list_, false);
+ RebuildSplineObj(va_, spline_list_list_, false);
+ }
+ if (this->HasSelection() && (state_>0 || sel_state_>0)) {
+ sel_va_.Clear();
+ Color sel_color=GetSelectionColor();
+ // extract spline segments from list_list that match
+ // (via id) the selection subset
+ // first put all ids into a set for fast lookup
+ std::set<int> id_set;
+ for(int nlc=0;nlc<sel_subset_.GetListCount();++nlc) {
+ const NodeEntryList& nelist=sel_subset_.GetList(nlc);
+ for(NodeEntryList::const_iterator nit=nelist.begin();nit!=nelist.end();++nit) {
+ id_set.insert(nit->id);
+ }
+ }
+ // now find all matching spline segments
+ sel_spline_list_list_.clear();
+ for(SplineEntryListList::const_iterator sit=spline_list_list_.begin();sit!=spline_list_list_.end();++sit) {
+ const SplineEntryList& slist=*sit;
+ SplineEntryList nlist;
+ unsigned int sc=0;
+ while(sc<slist.size()) {
+ int curr_id=slist.at(sc).id;
+ if(id_set.count(curr_id)>0) {
+ // if a match is found, add all until a new id is found
+ while(sc<slist.size() && slist.at(sc).id==curr_id) {
+ nlist.push_back(slist[sc++]);
+ // override with the selection color
+ nlist.back().color1=sel_color;
+ nlist.back().color2=sel_color;
+ }
+ } else {
+ // introduce break
+ if(!nlist.empty()) {
+ sel_spline_list_list_.push_back(nlist);
+ nlist.clear();
+ }
+ // and advance to the next id
+ while(sc<slist.size() && slist.at(sc).id==curr_id) ++sc;
+ }
+ }
+ if(!nlist.empty()) {
+ sel_spline_list_list_.push_back(nlist);
+ nlist.clear();
+ }
+ }
+ RebuildSplineObj(sel_va_, sel_spline_list_list_, true);
+ sel_va_.SetColorMaterial(true);
sel_va_.SetLighting(false);
+ sel_va_.SetMode(0x4);
+ sel_va_.SetPolyMode(options_->GetPolyMode());
+ sel_va_.SetOpacity(sel_color.Alpha());
}
sel_state_=0;
state_=0;
}
-void CartoonRenderer::Render(){}
-
bool CartoonRenderer::CanSetOptions(RenderOptionsPtr& render_options)
{
return render_options.get()->GetRenderMode()==RenderMode::HSC;
@@ -131,95 +195,286 @@ RenderOptionsPtr CartoonRenderer::GetOptions()
return options_;
}
-void CartoonRenderer::RebuildSplineObj(const SplineEntryList& l,
- IndexedVertexArray& va,
- SplineEntryListList& spline_list_list,
- const TraceSubset& subset, bool is_sel)
+namespace {
+ typedef Eigen::Matrix<Real,3,1> EVec3;
+ typedef Eigen::Matrix<Real,3,3> EMat3;
+ typedef Eigen::Matrix<Real,1,3> ERVec3;
+ typedef Eigen::Matrix<Real,Eigen::Dynamic,Eigen::Dynamic> EMatX;
+ typedef Eigen::Matrix<Real,1,Eigen::Dynamic> ERVecX;
+
+ ERVec3 to_eigen(const geom::Vec3& v)
+ {
+ EVec3 nrvo=EVec3::Zero();
+ nrvo[0]=v[0]; nrvo[1]=v[1]; nrvo[2]=v[2];
+ return nrvo;
+ }
+
+ std::pair<geom::Vec3,geom::Vec3> fit_helix(const std::vector<geom::Vec3>& points)
+ {
+ if(points.size()<4) {
+ return std::make_pair(points.front(),points.back());
+ }
+ geom::Vec3 cen(0.0,0.0,0.0);
+ for(unsigned int i=0;i<points.size();++i) cen+=points[i];
+ cen/=static_cast<float>(points.size());
+
+ EMatX A=EMatX::Zero(points.size(),3);
+ for(unsigned int i=0;i<points.size();++i) {
+ A.row(i)=to_eigen(points[i]-cen);
+ }
+
+ Eigen::SVD<EMatX> svd(A);
+ EMatX V=svd.matrixV();
+ geom::Vec3 ax(V(0,0),V(1,0),V(2,0));
+
+ geom::Vec3 p1=cen+ax*(-geom::Dot(cen,ax)+geom::Dot(points.front(),ax))/geom::Length2(ax);
+ geom::Vec3 p2=cen+ax*(-geom::Dot(cen,ax)+geom::Dot(points.back(),ax))/geom::Length2(ax);
+
+ return std::make_pair(p1,p2);
+ }
+
+} // ns
+
+void CartoonRenderer::FudgeSplineObj(SplineEntryListList& olistlist)
{
+ SplineEntryListList nlistlist;
+ SplineEntryList nlist;
+
+ for(unsigned int llc=0;llc<olistlist.size();++llc) {
+ LOGN_DEBUG("CartoonRenderer: fudging spline segment " << llc);
+ SplineEntryList olist = olistlist[llc];
+ for(unsigned int lc=0;lc<olist.size();++lc) {
+ if(olist.at(lc).type==1) {
+ if(options_->GetHelixMode()==1) {
+ // cylindrical helix
+ // collect all CA positions
+ std::vector<geom::Vec3> points;
+ SplineEntry tmp_end(olist.at(lc));
+ unsigned int lstart=lc;
+ for(;lc<olist.size() && olist.at(lc).type==1;++lc) {
+ points.push_back(olist.at(lc).position);
+ }
+ unsigned int lend=lc-1;
+ if(lend-lstart<3) {
+ // this is a short helix, may as well not bother
+ for(unsigned int i=lstart;i<=lend;++i) {
+ nlist.push_back(olist[i]);
+ nlist.back().type=0;
+ }
+ } else {
+ // fit points to a cylinder
+ std::pair<geom::Vec3,geom::Vec3> cyl=fit_helix(points);
+
+ // extend the current spline to start of cyl
+ geom::Vec3 cyl_dir = geom::Normalize(cyl.second-cyl.first);
+
+ if(lstart>0) {
+ SplineEntry tmp_end(olist[lstart]);
+ tmp_end.type=0;
+ tmp_end.position=cyl.first;
+ tmp_end.direction=cyl_dir;
+ tmp_end.color1=olist[lstart-1].color1;
+ tmp_end.color2=olist[lstart-1].color2;
+ tmp_end.normal=geom::Normalize(geom::Cross(cyl_dir,geom::Cross(tmp_end.normal,cyl_dir)));
+ if(geom::Dot(tmp_end.normal,olist[lstart].normal)<0.0) {
+ tmp_end.normal=-tmp_end.normal;
+ }
+ nlist.push_back(tmp_end);
+
+ // break nodelist
+ nlistlist.push_back(nlist);
+ nlist.clear();
+ }
+
+ // make a two entry list with the cyl type
+ nlist.push_back(SplineEntry(cyl.first,geom::Vec3(),geom::Vec3(),0.0,
+ olist[lstart].color1,olist[lstart].color1,
+ 6,olist[lstart].id));
+ nlist.push_back(SplineEntry(cyl.second,geom::Vec3(),geom::Vec3(),0.0,
+ olist[lend].color1,olist[lend].color1,
+ 6,olist[lend].id));
+ nlistlist.push_back(nlist);
+ nlist.clear();
+
+ if(lend+1<olist.size()) {
+ // and get going with an entry at the end of the cylinder
+ SplineEntry tmp_start(olist[lend]);
+ tmp_start.type=0;
+ tmp_start.position=cyl.second;
+ tmp_start.direction=cyl_dir;
+ tmp_start.color1=olist[lend+1].color1;
+ tmp_start.color2=olist[lend+1].color2;
+ tmp_start.normal=geom::Normalize(geom::Cross(cyl_dir,geom::Cross(tmp_start.normal,cyl_dir)));
+ if(geom::Dot(tmp_start.normal,olist[lstart].normal)<0.0) {
+ tmp_start.normal=-tmp_start.normal;
+ }
+ nlist.push_back(tmp_start);
+ }
+ }
+ } else { // helix mode 0
+ // just copy them over
+ for(;lc<olist.size() && olist.at(lc).type==1;++lc) {
+ nlist.push_back(olist.at(lc));
+ }
+ }
+ }
+ if(lc>=olist.size()) break;
+ // can't use else here in case the above routine advanced lc to end
+ if(olist.at(lc).type==2) {
+ // strand
+ unsigned int kstart=nlist.size();
+ unsigned int kend=kstart;
+ for(;lc<olist.size() && olist.at(lc).type==2;++lc,++kend) {
+ nlist.push_back(olist.at(lc));
+ }
+ if(kend-kstart<2) {
+ // dont bother with too short strands
+ for(unsigned int i=kstart;i<kend;++i) {
+ nlist.at(i).type=0;
+ }
+ } else {
+ kend-=1;
+ // these magic numbers are used in RebuildSplineObj for proper arrow rendering
+ nlist.at(kend-1).type=3;
+ nlist.at(kend).type=5;
+
+ if(options_->GetStrandMode()==1) {
+ // smooth the strands for mode 1
+ nlist.at(kstart).direction = geom::Normalize(nlist.at(kend).position-nlist.at(kstart).position);
+ nlist.at(kend).direction=nlist.at(kstart).direction;
+ float invf=1.0/static_cast<float>(kend-kstart);
+ for(unsigned int k=kstart;k<=kend;++k) {
+ float f = static_cast<float>(k-kstart)*invf;
+ nlist.at(k).position=nlist.at(kstart).position+f*(nlist.at(kend).position-nlist.at(kstart).position);
+ nlist.at(k).direction=nlist.at(kstart).direction;
+ geom::Vec3 tmpn=geom::Normalize(nlist.at(kstart).normal+f*(nlist.at(kend).normal-nlist.at(kstart).normal));
+ geom::Vec3 tmpx=geom::Normalize(geom::Cross(nlist.at(kstart).direction,tmpn));
+ nlist.at(k).normal=geom::Normalize(geom::Cross(tmpx,nlist.at(kstart).direction));
+ }
+ }
+
+ // break nodelist, re-start at arrow tip for both modes
+ if(lc+1<olist.size()) {
+ nlistlist.push_back(nlist);
+ nlist.clear();
+ nlist.push_back(nlistlist.back().back());
+ nlist.back().type=0;
+ nlist.back().color1=olist[lc+1].color1;
+ nlist.back().color2=olist[lc+1].color2;
+ }
+ }
+ }
+ if(lc<olist.size()) {
+ nlist.push_back(olist.at(lc));
+ }
+ }
+ if(!nlist.empty()) {
+ nlistlist.push_back(nlist);
+ nlist.clear();
+ }
+ }
+ olistlist.swap(nlistlist);
+}
+
+void CartoonRenderer::RebuildSplineObj(IndexedVertexArray& va,
+ const SplineEntryListList& spline_list_list,
+ bool is_sel)
+{
+ LOGN_DEBUG("CartoonRenderer: starting profile assembly");
unsigned int detail = std::min(MAX_ARC_DETAIL,
std::max(options_->GetArcDetail(),
(unsigned int)1));
- int spline_detail=std::max((unsigned int) 1, options_->GetSplineDetail());
std::vector<TraceProfile> profiles;
float factor=is_sel ? 0.2 : 0.0;
profiles.push_back(GetCircProfile(detail,
options_->GetTubeRadius()*options_->GetTubeRatio()+factor,
options_->GetTubeRadius()+factor,
options_->GetTubeProfileType(),
- 1.0)); // tube
+ 1.0)); // profile 0 = tube
if (!force_tube_) {
profiles.push_back(GetCircProfile(detail,
options_->GetHelixWidth()+factor,
options_->GetHelixThickness()+factor,
options_->GetHelixProfileType(),
- options_->GetHelixEcc())); // helix
+ options_->GetHelixEcc())); // profile 1 = helix
profiles.push_back(GetCircProfile(detail,
options_->GetStrandWidth()+factor,
options_->GetStrandThickness()+factor,
options_->GetStrandProfileType(),
- options_->GetStrandEcc())); // strand
- profiles.push_back(GetCircProfile(detail,
- 0.1*options_->GetStrandWidth()+factor,
- options_->GetStrandThickness()+factor,
- options_->GetTubeProfileType(),
- 1.0)); // arrow end, tube profile
+ options_->GetStrandEcc())); // profile 2 = strand
+ profiles.push_back(profiles.back()); // profile 3==2, strand
+
profiles.push_back(GetCircProfile(detail,
1.7*options_->GetStrandWidth()+factor,
1.1*options_->GetStrandThickness()+factor,
options_->GetStrandProfileType(),
- options_->GetStrandEcc())); // arrow start
+ options_->GetStrandEcc())); // profile 4 = arrow start
+ profiles.push_back(GetCircProfile(detail,
+ 0.01*options_->GetStrandWidth()+factor,
+ 1.1*options_->GetStrandThickness()+factor,
+ options_->GetStrandProfileType(),
+ options_->GetStrandEcc())); // profile 5 = arrow end
+
}
// iterate over all spline segments
- for(SplineEntryListList::iterator it=spline_list_list.begin();
+ unsigned int tmp_count=0;
+ for(SplineEntryListList::const_iterator it=spline_list_list.begin();
it<spline_list_list.end();++it) {
/*
for each spline segment, transform the profile according to the
normal and direction and assemble it together with the last
transformed profile into a graphical segment
*/
- SplineEntryList& slist=*it;
- const NodeListSubset& nl=subset[it-spline_list_list.begin()];
- int sit=0, send=slist.size()-spline_detail+1;
- if (nl.AtStart()>0) {
- sit+=nl.AtStart()*spline_detail-spline_detail/2;
- }
- if (nl.AtEnd()>0) {
- send-=nl.AtEnd()*spline_detail-spline_detail/2;
+ SplineEntryList slist=*it;
+ if(slist.empty()) continue;
+ LOGN_DEBUG("CartoonRenderer: assembling fragment " << tmp_count << " with " << slist.size() << " spline segments");
+
+ if(slist.size()==2 && slist[0].type==6) {
+ // make a cylinder
+ va.AddCylinder(CylinderPrim(slist[0].position,slist[1].position,
+ options_->GetHelixWidth(),
+ slist[0].color1,slist[1].color1),
+ options_->GetArcDetail(),true);
+ continue;
}
- TraceProfile tprof1=TransformAndAddProfile(profiles,slist[sit],va);
- CapProfile(tprof1,slist[sit],true,va);
+
+ TraceProfile tprof1=TransformAndAddProfile(profiles,slist[0],va);
+ CapProfile(tprof1,slist[0],true,va);
TraceProfile tprof2;
- SplineEntry& last_se=slist[send-1];
- for (int sc=sit+1; sc<send; ++sc) {
- if(slist[sc-1].type==2 && slist[sc].type==3) {
- // arrow on last strand segment
- // type1 is already set to 4 (Spline::Generate),
- // hence just insert single bridging profile
- SplineEntry se(slist[sc]);
- se.type=last_se.type;
- se.type1=last_se.type1;
- se.type2=last_se.type2;
- tprof2=TransformAndAddProfile(profiles,se, va);
- AssembleProfile(tprof1,tprof2,va);
- tprof1=tprof2;
- tprof2=TransformAndAddProfile(profiles,slist[sc], va);
- last_se=slist[sc];
+ unsigned int sc=1;
+ for (; sc<slist.size(); ++sc) {
+ if(slist.at(sc).type==3) {
+ if(slist.at(sc-1).type!=3) {
+ // boundary to arrow
+ SplineEntry se(slist[sc]);
+ tprof2=TransformAndAddProfile(profiles,se, va);
+ AssembleProfile(tprof1,tprof2,va);
+ tprof1=tprof2;
+ se.type=2;
+ se.type1=4;
+ se.type2=4;
+ tprof2=TransformAndAddProfile(profiles,se, va);
+ } else {
+ SplineEntry se(slist.at(sc));
+ se.type1=4;
+ if(options_->GetStrandMode()==1) se.type2=5;
+ tprof2=TransformAndAddProfile(profiles,se, va);
+ }
} else {
- tprof2=TransformAndAddProfile(profiles,slist[sc], va);
+ tprof2=TransformAndAddProfile(profiles,slist.at(sc), va);
}
AssembleProfile(tprof1,tprof2,va);
tprof1=tprof2;
- last_se=slist[sc];
}
- CapProfile(tprof1,slist[send-1],false,va);
+ CapProfile(tprof1,slist.at(sc-1),false,va);
}
}
-
-
TraceProfile CartoonRenderer::TransformAndAddProfile(const std::vector<TraceProfile>& profiles, const SplineEntry& se, IndexedVertexArray& va)
{
+ assert(se.type1>=0 && se.type1<=5);
+ assert(se.type2>=0 && se.type2<=5);
TraceProfile prof1 = profiles[se.type1];
TraceProfile prof2 = profiles[se.type2];
@@ -266,33 +521,44 @@ TraceProfile CartoonRenderer::TransformAndAddProfile(const std::vector<TraceProf
return tf_prof;
}
+namespace {
+
+ float spread(const geom::Vec3& v1, geom::Vec3& v2, geom::Vec3& v3, geom::Vec3& v4)
+ {
+ return geom::Dot(geom::Normalize(geom::Cross(geom::Normalize(v3-v1),geom::Normalize(v2-v1))),
+ geom::Normalize(geom::Cross(geom::Normalize(v3-v4),geom::Normalize(v2-v4))));
+ }
+
+}
+
void CartoonRenderer::AssembleProfile(const TraceProfile& prof1,
const TraceProfile& prof2,
IndexedVertexArray& va)
{
- // determine rotational offset with a heuristic routine
- int best_off=0;
-#if 0
- uint i1=0;
- uint i2=prof1.size()/4;
- uint i3=prof1.size()/2;
- uint i4=std::min(prof1.size()-1,size_t(i2+i3));
- float best_val = Dot(prof1[i1].n,prof2[i1].n)+
- Dot(prof1[i2].n,prof2[i2].n)+
- Dot(prof1[i3].n,prof2[i3].n)+
- Dot(prof1[i4].n,prof2[i4].n);
-
- for(unsigned int oo=1;oo<prof1.size();++oo) {
- float val = Dot(prof1[i1].n,prof2[oo].n)+
- Dot(prof1[i2].n,prof2[(oo+i2)%prof1.size()].n)+
- Dot(prof1[i3].n,prof2[(oo+i3)%prof1.size()].n)+
- Dot(prof1[i4].n,prof2[(oo+i4)%prof1.size()].n);
- if(val>best_val) {
- best_val=val;
- best_off=oo;
+ float accum[]={0.0,0.0,0.0,0.0,0.0};
+ for(int i=0;i<prof1.size();++i) {
+ int i1=(i+0)%prof1.size();
+ int i2=(i+1)%prof1.size();
+ geom::Vec3 v1=va.GetVert(prof1[i1].id);
+ geom::Vec3 v2=va.GetVert(prof1[i2].id);
+ for(int k=-2;k<=2;++k) {
+ int i3=(i+k+0+prof1.size())%prof1.size();
+ int i4=(i+k+1+prof1.size())%prof1.size();
+ geom::Vec3 v3=va.GetVert(prof2[i3].id);
+ geom::Vec3 v4=va.GetVert(prof2[i4].id);
+ accum[k+2]+=spread(v1,v2,v3,v4);
}
}
-#endif
+
+ float best_spread=accum[0];
+ int best_off=-2;
+ for(int k=-1;k<=2;++k) {
+ if(accum[k+2]<best_spread) {
+ best_spread=accum[k+2];
+ best_off=k;
+ }
+ }
+ best_off=(best_off+prof1.size())%prof1.size();
// assume both profiles have the same size
for(unsigned int i1=0;i1<prof1.size();++i1) {
diff --git a/modules/gfx/src/impl/cartoon_renderer.hh b/modules/gfx/src/impl/cartoon_renderer.hh
index ff9097e5c5f2bee0c04ac945aeb0ded32c4d26ca..95a7b3844802e14c9f3fd087b4f67b3021c47ab4 100644
--- a/modules/gfx/src/impl/cartoon_renderer.hh
+++ b/modules/gfx/src/impl/cartoon_renderer.hh
@@ -16,6 +16,11 @@
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+
+/*
+ Author: Ansgar Philippsen
+*/
+
#ifndef OST_GFX_CARTOON_RENDERER_HH
#define OST_GFX_CARTOON_RENDERER_HH
@@ -34,25 +39,26 @@ namespace ost { namespace gfx { namespace impl {
/// \internal
class DLLEXPORT_OST_GFX CartoonRenderer: public TraceRendererBase {
public:
- CartoonRenderer(BackboneTrace& trace, bool force_tube=false);
+ CartoonRenderer(BackboneTrace* trace, bool force_tube=false);
+ virtual ~CartoonRenderer();
virtual void PrepareRendering();
- virtual void Render();
virtual bool CanSetOptions(RenderOptionsPtr& render_options);
virtual void SetOptions(RenderOptionsPtr& render_options);
virtual RenderOptionsPtr GetOptions();
-
virtual void SetForceTube(bool force_tube);
-
-
- virtual ~CartoonRenderer();
private:
- void RebuildSplineObj(const SplineEntryList& l, IndexedVertexArray& va,
- SplineEntryListList& spline_list_list,
- const TraceSubset& subset, bool is_sel);
+ void PrepareRendering(const BackboneTrace& subset, IndexedVertexArray& va,
+ SplineEntryListList& spline_list_list, bool is_sel);
+
+ void FudgeSplineObj(SplineEntryListList&);
+
+ void RebuildSplineObj(IndexedVertexArray& va,
+ const SplineEntryListList& spline_list_list,
+ bool is_sel);
void CapProfile(const impl::TraceProfile& p,
const impl::SplineEntry& se,
@@ -66,9 +72,6 @@ private:
const SplineEntry& se,
IndexedVertexArray& va);
- void PrepareRendering(TraceSubset& subset, IndexedVertexArray& va,
- SplineEntryListList& spline_list_list, bool is_sel);
-
TraceProfile GetCircProfile(unsigned int detail, float rx, float ry, unsigned int type, float ecc);
bool force_tube_;
diff --git a/modules/gfx/src/impl/connect_renderer_base.hh b/modules/gfx/src/impl/connect_renderer_base.hh
index 78b730fc18c5bc56cf5b0edd3a7df89fda2d2d6e..1c88950fff335dc19b90d5b80a6d298f1096ada7 100644
--- a/modules/gfx/src/impl/connect_renderer_base.hh
+++ b/modules/gfx/src/impl/connect_renderer_base.hh
@@ -60,7 +60,7 @@ protected:
float GetFixedPickRadius() const { return pick_radius_; }
protected:
- float pick_radius_;
+ float pick_radius_;
GfxView view_;
GfxView sel_view_;
};
diff --git a/modules/gfx/src/impl/cpk_renderer.cc b/modules/gfx/src/impl/cpk_renderer.cc
index fc3b2b916170cc0e5dc16e2ea9f3a0b425fb6cdb..f2d74a4d2fdeec173258e53211d292ef7cb7af03 100644
--- a/modules/gfx/src/impl/cpk_renderer.cc
+++ b/modules/gfx/src/impl/cpk_renderer.cc
@@ -74,8 +74,8 @@ void CPKRenderer::Render(RenderPass pass)
{
if(options_!=NULL){
#if OST_SHADER_SUPPORT_ENABLED
- if(options_->GetCPKMode()==1 || options_->GetCPKMode()==2) {
- this->RenderCPK2();
+ if(pass==STANDARD_RENDER_PASS && (options_->GetSphereMode()==1 || options_->GetSphereMode()==2)) {
+ this->Render3DSprites();
return;
}
#endif
@@ -110,78 +110,11 @@ RenderOptionsPtr CPKRenderer::GetOptions(){
return options_;
}
-std::vector<impl::AtomEntry*> CPKRenderer::CPKOcclusion()
-{
-
- std::vector<impl::AtomEntry*> aelist;
-
-#if OST_SHADER_SUPPORT_ENABLED
- static const float isq2 = 1.0/sqrt(2.0);
- geom::Mat3 irot=geom::Transpose(Scene::Instance().GetTransform().GetRot());
- geom::Vec3 cx=irot*geom::Vec3(isq2,0.0,0.0);
- geom::Vec3 cy=irot*geom::Vec3(0.0,isq2,0.0);
-
- Shader::Instance().PushProgram();
- Shader::Instance().Activate("");
-
- glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glDisable(GL_LIGHTING);
- glDisable(GL_CULL_FACE);
- glDisable(GL_FOG);
- glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
-
- glBegin(GL_QUADS);
- for(AtomEntryMap::const_iterator it=view_.atom_map.begin();
- it!=view_.atom_map.end();++it) {
- geom::Vec3 pos = it->second.atom.GetPos();
- float rad = it->second.vdwr;
- glVertex3v((pos-rad*cx-rad*cy).Data());
- glVertex3v((pos-rad*cx+rad*cy).Data());
- glVertex3v((pos+rad*cx+rad*cy).Data());
- glVertex3v((pos+rad*cx-rad*cy).Data());
- }
- glEnd();
-
- cx=irot*geom::Vec3(1.0,0.0,0.0);
- cy=irot*geom::Vec3(0.0,1.0,0.0);
-
- glDepthMask(GL_FALSE);
-
- uint query_id;
- glGenQueries(1,&query_id);
-
- for(AtomEntryMap::iterator it=view_.atom_map.begin();
- it!=view_.atom_map.end();++it) {
- geom::Vec3 pos = it->second.atom.GetPos();
- float rad = it->second.vdwr;
- glBeginQuery(GL_SAMPLES_PASSED, query_id);
- glBegin(GL_QUADS);
- glVertex3v((pos-rad*cx-rad*cy).Data());
- glVertex3v((pos-rad*cx+rad*cy).Data());
- glVertex3v((pos+rad*cx+rad*cy).Data());
- glVertex3v((pos+rad*cx-rad*cy).Data());
- glEnd();
- glEndQuery(GL_SAMPLES_PASSED);
- GLint samples=0;
- glGetQueryObjectiv(query_id,GL_QUERY_RESULT,&samples);
- if(samples>0) aelist.push_back(&it->second);
- }
-
- glDeleteQueries(1,&query_id);
-
- glPopAttrib();
-
- Shader::Instance().PopProgram();
-#endif
-
- return aelist;
-}
-
namespace {
-void RenderCPK2InnerLoop(const AtomEntry* ae, const geom::Vec3& cx,
- const geom::Vec3& cy, const geom::Vec3& cz,
- GLdouble* gl_mmat, GLdouble* gl_pmat, GLint* gl_vp)
+void Render3DSpritesInnerLoop(const AtomEntry* ae, const geom::Vec3& cx,
+ const geom::Vec3& cy, const geom::Vec3& cz,
+ GLdouble* gl_mmat, GLdouble* gl_pmat, GLint* gl_vp)
{
geom::Vec3 pos = ae->atom.GetPos();
float rad = ae->vdwr;
@@ -206,7 +139,7 @@ void RenderCPK2InnerLoop(const AtomEntry* ae, const geom::Vec3& cx,
}
-void CPKRenderer::RenderCPK2()
+void CPKRenderer::Render3DSprites()
{
#if OST_SHADER_SUPPORT_ENABLED
if(options_!=NULL){
@@ -215,16 +148,13 @@ void CPKRenderer::RenderCPK2()
geom::Vec3 cy=irot*geom::Vec3(0.0,1.0,0.0);
geom::Vec3 cz=irot*geom::Vec3(0.0,0.0,1.0);
- std::vector<AtomEntry*> aelist;
- if(options_->GetCPKMode()==2) {
- aelist = CPKOcclusion();
- }
-
+ uint write_normals = Shader::Instance().GetCurrentName()=="dumpnorm" ? 1 : 0;
Shader::Instance().PushProgram();
Shader::Instance().Activate("fast_sphere");
Shader::Instance().UpdateState();
+ glUniform1i(glGetUniformLocation(Shader::Instance().GetCurrentProgram(),"write_normals"),write_normals);
- glPushAttrib(GL_ENABLE_BIT);
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
@@ -236,14 +166,8 @@ void CPKRenderer::RenderCPK2()
glBegin(GL_QUADS);
- if(options_->GetCPKMode()==2) {
- for(std::vector<AtomEntry*>::const_iterator it=aelist.begin();it!=aelist.end();++it) {
- RenderCPK2InnerLoop(*it,cx,cy,cz,gl_mmat,gl_pmat,gl_vp);
- }
- } else {
- for(AtomEntryMap::const_iterator it=view_.atom_map.begin();it!=view_.atom_map.end();++it) {
- RenderCPK2InnerLoop(&it->second,cx,cy,cz,gl_mmat,gl_pmat,gl_vp);
- }
+ for(AtomEntryMap::const_iterator it=view_.atom_map.begin();it!=view_.atom_map.end();++it) {
+ Render3DSpritesInnerLoop(&it->second,cx,cy,cz,gl_mmat,gl_pmat,gl_vp);
}
glEnd();
@@ -256,51 +180,4 @@ void CPKRenderer::RenderCPK2()
#endif
}
-void CPKRenderer::RenderCPK3()
-{
-#if OST_SHADER_SUPPORT_ENABLED
- if(options_!= NULL){
- std::vector<AtomEntry*> aelist = CPKOcclusion();
-
- IndexedVertexArray cpk_va;
- detail::PrebuildSphereEntry pre=detail::GetPrebuildSphere(options_->GetSphereDetail());
- GLuint dlist;
- dlist = glGenLists(1);
- glNewList(dlist,GL_COMPILE);
- glBegin(GL_TRIANGLES);
- for(uint c=0;c<pre.ilist.size();c+=3) {
- geom::Vec3 v0 = pre.vlist[pre.ilist[c+0]];
- geom::Vec3 v1 = pre.vlist[pre.ilist[c+1]];
- geom::Vec3 v2 = pre.vlist[pre.ilist[c+2]];
- glNormal3v(v0.Data());
- glVertex3v(v0.Data());
- glNormal3v(v1.Data());
- glVertex3v(v1.Data());
- glNormal3v(v2.Data());
- glVertex3v(v2.Data());
- }
- glEnd();
- glEndList();
-
- glEnable(GL_NORMALIZE);
-
- for(std::vector<AtomEntry*>::const_iterator it=aelist.begin();it!=aelist.end();++it) {
- geom::Vec3 pos = (*it)->atom.GetPos();
- float rad = (*it)->vdwr;
- glPushMatrix();
- glColor3fv((*it)->color);
- glTranslated(pos[0],pos[1],pos[2]);
- glScaled(rad,rad,rad);
- glCallList(dlist);
- glPopMatrix();
- }
- glDisable(GL_NORMALIZE);
- }
-#endif
-}
-
-CPKRenderer::~CPKRenderer() {
-
-}
-
}}}
diff --git a/modules/gfx/src/impl/cpk_renderer.hh b/modules/gfx/src/impl/cpk_renderer.hh
index 81372f2d022127c94df0dfff1cd189cc5ae4a3c4..241602b88aef133f722751339e14cbf79ebb9e15 100644
--- a/modules/gfx/src/impl/cpk_renderer.hh
+++ b/modules/gfx/src/impl/cpk_renderer.hh
@@ -37,19 +37,15 @@ public:
virtual void RenderPov(PovState& pov, const std::string& name);
- virtual void Render(RenderPass pass=STANDARD_RENDER_PASS);
+ virtual void Render(RenderPass pass);
virtual bool CanSetOptions(RenderOptionsPtr& render_options);
virtual void SetOptions(RenderOptionsPtr& render_options);
virtual RenderOptionsPtr GetOptions();
- virtual ~CPKRenderer();
-
private:
void PrepareRendering(GfxView& view, IndexedVertexArray& va, bool is_sel);
- std::vector<impl::AtomEntry*> CPKOcclusion();
- void RenderCPK2();
- void RenderCPK3();
+ void Render3DSprites();
CPKRenderOptionsPtr options_;
};
diff --git a/modules/gfx/src/impl/debug_renderer.cc b/modules/gfx/src/impl/debug_renderer.cc
index 918117400b0b4a1e2039590e4739cbcfd26aa611..bd8f883f03174ce7807165ecf9deea8e251c9c8f 100644
--- a/modules/gfx/src/impl/debug_renderer.cc
+++ b/modules/gfx/src/impl/debug_renderer.cc
@@ -33,7 +33,7 @@ namespace gfx {
using namespace impl;
using namespace mol;
-DebugRenderer::DebugRenderer(BackboneTrace& trace):
+DebugRenderer::DebugRenderer(BackboneTrace* trace):
TraceRendererBase(trace, 2), options_(new SlineRenderOptions()) {
this->SetName("Debug");
}
@@ -51,7 +51,7 @@ void DebugRenderer::PrepareRendering()
for(NodeEntryListList::const_iterator ll_it=node_list_list_->begin();ll_it!=node_list_list_->end();++ll_it) {
- Spline spl;
+ SplineEntryList spl;
for(NodeEntryList::const_iterator it=(*ll_it).begin();it!=(*ll_it).end();++it) {
int type=0;
ResidueHandle resh = it->atom.GetResidue();
@@ -62,12 +62,13 @@ void DebugRenderer::PrepareRendering()
type=2;
}
- SplineEntry& ee = spl.AddEntry(it->atom.GetPos(),it->direction,it->normal,
- it->rad,it->color1,it->color2,type);
+ SplineEntry ee(it->atom.GetPos(),it->direction,it->normal,
+ it->rad,it->color1,it->color2,type,it->id);
ee.v1 = it->v1;
+ spl.push_back(ee);
}
- SplineEntryList sel = spl.Generate(std::max((unsigned int) 1,options_->GetSplineDetail()));
+ SplineEntryList sel = Spline::Generate(spl,std::max((unsigned int) 1,options_->GetSplineDetail()));
SplineEntryList::const_iterator sit = sel.begin();
geom::Vec3 ap = sit->position;
@@ -103,8 +104,6 @@ void DebugRenderer::PrepareRendering()
#endif
}
-void DebugRenderer::Render(){}
-
bool DebugRenderer::CanSetOptions(RenderOptionsPtr& render_options){
return render_options.get()->GetRenderMode()==RenderMode::SLINE;
}
diff --git a/modules/gfx/src/impl/debug_renderer.hh b/modules/gfx/src/impl/debug_renderer.hh
index 206f592ddb3b7bcc4006d2a620f0a41488525e26..499a5d18c51703f5fcc3dca832a07d14adbaf398 100644
--- a/modules/gfx/src/impl/debug_renderer.hh
+++ b/modules/gfx/src/impl/debug_renderer.hh
@@ -30,10 +30,9 @@ namespace ost { namespace gfx { namespace impl {
class DLLEXPORT_OST_GFX DebugRenderer: public TraceRendererBase {
public:
- DebugRenderer(BackboneTrace& trace);
+ DebugRenderer(BackboneTrace* trace);
virtual void PrepareRendering();
- virtual void Render();
virtual bool CanSetOptions(RenderOptionsPtr& render_options);
virtual void SetOptions(RenderOptionsPtr& render_options);
diff --git a/modules/gfx/src/impl/entity_detail.cc b/modules/gfx/src/impl/entity_detail.cc
index 572de5bb7e2b995fba33d204cf3e7745110a42f5..59f1042337de0328a45bbc98a35fc3a75bb02445 100644
--- a/modules/gfx/src/impl/entity_detail.cc
+++ b/modules/gfx/src/impl/entity_detail.cc
@@ -16,20 +16,149 @@
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+
+#include <ost/gfx/gl_helper.hh>
+#include <ost/gfx/scene.hh>
+#include <ost/gfx/color.hh>
+
#include "entity_detail.hh"
+
namespace ost {
using namespace mol;
namespace gfx { namespace impl {
- namespace {
+namespace {
+
+static const float default_radius=0.28;
+
+struct BlurQuadEntry
+{
+ float zdist;
+ geom::Vec3 p1,p2,p3,p4;
+ gfx::Color c1,c2,c3,c4;
+};
+
+struct BlurQuadEntryLess
+{
+ bool operator()(const BlurQuadEntry& e1, const BlurQuadEntry& e2)
+ {
+ // provides back-to-front sorting
+ return e1.zdist<e2.zdist;
+ }
+};
+
+} // anon ns
- static const float default_radius=0.28;
+void DoRenderBlur(BondEntryList& bl, float bf1, float bf2)
+{
+ // add blur for this particular orientation!
+ // don't use vertex array, but on-the-fly oriented and z-sorted quads
+ mol::Transform tf = Scene::Instance().GetTransform();
+
+ std::vector<BlurQuadEntry> bql;
+ for (BondEntryList::iterator it=bl.begin(); it!=bl.end();++it) {
+
+ if(!it->atom1 || !it->atom2) continue;
+
+ const geom::Vec3 p0=tf.Apply(it->atom1->atom.GetPos());
+ const geom::Vec3 p2=tf.Apply(it->atom2->atom.GetPos());
+ geom::Vec3 p1=(p0+p2)*0.5;
+
+ const geom::Vec3 q0=tf.Apply(it->pp1);
+ const geom::Vec3 q2=tf.Apply(it->pp2);
+ geom::Vec3 q1=(q0+q2)*0.5;
+
+ float ll0 = geom::Length2(p0-q0);
+ float ll1 = geom::Length2(p1-q1);
+ float ll2 = geom::Length2(p2-q2);
+
+ if(ll0<1e-2 && ll1<1e-2 && ll2<1e-2) continue;
+
+ float x0 = exp(-bf1*ll0);
+ float x1 = exp(-bf1*ll1);
+ float x2 = exp(-bf1*ll2);
+
+ BlurQuadEntry bqe;
+
+ bqe.zdist=0.25*(p0[2]+p2[2]+q0[2]+q2[2]);
+
+ // first half
+ bqe.p1 = p0;
+ bqe.p2 = p1;
+ bqe.p3 = q0;
+ bqe.p4 = q1;
+ bqe.c1 = it->atom1->color;
+ bqe.c2 = it->atom1->color;
+ bqe.c3 = it->atom1->color;
+ bqe.c4 = it->atom1->color;
+ bqe.c1[3] = x0;
+ bqe.c2[3] = x1;
+ bqe.c3[3]=x0*bf2;
+ bqe.c4[3]=x1*bf2;
+
+ bql.push_back(bqe);
+
+ // second half
+ bqe.p1 = p1;
+ bqe.p2 = p2;
+ bqe.p3 = q1;
+ bqe.p4 = q2;
+ bqe.c1 = it->atom2->color;
+ bqe.c2 = it->atom2->color;
+ bqe.c3 = it->atom2->color;
+ bqe.c4 = it->atom2->color;
+ bqe.c1[3] = x1;
+ bqe.c2[3] = x2;
+ bqe.c3[3]=x1*bf2;
+ bqe.c4[3]=x2*bf2;
+
+ bql.push_back(bqe);
+ }
+ std::sort(bql.begin(),bql.end(),BlurQuadEntryLess());
+
+ glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_LIGHTING_BIT);
+ glDisable(GL_LIGHTING);
+ glDisable(GL_CULL_FACE);
+ glDepthFunc(GL_LESS);
+ glDepthMask(GL_FALSE);
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+ glBegin(GL_QUADS);
+ glNormal3f(0.0,0.0,0.0);
+ for (std::vector<BlurQuadEntry>::const_iterator it=bql.begin();
+ it!=bql.end();++it) {
+ glColor4fv(it->c1);
+ glVertex3v(it->p1.Data());
+ glColor4fv(it->c2);
+ glVertex3v(it->p2.Data());
+ glColor4fv(it->c4);
+ glVertex3v(it->p4.Data());
+ glColor4fv(it->c3);
+ glVertex3v(it->p3.Data());
}
+ glEnd();
+ glPopMatrix();
+ glPopAttrib();
+}
+
+void DoBlurSnapshot(BondEntryList& bl)
+{
+ for (BondEntryList::iterator it=bl.begin();
+ it!=bl.end();++it) {
+ if(it->atom1 && it->atom2) {
+ it->pp1=it->atom1->atom.GetPos();
+ it->pp2=it->atom2->atom.GetPos();
+ }
+ }
+}
+
+
void GfxView::Clear()
{
atom_map.clear();
@@ -43,9 +172,9 @@ void GfxView::AddAtom(const AtomView& av)
AtomEntry ae(a,default_radius,
a.GetRadius(),
GfxObj::Ele2Color(a.GetElement()));
- atom_map[a.GetHandle().GetHashCode()]=ae;
+ atom_map[a.GetHashCode()]=ae;
if(av.GetBondCount()==0) {
- orphan_atom_list.push_back(a.GetHandle().GetHashCode());
+ orphan_atom_list.push_back(a.GetHashCode());
}
}
@@ -87,85 +216,41 @@ void GfxView::AddBond(const BondHandle& b)
}
-void SplineEntry::ToQuat()
-{
- // assert orthonormal system
- // TODO: this seems broken
- geom::Vec3 dir = geom::Normalize(direction);
- geom::Vec3 norm0 = geom::Normalize(normal);
- geom::Vec3 norm2 = geom::Cross(dir,norm0);
- geom::Vec3 norm1 = geom::Cross(norm2,dir);
- geom::Mat3 rmat(dir[0],norm1[0],norm2[0],
- dir[1],norm1[1],norm2[1],
- dir[2],norm1[2],norm2[2]);
-
- geom::Quat quat(rmat);
- quat_value[0]=quat.w;
- quat_value[1]=quat.x;
- quat_value[2]=quat.y;
- quat_value[3]=quat.z;
-}
-
-void SplineEntry::FromQuat()
-{
- /*
- assert orthornormal system since direction was
- probably adjusted for curvature
- */
- // TODO: this seems broken
- geom::Quat quat(quat_value[0],quat_value[1],quat_value[2],quat_value[3]);
- geom::Mat3 rmat = quat.ToRotationMatrix();
- geom::Vec3 norm0 = geom::Normalize(geom::Vec3(rmat(0,1),rmat(1,1),rmat(2,1)));
- geom::Vec3 dir = geom::Normalize(direction);
- geom::Vec3 norm2 = geom::Normalize(geom::Cross(dir,norm0));
- normal = geom::Normalize(geom::Cross(norm2,dir));
-}
-
////////////////////////////
-Spline::Spline():
- entry_list_()
-{}
-
-
-SplineEntry& Spline::AddEntry(const geom::Vec3& pos, const geom::Vec3& dir, const geom::Vec3& normal, float rad, const Color& c1, const Color& c2, int type)
-{
- entry_list_.push_back(SplineEntry(pos,
- geom::Normalize(dir),
- geom::Normalize(normal),
- rad,c1,c2,type));
- entry_list_.back().ToQuat();
- return entry_list_.back();
-}
-
static int bsplineGen(float *x,float *y, int n, float yp1, float ypn, float *y2);
static int bsplineGet(float *xa, float *ya, float *y2a, int n, float x, float *y);
#define SPLINE_ENTRY_INTERPOLATE(COMPONENT) \
for(int c=0;c<size;++c) { \
- yc[c]=entry_list_[c]. COMPONENT ; \
+ yc[c]=entry_list.at(c). COMPONENT ; \
} \
bsplineGen(xp,yp,size,1.0e30,1.0e30,y2p); \
- for(int c=0;c<size;++c) { \
+ for(int c=0;c<size-1;++c) { \
for(int d=0;d<nsub;++d) { \
float u=static_cast<float>(c*nsub+d)*i_nsub; \
float v=0.0; \
bsplineGet(xp,yp,y2p,size,u,&v); \
- sublist[c*nsub+d]. COMPONENT = v; \
+ sublist.at(c*nsub+d). COMPONENT = v; \
} \
+ float u=static_cast<float>((size-1)*nsub)*i_nsub; \
+ float v=0.0; \
+ bsplineGet(xp,yp,y2p,size,u,&v); \
+ sublist.at((size-1)*nsub). COMPONENT = v; \
}
-SplineEntryList Spline::Generate(int nsub) const
+SplineEntryList Spline::Generate(const SplineEntryList& entry_list, int nsub, uint color_blend_mode)
{
if(nsub<=0) {
- return entry_list_;
+ return entry_list;
}
- int size=entry_list_.size();
- if (size==0) {
- return entry_list_;
+ int size=entry_list.size();
+ if (size<2) {
+ return entry_list;
}
- int ipsize=(size)*nsub;
+ // we want to go to the last point, but not beyond
+ int ipsize=(size-1)*nsub+1;
float i_nsub=1.0/static_cast<float>(nsub);
std::vector<float> xc(size);
std::vector<float> yc(size);
@@ -181,16 +266,34 @@ SplineEntryList Spline::Generate(int nsub) const
xc[c]=static_cast<float>(c);
}
+ LOGN_DEBUG("SplineGenerate: interpolating spline entry components");
+
// create sublist with enough entries
SplineEntryList sublist(ipsize);
- // interpolate internal quaternion and color
- for(int k=0;k<4;++k) {
- SPLINE_ENTRY_INTERPOLATE(quat_value[k]);
- SPLINE_ENTRY_INTERPOLATE(color1[k]);
- SPLINE_ENTRY_INTERPOLATE(color2[k]);
+ // interpolate color
+ if(color_blend_mode==0) {
+ for(int k=0;k<4;++k) {
+ SPLINE_ENTRY_INTERPOLATE(color1[k]);
+ SPLINE_ENTRY_INTERPOLATE(color2[k]);
+ }
+ } else {
+ for(int c=0;c<size-1;++c) {
+ for(int k=0;k<4;++k) {
+ int d=0;
+ for(;d<nsub/2;++d) {
+ sublist.at(c*nsub+d).color1[k]=entry_list[c].color1[k];
+ sublist.at(c*nsub+d).color2[k]=entry_list[c].color2[k];
+ }
+ for(;d<nsub;++d) {
+ sublist.at(c*nsub+d).color1[k]=entry_list[c+1].color1[k];
+ sublist.at(c*nsub+d).color2[k]=entry_list[c+1].color2[k];
+ }
+ }
+ }
}
+ // interpolate position and helper vectors
for(int k=0;k<3;++k) {
SPLINE_ENTRY_INTERPOLATE(position[k]);
//SPLINE_ENTRY_INTERPOLATE(v0[k]);
@@ -200,17 +303,18 @@ SplineEntryList Spline::Generate(int nsub) const
SPLINE_ENTRY_INTERPOLATE(rad);
+ LOGN_DEBUG("SplineGenerate: assigning direction and normal components");
// assign direction and normal
// entity trace has the same algorithm
- geom::Vec3 p0 = sublist[0].position;
- geom::Vec3 p1 = sublist[1].position;
- geom::Vec3 p2 = sublist[2].position;
+ geom::Vec3 p0 = sublist.at(0).position;
+ geom::Vec3 p1 = sublist.at(1).position;
+ geom::Vec3 p2 = ipsize>2 ? sublist.at(2).position : p1+(p1-p0);
// normal of 0 is set at the end
- sublist[0].direction=geom::Normalize(p1-p0);
- sublist[0].v1=geom::Normalize(sublist[0].v1);
- geom::Vec3 orth = geom::Cross(sublist[0].direction,sublist[0].v1);
- sublist[0].v0 = geom::Normalize(geom::Cross(orth,sublist[0].direction));
+ sublist.at(0).direction=geom::Normalize(p1-p0);
+ sublist.at(0).v1=geom::Normalize(sublist.at(0).v1);
+ geom::Vec3 orth = geom::Cross(sublist.at(0).direction,sublist.at(0).v1);
+ sublist.at(0).v0 = geom::Normalize(geom::Cross(orth,sublist.at(0).direction));
// reference normal to avoid twisting
//geom::Vec3 nref=geom::Normalize(geom::Cross(p0-p1,p2-p1));
@@ -220,88 +324,102 @@ SplineEntryList Spline::Generate(int nsub) const
geom::Vec3 p12 = p2-p1;
// correction for perfectly aligned consecutive directions
if(p10==-p12 || p10==p12) p12+=geom::Vec3(0.001,0.001,0.001);
- sublist[i].normal=geom::Normalize(geom::Cross(p10,p12));
+ sublist.at(i).normal=geom::Normalize(geom::Cross(p10,p12));
// paranoid error checking due to occasional roundoff troubles
float cosw = geom::Dot(geom::Normalize(p10),geom::Normalize(p12));
cosw = std::min(float(1.0),std::max(float(-1.0),cosw));
float omega=0.5*acos(cosw);
- orth=geom::AxisRotation(sublist[i].normal, -omega)*p12;
- sublist[i].direction=geom::Normalize(geom::Cross(sublist[i].normal,orth));
+ orth=geom::AxisRotation(sublist.at(i).normal, -omega)*p12;
+ sublist.at(i).direction=geom::Normalize(geom::Cross(sublist.at(i).normal,orth));
// twist avoidance
- sublist[i].v1=geom::Normalize(sublist[i].v1);
- orth = geom::Cross(sublist[i].direction,sublist[i].v1);
- sublist[i].v0 = geom::Normalize(geom::Cross(orth,sublist[i].direction));
- if(geom::Dot(sublist[i-1].v0,sublist[i].v0)<0.0) {
- sublist[i].v0=-sublist[i].v0;
- //sublist[i].nflip = !sublist[i].nflip;
+ sublist.at(i).v1=geom::Normalize(sublist.at(i).v1);
+ orth = geom::Cross(sublist.at(i).direction,sublist.at(i).v1);
+ sublist.at(i).v0 = geom::Normalize(geom::Cross(orth,sublist.at(i).direction));
+ if(geom::Dot(sublist.at(i-1).v0,sublist.at(i).v0)<0.0) {
+ sublist.at(i).v0=-sublist.at(i).v0;
+ //sublist.at(i).nflip = !sublist.at(i).nflip;
}
// avoid twisting
- //if(geom::Dot(sublist[i].normal,nref)<0.0) sublist[i].normal=-sublist[i].normal;
- //nref=sublist[i].normal;
+ //if(geom::Dot(sublist.at(i).normal,nref)<0.0) sublist.at(i).normal=-sublist.at(i).normal;
+ //nref=sublist.at(i).normal;
// skip over shift for the last iteration
if(i==sublist.size()-2) break;
// shift to i+1 for next iteration
- p0 = sublist[i].position;
- p1 = sublist[i+1].position;
- p2 = sublist[i+2].position;
+ p0 = sublist.at(i).position;
+ p1 = sublist.at(i+1).position;
+ p2 = sublist.at(i+2).position;
}
// assign remaining ones
- sublist[0].normal=sublist[1].normal;
- sublist[i+1].direction=geom::Normalize(p2-p1);
- sublist[i+1].normal=sublist[i].normal;
- sublist[i+1].v1=geom::Normalize(sublist[i+1].v1);
- orth = geom::Cross(sublist[i+1].direction,sublist[i+1].v1);
- sublist[i+1].v0 = geom::Normalize(geom::Cross(orth,sublist[i+1].direction));
+ sublist.at(0).normal=sublist.at(1).normal;
+ sublist.at(i+1).direction=geom::Normalize(p2-p1);
+ sublist.at(i+1).normal=sublist.at(i).normal;
+ sublist.at(i+1).v1=geom::Normalize(sublist.at(i+1).v1);
+ orth = geom::Cross(sublist.at(i+1).direction,sublist.at(i+1).v1);
+ sublist.at(i+1).v0 = geom::Normalize(geom::Cross(orth,sublist.at(i+1).direction));
+ if(geom::Dot(sublist.at(i).v0,sublist.at(i+1).v0)<0.0) {
+ sublist.at(i+1).v0=-sublist.at(i+1).v0;
+ }
// hack
// TODO: merge this with above routine
- for(unsigned int i=0;i<sublist.size()-1;++i) {
- sublist[i].normal = sublist[i].v0;
+ for(unsigned int i=0;i<sublist.size();++i) {
+ sublist.at(i).normal = sublist.at(i).v0;
}
+ LOGN_DEBUG("SplineGenerate: assigning non-interpolated entry components");
// finally the non-interpolated type
// with some tweaks for proper strand rendering
- for(int c=0;c<size;++c) {
+ // part of this probably belongs into cartoon renderer
+ for(int c=0;c<size-1;++c) {
+ int type1=entry_list[c].type;
+ int type2=entry_list[std::min(c+1,size-1)].type;
for(int d=0;d<nsub;++d) {
- sublist[c*nsub+d].type=entry_list_[c].type;
- int type1=entry_list_[c].type;
- int type2=entry_list_[std::min(c+1,size-1)].type;
- //int type0=entry_list_[std::max(0,c-1)].type;
- if(type1==2 && type2==3) {
- type1=2;
- type2=2;
- } else if(type1==3) {
- type1=4;
- // uncommenting this causes the strand arrows
- // to blend into a tip instead of the n+1
- // profile - gives visual artefacts
- //type2=3;
- }
- sublist[c*nsub+d].type1=type1;
- sublist[c*nsub+d].type2=type2;
- sublist[c*nsub+d].frac=float(d)/float(nsub);
+ sublist.at(c*nsub+d).type=entry_list[c].type;
+ sublist.at(c*nsub+d).type1=type1;
+ sublist.at(c*nsub+d).type2=type2;
+ sublist.at(c*nsub+d).frac=float(d)/float(nsub);
}
}
+ int type1=entry_list.back().type;
+ int type2=type1;
+ sublist.back().type=entry_list.back().type;
+ sublist.back().type1=type1;
+ sublist.back().type2=type2;
+ sublist.back().frac=0.0;
+
+ // the id for selections, shifted by one half
+ for(int c=0;c<size-1;++c) {
+ int d=0;
+ for(;d<nsub/2;++d) {
+ sublist.at(c*nsub+d).id=entry_list[c].id;
+ }
+ for(;d<nsub;++d) {
+ sublist.at(c*nsub+d).id=entry_list[c+1].id;
+ }
+ }
+ sublist.back().id=entry_list.back().id;
// the nflip flags for helices for correct inside/outside assignment
- int c=0;
+ // this probably belongs into cartoon renderer
+ LOGN_DEBUG("SplineGenerate: setting nflip flags for helices");
+ unsigned int c=0;
bool nflip=false;
- while(c<nsub*size-1) {
+ while(c<sublist.size()-1) {
int cstart=c;
- if(sublist[c].type==1 && sublist[c+1].type==1) {
- geom::Vec3 n = geom::Normalize(geom::Cross(sublist[c].normal,
- sublist[c].direction));
- geom::Vec3 p0 = sublist[c].position+n;
- geom::Vec3 q0 = sublist[c].position-n;
+ if(sublist.at(c).type==1 && sublist.at(c+1).type==1) {
+ geom::Vec3 n = geom::Normalize(geom::Cross(sublist.at(c).normal,
+ sublist.at(c).direction));
+ geom::Vec3 p0 = sublist.at(c).position+n;
+ geom::Vec3 q0 = sublist.at(c).position-n;
float psum=0.0;
float qsum=0.0;
++c;
- while(c<nsub*size && sublist[c].type==1) {
- n = geom::Normalize(geom::Cross(sublist[c].normal,
- sublist[c].direction));
- geom::Vec3 p1 = sublist[c].position+n;
- geom::Vec3 q1 = sublist[c].position-n;
+ while(c<sublist.size() && sublist.at(c).type==1) {
+ n = geom::Normalize(geom::Cross(sublist.at(c).normal,
+ sublist.at(c).direction));
+ geom::Vec3 p1 = sublist.at(c).position+n;
+ geom::Vec3 q1 = sublist.at(c).position-n;
psum+=Length(p1-p0);
qsum+=Length(q1-q0);
p0=p1;
@@ -310,8 +428,8 @@ SplineEntryList Spline::Generate(int nsub) const
}
nflip = qsum>psum;
- for(int cc=cstart;cc<c;++cc) {
- sublist[cc].nflip=nflip;
+ for(unsigned int cc=cstart;cc<c;++cc) {
+ sublist.at(cc).nflip=nflip;
}
} else {
++c;
@@ -319,6 +437,8 @@ SplineEntryList Spline::Generate(int nsub) const
}
sublist.back().nflip=nflip;
+ LOGN_DEBUG("SplineGenerate: done");
+
// done
return sublist;
}
diff --git a/modules/gfx/src/impl/entity_detail.hh b/modules/gfx/src/impl/entity_detail.hh
index 7cf19d622fda4ad015caca9d3643cbb152f4793e..243ade1572723e578753901f6c9bb0ffdfe0f0f3 100644
--- a/modules/gfx/src/impl/entity_detail.hh
+++ b/modules/gfx/src/impl/entity_detail.hh
@@ -70,6 +70,9 @@ struct DLLEXPORT_OST_GFX BondEntry
typedef std::vector<BondEntry> BondEntryList;
+void DoRenderBlur(BondEntryList& bl, float bf1, float bf2);
+void DoBlurSnapshot(BondEntryList& bl);
+
class DLLEXPORT_OST_GFX GfxView {
public:
void Clear();
@@ -90,6 +93,7 @@ struct DLLEXPORT_OST_GFX NodeEntry {
float rad;
geom::Vec3 v0,v1,v2; // helper vectors
bool nflip;
+ int id;
};
typedef std::vector<NodeEntry> NodeEntryList;
@@ -115,7 +119,15 @@ struct DLLEXPORT_OST_GFX SplineEntry {
color1(1.0,1.0,1.0,1.0),
color2(1.0,1.0,1.0,1.0),
rad(1.0),
- type(0)
+ type(0),
+ type1(0),
+ type2(0),
+ frac(0.0),
+ v0(1.0,0.0,0.0),
+ v1(0.0,1.0,0.0),
+ v2(0.0,0.0,1.0),
+ nflip(false),
+ id(-1)
{
}
SplineEntry(const geom::Vec3& p,
@@ -123,25 +135,21 @@ struct DLLEXPORT_OST_GFX SplineEntry {
const geom::Vec3& n,
float r,
const Color& c1, const Color& c2,
- int t):
+ unsigned int t, int i):
position(p),direction(d),normal(n),color1(c1),color2(c2),rad(r),type(t),
- type1(t),type2(t),frac(0.0),v0(),v1(),v2(),nflip(false)
+ type1(t),type2(t),frac(0.0),v0(),v1(),v2(),nflip(false),id(i)
{
}
- void ToQuat();
-
- void FromQuat();
-
geom::Vec3 position,direction,normal;
Color color1, color2;
- float quat_value[4];
float rad;
- int type;
- int type1, type2;
+ unsigned int type;
+ unsigned int type1, type2;
float frac;
geom::Vec3 v0,v1,v2; // helper vectors
bool nflip;
+ int id;
};
typedef std::vector<SplineEntry> SplineEntryList;
@@ -149,20 +157,7 @@ typedef std::vector<SplineEntryList> SplineEntryListList;
class DLLEXPORT_OST_GFX Spline {
public:
-
-public:
- // ctor
- Spline();
-
- // add entry at a given position, with direction and normal vectors
- SplineEntry& AddEntry(const geom::Vec3& pos, const geom::Vec3& dir,
- const geom::Vec3& normal, float r, const Color& col1,
- const Color& col2, int type);
-
- SplineEntryList Generate(int nsub) const;
-
-private:
- SplineEntryList entry_list_;
+ static SplineEntryList Generate(const SplineEntryList& entry_list,int nsub,uint color_blend_mode=0);
};
}}} // ns
diff --git a/modules/gfx/src/impl/entity_renderer.hh b/modules/gfx/src/impl/entity_renderer.hh
index 28a932abfe81aa3ff3fd47bbee41caf91200b980..c43bd5d3399ae6cf51bf3debe0aad3c623513c64 100644
--- a/modules/gfx/src/impl/entity_renderer.hh
+++ b/modules/gfx/src/impl/entity_renderer.hh
@@ -24,8 +24,8 @@
*/
-#if defined(GetProp)
-#undef GetProp
+#if defined(GetAtomProps)
+#undef GetAtomProps
#endif
#include <vector>
@@ -56,11 +56,11 @@
namespace ost { namespace gfx { namespace impl {
typedef enum {
- DIRTY_VIEW =1,
- DIRTY_VA =2,
+ DIRTY_VIEW = 0x1,
+ DIRTY_VA = 0x2
} DirtyFlag;
-typedef char DirtyFlags;
+typedef unsigned int DirtyFlags;
/// \internal
class DLLEXPORT_OST_GFX EntityRenderer {
@@ -118,7 +118,7 @@ public:
///
/// The rendering buffers and vertex arrays should be prepared in
/// PrepareRendering()
- virtual void Render(RenderPass pass=STANDARD_RENDER_PASS);
+ virtual void Render(RenderPass pass);
///\brief povray rendering call
virtual void RenderPov(PovState& pov, const std::string& name);
@@ -160,6 +160,8 @@ public:
void FlagPositionsDirty();
void Debug(unsigned int flags);
+
+ IndexedVertexArray& VA() {return va_;}
protected:
virtual void SetName(const String& name);
@@ -178,12 +180,13 @@ protected:
DirtyFlags sel_state_;
DirtyFlags state_;
unsigned int debug_flags_;
+ float opacity_;
};
//Simplify color ops
struct ByElementGetCol {
Color ColorOfAtom(mol::AtomHandle& atom) const{
- return GfxObj::Ele2Color(atom.GetAtomProps().element);
+ return GfxObj::Ele2Color(atom.GetElement());
}
};
diff --git a/modules/gfx/src/impl/glx_offscreen_buffer.cc b/modules/gfx/src/impl/glx_offscreen_buffer.cc
index fc1e2b0e9cff8bad35a7da4cad80627c678c0d40..78fc8cc7a603a1afb4bda93a161d2cd3d6b0df86 100644
--- a/modules/gfx/src/impl/glx_offscreen_buffer.cc
+++ b/modules/gfx/src/impl/glx_offscreen_buffer.cc
@@ -107,7 +107,9 @@ OffscreenBuffer::OffscreenBuffer(unsigned int width, unsigned int height, const
OffscreenBuffer::~OffscreenBuffer()
{
if(valid_) {
+ LOGN_DEBUG("offscreen buffer: glXDestroyContext()");
glXDestroyContext(dpy_, context_);
+ LOGN_DEBUG("offscreen buffer: glXDestroyPbuffer()");
glXDestroyPbuffer(dpy_, pbuffer_);
}
}
diff --git a/modules/gfx/src/impl/line_trace_renderer.cc b/modules/gfx/src/impl/line_trace_renderer.cc
index b0279b71f0f274f101757c0e2c321fc102e4c3e2..f183c6b5b0439696f8fa357baaeb24951c65dc49 100644
--- a/modules/gfx/src/impl/line_trace_renderer.cc
+++ b/modules/gfx/src/impl/line_trace_renderer.cc
@@ -17,15 +17,45 @@
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+/*
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#include "line_trace_renderer.hh"
#include <ost/gfx/entity.hh>
namespace ost { namespace gfx { namespace impl {
-LineTraceRenderer::LineTraceRenderer(BackboneTrace& trace):
- TraceRendererBase(trace, 1), options_(new LineTraceRenderOptions())
+namespace {
+
+void add_atom_and_bond(mol::AtomHandle atom1,mol::AtomHandle atom2, AtomEntryMap& amap, BondEntryList& blist)
+{
+ AtomEntry ae1(atom1,0.0,0.0,Color(1,1,1));
+ amap[atom1.GetHashCode()]=ae1;
+ AtomEntry ae2(atom2,0.0,0.0,Color(1,1,1));
+ amap[atom2.GetHashCode()]=ae2;
+ blist.push_back(BondEntry(mol::BondHandle(),0.0f,
+ &amap[atom1.GetHashCode()],
+ &amap[atom2.GetHashCode()]));
+}
+
+}
+
+
+LineTraceRenderer::LineTraceRenderer(BackboneTrace* trace):
+ TraceRendererBase(trace, 1),
+ options_(new LineTraceRenderOptions()),
+ amap_(),
+ blist_()
{
this->SetName("Fast Trace");
+
+ for (int node_list=0; node_list<trace->GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace->GetList(node_list);
+ for (unsigned int i=0; i<nl.size()-1;++i) {
+ add_atom_and_bond(nl[i].atom,nl[i+1].atom,amap_,blist_);
+ }
+ }
}
void LineTraceRenderer::PrepareRendering()
@@ -36,15 +66,15 @@ void LineTraceRenderer::PrepareRendering()
sel_va_.Clear();
sel_va_.SetOutlineWidth(options_->GetLineWidth()+3.0);
if (this->HasSelection()) {
- this->PrepareRendering(sel_subset_, sel_va_, true);
+ //this->PrepareRendering(sel_subset_, sel_va_, true);
+ this->PrepareRendering(trace_subset_, sel_va_, true);
sel_va_.SetLineWidth(options_->GetLineWidth()+4.0);
}
}
-void LineTraceRenderer::PrepareRendering(TraceSubset& trace_subset,
+void LineTraceRenderer::PrepareRendering(const BackboneTrace& trace_subset,
IndexedVertexArray& va, bool is_sel)
{
-
const Color& sel_clr=this->GetSelectionColor();
if(options_!=NULL){
va.Clear();
@@ -56,53 +86,45 @@ void LineTraceRenderer::PrepareRendering(TraceSubset& trace_subset,
va.SetLineWidth(options_->GetLineWidth());
va.SetPointSize(options_->GetLineWidth());
va.SetAALines(options_->GetAALines());
- for (int node_list=0; node_list<trace_subset.GetSize(); ++node_list) {
- const NodeListSubset& nl=trace_subset[node_list];
-
- if (nl.GetSize()==2) {
- VertexID p0, p1;
- if (nl.AtStart()==0) {
- p0=va.Add(nl[0].atom.GetPos(), geom::Vec3(),
- is_sel ? sel_clr : nl[0].color1);
- p1=va.Add((nl[0].atom.GetPos()+nl[1].atom.GetPos())/2,
- geom::Vec3(), is_sel ? sel_clr : nl[1].color1);
- } else {
- p0=va.Add((nl[0].atom.GetPos()+nl[1].atom.GetPos())/2,
- geom::Vec3(), is_sel ? sel_clr : nl[0].color1);
- p1=va.Add(nl[1].atom.GetPos(),
- geom::Vec3(), is_sel ? sel_clr : nl[1].color1);
- }
- va.AddLine(p0, p1);
- continue;
- }
- if (nl.GetSize()<3) {
- continue;
- }
- VertexID p0;
- if (nl.AtStart()==0) {
- p0=va.Add(nl[0].atom.GetPos(), geom::Vec3(),
- is_sel ? sel_clr : nl[0].color1);
- } else {
- p0=va.Add((nl[0].atom.GetPos()+nl[1].atom.GetPos())/2,
- geom::Vec3(), is_sel ? sel_clr : nl[0].color1);
- }
- for (int i=1; i<nl.GetSize()-1;++i) {
- const NodeEntry& entry=nl[i];
- VertexID p1 =va.Add(entry.atom.GetPos(), geom::Vec3(),
- is_sel ? sel_clr : entry.color1);
- va.AddLine(p0, p1);
- p0=p1;
+ if(is_sel) {
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace_subset.GetList(node_list);
+ if(nl.size()<1) continue;
+ for(unsigned int i=0;i<nl.size();++i) {
+ const NodeEntry& entry=nl[i];
+ if(sel_.FindAtom(entry.atom).IsValid()) {
+ geom::Vec3 apos = entry.atom.GetPos();
+ VertexID p0=va.Add(apos, geom::Vec3(),sel_clr);
+ if(i>0) {
+ VertexID p1 =va.Add(apos+0.5*(nl[i-1].atom.GetPos()-apos), geom::Vec3(), sel_clr);
+ va.AddLine(p0, p1);
+ }
+ if(i<nl.size()-1) {
+ VertexID p1 =va.Add(apos+0.5*(nl[i+1].atom.GetPos()-apos), geom::Vec3(), sel_clr);
+ va.AddLine(p0, p1);
+ }
+ }
+ }
}
- const NodeEntry& entry=nl[nl.GetSize()-1];
- if (nl.AtEnd()==0) {
- VertexID p1 =va.Add(entry.atom.GetPos(), geom::Vec3(),
- is_sel ? sel_clr : entry.color1);
- va.AddLine(p0, p1);
- } else {
- geom::Vec3 p=(entry.atom.GetPos()+nl[nl.GetSize()-2].atom.GetPos())*0.5;
- VertexID p1 =va.Add(p, geom::Vec3(),
- is_sel ? sel_clr : entry.color1);
- va.AddLine(p0, p1);
+ } else {
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace_subset.GetList(node_list);
+
+ if (nl.size()<2) continue;
+
+ VertexID p0=va.Add(nl[0].atom.GetPos(), geom::Vec3(),
+ nl[0].color1);
+ for (unsigned int i=1; i<nl.size()-1;++i) {
+ const NodeEntry& entry=nl[i];
+ VertexID p1 =va.Add(entry.atom.GetPos(), geom::Vec3(),
+ entry.color1);
+ va.AddLine(p0, p1);
+ p0=p1;
+ }
+ const NodeEntry& entry=nl.back();
+ VertexID p1 =va.Add(entry.atom.GetPos(), geom::Vec3(),
+ entry.color1);
+ va.AddLine(p0, p1);
}
}
}
@@ -110,11 +132,6 @@ void LineTraceRenderer::PrepareRendering(TraceSubset& trace_subset,
state_=0;
}
-void LineTraceRenderer::Render()
-{
-
-}
-
bool LineTraceRenderer::CanSetOptions(RenderOptionsPtr& render_options)
{
return render_options.get()->GetRenderMode()==RenderMode::LINE_TRACE;
diff --git a/modules/gfx/src/impl/line_trace_renderer.hh b/modules/gfx/src/impl/line_trace_renderer.hh
index d4b904e0fa478286e1bcb7f47e677f6772051344..ce42fc004dd6c70b444c04d7bea50d751dedb330 100644
--- a/modules/gfx/src/impl/line_trace_renderer.hh
+++ b/modules/gfx/src/impl/line_trace_renderer.hh
@@ -16,6 +16,11 @@
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+
+/*
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#ifndef OST_GFX_IMPL_LINE_TRACE_RENDERER_HH
#define OST_GFX_IMPL_LINE_TRACE_RENDERER_HH
@@ -36,12 +41,11 @@ using namespace impl;
/// \internal
class DLLEXPORT_OST_GFX LineTraceRenderer: public TraceRendererBase {
public:
- LineTraceRenderer(BackboneTrace& trace);
+ LineTraceRenderer(BackboneTrace* trace);
virtual void PrepareRendering();
- virtual void PrepareRendering(TraceSubset& trace_subset,
+ virtual void PrepareRendering(const BackboneTrace& trace_subset,
IndexedVertexArray& va, bool is_sel);
- virtual void Render();
virtual bool CanSetOptions(RenderOptionsPtr& render_options);
virtual void SetOptions(RenderOptionsPtr& render_options);
@@ -49,8 +53,12 @@ public:
virtual ~LineTraceRenderer();
+ BondEntryList& GetBondEntryList() {return blist_;}
+
private:
LineTraceRenderOptionsPtr options_;
+ AtomEntryMap amap_; // for blur rendering
+ BondEntryList blist_; // dito
};
}}}
diff --git a/modules/gfx/src/impl/scene_fx.cc b/modules/gfx/src/impl/scene_fx.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bb3012e88a84868fcd961c5ba33286dd6d0125f4
--- /dev/null
+++ b/modules/gfx/src/impl/scene_fx.cc
@@ -0,0 +1,717 @@
+#include <boost/random.hpp>
+
+#include "scene_fx.hh"
+
+#include <ost/log.hh>
+
+#include <ost/gfx/gfx_node.hh>
+#include <ost/gfx/shader.hh>
+#include <ost/gfx/scene.hh>
+
+#if !GL_VERSION_3_0
+#warning using OpenGL 2.0 interface
+#endif
+
+namespace ost { namespace gfx { namespace impl {
+
+namespace {
+ boost::mt19937 RandomGenerator(time(NULL));
+ boost::uniform_01<boost::mt19937> UniformRandom(RandomGenerator);
+}
+
+SceneFX& SceneFX::Instance()
+{
+ static SceneFX inst;
+ return inst;
+}
+
+SceneFX::SceneFX():
+ shadow_flag(false),
+ shadow_quality(1),
+ shadow_weight(1.0),
+ depth_dark_flag(false),
+ depth_dark_factor(1.0),
+ amb_occl_flag(false),
+ amb_occl_factor(1.0),
+ amb_occl_mode(1),
+ amb_occl_quality(1),
+ use_beacon(false),
+ beacon(),
+ scene_tex_id_(),
+ depth_tex_id_(),
+ shadow_tex_id_(),
+ shadow_tex_mat_(),
+ occl_tex_id_(),
+ dark_tex_id_(),
+ norm_tex_id_(),
+ kernel_tex_id_(),
+ kernel_size_(0),
+ kernel2_tex_id_(),
+ kernel2_size_(0),
+ scene_tex2_id_(),
+ norm_tex2_id_(),
+ scene_fb_(),
+ scene_rb_(),
+ depth_rb_(),
+ use_fb_(false)
+{}
+
+SceneFX::~SceneFX()
+{}
+
+void SceneFX::Setup()
+{
+ if(!GLEW_VERSION_2_0) return;
+ LOGN_DEBUG("SceneFX: setup");
+
+ glGenTextures(1,&scene_tex_id_);
+ glGenTextures(1,&depth_tex_id_);
+ glGenTextures(1,&shadow_tex_id_);
+ glGenTextures(1,&occl_tex_id_);
+ glGenTextures(1,&dark_tex_id_);
+ glGenTextures(1,&norm_tex_id_);
+ glGenTextures(1,&kernel_tex_id_);
+ glGenTextures(1,&kernel2_tex_id_);
+
+#if GL_VERSION_3_0
+ glGenFramebuffers(1,&scene_fb_);
+ glGenRenderbuffers(1,&scene_rb_);
+ glGenRenderbuffers(1,&depth_rb_);
+#else
+ glGenFramebuffersEXT(1,&scene_fb_);
+ glGenRenderbuffersEXT(1,&scene_rb_);
+ glGenRenderbuffersEXT(1,&depth_rb_);
+#endif
+ glGenTextures(1,&scene_tex2_id_);
+ glGenTextures(1,&norm_tex2_id_);
+
+ glBindTexture(GL_TEXTURE_2D, scene_tex_id_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glBindTexture(GL_TEXTURE_2D, depth_tex_id_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glBindTexture(GL_TEXTURE_2D, shadow_tex_id_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glBindTexture(GL_TEXTURE_2D, occl_tex_id_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glBindTexture(GL_TEXTURE_2D, dark_tex_id_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glBindTexture(GL_TEXTURE_2D, norm_tex_id_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_1D, kernel_tex_id_);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ std::vector<GLfloat> tmp;
+ for(int u=-20;u<=20;++u) {
+ for(int v=-20;v<=20;++v) {
+ if(UniformRandom()<0.1) {
+ // norm to 1
+ float x = static_cast<float>(u+20)*0.025;
+ float y = static_cast<float>(v+20)*0.025;
+ tmp.push_back(x);
+ tmp.push_back(y);
+ tmp.push_back(0.0);
+ tmp.push_back(0.0);
+ }
+ }
+ }
+
+ kernel_size_=tmp.size()/4;
+ glTexImage1D(GL_TEXTURE_1D,0,4,kernel_size_,0,GL_RGBA, GL_FLOAT, &tmp[0]);
+
+ glBindTexture(GL_TEXTURE_1D, kernel2_tex_id_);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+
+ // depth darkening kernel
+ tmp.clear();
+ for(int u=-5;u<=5;++u) {
+ for(int v=-5;v<=5;++v) {
+ if(UniformRandom()<0.5) {
+ // norm to -1 ... 1
+ float x = static_cast<float>(u)*0.2;
+ float y = static_cast<float>(v)*0.2;
+ // gaussian kernel with sigma
+ float v = exp((-x*x-y*y)*0.5);
+ // norml to 0 ... 1
+ tmp.push_back(x*0.5+0.5);
+ tmp.push_back(y*0.5+0.5);
+ tmp.push_back(v);
+ tmp.push_back(0.0);
+ }
+ }
+ }
+
+ kernel2_size_=tmp.size()/4;
+ glTexImage1D(GL_TEXTURE_1D,0,4,kernel2_size_,0,GL_RGBA, GL_FLOAT, &tmp[0]);
+}
+
+void SceneFX::Resize(unsigned int w, unsigned int h)
+{
+#if 0
+ glBindTexture(GL_TEXTURE_2D, scene_tex2_id_);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+ glBindTexture(GL_TEXTURE_2D, norm_tex2_id_);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+ glBindTexture(GL_TEXTURE_2D, 0);
+
+ glBindFramebuffer(GL_FRAMEBUFFER, scene_fb_);
+
+ glBindRenderbuffer(GL_RENDERBUFFER, depth_rb_);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,w,h);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_rb_);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, scene_tex2_id_, 0);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, norm_tex2_id_, 0);
+
+ GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+ if(status!=GL_FRAMEBUFFER_COMPLETE) {
+ use_fb_=false;
+ LOGN_VERBOSE("SceneFX: framebuffer error code " << status);
+ } else {
+ use_fb_=true;
+ }
+
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+#endif
+}
+
+void SceneFX::Preprocess()
+{
+ if(!GLEW_VERSION_2_0) return;
+ if(use_fb_) {
+#if GL_VERSION_3_0
+ glBindFramebuffer(GL_FRAMEBUFFER, scene_fb_);
+#else
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, scene_fb_);
+#endif
+ }
+}
+
+void SceneFX::Postprocess()
+{
+ if(!GLEW_VERSION_2_0) return;
+ if(use_fb_) {
+#if GL_VERSION_3_0
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+#else
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+#endif
+ }
+
+ if(!shadow_flag && !amb_occl_flag && !depth_dark_flag && !use_beacon) {
+ // no postprocessing is needed
+ return;
+ }
+
+ Viewport vp=Scene::Instance().GetViewport();
+
+ if(!use_fb_) {
+ // grab color buffer
+ glBindTexture(GL_TEXTURE_2D, scene_tex_id_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, vp.x, vp.y, vp.width, vp.height, 0);
+ // and depth buffer
+ glBindTexture(GL_TEXTURE_2D, depth_tex_id_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, vp.x, vp.y, vp.width, vp.height, 0);
+
+ if(amb_occl_flag) {
+ // now for the normal buffer hack if the framebuffer stuff failed
+ Shader::Instance().PushProgram();
+ Shader::Instance().Activate("dumpnorm");
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ Scene::Instance().GetRootNode()->RenderGL(STANDARD_RENDER_PASS);
+ glBindTexture(GL_TEXTURE_2D, norm_tex_id_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, vp.x, vp.y, vp.width, vp.height, 0);
+ Shader::Instance().PopProgram();
+ }
+ }
+
+ if(shadow_flag) {
+ prep_shadow_map();
+ }
+ if(amb_occl_flag) {
+ prep_amb_occlusion();
+ }
+ if(depth_dark_flag) {
+ prep_depth_darkening();
+ }
+
+ Shader::Instance().PushProgram();
+ glEnable(GL_TEXTURE_2D);
+ glEnable(GL_TEXTURE_1D);
+ Shader::Instance().Activate("scenefx");
+ GLuint cpr=Shader::Instance().GetCurrentProgram();
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D,depth_tex_id_);
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D,scene_tex_id_);
+
+ glUniform1i(glGetUniformLocation(cpr,"scene_map"),0);
+ glUniform1i(glGetUniformLocation(cpr,"depth_map"),1);
+
+ glUniform2f(glGetUniformLocation(cpr,"i_vp"),
+ 1.0/static_cast<float>(vp.width),
+ 1.0/static_cast<float>(vp.height));
+
+ if(shadow_flag) {
+ glActiveTexture(GL_TEXTURE2);
+ glBindTexture(GL_TEXTURE_2D,shadow_tex_id_);
+ glMatrixMode(GL_TEXTURE);
+ glPushMatrix();
+ geom::Mat4 ttmp=geom::Transpose(shadow_tex_mat_);
+ glLoadMatrix(ttmp.Data());
+ glMatrixMode(GL_MODELVIEW);
+ glActiveTexture(GL_TEXTURE0);
+ glUniform1i(glGetUniformLocation(cpr,"shadow_flag"),1);
+ glUniform1i(glGetUniformLocation(cpr,"shadow_map"),2);
+ glUniform1f(glGetUniformLocation(cpr,"shadow_depth_bias"),0.008);
+ glUniform1f(glGetUniformLocation(cpr,"shadow_epsilon"),0.002);
+ glUniform1f(glGetUniformLocation(cpr,"shadow_multiplier"),0.4);
+ glUniform1f(glGetUniformLocation(cpr,"shadow_weight"),shadow_weight);
+
+ } else {
+ glUniform1i(glGetUniformLocation(cpr,"shadow_flag"),0);
+ }
+ if(amb_occl_flag) {
+ glActiveTexture(GL_TEXTURE3);
+ glBindTexture(GL_TEXTURE_2D,occl_tex_id_);
+ glActiveTexture(GL_TEXTURE0);
+ glUniform1i(glGetUniformLocation(cpr,"occl_flag"),1);
+ glUniform1i(glGetUniformLocation(cpr,"occl_map"),3);
+ glUniform1f(glGetUniformLocation(cpr,"occl_mult"),amb_occl_factor);
+ } else {
+ glUniform1i(glGetUniformLocation(cpr,"occl_flag"),0);
+ }
+
+ if(depth_dark_flag) {
+ glActiveTexture(GL_TEXTURE4);
+ glBindTexture(GL_TEXTURE_2D,dark_tex_id_);
+ glActiveTexture(GL_TEXTURE0);
+ glUniform1i(glGetUniformLocation(cpr,"dark_flag"),1);
+ glUniform1i(glGetUniformLocation(cpr,"dark_map"),4);
+ glUniform1f(glGetUniformLocation(cpr,"dark_mult"),depth_dark_factor);
+ } else {
+ glUniform1i(glGetUniformLocation(cpr,"dark_flag"),0);
+ }
+
+ if(use_beacon) {
+ prep_beacon();
+ }
+
+ draw_screen_quad(vp.width,vp.height);
+
+ if(shadow_flag) {
+ glActiveTexture(GL_TEXTURE2);
+ glMatrixMode(GL_TEXTURE);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glActiveTexture(GL_TEXTURE0);
+ }
+
+ if(use_beacon) {
+ draw_beacon();
+ }
+
+ glDisable(GL_TEXTURE_1D);
+ glDisable(GL_TEXTURE_2D);
+ Shader::Instance().PopProgram();
+}
+
+void SceneFX::DrawTex(unsigned int w, unsigned int h, GLuint texid)
+{
+ if(!GLEW_VERSION_2_0) return;
+ Shader::Instance().PushProgram();
+ Shader::Instance().Activate("");
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, texid);
+
+ draw_screen_quad(w,h);
+
+ Shader::Instance().PopProgram();
+}
+
+void SceneFX::prep_shadow_map()
+{
+ GLint smap_size=256 * (1+shadow_quality);
+
+#if GL_VERSION_3_0
+ glBindFramebuffer(GL_FRAMEBUFFER, scene_fb_);
+ glBindRenderbuffer(GL_RENDERBUFFER, scene_rb_);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA,smap_size,smap_size);
+ glBindRenderbuffer(GL_RENDERBUFFER, depth_rb_);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,smap_size,smap_size);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, scene_rb_);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_rb_);
+
+ GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+ if(status!=GL_FRAMEBUFFER_COMPLETE) {
+ LOGN_DEBUG("fbo switch for shadow mapping failed, using fallback");
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ smap_size=512;
+ }
+#else
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, scene_fb_);
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, scene_rb_);
+ glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA,smap_size,smap_size);
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb_);
+ glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,smap_size,smap_size);
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, scene_rb_);
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb_);
+
+ GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+
+ if(status!=GL_FRAMEBUFFER_COMPLETE_EXT) {
+ LOGN_DEBUG("fbo switch for shadow mapping failed, using fallback");
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+ smap_size=512;
+ }
+#endif
+
+ // modelview transform for the lightsource pov
+ mol::Transform ltrans(Scene::Instance().GetTransform());
+ ltrans.SetRot(Scene::Instance().GetLightRot()*ltrans.GetRot());
+
+ // calculate encompassing box for ortho projection
+ geom::AlignedCuboid bb=Scene::Instance().GetBoundingBox(ltrans);
+ geom::Vec3 tmin=bb.GetMin();
+ geom::Vec3 tmax=bb.GetMax();
+
+ // save overall gl settings
+ glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
+ // maximize rendering for depth-only information
+ glDisable(GL_LIGHTING);
+ glDisable(GL_FOG);
+ glDisable(GL_COLOR_MATERIAL);
+ glDisable(GL_NORMALIZE);
+ //glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
+
+ // render scene with only depth components
+ // seen from the light's perspective
+ glViewport(0,0,smap_size,smap_size);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+ glLoadIdentity();
+ glOrtho(tmin[0],tmax[0],tmin[1],tmax[1],-tmax[2],-tmin[2]);
+ //glFrustum(tmin[0],tmax[0],tmin[1],tmax[1],-tmax[2],-tmin[2]);
+ float glpmat[16];
+ glGetv(GL_PROJECTION_MATRIX, glpmat);
+ geom::Mat4 pmat(geom::Transpose(geom::Mat4(glpmat)));
+
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+ glMultMatrix(ltrans.GetTransposedMatrix().Data());
+
+ // only render non-transparent objects for the shadow map
+ Scene::Instance().GetRootNode()->RenderGL(STANDARD_RENDER_PASS);
+
+ // now get the shadow map
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, shadow_tex_id_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0,0, smap_size,smap_size, 0);
+
+ // restore settings
+ glPopMatrix();
+ glMatrixMode(GL_PROJECTION);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+
+ glPopAttrib();
+ //glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
+
+#if GL_VERSION_3_0
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+#else
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+#endif
+
+ // set up appropriate texture matrix
+ geom::Mat4 bias(0.5,0.0,0.0,0.5,
+ 0.0,0.5,0.0,0.5,
+ 0.0,0.0,0.5,0.5,
+ 0.0,0.0,0.0,1.0);
+ //shadow_tex_mat_ = bias*pmat*ltrans.GetMatrix();
+ glGetv(GL_PROJECTION_MATRIX, glpmat);
+ geom::Mat4 pmat2(geom::Transpose(geom::Mat4(glpmat)));
+ /*
+ given the normalized coordinates in scenefx, the camera projection and modelview transformation
+ are first reverted, and then the light modelview and projection are applied, resulting (with the
+ bias) in the proper 2D lookup into the shadow map
+ */
+ shadow_tex_mat_ = bias*pmat*ltrans.GetMatrix()*geom::Invert(Scene::Instance().GetTransform().GetMatrix())*geom::Invert(pmat2);
+}
+
+void SceneFX::prep_amb_occlusion()
+{
+ Viewport vp=Scene::Instance().GetViewport();
+
+ uint qf=1;
+ if(amb_occl_quality==0) {qf=4;}
+ else if(amb_occl_quality==1) {qf=2;}
+ uint width=vp.width/qf;
+ uint height=vp.height/qf;
+
+ Shader::Instance().PushProgram();
+ Shader::Instance().Activate("amboccl");
+ GLuint cpr=Shader::Instance().GetCurrentProgram();
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D,depth_tex_id_);
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D,norm_tex_id_);
+ glActiveTexture(GL_TEXTURE2);
+ glBindTexture(GL_TEXTURE_1D,kernel_tex_id_);
+ glActiveTexture(GL_TEXTURE0);
+ glUniform1i(glGetUniformLocation(cpr,"depth_map"),0);
+ glUniform1i(glGetUniformLocation(cpr,"norm_map"),1);
+ glUniform1i(glGetUniformLocation(cpr,"kernel"),2);
+ glUniform1f(glGetUniformLocation(cpr,"step"),1.0/static_cast<float>(kernel_size_));
+ glUniform2f(glGetUniformLocation(cpr,"i_vp"),1.0/static_cast<float>(width),1.0/static_cast<float>(height));
+ glUniform1i(glGetUniformLocation(cpr,"mode"),amb_occl_mode);
+ double pm[16];
+ glGetDoublev(GL_PROJECTION_MATRIX,pm);
+ glUniform4f(glGetUniformLocation(cpr,"abcd"),pm[0],pm[5],pm[10],pm[14]);
+
+ glMatrixMode(GL_TEXTURE);
+ glPushMatrix();
+ geom::Mat4 ipm(geom::Transpose(geom::Invert(geom::Transpose(geom::Mat4(pm)))));
+ glLoadMatrix(ipm.Data());
+ glMatrixMode(GL_MODELVIEW);
+
+ // set up viewport filling quad to run the fragment shader
+ draw_screen_quad(width,height);
+
+ glMatrixMode(GL_TEXTURE);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, occl_tex_id_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0,0, width, height, 0);
+ Shader::Instance().PopProgram();
+}
+
+void SceneFX::prep_depth_darkening()
+{
+ Viewport vp=Scene::Instance().GetViewport();
+
+ Shader::Instance().PushProgram();
+ Shader::Instance().Activate("convolute1");
+ GLuint cpr=Shader::Instance().GetCurrentProgram();
+ // assign tex units
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D,depth_tex_id_);
+ glActiveTexture(GL_TEXTURE2);
+ glBindTexture(GL_TEXTURE_1D,kernel2_tex_id_);
+ glActiveTexture(GL_TEXTURE0);
+
+ glUniform1i(glGetUniformLocation(cpr,"data"),1);
+ glUniform1i(glGetUniformLocation(cpr,"kernel"),2);
+ glUniform1f(glGetUniformLocation(cpr,"step"),1.0/static_cast<float>(kernel2_size_));
+ glUniform2f(glGetUniformLocation(cpr,"i_vp"),1.0/static_cast<float>(vp.width),1.0/static_cast<float>(vp.height));
+
+ // set up viewport filling quad to run the fragment shader
+ draw_screen_quad(vp.width/2,vp.height/2);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, dark_tex_id_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0,0,vp.width/2, vp.height/2, 0);
+
+ Shader::Instance().PopProgram();
+}
+
+void SceneFX::draw_screen_quad(unsigned int w, unsigned int h)
+{
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+ // setup
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_LIGHTING);
+ glDisable(GL_COLOR_MATERIAL);
+ glDisable(GL_FOG);
+ glDisable(GL_CULL_FACE);
+ glDisable(GL_BLEND);
+ glDisable(GL_LINE_SMOOTH);
+ glDisable(GL_POINT_SMOOTH);
+ glShadeModel(GL_FLAT);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ glViewport(0,0,w,h);
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+ glLoadIdentity();
+ glOrtho(0,1,0,1,-1,1);
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+ glEnable(GL_TEXTURE_2D);
+ glActiveTexture(GL_TEXTURE0);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+ // draw
+ glColor3f(1.0,0.0,1.0);
+ glBegin(GL_QUADS);
+ glTexCoord2f(0.0,0.0);
+ glVertex2f(0.0,0.0);
+ glTexCoord2f(0.0,1.0);
+ glVertex2f(0.0,1.0);
+ glTexCoord2f(1.0,1.0);
+ glVertex2f(1.0,1.0);
+ glTexCoord2f(1.0,0.0);
+ glVertex2f(1.0,0.0);
+ glEnd();
+
+ // restore settings
+ glMatrixMode(GL_PROJECTION);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ glPopAttrib();
+}
+
+void SceneFX::prep_beacon()
+{
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+ glLoadIdentity();
+ Scene::Instance().stereo_projection(0);
+ GLdouble glpmat[16];
+ glGetDoublev(GL_PROJECTION_MATRIX, glpmat);
+ geom::Mat4 pmat(geom::Transpose(geom::Mat4(glpmat)));
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ geom::Mat4 mmat=Scene::Instance().GetTransform().GetTransposedMatrix();
+ GLdouble glmmat[16];
+ for(int i=0;i<16;++i) glmmat[i]=static_cast<GLdouble>(mmat.Data()[i]);
+ GLint glvp[4];
+ glGetIntegerv(GL_VIEWPORT,glvp);
+
+ double res[3];
+ gluUnProject(beacon.wx,beacon.wy,0.0,
+ glmmat,glpmat,glvp,
+ &res[0],&res[1],&res[2]);
+ beacon.p0=geom::Vec3(res[0],res[1],res[2]);
+ gluUnProject(beacon.wx,beacon.wy,1.0,
+ glmmat,glpmat,glvp,
+ &res[0],&res[1],&res[2]);
+ beacon.p1=geom::Vec3(res[0],res[1],res[2]);
+
+ glGetv(GL_PROJECTION_MATRIX, glpmat);
+ geom::Mat4 pmat2(geom::Transpose(geom::Mat4(glpmat)));
+ beacon.mat = geom::Invert(Scene::Instance().GetTransform().GetMatrix())*geom::Invert(pmat2);
+}
+
+void SceneFX::draw_beacon()
+{
+ Viewport vp=Scene::Instance().GetViewport();
+ float iw=1.0/static_cast<float>(vp.width);
+ float ih=1.0/static_cast<float>(vp.height);
+ Shader::Instance().PushProgram();
+ Shader::Instance().Activate("beacon");
+ uint cpr=Shader::Instance().GetCurrentProgram();
+
+ float rad=0.6;
+ float delta = rad/(std::max<float>(1.0,Scene::Instance().znear_) * Scene::Instance().aspect_ratio_ * std::tan(Scene::Instance().fov_*M_PI/360.0))/iw;
+ geom::Vec2 q0(beacon.wx-delta,beacon.wy-delta);
+ geom::Vec2 q1(beacon.wx-delta,beacon.wy+delta);
+ geom::Vec2 q2(beacon.wx+delta,beacon.wy+delta);
+ geom::Vec2 q3(beacon.wx+delta,beacon.wy-delta);
+
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D,depth_tex_id_);
+ glMatrixMode(GL_TEXTURE);
+ glPushMatrix();
+ geom::Mat4 ttmp=geom::Transpose(beacon.mat);
+ glLoadMatrix(ttmp.Data());
+ glActiveTexture(GL_TEXTURE0);
+ glUniform1i(glGetUniformLocation(cpr,"depth_map"),1);
+ glUniform3f(glGetUniformLocation(cpr,"pos"),beacon.p0[0],beacon.p0[1],beacon.p0[2]);
+ geom::Vec3 dir=beacon.p1-beacon.p0;
+ glUniform3f(glGetUniformLocation(cpr,"dir"),dir[0],dir[1],dir[2]);
+ glUniform1f(glGetUniformLocation(cpr,"len"),geom::Length(dir));
+ glUniform1f(glGetUniformLocation(cpr,"rad"),rad);
+
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+ glLoadIdentity();
+ glOrtho(0,vp.width,0,vp.height,-1,1);
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glEnable(GL_BLEND);
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_LIGHTING);
+ glDisable(GL_COLOR_MATERIAL);
+ glDisable(GL_FOG);
+ glDisable(GL_CULL_FACE);
+ glDisable(GL_LINE_SMOOTH);
+ glDisable(GL_POINT_SMOOTH);
+ glShadeModel(GL_FLAT);
+ glViewport(0,0,vp.width,vp.height);
+ glEnable(GL_TEXTURE_2D);
+ glColor3f(1.0,0.0,1.0);
+ glBegin(GL_QUADS);
+ glTexCoord2f(iw*q0[0],ih*q0[1]);
+ glVertex2f(q0[0],q0[1]);
+ glTexCoord2f(iw*q1[0],ih*q1[1]);
+ glVertex2f(q1[0],q1[1]);
+ glTexCoord2f(iw*q2[0],ih*q2[1]);
+ glVertex2f(q2[0],q2[1]);
+ glTexCoord2f(iw*q3[0],ih*q3[1]);
+ glVertex2f(q3[0],q3[1]);
+ glEnd();
+ glActiveTexture(GL_TEXTURE1);
+ glMatrixMode(GL_TEXTURE);
+ glPopMatrix();
+ glActiveTexture(GL_TEXTURE0);
+ glMatrixMode(GL_PROJECTION);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ glPopAttrib();
+ Shader::Instance().PopProgram();
+}
+
+
+}}} // ns
diff --git a/modules/gfx/src/impl/scene_fx.hh b/modules/gfx/src/impl/scene_fx.hh
new file mode 100644
index 0000000000000000000000000000000000000000..e4def5e09b571a936fd28cda71c3b9ef34493fe9
--- /dev/null
+++ b/modules/gfx/src/impl/scene_fx.hh
@@ -0,0 +1,106 @@
+//------------------------------------------------------------------------------
+// This file is part of the OpenStructure project <www.openstructure.org>
+//
+// Copyright (C) 2008-2010 by the OpenStructure authors
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation; either version 3.0 of the License, or (at your option)
+// any later version.
+// This library is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this library; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+//------------------------------------------------------------------------------
+#ifndef OST_SCENE_FX_HH
+#define OST_SCENE_FX_HH
+
+#include <ost/gfx/gl_helper.hh>
+#include <ost/geom/geom.hh>
+
+/*
+ low level code for scene shading effects
+
+ Author: Ansgar Philippsen
+*/
+
+namespace ost { namespace gfx {
+
+class Scene;
+
+namespace impl {
+
+struct Beacon {
+ float wx, wy;
+ geom::Vec3 p0,p1;
+ geom::Mat4 mat;
+};
+
+class SceneFX {
+ friend class ::ost::gfx::Scene;
+public:
+ ~SceneFX();
+ static SceneFX& Instance();
+
+ void Setup();
+
+ void Resize(unsigned int w, unsigned int h);
+
+ void Preprocess();
+ // assumes scene has been drawn in the active framebuffer
+ void Postprocess();
+
+ void DrawTex(unsigned int w, unsigned int h, GLuint texid);
+
+ bool shadow_flag;
+ int shadow_quality;
+ float shadow_weight;
+ bool depth_dark_flag;
+ float depth_dark_factor;
+ bool amb_occl_flag;
+ float amb_occl_factor;
+ uint amb_occl_mode;
+ uint amb_occl_quality;
+ bool use_beacon;
+ Beacon beacon;
+
+private:
+ SceneFX();
+ SceneFX(const SceneFX&) {}
+ SceneFX& operator=(const SceneFX&) {return *this;}
+
+ void prep_shadow_map();
+ void prep_depth_darkening();
+ void prep_amb_occlusion();
+ void draw_screen_quad(uint w, uint h);
+ void prep_beacon();
+ void draw_beacon();
+
+ GLuint scene_tex_id_;
+ GLuint depth_tex_id_;
+ GLuint shadow_tex_id_;
+ geom::Mat4 shadow_tex_mat_;
+ GLuint occl_tex_id_;
+ GLuint dark_tex_id_;
+ GLuint norm_tex_id_;
+ GLuint kernel_tex_id_;
+ uint kernel_size_;
+ GLuint kernel2_tex_id_;
+ uint kernel2_size_;
+
+ GLuint scene_tex2_id_;
+ GLuint norm_tex2_id_;
+ GLuint scene_fb_;
+ GLuint scene_rb_;
+ GLuint depth_rb_;
+
+ bool use_fb_;
+};
+
+}}} // ns
+
+#endif
diff --git a/modules/gfx/src/impl/simple_renderer.cc b/modules/gfx/src/impl/simple_renderer.cc
index 4e228f0dc06f9e7fee003411bbf02f241de77e26..983ef012d4476adf0857c3a747787dfeccb740cf 100644
--- a/modules/gfx/src/impl/simple_renderer.cc
+++ b/modules/gfx/src/impl/simple_renderer.cc
@@ -30,25 +30,6 @@
namespace ost { namespace gfx { namespace impl {
-namespace {
-
-struct BlurQuadEntry
-{
- float zdist;
- geom::Vec3 p1,p2,p3,p4;
- Color c1,c2,c3,c4;
-};
-
-struct BlurQuadEntryLess
-{
- bool operator()(const BlurQuadEntry& e1, const BlurQuadEntry& e2)
- {
- // provides back-to-front sorting
- return e1.zdist<e2.zdist;
- }
-};
-
-}
SimpleRenderer::SimpleRenderer(): options_(new SimpleRenderOptions())
{
@@ -200,120 +181,9 @@ void SimpleRenderer::PrepareRendering(GfxView& view, IndexedVertexArray& va)
}
}
-void SimpleRenderer::RenderBlur()
-{
- // add blur for this particular orientation!
- // don't use vertex array, but on-the-fly oriented and z-sorted quads
- mol::Transform tf = Scene::Instance().GetTransform();
-
- std::vector<BlurQuadEntry> bql;
- const std::pair<Real, Real>& bf=options_->GetBlurFactors();
- for (BondEntryList::iterator it=view_.bond_list.begin();
- it!=view_.bond_list.end();++it) {
-
- const geom::Vec3 p0=tf.Apply(it->bond.GetFirst().GetPos());
- const geom::Vec3 p2=tf.Apply(it->bond.GetSecond().GetPos());
- geom::Vec3 p1=(p0+p2)*0.5;
-
- const geom::Vec3 q0=tf.Apply(it->pp1);
- const geom::Vec3 q2=tf.Apply(it->pp2);
- geom::Vec3 q1=(q0+q2)*0.5;
-
- float ll0 = geom::Length2(p0-q0);
- float ll1 = geom::Length2(p1-q1);
- float ll2 = geom::Length2(p2-q2);
-
- if(ll0<1e-2 && ll1<1e-2 && ll2<1e-2) continue;
-
- float x0 = exp(-bf.first*ll0);
- float x1 = exp(-bf.first*ll1);
- float x2 = exp(-bf.first*ll2);
-
- BlurQuadEntry bqe;
-
- bqe.zdist=0.25*(p0[2]+p2[2]+q0[2]+q2[2]);
-
- // first half
- bqe.p1 = p0;
- bqe.p2 = p1;
- bqe.p3 = q0;
- bqe.p4 = q1;
- bqe.c1 = it->atom1->color;
- bqe.c2 = it->atom1->color;
- bqe.c3 = it->atom1->color;
- bqe.c4 = it->atom1->color;
- bqe.c1[3] = x0;
- bqe.c2[3] = x1;
- bqe.c3[3]=x0*bf.second;
- bqe.c4[3]=x1*bf.second;
-
- bql.push_back(bqe);
-
- // first half
- bqe.p1 = p1;
- bqe.p2 = p2;
- bqe.p3 = q1;
- bqe.p4 = q2;
- bqe.c1 = it->atom2->color;
- bqe.c2 = it->atom2->color;
- bqe.c3 = it->atom2->color;
- bqe.c4 = it->atom2->color;
- bqe.c1[3] = x1;
- bqe.c2[3] = x2;
- bqe.c3[3]=x1*bf.second;
- bqe.c4[3]=x2*bf.second;
-
- bql.push_back(bqe);
- }
-
- std::sort(bql.begin(),bql.end(),BlurQuadEntryLess());
-
- glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);
- glDisable(GL_LIGHTING);
- glDisable(GL_CULL_FACE);
- glDepthFunc(GL_LESS);
- glDepthMask(GL_FALSE);
- glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- glLoadIdentity();
- glBegin(GL_QUADS);
- glNormal3f(0.0,0.0,0.0);
- for (std::vector<BlurQuadEntry>::const_iterator it=bql.begin();
- it!=bql.end();++it) {
- glColor4fv(it->c1);
- glVertex3v(it->p1.Data());
- glColor4fv(it->c2);
- glVertex3v(it->p2.Data());
- glColor4fv(it->c4);
- glVertex3v(it->p4.Data());
- glColor4fv(it->c3);
- glVertex3v(it->p3.Data());
- }
-
- glEnd();
- glPopMatrix();
- glPopAttrib();
-}
-
-void SimpleRenderer::BlurSnapshot()
+BondEntryList& SimpleRenderer::GetBondEntryList()
{
- for (BondEntryList::iterator it=view_.bond_list.begin();
- it!=view_.bond_list.end();++it) {
- it->pp1=it->atom1->atom.GetPos();
- it->pp2=it->atom2->atom.GetPos();
- }
-}
-void SimpleRenderer::Render(RenderPass pass)
-{
- ConnectRendererBase::Render(pass);
- if (pass==STANDARD_RENDER_PASS && options_->GetBlurFlag()) {
- this->RenderBlur();
- }
-}
-
-SimpleRenderer::~SimpleRenderer()
-{
-
+ return view_.bond_list;
}
void SimpleRenderer::RenderPov(PovState& pov, const std::string& name)
diff --git a/modules/gfx/src/impl/simple_renderer.hh b/modules/gfx/src/impl/simple_renderer.hh
index 78038ffe543780b5d92389866d142c105cbcd8ba..41b801cbd6721d4a57309edf271c80f6d7dbb8e3 100644
--- a/modules/gfx/src/impl/simple_renderer.hh
+++ b/modules/gfx/src/impl/simple_renderer.hh
@@ -43,12 +43,10 @@ public:
virtual void SetOptions(RenderOptionsPtr& render_options);
virtual RenderOptionsPtr GetOptions();
- virtual void Render(RenderPass pass);
- virtual ~SimpleRenderer();
virtual void RenderPov(PovState& pov, const std::string& name);
- void BlurSnapshot();
+
+ BondEntryList& GetBondEntryList();
private:
- void RenderBlur();
void PrepareRendering(GfxView& view, IndexedVertexArray& va);
geom::Vec3 GetDoubleBondPlane(mol::BondHandle b);
void GetBondPartnerNormal(geom::Vec3& vec, int& n, geom::Vec3& bond_vec,
diff --git a/modules/gfx/src/impl/sline_renderer.cc b/modules/gfx/src/impl/sline_renderer.cc
index 6d1fe022dd2f56dcad4b6245f89c57df79632b3a..62ef7ba45aa756d0ce5c4f45d4e4b22c0418b78a 100644
--- a/modules/gfx/src/impl/sline_renderer.cc
+++ b/modules/gfx/src/impl/sline_renderer.cc
@@ -16,13 +16,18 @@
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+
+/*
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#include "sline_renderer.hh"
#include <ost/gfx/entity.hh>
namespace ost { namespace gfx { namespace impl {
-SlineRenderer::SlineRenderer(BackboneTrace& trace):
+SlineRenderer::SlineRenderer(BackboneTrace* trace):
TraceRendererBase(trace, 3), options_(new SlineRenderOptions())
{
this->SetName("Fast Spline");
@@ -40,7 +45,7 @@ void SlineRenderer::PrepareRendering()
}
}
-void SlineRenderer::PrepareRendering(TraceSubset& trace_subset,
+void SlineRenderer::PrepareRendering(const BackboneTrace& trace_subset,
IndexedVertexArray& va, bool is_sel)
{
const Color& sel_clr=this->GetSelectionColor();
@@ -56,30 +61,25 @@ void SlineRenderer::PrepareRendering(TraceSubset& trace_subset,
va.SetLineWidth(options_->GetLineWidth());
va.SetPointSize(options_->GetLineWidth());
va.SetAALines(options_->GetAALines());
- for (int node_list=0; node_list<trace_subset.GetSize(); ++node_list) {
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
// first build the spline
- Spline spl;
- const NodeListSubset& nl=trace_subset[node_list];
- assert(nl.GetSize() && "node list subset with zero eles encountered!");
- for (int i=0; i<nl.GetSize();++i) {
+ SplineEntryList spl;
+ const NodeEntryList& nl=trace_subset.GetList(node_list);
+ if(nl.empty()) continue;
+ for (unsigned int i=0; i<nl.size();++i) {
const NodeEntry& entry=nl[i];
- SplineEntry& ee = spl.AddEntry(entry.atom.GetPos(), entry.direction,
- entry.normal, entry.rad,
- is_sel ? sel_clr : entry.color1,
- is_sel ? sel_clr : entry.color2, 0);
+ SplineEntry ee(entry.atom.GetPos(), entry.direction,
+ entry.normal, entry.rad,
+ is_sel ? sel_clr : entry.color1,
+ is_sel ? sel_clr : entry.color2,
+ 0, entry.id);
ee.v1 = entry.v1;
+ spl.push_back(ee);
}
- SplineEntryList sel = spl.Generate(spline_detail);
- SplineEntryList::const_iterator sit=sel.begin(),
- send=sel.end()-spline_detail+1;
- if (nl.AtStart()>0) {
- sit+=nl.AtStart()*spline_detail-spline_detail/2;
- }
- if (nl.AtEnd()>0) {
- send-=nl.AtEnd()*spline_detail-spline_detail/2;
- }
+ SplineEntryList sel = Spline::Generate(spl,spline_detail);
+ SplineEntryList::const_iterator sit=sel.begin();
VertexID p0=va.Add(sit->position, geom::Vec3(),sit->color1);
- for (++sit; sit<send; ++sit) {
+ for (++sit; sit!=sel.end(); ++sit) {
VertexID p1 = va.Add(sit->position, geom::Vec3(),sit->color1);
va.AddLine(p0,p1);
p0=p1;
diff --git a/modules/gfx/src/impl/sline_renderer.hh b/modules/gfx/src/impl/sline_renderer.hh
index b264fc4b61f99088f595c4e5df6bb42977b19a31..4c08ba3b0fe587960af2b0a48fe808c84e8ed629 100644
--- a/modules/gfx/src/impl/sline_renderer.hh
+++ b/modules/gfx/src/impl/sline_renderer.hh
@@ -16,6 +16,11 @@
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+
+/*
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#ifndef OST_GFX_SLINE_RENDERER_HH
#define OST_GFX_SLINE_RENDERER_HH
@@ -32,7 +37,7 @@ namespace ost { namespace gfx { namespace impl {
/// \internal
class DLLEXPORT_OST_GFX SlineRenderer: public TraceRendererBase {
public:
- SlineRenderer(BackboneTrace& trace);
+ SlineRenderer(BackboneTrace* trace);
virtual void PrepareRendering();
@@ -43,7 +48,7 @@ public:
virtual ~SlineRenderer();
private:
- void PrepareRendering(TraceSubset& subset, IndexedVertexArray& va,
+ void PrepareRendering(const BackboneTrace& subset, IndexedVertexArray& va,
bool is_sel);
SlineRenderOptionsPtr options_;
};
diff --git a/modules/gfx/src/impl/trace_renderer.cc b/modules/gfx/src/impl/trace_renderer.cc
index 29691cc1d39bc669628ab6bf7e211d22f8d52fee..838a23a759996ecf97577c87077c93d0f90cc459 100644
--- a/modules/gfx/src/impl/trace_renderer.cc
+++ b/modules/gfx/src/impl/trace_renderer.cc
@@ -17,6 +17,10 @@
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+/*
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#include <ost/gfx/entity.hh>
#include <ost/gfx/povray.hh>
@@ -25,7 +29,7 @@
namespace ost { namespace gfx { namespace impl {
-TraceRenderer::TraceRenderer(BackboneTrace& trace):
+TraceRenderer::TraceRenderer(BackboneTrace* trace):
TraceRendererBase(trace, 1), options_(new TraceRenderOptions())
{
this->SetName("Trace");
@@ -38,16 +42,15 @@ void TraceRenderer::PrepareRendering()
this->PrepareRendering(trace_subset_, va_, false);
sel_va_.Clear();
if (this->HasSelection()) {
- this->PrepareRendering(sel_subset_, sel_va_, true);
- sel_va_.SetLighting(false);
+ //this->PrepareRendering(sel_subset_, sel_va_, true);
+ this->PrepareRendering(trace_subset_, sel_va_, true);
+ sel_va_.SetLighting(false);
}
}
-#if 1
-void TraceRenderer::PrepareRendering(TraceSubset& trace_subset,
+void TraceRenderer::PrepareRendering(BackboneTrace& trace_subset,
IndexedVertexArray& va, bool is_sel)
{
- float plus=is_sel ? 0.05: 0.0;
const Color& sel_clr=this->GetSelectionColor();
if(options_!=NULL){
va.Clear();
@@ -55,197 +58,77 @@ void TraceRenderer::PrepareRendering(TraceSubset& trace_subset,
va.SetCullFace(true);
va.SetColorMaterial(true);
va.SetTwoSided(false);
- for (int node_list=0; node_list<trace_subset.GetSize(); ++node_list) {
- const NodeListSubset& nl=trace_subset[node_list];
- mol::AtomHandle a1=nl[0].atom;
- va.AddSphere(SpherePrim(a1.GetPos(),
- options_->GetTubeRadius()+plus,
- is_sel ? sel_clr : nl[0].color1),
- options_->GetArcDetail());
- for(int i=1;i<nl.GetSize();++i) {
- mol::AtomHandle a2=nl[i].atom;
- va.AddSphere(SpherePrim(a2.GetPos(),
- options_->GetTubeRadius()+plus,
- is_sel ? sel_clr : nl[i].color1),
- options_->GetArcDetail());
- const geom::Vec3& p0=a1.GetPos();
- const geom::Vec3& p2=a2.GetPos();
- geom::Vec3 p1=(p0+p2)*0.5;
- va.AddCylinder(CylinderPrim(p0,p1,options_->GetTubeRadius()+plus,nl[i-1].color1),
- options_->GetArcDetail());
- va.AddCylinder(CylinderPrim(p1,p2,options_->GetTubeRadius()+plus,nl[i].color1),
- options_->GetArcDetail());
- a1=a2;
- }
- }
- }
- sel_state_=0;
- state_=0;
-}
-
-#else
-
-void TraceRenderer::PrepareRendering(TraceSubset& trace_subset,
- IndexedVertexArray& va, bool is_sel)
-{
- const Color& sel_clr=this->GetSelectionColor();
- float radius=options_->GetTubeRadius();
- if (is_sel) {
- radius+=0.1;
- }
- int n=8*options_->GetArcDetail();
- if(options_!=NULL) {
- va.SetLighting(true);
- va.SetCullFace(false);
- for (int node_list=0; node_list<trace_subset.GetSize(); ++node_list) {
- const NodeListSubset& nl=trace_subset[node_list];
- geom::Vec3 cursor_pos;
- geom::Mat3 cursor_ori;
- if (nl.GetSize()==2) {
- VertexID p0, p1;
- if (nl.AtStart()==0) {
- p0=va.Add(nl[0].atom.GetPos(), geom::Vec3(),
- is_sel ? sel_clr : nl[0].color1);
- p1=va.Add((nl[0].atom.GetPos()+nl[1].atom.GetPos())/2,
- geom::Vec3(), is_sel ? sel_clr : nl[1].color1);
- } else {
- p0=va.Add((nl[0].atom.GetPos()+nl[1].atom.GetPos())/2,
- geom::Vec3(), is_sel ? sel_clr : nl[0].color1);
- p1=va.Add(nl[1].atom.GetPos(),
- geom::Vec3(), is_sel ? sel_clr : nl[1].color1);
- }
- va.AddLine(p0, p1);
- continue;
- }
- if (nl.GetSize()<3) {
- continue;
- }
- VertexID p0;
- geom::Vec3 z=geom::Normalize(nl[1].atom.GetPos()-nl[0].atom.GetPos());
- geom::Vec3 y=geom::OrthogonalVector(z);
- geom::Vec3 x=geom::Cross(y, z);
- cursor_ori=geom::Mat3(x[0], y[0], z[0], x[1], y[1], z[1],
- x[2], y[2], z[2]);
- if (nl.AtStart()==0) {
- cursor_pos=nl[0].atom.GetPos();
- } else {
- cursor_pos=(nl[0].atom.GetPos()+nl[1].atom.GetPos())/2;
- }
- p0=this->AddCappedProfile(va, is_sel? sel_clr : nl[0].color1,
- cursor_pos, cursor_ori, radius, true, n);
- for (int i=1; i<nl.GetSize()-1;++i) {
- const NodeEntry& entry=nl[i];
- geom::Vec3 old_dir=geom::Normalize(entry.atom.GetPos()-cursor_pos);
- cursor_pos=entry.atom.GetPos();
-
- geom::Vec3 z=geom::Normalize(nl[i+1].atom.GetPos()-cursor_pos);
- geom::Vec3 y=geom::Normalize(geom::Cross(z, cursor_ori.GetCol(0)));
- geom::Vec3 x=geom::Normalize(geom::Cross(y, z));
- geom::Vec3 iz=geom::Normalize(cursor_ori.GetCol(2)+z);
-
- geom::Vec3 iy=geom::Normalize(geom::Cross(cursor_ori.GetCol(2), z));
- geom::Vec3 ix=geom::Normalize(geom::Cross(iy, iz));
-
- geom::Mat3 i_ori=geom::Mat3(ix[0], iy[0], iz[0], ix[1], iy[1], iz[1],
- ix[2], iy[2], iz[2]);
- cursor_ori=geom::Mat3(x[0], y[0], z[0], x[1], y[1], z[1],
- x[2], y[2], z[2]);
- // TODO. The intersection of two cylinders is an ellipse. Use an
- // elliptic profile instead of a circular profile.
- VertexID p1=this->AddCircularProfile(va, is_sel ? sel_clr : entry.color1,
- cursor_pos, i_ori, radius, n);
- this->ConnectProfiles(p0, p1, n, old_dir, va);
- p0=p1;
+ if(is_sel) {
+ va.SetOpacity(GetSelectionColor().Alpha());
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace_subset.GetList(node_list);
+ for(unsigned int i=0;i<nl.size();++i) {
+ mol::AtomHandle ah=nl[i].atom;
+ if(sel_.FindAtom(ah).IsValid()) {
+ geom::Vec3 apos = ah.GetPos();
+ va.AddSphere(SpherePrim(apos,
+ options_->GetTubeRadius()+0.05,
+ sel_clr),
+ options_->GetArcDetail());
+ if(i>0) {
+ va.AddCylinder(CylinderPrim(apos+0.5*(nl[i-1].atom.GetPos()-apos),
+ apos,
+ options_->GetTubeRadius()+0.05,
+ sel_clr),
+ options_->GetArcDetail());
+ }
+ if(i<nl.size()-1) {
+ va.AddCylinder(CylinderPrim(apos,
+ apos+0.5*(nl[i+1].atom.GetPos()-apos),
+ options_->GetTubeRadius()+0.05,
+ sel_clr),
+ options_->GetArcDetail());
+ }
+ }
+ }
}
- const NodeEntry& entry=nl[nl.GetSize()-1];
- if (nl.AtEnd()==0) {
- cursor_pos=entry.atom.GetPos();
- } else {
- cursor_pos=(entry.atom.GetPos()+nl[nl.GetSize()-2].atom.GetPos())*0.5;
+ } else {
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace_subset.GetList(node_list);
+ mol::AtomHandle a1=nl[0].atom;
+ va.AddSphere(SpherePrim(a1.GetPos(),
+ options_->GetTubeRadius(),
+ nl[0].color1),
+ options_->GetArcDetail());
+ for(unsigned int i=1;i<nl.size();++i) {
+ mol::AtomHandle a2=nl[i].atom;
+ va.AddSphere(SpherePrim(a2.GetPos(),
+ options_->GetTubeRadius(),
+ nl[i].color1),
+ options_->GetArcDetail());
+ const geom::Vec3& p0=a1.GetPos();
+ const geom::Vec3& p2=a2.GetPos();
+ geom::Vec3 p1=(p0+p2)*0.5;
+ va.AddCylinder(CylinderPrim(p0,p1,options_->GetTubeRadius(),nl[i-1].color1),
+ options_->GetArcDetail());
+ va.AddCylinder(CylinderPrim(p1,p2,options_->GetTubeRadius(),nl[i].color1),
+ options_->GetArcDetail());
+ a1=a2;
+ }
}
- VertexID p1 =this->AddCappedProfile(va, is_sel ? sel_clr : entry.color1,
- cursor_pos, cursor_ori,
- radius, false, n);
- this->ConnectProfiles(p0, p1, n, cursor_ori.GetCol(2), va);
}
}
sel_state_=0;
state_=0;
}
-#endif
-
-VertexID TraceRenderer::AddCappedProfile(IndexedVertexArray& va,
- const Color& color,
- const geom::Vec3& center,
- const geom::Mat3& ori, float radius,
- bool flip_normal,
- int n)
-{
- VertexID center_id=va.Add(center, geom::Vec3(), color);
- VertexID first=this->AddCircularProfile(va, color, center, ori, radius, n);
- for (int i=0; i<n; ++i) {
- va.AddTriN(center_id, first+i, first+((i+1) % n));
- }
- return first;
-}
-
-VertexID TraceRenderer::AddCircularProfile(IndexedVertexArray& va,
- const Color& color,
- const geom::Vec3& center,
- const geom::Mat3& ori,
- float radius,
- int n)
-{
- float delta_angle=2*M_PI/n;
- VertexID f=0;
- geom::Vec3 normal=ori.GetRow(2);
- for (int i=0; i<n; ++i) {
- geom::Vec3 normal=ori*geom::Vec3(cos(i*delta_angle),
- sin(i*delta_angle), 0.0);
- VertexID x=va.Add(center+normal*radius, normal, color);
- if (i==0) {
- f=x;
- }
- }
- return f;
-}
-
-void TraceRenderer::ConnectProfiles(VertexID prof0, VertexID prof1, int n,
- const geom::Vec3& dir,
- IndexedVertexArray& va)
-{
- // avoid twisting
- int off=0;
- float best=0.0;
- geom::Vec3 pp=va.GetVert(prof0);
- for (int i=0; i<n; ++i) {
- geom::Vec3 dir2=geom::Normalize(va.GetVert(prof1+i)-pp);
- float dot=fabs(geom::Dot(dir, dir2));
- if (best<dot) {
- best=dot;
- off=i;
- }
- }
- for (int i=0; i<n; ++i) {
- VertexID i1=prof1+((i+off) % n), i2=prof1+((i+off+1) % n);
- VertexID i3=prof0+i, i4=prof0+((i+1)%n);
- va.AddTriN(i1, i2, i3);
- va.AddTriN(i2, i3, i4);
- }
-}
void TraceRenderer::RenderPov(PovState& pov, const std::string& name)
{
pov.write_merge_or_union(name);
- for (int node_list=0; node_list<trace_subset_.GetSize(); ++node_list) {
- const NodeListSubset& nl=trace_subset_[node_list];
+ for (int node_list=0; node_list<trace_subset_.GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace_subset_.GetList(node_list);
geom::Vec3 p0=nl[0].atom.GetPos();
float rad0=0.2;
Color col0=nl[0].color1;
pov.write_sphere(p0,rad0,col0,name);
- for (int i=1; i<nl.GetSize();++i) {
+ for (unsigned int i=1; i<nl.size();++i) {
geom::Vec3 p1=nl[i].atom.GetPos();
float rad1=0.2;
Color col1=nl[i].color1;
@@ -262,11 +145,6 @@ void TraceRenderer::RenderPov(PovState& pov, const std::string& name)
pov.inc() << " }\n";
}
-void TraceRenderer::Render()
-{
-
-}
-
bool TraceRenderer::CanSetOptions(RenderOptionsPtr& render_options)
{
return render_options.get()->GetRenderMode()==RenderMode::TRACE;
diff --git a/modules/gfx/src/impl/trace_renderer.hh b/modules/gfx/src/impl/trace_renderer.hh
index 77cb8d3daa3d1584b45d38ea125bc03f6181a470..e8f9cff3bd1f66650f797f7c29888553dd31371a 100644
--- a/modules/gfx/src/impl/trace_renderer.hh
+++ b/modules/gfx/src/impl/trace_renderer.hh
@@ -20,8 +20,9 @@
#define OST_GFX_IMPL_TRACE_RENDERER_HH
/*
- Author: Marco Biasini
- */
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#include <ost/gfx/impl/backbone_trace.hh>
#include <ost/gfx/impl/entity_detail.hh>
#include <ost/gfx/impl/trace_renderer_base.hh>
@@ -37,12 +38,12 @@ using namespace impl;
/// \internal
class DLLEXPORT_OST_GFX TraceRenderer: public TraceRendererBase {
public:
- TraceRenderer(BackboneTrace& trace);
+ TraceRenderer(BackboneTrace* trace);
virtual void PrepareRendering();
- virtual void PrepareRendering(TraceSubset& trace_subset,
+ virtual void PrepareRendering(BackboneTrace& trace_subset,
IndexedVertexArray& va, bool is_sel);
- virtual void Render();
+
virtual void RenderPov(PovState& pov, const std::string& name);
virtual bool CanSetOptions(RenderOptionsPtr& render_options);
@@ -51,14 +52,6 @@ public:
virtual ~TraceRenderer();
private:
- VertexID AddCappedProfile(IndexedVertexArray& va, const Color& color,
- const geom::Vec3& center, const geom::Mat3& ori,
- float radius, bool flip_normal, int n);
- VertexID AddCircularProfile(IndexedVertexArray& va, const Color& color,
- const geom::Vec3& center, const geom::Mat3& ori,
- float radius, int n);
- void ConnectProfiles(VertexID prof1, VertexID prof2, int n,
- const geom::Vec3& dir, IndexedVertexArray& va);
TraceRenderOptionsPtr options_;
};
diff --git a/modules/gfx/src/impl/trace_renderer_base.cc b/modules/gfx/src/impl/trace_renderer_base.cc
index 46084a880b330f86fe618c86cb88e4eb315bc3d1..8ccf5e26ee514d6a4dae4d54062b94d765e52598 100644
--- a/modules/gfx/src/impl/trace_renderer_base.cc
+++ b/modules/gfx/src/impl/trace_renderer_base.cc
@@ -17,6 +17,10 @@
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
+/*
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
+
#include <ost/gfx/scene.hh>
#include "trace_renderer_base.hh"
@@ -34,15 +38,15 @@ void set_node_entry_color(NodeEntry& e, ColorMask mask,
}
template <typename T1>
-inline void apply_color_op(TraceRendererBase* rend, TraceSubset& trace_subset, T1 get_col, const ColorOp& op)
+inline void apply_color_op(TraceRendererBase* rend, BackboneTrace& trace_subset, T1 get_col, const ColorOp& op)
{
rend->UpdateViews();
ColorMask mask = op.GetMask();
if(op.IsSelectionOnly()){
mol::Query q(op.GetSelection());
- for (int node_list=0; node_list<trace_subset.GetSize(); ++node_list) {
- NodeListSubset& nl=trace_subset[node_list];
- for (int i=0; i<nl.GetSize();++i) {
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
+ NodeEntryList& nl=trace_subset.GetList(node_list);
+ for (unsigned int i=0; i<nl.size();++i) {
if (q.IsAtomSelected(nl[i].atom)) {
Color clr =get_col.ColorOfAtom(nl[i].atom);
set_node_entry_color(nl[i],mask,clr);
@@ -52,9 +56,9 @@ inline void apply_color_op(TraceRendererBase* rend, TraceSubset& trace_subset, T
}
else{
mol::EntityView view = op.GetView();
- for (int node_list=0; node_list<trace_subset.GetSize(); ++node_list) {
- NodeListSubset& nl=trace_subset[node_list];
- for (int i=0; i<nl.GetSize();++i) {
+ for (int node_list=0; node_list<trace_subset.GetListCount(); ++node_list) {
+ NodeEntryList& nl=trace_subset.GetList(node_list);
+ for (unsigned int i=0; i<nl.size();++i) {
if(view.FindAtom(nl[i].atom)){
Color clr =get_col.ColorOfAtom(nl[i].atom);
set_node_entry_color(nl[i],mask,clr);
@@ -67,8 +71,8 @@ inline void apply_color_op(TraceRendererBase* rend, TraceSubset& trace_subset, T
} //ns
-TraceRendererBase::TraceRendererBase(BackboneTrace& trace, int n):
- trace_(trace), trace_subset_(trace, n), sel_subset_(trace, n)
+TraceRendererBase::TraceRendererBase(BackboneTrace* trace, int n):
+ trace_(trace), trace_subset_(), sel_subset_()
{
}
@@ -80,44 +84,37 @@ void TraceRendererBase::UpdateViews()
{
if (state_ & DIRTY_VIEW) {
mol::EntityView view=this->GetEffectiveView();
- trace_subset_.Update(view);
+ trace_subset_=trace_->CreateSubset(view);
state_&=~DIRTY_VIEW;
}
if (this->HasSelection() && (sel_state_ & DIRTY_VIEW)) {
- sel_subset_.Update(sel_);
+ sel_subset_ = trace_->CreateSubset(sel_);
sel_state_&=~DIRTY_VIEW;
}
}
geom::AlignedCuboid TraceRendererBase::GetBoundingBox() const
{
- geom::Vec3 mmin, mmax;
+ geom::Vec3 mmin(std::numeric_limits<float>::max(),
+ std::numeric_limits<float>::max(),
+ std::numeric_limits<float>::max());
+ geom::Vec3 mmax(-std::numeric_limits<float>::max(),
+ -std::numeric_limits<float>::max(),
+ -std::numeric_limits<float>::max());
+
assert(!(state_ & DIRTY_VIEW));
- bool empty=true;
- for (int node_list=0; node_list<trace_subset_.GetSize(); ++node_list) {
- // first build the spline
- Spline spl;
- const NodeListSubset& nl=trace_subset_[node_list];
- for (int i=0; i<nl.GetSize();++i) {
+ for (int node_list=0; node_list<trace_subset_.GetListCount(); ++node_list) {
+ const NodeEntryList& nl=trace_subset_.GetList(node_list);
+ for (unsigned int i=0; i<nl.size();++i) {
const NodeEntry& entry=nl[i];
- empty=false;
geom::Vec3 p=entry.atom.GetPos();
- if (node_list+i==0) {
- mmin=p;
- mmax=p;
- } else {
- mmin=geom::Min(mmin, p);
- mmax=geom::Max(mmax, p);
- }
+ mmin=geom::Min(mmin, p);
+ mmax=geom::Max(mmax, p);
}
}
- if (empty) {
- throw Error("Can't calculate bounding box of empty renderer");
- }
return geom::AlignedCuboid(mmin, mmax);
}
-
void TraceRendererBase::Apply(const gfx::ByElementColorOp& op)
{
apply_color_op(this,trace_subset_,ByElementGetCol(),op);
@@ -152,16 +149,16 @@ void TraceRendererBase::Apply(const gfx::EntityViewColorOp& op)
bool TraceRendererBase::HasDataToRender() const
{
assert(!(state_ & DIRTY_VIEW));
- return this->trace_subset_.GetSize()>0;
+ return this->trace_subset_.GetListCount()>0;
}
void TraceRendererBase::set_node_colors(const Color& col, const mol::Query& q,
ColorMask mask)
{
this->UpdateViews();
- for (int node_list=0; node_list<trace_subset_.GetSize(); ++node_list) {
- NodeListSubset& nl=trace_subset_[node_list];
- for (int i=0; i<nl.GetSize();++i) {
+ for (int node_list=0; node_list<trace_subset_.GetListCount(); ++node_list) {
+ NodeEntryList& nl=trace_subset_.GetList(node_list);
+ for (unsigned int i=0; i<nl.size();++i) {
if(q.IsAtomSelected(nl[i].atom)) {
set_node_entry_color(nl[i],mask,col);
}
@@ -170,13 +167,6 @@ void TraceRendererBase::set_node_colors(const Color& col, const mol::Query& q,
state_|=DIRTY_VA;
}
-void TraceRendererBase::set_node_entry_color(NodeEntry& e, ColorMask mask,
- const Color& c)
-{
- if (mask & MAIN_COLOR) e.color1=c;
- if (mask & DETAIL_COLOR) e.color2=c;
-}
-
void TraceRendererBase::PickAtom(const geom::Line3& line, Real line_width,
mol::AtomHandle& picked_atom)
{
@@ -190,9 +180,9 @@ void TraceRendererBase::PickAtom(const geom::Line3& line, Real line_width,
}
mol::AtomHandle atom;
- for (int node_list=0; node_list<trace_subset_.GetSize(); ++node_list) {
- NodeListSubset& nl=trace_subset_[node_list];
- for (int i=0; i<nl.GetSize();++i) {
+ for (int node_list=0; node_list<trace_subset_.GetListCount(); ++node_list) {
+ NodeEntryList& nl=trace_subset_.GetList(node_list);
+ for (unsigned int i=0; i<nl.size();++i) {
geom::Vec3 p=nl[i].atom.GetPos();
float dist = geom::Distance(line, p);
if(dist<=max_dist) {
diff --git a/modules/gfx/src/impl/trace_renderer_base.hh b/modules/gfx/src/impl/trace_renderer_base.hh
index b102e1cc2c78c5ad1f2881e8530f51fb21a1b205..36e3b960270fa1c1882ae67c9b288eb77ed3613a 100644
--- a/modules/gfx/src/impl/trace_renderer_base.hh
+++ b/modules/gfx/src/impl/trace_renderer_base.hh
@@ -20,8 +20,8 @@
#define OST_GFX_IMPL_TRACE_RENDERER_BASE_HH
/*
- Author: Marco Biasini
- */
+ Authors: Marco Biasini, Ansgar Philippsen
+*/
#include <ost/gfx/module_config.hh>
#include <ost/gfx/impl/entity_renderer.hh>
@@ -35,11 +35,11 @@ namespace ost { namespace gfx { namespace impl {
/// \ref "line trace" LineTraceRenderer and
/// \ref "smooth trace" SlineRenderer.
///
-/// The trace-based entity renderer share a common instance of BackboneTrace
-/// that encapulates a smoothed C-alpha trace.
+/// All trace-based entity renderers share a common instance of BackboneTrace
+/// (which is held by gfx::Entity); it encapulates a smoothed C-alpha trace.
class DLLEXPORT_OST_GFX TraceRendererBase : public EntityRenderer {
public:
- TraceRendererBase(BackboneTrace& trace, int overshoot);
+ TraceRendererBase(BackboneTrace* trace, int overshoot);
virtual geom::AlignedCuboid GetBoundingBox() const;
@@ -63,12 +63,10 @@ public:
protected:
void set_node_colors(const Color& c, const mol::Query& q, ColorMask mask);
- void set_node_entry_color(NodeEntry& e, ColorMask mask, const Color& c);
-
- BackboneTrace& trace_;
- TraceSubset trace_subset_;
- TraceSubset sel_subset_;
+ BackboneTrace* trace_;
+ BackboneTrace trace_subset_;
+ BackboneTrace sel_subset_;
};
}}}
diff --git a/modules/gfx/src/map_iso.cc b/modules/gfx/src/map_iso.cc
index 9acb420c4703c86072b40924d9b1073858c166ce..2c8c96d1e42edc92d328bd1f8ec99d6f54bff9fb 100644
--- a/modules/gfx/src/map_iso.cc
+++ b/modules/gfx/src/map_iso.cc
@@ -237,25 +237,17 @@ private:
void MapIso::CustomRenderGL(RenderPass pass)
{
- switch (pass) {
- case OPAQUE_RENDER_PASS:
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
- va_.RenderGL();
- glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
- break;
- case STANDARD_RENDER_PASS:
- va_.RenderGL();
- if (debug_octree_) {
- OctreeDebugger d(level_, mh_.IndexToCoord(img::Point(1,1,1))-
- mh_.IndexToCoord(img::Point(0,0,0)));
- glPushAttrib(GL_ENABLE_BIT);
- glDisable(GL_LIGHTING);
- octree_.VisitDF(d);
- glPopAttrib();
- }
- break;
- case GLOW_RENDER_PASS:
- return;
+ if(pass==STANDARD_RENDER_PASS) {
+ va_.RenderGL();
+ if (debug_octree_) {
+ OctreeDebugger d(level_,
+ mh_.IndexToCoord(img::Point(1,1,1))-
+ mh_.IndexToCoord(img::Point(0,0,0)));
+ glPushAttrib(GL_ENABLE_BIT);
+ glDisable(GL_LIGHTING);
+ octree_.VisitDF(d);
+ glPopAttrib();
+ }
}
}
diff --git a/modules/gfx/src/map_slab.cc b/modules/gfx/src/map_slab.cc
index 32da5912cf1a9fee1395c8f65e3e150c84e45670..3656eec4d716b69269167d4a16bdf52c727b2dd6 100644
--- a/modules/gfx/src/map_slab.cc
+++ b/modules/gfx/src/map_slab.cc
@@ -108,16 +108,9 @@ void MapSlab::CustomRenderGL(RenderPass pass)
{
if(rebuild_) rebuild_tex();
- if(GetOpacity()<1.0) {
- if(pass!=1) return;
- glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
+ if(pass==STANDARD_RENDER_PASS) {
render_slab();
- glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
- } else {
- if(pass!=0) return;
}
-
- render_slab();
}
void MapSlab::CustomRenderPov(PovState& pov)
diff --git a/modules/gfx/src/offscreen_buffer.hh b/modules/gfx/src/offscreen_buffer.hh
index c033d88169fe949febf3385df9fd4d5a6fdfa0d4..df2ca183fb9371e1f37de1ac46cc47141af2d623 100644
--- a/modules/gfx/src/offscreen_buffer.hh
+++ b/modules/gfx/src/offscreen_buffer.hh
@@ -22,86 +22,54 @@
/*
Wraps GL offscreen rendering per platform
- Authors: Ansgar Philippsen, Marco Biasini
+ boilerplate header, includes platform dependent stuff
*/
-#include <ost/gfx/gl_include.hh>
-
-#if defined(__linux__)
-# include <GL/glx.h>
-#elif defined(__APPLE__)
-# include <OpenGL/OpenGL.h>
-//#elif defined(_WIN32)
-//# include <ost/gfx/GL/wglew.h>
-#endif
-
-#ifdef Complex
-# undef Complex
-#endif
+#include <vector>
namespace ost { namespace gfx {
-/// \brief offscreen management
-class OffscreenBuffer {
+class OffscreenBufferFormat
+{
public:
-
- /// \brief singleton interface
- static OffscreenBuffer& Instance();
+ OffscreenBufferFormat(): cbits(8),abits(8),dbits(12),accum(false),multisample(false),samples(0) {}
- /// \brief activate offscreen context for rendering
- bool Begin();
- /// \brief switch back to normal rendering context
- bool End();
- /// \ brief resize offscreen rendering context
- bool Resize(unsigned int width, unsigned int height);
+ unsigned int cbits,abits,dbits; // color, alpha, depth bits
+ bool accum;
+ bool multisample;
+ unsigned int samples;
+};
- /// \brief returns true if offscreen rendering context is available
- bool IsValid() const;
+}} // ns
- /// \brief returns true between Begin/End bracket
- bool IsActive() const;
+/*
+ instead of creating an abstract base class and
+ making runtime polymorphic classes for each
+ platform, we do a bit more typing and copy
+ the minimal interface to each of the platform
+ specific OffscreenBuffer implementations
-private:
- OffscreenBuffer(int width, int height, int r_bits, int b_bits,
- int g_bits, int a_bits, int depth_bits);
+ OffscreenBuffer interface:
- OffscreenBuffer(const OffscreenBuffer& b) {}
- OffscreenBuffer& operator=(const OffscreenBuffer& b) {return *this;}
-
- int width_;
- int height_;
- bool valid_;
- bool active_;
+ OffscreenBuffer(unsigned int width, unsigned int height, const OffscreenBufferFormat& f, bool shared=true);
+ bool Resize(unsigned int w, unsigned int h);
+ bool MakeActive();
+ bool IsActive();
+ bool IsValid();
+*/
#if defined(__linux__)
- Display* dpy_;
- GLXFBConfig* fbconfig_;
- GLXPbuffer pbuffer_;
- GLXContext context_;
- GLXContext old_context_;
- GLXDrawable old_dr1_;
- GLXDrawable old_dr2_;
-
+#include "impl/glx_offscreen_buffer.hh"
#elif defined(__APPLE__)
-
- CGLPBufferObj pbuffer_;
- CGLContextObj context_;
- CGLPixelFormatObj pix_format_;
- CGLContextObj old_context_;
-
+#include "impl/cgl_offscreen_buffer.hh"
#elif defined(_WIN32)
-/* HPBUFFERARB pbuffer_;
- HGLRC context_; //rendering context
- HGLRC old_context_;
-
- HDC dev_context_;//device context
- HDC old_dev_context_;
- */
+#include "impl/wgl_offscreen_buffer.hh"
+#else
+#error platform not found for offscreen rendering
#endif
-
- GLint old_vp_[4];
-};
-}}
+#ifdef Complex
+# undef Complex
+#endif
#endif
diff --git a/modules/gfx/src/prim_list.cc b/modules/gfx/src/prim_list.cc
index 2302dc7fea417ff6c07748da0d0a5c1c0c11ed5e..72047addeb091fbec674ae9372f1c98125ee67ee 100644
--- a/modules/gfx/src/prim_list.cc
+++ b/modules/gfx/src/prim_list.cc
@@ -31,7 +31,9 @@ PrimList::PrimList(const String& name):
points_(),
lines_(),
radius_(0.5),
- diameter_(0.5)
+ diameter_(0.5),
+ sphere_detail_(4),
+ arc_detail_(4)
{}
void PrimList::Clear()
@@ -95,8 +97,6 @@ void PrimList::CustomPreRenderGL(bool flag)
} else {
render_simple();
}
- } else {
- RefreshVA(va_);
}
}
@@ -129,12 +129,14 @@ struct AALineEntryLess
void PrimList::CustomRenderGL(RenderPass pass)
{
- if(pass!=STANDARD_RENDER_PASS) return;
- va_.RenderGL();
+ if(pass==STANDARD_RENDER_PASS || pass==TRANSPARENT_RENDER_PASS) {
+ va_.RenderGL();
+ }
}
void PrimList::CustomRenderPov(PovState& pov)
{
+ // TODO: add primlist pov export
}
void PrimList::AddPoint(geom::Vec3& p, const Color& col)
@@ -155,12 +157,28 @@ void PrimList::SetDiameter(float d)
{
diameter_=d;
Scene::Instance().RequestRedraw();
+ FlagRebuild();
}
void PrimList::SetRadius(float r)
{
radius_=r;
Scene::Instance().RequestRedraw();
+ FlagRebuild();
+}
+
+void PrimList::SetSphereDetail(unsigned int d)
+{
+ sphere_detail_=d;
+ Scene::Instance().RequestRedraw();
+ FlagRebuild();
+}
+
+void PrimList::SetArcDetail(unsigned int d)
+{
+ arc_detail_=d;
+ Scene::Instance().RequestRedraw();
+ FlagRebuild();
}
void PrimList::SetColor(const Color& c)
@@ -169,6 +187,7 @@ void PrimList::SetColor(const Color& c)
it->color=c;
}
Scene::Instance().RequestRedraw();
+ FlagRebuild();
}
diff --git a/modules/gfx/src/prim_list.hh b/modules/gfx/src/prim_list.hh
index 1de40d7f9c862cc71fd995b7fd8d5c300c081304..fbac2cffc2f633bdf5bfe4ef8fc20ce6658c72d4 100644
--- a/modules/gfx/src/prim_list.hh
+++ b/modules/gfx/src/prim_list.hh
@@ -98,6 +98,12 @@ class DLLEXPORT_OST_GFX PrimList: public GfxObj
/// \brief set global prims color, overriding individual ones
void SetColor(const Color& c);
+ void SetSphereDetail(unsigned int d);
+ unsigned int GetSphereDetail() const {return sphere_detail_;}
+
+ void SetArcDetail(unsigned int d);
+ unsigned int GetArcDetail() const {return arc_detail_;}
+
protected:
virtual void CustomPreRenderGL(bool flag);
@@ -106,6 +112,8 @@ class DLLEXPORT_OST_GFX PrimList: public GfxObj
LineEntryList lines_;
float radius_;
float diameter_;
+ unsigned int sphere_detail_;
+ unsigned int arc_detail_;
void render_simple();
void render_custom();
diff --git a/modules/gfx/src/primitives.cc b/modules/gfx/src/primitives.cc
index 712a9077a58c97fb202179987982e49b572d100b..b649c17f071fe5b17312bd8e96c14943b3486031 100644
--- a/modules/gfx/src/primitives.cc
+++ b/modules/gfx/src/primitives.cc
@@ -225,7 +225,7 @@ void Quad::RenderGL(RenderPass pass)
if (!this->IsVisible()) {
return;
}
- if (!(pass==OPAQUE_RENDER_PASS || pass==STANDARD_RENDER_PASS)) {
+ if (!(pass==DEPTH_RENDER_PASS || pass==STANDARD_RENDER_PASS)) {
return;
}
glDisable(GL_LIGHTING);
diff --git a/modules/gfx/src/render_options/cartoon_render_options.cc b/modules/gfx/src/render_options/cartoon_render_options.cc
index da5d2e70376999782799e027b87586530b9016ed..018548363b49f61a74dc46334478147da930d02b 100644
--- a/modules/gfx/src/render_options/cartoon_render_options.cc
+++ b/modules/gfx/src/render_options/cartoon_render_options.cc
@@ -39,10 +39,13 @@ CartoonRenderOptions::CartoonRenderOptions(bool force_tube):
helix_thickness_(0.2),
helix_ecc_(0.3),
helix_profile_(1),
+ helix_mode_(0),
strand_width_(1.2),
strand_thickness_(0.2),
strand_ecc_(0.3),
- strand_profile_(1)
+ strand_profile_(1),
+ strand_mode_(0),
+ color_blend_mode_(0)
{}
RenderMode::Type CartoonRenderOptions::GetRenderMode(){
@@ -66,12 +69,17 @@ void CartoonRenderOptions::ApplyRenderOptions(RenderOptionsPtr render_options){
smooth_factor_=options->GetNormalSmoothFactor();
tube_radius_=options->GetTubeRadius();
tube_ratio_=options->GetTubeRatio();
+ tube_profile_=options->GetTubeProfileType();
helix_width_=options->GetHelixWidth();
helix_thickness_=options->GetHelixThickness();
helix_ecc_=options->GetHelixEcc();
+ helix_profile_=options->GetHelixProfileType();
+ helix_mode_=options->GetHelixMode();
strand_width_=options->GetStrandWidth();
strand_thickness_=options->GetStrandThickness();
strand_ecc_=options->GetStrandEcc();
+ strand_profile_=options->GetStrandProfileType();
+ strand_mode_=options->GetStrandMode();
this->NotifyStateChange();
}
@@ -196,6 +204,17 @@ void CartoonRenderOptions::SetHelixProfileType(unsigned int t)
this->NotifyStateChange();
}
+unsigned int CartoonRenderOptions::GetHelixMode() const
+{
+ return helix_mode_;
+}
+
+void CartoonRenderOptions::SetHelixMode(unsigned int m)
+{
+ helix_mode_=m;
+ this->NotifyStateChange();
+}
+
void CartoonRenderOptions::SetStrandWidth(float strand_width){
if(strand_width_ != strand_width){
strand_width_= strand_width>0.0 ? strand_width : strand_width_;
@@ -240,6 +259,27 @@ void CartoonRenderOptions::SetStrandProfileType(unsigned int t)
this->NotifyStateChange();
}
+unsigned int CartoonRenderOptions::GetStrandMode() const
+{
+ return strand_mode_;
+}
+
+void CartoonRenderOptions::SetStrandMode(unsigned int m)
+{
+ strand_mode_=m;
+ this->NotifyStateChange();
+}
+
+void CartoonRenderOptions::SetColorBlendMode(unsigned int m)
+{
+ color_blend_mode_=m;
+ this->NotifyStateChange();
+}
+unsigned int CartoonRenderOptions::GetColorBlendMode() const
+{
+ return color_blend_mode_;
+}
+
float CartoonRenderOptions::GetMaxRad() const{
float max_rad=std::max(float(3.0),tube_radius_*tube_ratio_);
max_rad=std::max(max_rad,tube_radius_);
diff --git a/modules/gfx/src/render_options/cartoon_render_options.hh b/modules/gfx/src/render_options/cartoon_render_options.hh
index 092fafe69f85cf55a6e6a29592288ac53b8e5566..a4a5d4cb67c8693765e21c7dd374e664b7237768 100644
--- a/modules/gfx/src/render_options/cartoon_render_options.hh
+++ b/modules/gfx/src/render_options/cartoon_render_options.hh
@@ -67,6 +67,8 @@ public:
virtual float GetHelixEcc() const;
virtual unsigned int GetHelixProfileType() const;
virtual void SetHelixProfileType(unsigned int);
+ virtual unsigned int GetHelixMode() const;
+ virtual void SetHelixMode(unsigned int);
virtual void SetStrandWidth(float strand_width);
virtual float GetStrandWidth() const;
@@ -76,6 +78,11 @@ public:
virtual float GetStrandEcc() const;
virtual unsigned int GetStrandProfileType() const;
virtual void SetStrandProfileType(unsigned int);
+ virtual unsigned int GetStrandMode() const;
+ virtual void SetStrandMode(unsigned int);
+
+ virtual void SetColorBlendMode(unsigned int);
+ virtual unsigned int GetColorBlendMode() const;
float GetMaxRad() const;
@@ -96,10 +103,14 @@ private:
float helix_thickness_;
float helix_ecc_;
unsigned int helix_profile_;
+ unsigned int helix_mode_;
float strand_width_;
float strand_thickness_;
float strand_ecc_;
unsigned int strand_profile_;
+ unsigned int strand_mode_;
+
+ unsigned int color_blend_mode_;
};
typedef boost::shared_ptr<CartoonRenderOptions> CartoonRenderOptionsPtr;
diff --git a/modules/gfx/src/render_options/cpk_render_options.cc b/modules/gfx/src/render_options/cpk_render_options.cc
index 611db0f48b7de674a82ceb956bec2589bbb23dd8..a8cca254d46dd64dbf8c5698556a7353724f5688 100644
--- a/modules/gfx/src/render_options/cpk_render_options.cc
+++ b/modules/gfx/src/render_options/cpk_render_options.cc
@@ -46,7 +46,7 @@ void CPKRenderOptions::ApplyRenderOptions(RenderOptionsPtr render_options){
CPKRenderOptionsPtr options = boost::static_pointer_cast<CPKRenderOptions>(render_options);
sphere_detail_=options->GetSphereDetail();
- cpk_mode_=options->GetCPKMode();
+ cpk_mode_=options->GetSphereMode();
this->NotifyStateChange();
}
@@ -61,14 +61,14 @@ uint CPKRenderOptions::GetSphereDetail(){
return sphere_detail_;
}
-void CPKRenderOptions::SetCPKMode(uint mode){
+void CPKRenderOptions::SetSphereMode(uint mode){
if(cpk_mode_!=mode) {
cpk_mode_=mode;
this->NotifyStateChange();
}
}
-uint CPKRenderOptions::GetCPKMode(){
+uint CPKRenderOptions::GetSphereMode(){
return cpk_mode_;
}
diff --git a/modules/gfx/src/render_options/cpk_render_options.hh b/modules/gfx/src/render_options/cpk_render_options.hh
index 079822fbdb2d5fd76872df6d6c34cf32c6ec0d4e..478765ce1724a5c759653a1a3bfbb79a828a3ee4 100644
--- a/modules/gfx/src/render_options/cpk_render_options.hh
+++ b/modules/gfx/src/render_options/cpk_render_options.hh
@@ -42,9 +42,8 @@ public:
virtual void SetSphereDetail(uint detail);
virtual uint GetSphereDetail();
- virtual void SetCPKMode(uint mode);
- virtual uint GetCPKMode();
-
+ virtual void SetSphereMode(uint mode);
+ virtual uint GetSphereMode();
virtual ~CPKRenderOptions();
diff --git a/modules/gfx/src/render_pass.hh b/modules/gfx/src/render_pass.hh
index dd7a34a330b0ed36b817ce61f4b5131bdd31385c..2105b9bb550ce939738b2652728efbe280cf6cd6 100644
--- a/modules/gfx/src/render_pass.hh
+++ b/modules/gfx/src/render_pass.hh
@@ -32,9 +32,14 @@ typedef enum {
GLOW_RENDER_PASS,
/// \brief renders objects with solid color as used for shadow map
/// generation
- OPAQUE_RENDER_PASS,
+ DEPTH_RENDER_PASS,
+ /// \ brief for transparent objects
+ /// the standard render pass is not supposed to render transparent
+ /// objects, as they should get drawn after the rest of the scene
+ TRANSPARENT_RENDER_PASS,
+ OVERLAY_RENDER_PASS
} RenderPass;
}}
-#endif
\ No newline at end of file
+#endif
diff --git a/modules/gfx/src/scene.cc b/modules/gfx/src/scene.cc
index 46af476261dc78f9552f4ec9f166669ec2fdbb7c..64ee1fae3bce12c4f1f61a5ba390f5039833e696 100644
--- a/modules/gfx/src/scene.cc
+++ b/modules/gfx/src/scene.cc
@@ -42,7 +42,6 @@
#include "gl_helper.hh"
#include <ost/config.hh>
-#include "offscreen_buffer.hh"
#include "scene.hh"
#include "input.hh"
#include "gfx_node.hh"
@@ -51,13 +50,13 @@
#include "bitmap_io.hh"
#include "entity.hh"
#include "povray.hh"
+#include "offscreen_buffer.hh"
#if OST_SHADER_SUPPORT_ENABLED
# include "shader.hh"
+# include "impl/scene_fx.hh"
#endif
-//#define DEBUG_SMAP
-
using boost::bind;
namespace ost {
@@ -95,10 +94,11 @@ Scene::Scene():
root_node_(new GfxNode("Scene")),
observers_(),
transform_(),
+ gl_init_(false),
fov_(30.0),
- znear_(-200.0),zfar_(200.0),
- fnear_(5.0), ffar_(0.0),
- vp_width_(100),vp_height_(100),
+ znear_(1.0),zfar_(1000.0),
+ fnear_(1.0), ffar_(1000.0),
+ vp_width_(1000),vp_height_(1000),
scene_view_stack_(),
aspect_ratio_(1.0),
background_(Color(0.0,0.0,0.0,0.0)),
@@ -110,11 +110,11 @@ Scene::Scene():
axis_flag_(false),
fog_flag_(true),
fog_color_(0.0,0.0,0.0,0.0),
- shadow_flag_(false),
- shadow_quality_(1),
- texture_id_(),
auto_autoslab_(true),
offscreen_flag_(false),
+ main_offscreen_buffer_(0),
+ old_vp_(),
+ def_shading_mode_("default"),
selection_mode_(1),
test_flag_(false),
tmp_tex_(),
@@ -126,8 +126,10 @@ Scene::Scene():
stereo_(0),
stereo_inverted_(false),
stereo_eye_(0),
- stereo_eye_dist_(150.0),
- stereo_eye_offset_(10.0)
+ stereo_eye_dist_(5.0),
+ stereo_eye_off_(0.0),
+ scene_left_tex_(),
+ scene_right_tex_()
{
transform_.SetTrans(Vec3(0,0,-100));
}
@@ -143,6 +145,11 @@ void Scene::SetFog(bool f)
RequestRedraw();
}
+bool Scene::GetFog() const
+{
+ return fog_flag_;
+}
+
void Scene::SetFogColor(const Color& c)
{
GLfloat fogc[]={c.Red(),c.Green(),c.Blue(),1.0};
@@ -151,21 +158,143 @@ void Scene::SetFogColor(const Color& c)
RequestRedraw();
}
+Color Scene::GetFogColor() const
+{
+ return fog_color_;
+}
+
void Scene::SetShadow(bool f)
{
- shadow_flag_=f;
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().shadow_flag=f;
+ // the redraw routine will deal with the Shader
RequestRedraw();
+#endif
}
-bool Scene::GetShadow()
+bool Scene::GetShadow() const
{
- return shadow_flag_;
+#if OST_SHADER_SUPPORT_ENABLED
+ return impl::SceneFX::Instance().shadow_flag;
+#endif
}
void Scene::SetShadowQuality(int q)
{
- shadow_quality_=std::min(3,std::max(0,q));
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().shadow_quality=std::min(8,std::max(0,q));
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetShadowWeight(float w)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().shadow_weight=w;
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetDepthDarkening(bool f)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().depth_dark_flag=f;
+ // the redraw routine will deal with the Shader
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetDepthDarkeningWeight(float f)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().depth_dark_factor=f;
+ // the redraw routine will deal with the Shader
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetAmbientOcclusion(bool f)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().amb_occl_flag=f;
+ // the redraw routine will deal with the Shader
+ RequestRedraw();
+#endif
+}
+
+bool Scene::GetAmbientOcclusion() const
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ return impl::SceneFX::Instance().amb_occl_flag;
+#else
+ return false;
+#endif
+}
+
+void Scene::SetAmbientOcclusionWeight(float f)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().amb_occl_factor=f;
+ // the redraw routine will deal with the Shader
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetAmbientOcclusionMode(uint m)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().amb_occl_mode=m;
+ // the redraw routine will deal with the Shader
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetAmbientOcclusionQuality(uint m)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().amb_occl_quality=m;
+ // the redraw routine will deal with the Shader
+ RequestRedraw();
+#endif
+}
+
+void Scene::SetShadingMode(const std::string& smode)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ // this here is required - in case SetShadingMode is called
+ // before GL is initialized (e.g. during batch mode rendering)
+ def_shading_mode_=smode;
+ if(smode=="fallback") {
+ Shader::Instance().Activate("");
+ } else if(smode=="basic") {
+ Shader::Instance().Activate("basic");
+ } else if(smode=="hf") {
+ Shader::Instance().Activate("hemilight");
+ } else if(smode=="toon1") {
+ Shader::Instance().Activate("toon1");
+ } else if(smode=="toon2") {
+ Shader::Instance().Activate("toon2");
+ } else {
+ Shader::Instance().Activate("fraglight");
+ }
RequestRedraw();
+#endif
+}
+
+void Scene::SetBeacon(int wx, int wy)
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().use_beacon=true;
+ impl::SceneFX::Instance().beacon.wx=static_cast<float>(wx);
+ impl::SceneFX::Instance().beacon.wy=static_cast<float>(wy);
+#endif
+}
+
+void Scene::SetBeaconOff()
+{
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().use_beacon=false;
+#endif
}
namespace {
@@ -179,13 +308,18 @@ void set_light_dir(Vec3 ld)
}
-void Scene::InitGL()
+void Scene::InitGL(bool full)
{
- LOG_DEBUG("scene: initializing GL state" << std::endl);
+ LOGN_DEBUG("scene: initializing GL state");
+
+ if(full) {
+ LOGN_VERBOSE(glGetString(GL_RENDERER) << ", openGL version " << glGetString(GL_VERSION));
#if OST_SHADER_SUPPORT_ENABLED
- Shader::Instance().PreGLInit();
+ LOGN_DEBUG("scene: shader pre-gl");
+ Shader::Instance().PreGLInit();
#endif
+ }
// TODO: add more lights
glLightfv(GL_LIGHT0, GL_AMBIENT, light_amb_);
@@ -234,9 +368,31 @@ void Scene::InitGL()
glShadeModel(GL_SMOOTH);
// line and point anti-aliasing
+
+#if OST_SHADER_SUPPORT_ENABLED
+ GLint mbufs=0,msamples=0;
+ if(GLEW_VERSION_2_0) {
+ glGetIntegerv(GL_SAMPLE_BUFFERS, &mbufs);
+ glGetIntegerv(GL_SAMPLES, &msamples);
+ }
+
+ if(mbufs>0 && msamples>0) {
+ LOGN_VERBOSE("Scene: enabling multisampling with: " << msamples << " samples");
+ glDisable(GL_LINE_SMOOTH);
+ glDisable(GL_POINT_SMOOTH);
+ glDisable(GL_POLYGON_SMOOTH);
+ glEnable(GL_MULTISAMPLE);
+ } else {
+ glEnable(GL_LINE_SMOOTH);
+ glDisable(GL_POINT_SMOOTH);
+ glDisable(GL_POLYGON_SMOOTH);
+ }
+#else
glEnable(GL_LINE_SMOOTH);
glDisable(GL_POINT_SMOOTH);
glDisable(GL_POLYGON_SMOOTH);
+#endif
+
// rendering hints
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glHint(GL_FOG_HINT, GL_NICEST);
@@ -247,20 +403,52 @@ void Scene::InitGL()
glDisable(GL_NORMALIZE);
// double-buffer rendering requires this
// glDrawBuffer(GL_BACK);
- // initialize shaders
-#if OST_SHADER_SUPPORT_ENABLED
- Shader::Instance().Setup();
- Shader::Instance().Activate("fraglight");
- glGenTextures(1,&texture_id_);
+#if OST_SHADER_SUPPORT_ENABLED
+ if(full) {
+ LOGN_DEBUG("scene: shader setup");
+ Shader::Instance().Setup();
+ SetShadingMode(def_shading_mode_);
+ LOGN_DEBUG("scene: scenefx setup");
+ impl::SceneFX::Instance().Setup();
+ }
#endif
- prep_glyphs();
+ if(full) {
+ prep_glyphs();
+ }
+
+ if(full) {
+ glGenTextures(1,&scene_left_tex_);
+ glGenTextures(1,&scene_right_tex_);
+ }
+
+ glEnable(GL_TEXTURE_2D);
+ if(GLEW_VERSION_2_0) {
+ glActiveTexture(GL_TEXTURE0);
+ }
+
+ glBindTexture(GL_TEXTURE_2D, scene_left_tex_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ glBindTexture(GL_TEXTURE_2D, scene_right_tex_);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+ LOGN_DEBUG("scene: gl init done");
+ gl_init_=true;
}
void Scene::RequestRedraw()
{
- if (win_) {
+ if (win_ && !offscreen_flag_) {
win_->DoRefresh();
}
}
@@ -278,6 +466,11 @@ void Scene::SetBackground(const Color& c)
RequestRedraw();
}
+Color Scene::GetBackground() const
+{
+ return background_;
+}
+
Viewport Scene::GetViewport() const
{
Viewport vp;
@@ -292,6 +485,9 @@ void Scene::SetViewport(int w, int h)
vp_height_=h;
aspect_ratio_=static_cast<float>(w)/static_cast<float>(h);
ResetProjection();
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().Resize(w,h);
+#endif
}
void Scene::Resize(int w, int h)
@@ -306,6 +502,7 @@ void Scene::SetCenter(const Vec3& cen)
float delta_z = tcen[2]-transform_.GetTrans()[2];
transform_.SetCenter(cen);
+ transform_.SetTrans(Vec3(0,0,transform_.GetTrans()[2]));
SetNearFar(znear_+delta_z,zfar_+delta_z);
RequestRedraw();
}
@@ -428,36 +625,13 @@ void Scene::RenderGL()
{
if(auto_autoslab_) Autoslab(false, false);
- #if OST_SHADER_SUPPORT_ENABLED
- if(shadow_flag_) {
- prep_shadow_map();
- #if DEBUG_SMAP
- return;
- #endif
- }
- #endif
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
prep_blur();
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- set_light_dir(light_dir_);
-
- glMultMatrix(transform_.GetTransposedMatrix().Data());
-
- if(stereo_==2 || stereo_==3) {
- render_interlaced_stereo();
- } else if (stereo_==1) {
- this->render_quad_buffered_stereo();
+ if(stereo_==1 || stereo_==2) {
+ render_stereo();
} else {
- this->render_scene_with_glow();
- }
- #if OST_SHADER_SUPPORT_ENABLED
- if(shadow_flag_) {
- glDisable(GL_TEXTURE_2D);
+ render_scene();
}
- #endif
}
void Scene::Register(GLWinBase* win)
@@ -506,6 +680,37 @@ namespace {
GfxObjP node;
};
+#if 0
+ struct RegexFindObj: public GfxNodeVisitor {
+ RegexFindObj(const String& rs): reg(), valid(false), node() {
+ try {
+ reg = boost::regex(rs);
+ valid = true;
+ } catch (boost::regex_error& e) {
+ LOGN_ERROR("invalid regex");
+ }
+ }
+
+ virtual bool VisitNode(GfxNode* n, const Stack& st) {
+ return true;
+ }
+
+ virtual void VisitObject(GfxObj* o, const Stack& st) {
+ if(boost::regex_match(o->GetName(),reg)) {
+ GfxNodeP nn = o->shared_from_this();
+ GfxObjP oo = dyn_cast<GfxObj>(nn);
+ if(oo) {
+ olist.push_back(oo);
+ }
+ }
+ }
+
+ boost::regex reg;
+ bool valid;
+ std::vector<GfxObjP> olist;
+ };
+#endif
+
struct FindNode2: public GfxNodeVisitor {
FindNode2(GfxNodeP n): node(n), found(false) {}
virtual bool VisitNode(GfxNode* n, const Stack& st) {
@@ -545,6 +750,14 @@ void Scene::Add(const GfxNodeP& n, bool redraw)
}
LOG_DEBUG("scene: graphical object added @" << n.get() << std::endl);
+
+ if(root_node_->GetChildCount()==0) {
+ GfxObjP go = boost::dynamic_pointer_cast<GfxObj>(n);
+ if(go) {
+ SetCenter(go->GetCenter());
+ }
+ }
+
root_node_->Add(n);
if (redraw) {
this->RequestRedraw();
@@ -604,7 +817,6 @@ void Scene::Remove(const GfxNodeP& go)
if(!go) return;
root_node_->Remove(go);
this->NotifyObservers(bind(&SceneObserver::NodeRemoved, _1,go));
- this->RequestRedraw();
}
void Scene::Remove(const String& name)
@@ -615,7 +827,6 @@ void Scene::Remove(const String& name)
root_node_->Remove(name);
if(GfxObjP go = dyn_cast<GfxObj>(fn.node)) {
this->NotifyObservers(bind(&SceneObserver::NodeRemoved, _1,go));
- this->RequestRedraw();
}
}
}
@@ -683,7 +894,6 @@ void Scene::Apply(GfxNodeVisitor& v) const
void Scene::OnInput(const InputEvent& e)
{
- float sf=1.0;
if(e.GetCommand()==INPUT_COMMAND_AUTOSLAB) {
Autoslab();
} else if(e.GetCommand()==INPUT_COMMAND_TOGGLE_FOG) {
@@ -719,7 +929,8 @@ void Scene::OnInput(const InputEvent& e)
transform_.ApplyYAxisTranslation(e.GetDelta()*fxy[1]);
}
} else if(e.GetCommand()==INPUT_COMMAND_TRANSZ) {
- float delta=e.GetDelta()*sf;
+ float currz=transform_.GetTrans()[2];
+ float delta=currz*pow(1.01,-e.GetDelta())-currz;
transform_.ApplyZAxisTranslation(delta);
SetNearFar(znear_-delta,zfar_-delta);
} else if(e.GetCommand()==INPUT_COMMAND_SLABN) {
@@ -1052,14 +1263,16 @@ void Scene::SetFogOffsets(float no, float fo)
void Scene::Stereo(unsigned int m)
{
if(m==1) {
- stereo_=m;
- if(win_) win_->SetStereo(true);
- } else if(m==2 || m==3) {
- stereo_=m;
- if(win_) win_->SetStereo(false);
+ if(win_ && win_->HasStereo()) {
+ stereo_=1;
+ } else {
+ LOGN_MESSAGE("No visual present for quad-buffered stereo");
+ stereo_=0;
+ }
+ } else if(m==2) {
+ stereo_=2;
} else {
stereo_=0;
- if(win_) win_->SetStereo(false);
}
RequestRedraw();
}
@@ -1067,15 +1280,31 @@ void Scene::Stereo(unsigned int m)
void Scene::SetStereoInverted(bool f)
{
stereo_inverted_=f;
+ RequestRedraw();
}
-void Scene::SetStereoEye(unsigned int m)
+void Scene::SetStereoView(unsigned int m)
{
stereo_eye_= (m>2) ? 0: m;
ResetProjection();
RequestRedraw();
}
+void Scene::SetStereoEyeDist(float d)
+{
+ stereo_eye_dist_=d;
+ if(stereo_>0) {
+ RequestRedraw();
+ }
+}
+
+void Scene::SetStereoEyeOff(float d)
+{
+ stereo_eye_off_=d;
+ if(stereo_>0) {
+ RequestRedraw();
+ }
+}
void Scene::SetLightDir(const Vec3& dir)
{
@@ -1125,24 +1354,60 @@ uint Scene::GetSelectionMode() const
return selection_mode_;
}
-namespace {
-
-struct OffscreenSwitcher
+bool Scene::StartOffscreenMode(unsigned int width, unsigned int height)
{
- OffscreenSwitcher()
- {
- LOGN_TRACE("offscreen begin");
- OffscreenBuffer::Instance().Begin();
+ if(main_offscreen_buffer_) return false;
+ main_offscreen_buffer_ = new OffscreenBuffer(width,height,OffscreenBufferFormat(),true);
+
+ if(!main_offscreen_buffer_->IsValid()) {
+ LOGN_ERROR("error during offscreen buffer creation");
+ delete main_offscreen_buffer_;
+ main_offscreen_buffer_=0;
+ return false;
}
+ old_vp_[0]=vp_width_;
+ old_vp_[1]=vp_height_;
+ main_offscreen_buffer_->MakeActive();
+ offscreen_flag_=true;
+ root_node_->ContextSwitch();
- ~OffscreenSwitcher()
- {
- LOGN_TRACE("offscreen end");
- OffscreenBuffer::Instance().End();
+#if OST_SHADER_SUPPORT_ENABLED
+ String shader_name = Shader::Instance().GetCurrentName();
+#endif
+
+ LOGN_DEBUG("initializing GL");
+ if(gl_init_) {
+ this->InitGL(false);
+ } else {
+ this->InitGL(true);
}
-};
+ LOGN_DEBUG("setting viewport");
+ Resize(width,height);
+ LOGN_DEBUG("updating fog settings");
+ update_fog();
+ glDrawBuffer(GL_FRONT);
+#if OST_SHADER_SUPPORT_ENABLED
+ LOGN_DEBUG("activating shader");
+ Shader::Instance().Activate(shader_name);
+#endif
+ return true;
+}
-} // anon ns
+void Scene::StopOffscreenMode()
+{
+ if(main_offscreen_buffer_) {
+ if (win_) {
+ win_->MakeActive();
+ }
+ delete main_offscreen_buffer_;
+ main_offscreen_buffer_=0;
+ Scene::Instance().SetViewport(old_vp_[0],old_vp_[1]);
+ offscreen_flag_=false;
+ root_node_->ContextSwitch();
+ glDrawBuffer(GL_BACK);
+ update_fog();
+ }
+}
void Scene::Export(const String& fname, unsigned int width,
unsigned int height, bool transparent)
@@ -1158,61 +1423,50 @@ void Scene::Export(const String& fname, unsigned int width,
return;
}
- offscreen_flag_=true;
- LOGN_TRACE("offscreen resize");
- OffscreenBuffer::Instance().Resize(width, height);
- try {
- // ensures that context is switched back when this goes out of scope
- OffscreenSwitcher offscreen_switch;
-
-#if OST_SHADER_SUPPORT_ENABLED
- String shader_name = Shader::Instance().GetCurrentName();
-#endif
- LOGN_TRACE("initializing GL");
- this->InitGL();
- LOGN_TRACE("setting viewport");
- SetViewport(width,height);
- LOGN_TRACE("reseting projection");
- ResetProjection();
- LOGN_TRACE("updating fog settings");
- update_fog();
- glDrawBuffer(GL_FRONT);
- //this->flag_all_dirty();
-#if OST_SHADER_SUPPORT_ENABLED
- LOGN_TRACE("activating shader");
- Shader::Instance().Activate(shader_name);
-#endif
- LOGN_TRACE("doing rendering");
- this->RenderGL();
- // make sure drawing operations are finished
- glFinish();
- boost::shared_array<uchar> img_data(new uchar[width*height*4]);
+ bool of_flag = (main_offscreen_buffer_==0);
- LOGN_TRACE("setting background transparency");
- if (transparent) {
- glPixelTransferf(GL_ALPHA_BIAS, 0.0);
- } else {
- // shift alpha channel by one to make sure pixels are read out as opaque
- glPixelTransferf(GL_ALPHA_BIAS, 1.0);
+ // only switch if offscreen mode is not active
+ if(of_flag) {
+ if(!StartOffscreenMode(width,height)) {
+ return;
}
+ }
+ LOGN_DEBUG("rendering into offscreen buffer");
+ this->RenderGL();
+ // make sure drawing operations are finished
+ glFlush();
+ glFinish();
- LOGN_TRACE("reading framebuffer pixels");
- glReadBuffer(GL_FRONT);
- glReadPixels(0,0,width,height,GL_RGBA,GL_UNSIGNED_BYTE,img_data.get());
-
- LOGN_DEBUG("calling bitmap export");
- BitmapExport(fname,ext,width,height,img_data.get());
- } catch (...) {
- // noop
- } // offscreen_switch goes out of scope
- offscreen_flag_=false;
- glDrawBuffer(GL_BACK);
- LOGN_TRACE("updating fog");
- update_fog();
+ boost::shared_array<uchar> img_data(new uchar[width*height*4]);
+
+ LOGN_DEBUG("setting background transparency");
+ if (transparent) {
+ glPixelTransferf(GL_ALPHA_BIAS, 0.0);
+ } else {
+ // shift alpha channel by one to make sure pixels are read out as opaque
+ glPixelTransferf(GL_ALPHA_BIAS, 1.0);
+ }
+
+ LOGN_DEBUG("reading framebuffer pixels");
+ glReadBuffer(GL_FRONT);
+ glReadPixels(0,0,width,height,GL_RGBA,GL_UNSIGNED_BYTE,img_data.get());
+ glReadBuffer(GL_BACK);
+
+ LOGN_DEBUG("calling bitmap export");
+ BitmapExport(fname,ext,width,height,img_data.get());
+
+ // only switch back if it was not on to begin with
+ if(of_flag) {
+ StopOffscreenMode();
+ }
}
void Scene::Export(const String& fname, bool transparent)
{
+ if(!win_ && !main_offscreen_buffer_) {
+ LOGN_ERROR("Export without dimensions either requires an interactive session \nor an active offscreen mode (scene.StartOffscreenMode(W,H))");
+ return;
+ }
int d_index=fname.rfind('.');
if (d_index==-1) {
LOGN_ERROR("no file extension specified");
@@ -1226,6 +1480,12 @@ void Scene::Export(const String& fname, bool transparent)
GLint vp[4];
glGetIntegerv(GL_VIEWPORT,vp);
+ if(main_offscreen_buffer_) {
+ this->RenderGL();
+ glFlush();
+ glFinish();
+ }
+
if (transparent) {
glPixelTransferf(GL_ALPHA_BIAS, 0.0);
} else {
@@ -1385,146 +1645,6 @@ void Scene::update_fog()
glFogf(GL_FOG_END,zfar_+ffar_);
}
-void Scene::prep_shadow_map()
-{
-#if OST_SHADER_SUPPORT_ENABLED
- GLint smap_size=256 << shadow_quality_;
-
- // modelview transform for the lightsource pov
- mol::Transform ltrans(transform_);
- ltrans.SetRot(light_rot_*transform_.GetRot());
-
- // calculate encompassing box for ortho projection
- geom::AlignedCuboid bb=this->GetBoundingBox(ltrans);
- const Vec3& tmin=bb.GetMin();
- const Vec3& tmax=bb.GetMax();
-
- // render pass 1 - without shadows
-
- // turn shadowing off for subsequent rendering
- glUniform1i(glGetUniformLocation(Shader::Instance().GetCurrentProgram(),
- "shadow_flag"),0);
- // save overall gl settings
- glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
- // maximize rendering for depth-only information
-#ifndef DEBUG_SMAP
- glDisable(GL_LIGHTING);
- glDisable(GL_FOG);
- glDisable(GL_COLOR_MATERIAL);
- glDisable(GL_NORMALIZE);
- glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
-#endif
-
- // render scene with only depth components
- glViewport(0,0,smap_size,smap_size);
- glClear(GL_DEPTH_BUFFER_BIT);
-
- glMatrixMode(GL_PROJECTION);
- glPushMatrix();
- glLoadIdentity();
- glOrtho(tmin[0],tmax[0],tmin[1],tmax[1],-tmax[2],-tmin[2]);
- //glFrustum(tmin[0],tmax[0],tmin[1],tmax[1],-tmax[2],-tmin[2]);
- float glpmat[16];
- glGetv(GL_PROJECTION_MATRIX, glpmat);
- Mat4 pmat(Transpose(Mat4(glpmat)));
-
- glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- glLoadIdentity();
- glMultMatrix(ltrans.GetTransposedMatrix().Data());
-
- // only render non-transparent objects for the shadow map
- root_node_->RenderGL(OPAQUE_RENDER_PASS);
-
- // now get the shadow map
- glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D, texture_id_);
-
- glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
- 0,0, smap_size,smap_size, 0);
-
- ////////////////
- // all of the following texture and shader params need to be moved
- // to a one-time initialization place
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-
- GLuint cpr=Shader::Instance().GetCurrentProgram();
-
- // assign tex unit 0 to shadow map
- glUniform1i(glGetUniformLocation(Shader::Instance().GetCurrentProgram(),"shadow_map"),0);
- //int depth_bits;
- //glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
- //float depth_bias = 1.0/static_cast<float>(1<<depth_bits);
- glUniform1f(glGetUniformLocation(cpr,"depth_bias"),0.008);
-
- glUniform1f(glGetUniformLocation(cpr,"epsilon"),0.002);
-
- glUniform1f(glGetUniformLocation(cpr,"shadow_multiplier"),0.4);
-
- //
- //////////////////
-
- // restore settings
- glPopMatrix();
- glMatrixMode(GL_PROJECTION);
- glPopMatrix();
- glMatrixMode(GL_MODELVIEW);
-
- glPopAttrib();
- glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
-
- glEnable(GL_TEXTURE_2D);
-
- // and turn shadowing on for subsequent rendering
- glUniform1i(glGetUniformLocation(cpr,"shadow_flag"),1);
-
-#ifndef DEBUG_SMAP
- // set up appropriate texture matrix
- Mat4 bias(0.5,0.0,0.0,0.5,
- 0.0,0.5,0.0,0.5,
- 0.0,0.0,0.5,0.5,
- 0.0,0.0,0.0,1.0);
-
- Mat4 texm = bias*pmat*ltrans.GetMatrix();
-
- glMatrixMode(GL_TEXTURE);
- // make explicit object instead of temporary to avoid potential crash with Data()
- Mat4 ttmp=Transpose(texm);
- glLoadMatrix(ttmp.Data());
- glMatrixMode(GL_MODELVIEW);
-#else
- // this debug code draws the depth map across the screen
- Shader::Instance().Activate("");
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glDisable(GL_CULL_FACE);
- glDisable(GL_LIGHTING);
- glDisable(GL_FOG);
- glEnable(GL_TEXTURE_2D);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(-1,11,-1,11,-1,1);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glColor3f(1.0,1.0,1.0);
- glBegin(GL_QUADS);
- glTexCoord2f(0.0,0.0);
- glVertex2f(0.0,0.0);
- glTexCoord2f(0.0,1.0);
- glVertex2f(0.0,10.0);
- glTexCoord2f(1.0,1.0);
- glVertex2f(10.0,10.0);
- glTexCoord2f(1.0,0.0);
- glVertex2f(10.0,0.0);
- glEnd();
- Shader::Instance().Activate("basic_shadow");
-#endif
-#endif
-}
namespace {
class DirtyAll: public GfxNodeVisitor
@@ -1551,11 +1671,6 @@ bool Scene::InOffscreenMode() const
return offscreen_flag_;
}
-void Scene::SetOffscreenMode()
-{
- OffscreenBuffer::Instance().Begin();
-}
-
float Scene::ElapsedTime() const
{
#ifndef _MSC_VER
@@ -1578,14 +1693,6 @@ void Scene::SetTestMode(bool f)
}
}
-// temporary interface
-void Scene::ActivateShader(const String& name)
-{
-#if OST_SHADER_SUPPORT_ENABLED
- Shader::Instance().Activate(name);
-#endif
-}
-
void Scene::prep_glyphs()
{
glGenTextures(1,&glyph_tex_id_);
@@ -1623,8 +1730,7 @@ void Scene::prep_glyphs()
}
for(int cc=128;cc<256;++cc) glyph_map_[cc]=Vec2(0.0,0.0);
- LOGN_VERBOSE("done loading glyphs");
-
+ LOGN_DEBUG("done loading glyphs");
}
void Scene::prep_blur()
@@ -1634,13 +1740,36 @@ void Scene::prep_blur()
glFlush();
}
-void Scene::render_scene_with_glow()
+void Scene::render_scene()
{
- glDepthFunc(GL_LEQUAL);
- glDepthMask(1);
- glEnable(GL_DEPTH_TEST);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ glMultMatrix(transform_.GetTransposedMatrix().Data());
+
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().Preprocess();
+#endif
+
root_node_->RenderGL(STANDARD_RENDER_PASS);
- glPushAttrib(GL_ENABLE_BIT);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ root_node_->RenderGL(TRANSPARENT_RENDER_PASS);
+ glDisable(GL_BLEND);
+ root_node_->RenderGL(OVERLAY_RENDER_PASS);
+
+#if OST_SHADER_SUPPORT_ENABLED
+ impl::SceneFX::Instance().Postprocess();
+#endif
+
+ render_glow();
+}
+
+void Scene::render_glow()
+{
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_FLAT);
glDisable(GL_FOG);
@@ -1668,33 +1797,60 @@ void Scene::stereo_projection(unsigned int view)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
- float zn=std::max(float(1.0),znear_);
- float zf=std::max(float(1.1),zfar_);
-
- gluPerspective(fov_,aspect_ratio_,zn,zf);
-
- if(view>0) {
- float iod = (view==1) ? -stereo_eye_dist_ : stereo_eye_dist_;
- //float fr=(-stereo_eye_offset_-zn)/(zf-zn);
- float angle=180.0f/M_PI*std::atan(stereo_eye_offset_/(2.0*iod));
- glTranslated(0.0,0.0,transform_.GetTrans()[2]);
- glRotated(-angle,0.0,1.0,0.0);
- glTranslated(0.0,0.0,-transform_.GetTrans()[2]);
+ GLdouble zn=std::max<float>(1.0,znear_);
+ GLdouble zf=std::max<float>(1.1,zfar_);
+
+ GLdouble top = zn * std::tan(fov_*M_PI/360.0);
+ GLdouble bot = -top;
+ GLdouble right = top*aspect_ratio_;
+ GLdouble left = -right;
+
+ glFrustum(left,right,bot,top,zn,zf);
+
+ if(view==1 || view==2) {
+ float ff=(view==1 ? -1.0 : 1.0);
+ float dist=-transform_.GetTrans()[2];
+ geom::Mat4 skew=geom::Transpose(geom::Mat4(1.0,0.0,ff*stereo_eye_dist_/dist,ff*stereo_eye_dist_,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ 0.0,0.0,0.0,1.0));
+ glMultMatrix(skew.Data());
}
+
}
-void Scene::render_interlaced_stereo()
+void Scene::render_stereo()
{
- // set up stencil buffer
- glPushAttrib(GL_STENCIL_BUFFER_BIT| GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
- glMatrixMode(GL_PROJECTION);
- glPushMatrix();
- glLoadIdentity();
- glOrtho(0,vp_width_,0,vp_height_,-1,1);
- glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- glLoadIdentity();
- glDrawBuffer(GL_NONE);
+ stereo_eye_=1;
+ stereo_projection(1);
+ render_scene();
+
+ glEnable(GL_TEXTURE_2D);
+ if(GLEW_VERSION_2_0) {
+ glActiveTexture(GL_TEXTURE0);
+ }
+ glBindTexture(GL_TEXTURE_2D, scene_left_tex_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, vp_width_, vp_height_, 0);
+
+ stereo_eye_=2;
+ stereo_projection(2);
+ render_scene();
+ glEnable(GL_TEXTURE_2D);
+ if(GLEW_VERSION_2_0) {
+ glActiveTexture(GL_TEXTURE0);
+ }
+ glBindTexture(GL_TEXTURE_2D, scene_right_tex_);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, vp_width_, vp_height_, 0);
+ check_gl_error();
+ stereo_eye_=0;
+ stereo_projection(0);
+
+#if OST_SHADER_SUPPORT_ENABLED
+ Shader::Instance().PushProgram();
+ Shader::Instance().Activate("");
+#endif
+
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
@@ -1703,63 +1859,85 @@ void Scene::render_interlaced_stereo()
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
glDisable(GL_POINT_SMOOTH);
- glLineWidth(1.0);
- glEnable(GL_STENCIL_TEST);
- glStencilMask(0x1);
- glClearStencil(0x0);
- glClear(GL_STENCIL_BUFFER_BIT);
- glStencilFunc(GL_ALWAYS,0x1,0x1);
- glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
- glBegin(GL_LINES);
- glColor3f(1.0,1.0,1.0);
- for(unsigned int i=0;i<vp_height_;i+=2) {
- glVertex2i(0,i);
- glVertex2i(vp_width_-1,i);
- }
- glEnd();
- glPopMatrix();
+ glDisable(GL_MULTISAMPLE);
glMatrixMode(GL_PROJECTION);
- glPopMatrix();
+ glPushMatrix();
+ glLoadIdentity();
+ glOrtho(0,vp_width_,0,vp_height_,-1,1);
glMatrixMode(GL_MODELVIEW);
- glPopAttrib();
-
- glEnable(GL_STENCIL_TEST);
- glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
+ glPushMatrix();
+ glLoadIdentity();
- glStencilFunc(GL_EQUAL,0x1,0x1);
- stereo_projection(stereo_==2 ? 1 : 2);
- root_node_->RenderGL(STANDARD_RENDER_PASS);
- root_node_->RenderGL(GLOW_RENDER_PASS);
+ if(stereo_==2) {
+ // draw interlace lines in stencil buffer
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ glLineWidth(1.0);
+ glEnable(GL_STENCIL_TEST);
+ glStencilMask(0x1);
+ glClearStencil(0x0);
+ glClear(GL_STENCIL_BUFFER_BIT);
+ glStencilFunc(GL_ALWAYS,0x1,0x1);
+ glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
+ glBegin(GL_LINES);
+ glColor3f(1.0,1.0,1.0);
+ for(unsigned int i=0;i<vp_height_;i+=2) {
+ glVertex2i(0,i);
+ glVertex2i(vp_width_-1,i);
+ }
+ glEnd();
+
+ glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
+ }
- glStencilFunc(GL_EQUAL,0x0,0x1);
- stereo_projection(stereo_==2 ? 2 : 1);
- root_node_->RenderGL(STANDARD_RENDER_PASS);
- root_node_->RenderGL(GLOW_RENDER_PASS);
- glDisable(GL_STENCIL_TEST);
- glPopAttrib();
-}
+ // right eye
+ if(stereo_==1) {
+ glDrawBuffer(GL_BACK_RIGHT);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ } else if(stereo_==2) {
+ glStencilFunc(GL_EQUAL,0x0,0x1);
+ }
+ if(GLEW_VERSION_2_0) {
+ glActiveTexture(GL_TEXTURE0);
+ }
+ glBindTexture(GL_TEXTURE_2D, stereo_inverted_ ? scene_left_tex_ : scene_right_tex_);
+ // draw
+ glColor3f(1.0,0.0,1.0);
+ glBegin(GL_QUADS);
+ glTexCoord2f(0.0,0.0); glVertex2i(0,0);
+ glTexCoord2f(0.0,1.0); glVertex2i(0,vp_height_);
+ glTexCoord2f(1.0,1.0); glVertex2i(vp_width_,vp_height_);
+ glTexCoord2f(1.0,0.0); glVertex2i(vp_width_,0);
+ glEnd();
-void Scene::render_quad_buffered_stereo()
-{
- glDrawBuffer(GL_BACK);
- glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
- glDrawBuffer(GL_BACK_LEFT);
- glClear(GL_DEPTH_BUFFER_BIT);
- if (stereo_inverted_) {
- stereo_projection(stereo_==1 ? 2 : 1);
- } else {
- stereo_projection(stereo_==1 ? 1 : 2);
+ // left eye
+ if(stereo_==1) {
+ glDrawBuffer(GL_BACK_LEFT);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ } else if(stereo_==2) {
+ glStencilFunc(GL_EQUAL,0x1,0x1);
}
- this->render_scene_with_glow();
- glDrawBuffer(GL_BACK_RIGHT);
- glClear(GL_DEPTH_BUFFER_BIT);
- if (stereo_inverted_) {
- stereo_projection(stereo_==1 ? 1 : 2);
- } else {
- stereo_projection(stereo_==1 ? 2 : 1);
+ if(GLEW_VERSION_2_0) {
+ glActiveTexture(GL_TEXTURE0);
}
- this->render_scene_with_glow();
- glDrawBuffer(GL_BACK);
+ glBindTexture(GL_TEXTURE_2D, stereo_inverted_ ? scene_right_tex_ : scene_left_tex_);
+ // draw
+ glColor3f(1.0,0.0,1.0);
+ glBegin(GL_QUADS);
+ glTexCoord2f(0.0,0.0); glVertex2i(0,0);
+ glTexCoord2f(0.0,1.0); glVertex2i(0,vp_height_);
+ glTexCoord2f(1.0,1.0); glVertex2i(vp_width_,vp_height_);
+ glTexCoord2f(1.0,0.0); glVertex2i(vp_width_,0);
+ glEnd();
+
+ // restore settings
+ glMatrixMode(GL_PROJECTION);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ glPopAttrib();
+#if OST_SHADER_SUPPORT_ENABLED
+ Shader::Instance().PopProgram();
+#endif
}
}} // ns
diff --git a/modules/gfx/src/scene.hh b/modules/gfx/src/scene.hh
index d86e46a6a6d9653f6cc95256714fff4331b61cfc..79842843783a839390e89608aa80bed46c7338cb 100644
--- a/modules/gfx/src/scene.hh
+++ b/modules/gfx/src/scene.hh
@@ -46,16 +46,19 @@
namespace ost { namespace gfx {
class InputEvent;
+class OffscreenBuffer;
typedef std::vector<SceneObserver*> SceneObserverList;
struct Viewport {
- int bottom;
- int left;
+ int x;
+ int y;
int width;
int height;
};
+namespace impl {class SceneFX;}
+
/// \brief main class for organization and root for the graphical display
///
/// The scene manages graphical objects for rendering. Typical graphical objects
@@ -73,6 +76,7 @@ struct Viewport {
/// disabling the AutoAutoslab(). The near and far clipping plane can then be
/// adjusted manually.
class DLLEXPORT_OST_GFX Scene {
+ friend class impl::SceneFX;
private:
// TODO: this struct may be the seed for a proper
@@ -92,18 +96,39 @@ class DLLEXPORT_OST_GFX Scene {
/// \brief turn fog on or off
void SetFog(bool f);
+ /// \brief check fog status
+ bool GetFog() const;
+
/// \brief set the fog color
void SetFogColor(const Color& c);
- /// \brief turn shadow on and off
+ /// \brief get the fog color
+ Color GetFogColor() const;
+
+ /// \brief turn shadow mapping on and off
void SetShadow(bool f);
- /// \brief returns true if shadow is on
- bool GetShadow();
+ /// \brief get shadow mapping status
+ bool GetShadow() const;
/// \brief shadow quality from 0 (low) to 3 (high), default=1
void SetShadowQuality(int q);
+
+ void SetShadowWeight(float w);
+
+ void SetDepthDarkening(bool f);
+ void SetDepthDarkeningWeight(float f);
+
+ void SetAmbientOcclusion(bool f);
+ bool GetAmbientOcclusion() const;
+ void SetAmbientOcclusionWeight(float f);
+ void SetAmbientOcclusionMode(uint m);
+ void SetAmbientOcclusionQuality(uint q);
+ /// \brief select shading mode
+ /// one of fallback, basic, default, hf, toon1, toon2
+ void SetShadingMode(const std::string& smode);
+
/// \name clipping planes
//@{
/// \brief get near clipping plane
@@ -156,16 +181,18 @@ class DLLEXPORT_OST_GFX Scene {
/*
0=off
1=quad-buffered
- 2=interlaced variant #1
- 3=interlaced variant #2
+ 2=interlaced stereo
*/
void Stereo(unsigned int);
/// \brief invert stereo eyes for stereo mode=0
void SetStereoInverted(bool f);
- /// \brief eye mode, 0=center, 1=left, 2=right
- void SetStereoEye(unsigned int);
+ /// \brief stereo view mode, 0=center, 1=left, 2=right
+ void SetStereoView(unsigned int);
+
+ void SetStereoEyeDist(float);
+ void SetStereoEyeOff(float);
/// \brief set main light direction
void SetLightDir(const geom::Vec3& dir);
@@ -184,20 +211,22 @@ class DLLEXPORT_OST_GFX Scene {
/// \name Export
//@}
/// \brief export scene into a bitmap, rendering into offscreen of given size
+ /// if a main offscreen buffer is active (\sa StartOffscreenMode), then the
+ /// dimensions here are ignored
void Export(const String& fname, unsigned int w,
unsigned int h, bool transparent=true);
/// \brief export snapshot of current scene
void Export(const String& fname, bool transparent=true);
- /// \brief export scene into povray files names fname.pov and fname.inc
+ /// \brief export scene into povray files named fname.pov and fname.inc
void ExportPov(const std::string& fname, const std::string& wdir=".");
//@}
/// \brief entry point for gui events (internal use)
void OnInput(const InputEvent& e);
/// \brief initialize OpenGL after context has been setup (internal use)
- void InitGL();
+ void InitGL(bool full=true);
/// \brief handle new viewport size (internal use)
void Resize(int w, int h);
@@ -225,6 +254,9 @@ class DLLEXPORT_OST_GFX Scene {
/// \brief set background color
void SetBackground(const Color& c);
+ /// \brief get background color
+ Color GetBackground() const;
+
/// \brief center rotation on the given point
void SetCenter(const geom::Vec3& cen);
@@ -311,24 +343,41 @@ class DLLEXPORT_OST_GFX Scene {
bool InOffscreenMode() const;
- /// \brief internal use
- static void SetOffscreenMode();
-
/// \brief switch into test mode (internal use)
void SetTestMode(bool t);
float ElapsedTime() const;
Viewport GetViewport() const;
-
- // temporary interface
- void ActivateShader(const String& name);
+ /*!
+ This method has two different tasks.
+
+ During interactive rendering, it facilitates export
+ into an offscreen buffer with Scene::Export(file,width,height)
+ by avoiding repeated initializations of the GL state, e.g.
+ during animation rendering.
+
+ During batch mode, this is the only way to get meaningful
+ functionality with the gfx module
+
+ returns true upon success and false upon failure
+ */
+ bool StartOffscreenMode(unsigned int w, unsigned int h);
+ /// \brief stops offline rendering in interactive mode
+ void StopOffscreenMode();
+
void SetBlur(uint n);
void BlurSnapshot();
void RenderText(const TextPrim& t);
+ geom::Vec3 GetLightDir() const {return light_dir_;}
+ geom::Mat3 GetLightRot() const {return light_rot_;}
+
+ void SetBeacon(int wx, int wy);
+ void SetBeaconOff();
+
protected:
friend class GfxObj;
friend class GfxNode;
@@ -356,6 +405,8 @@ private:
mol::Transform transform_; // overall modelview transformation
+ bool gl_init_;
+
float fov_; // field of view
float znear_,zfar_; // near and far clipping plane
float fnear_,ffar_; // fog near and far offsets
@@ -377,12 +428,12 @@ private:
bool axis_flag_;
bool fog_flag_;
Color fog_color_;
- bool shadow_flag_;
- int shadow_quality_;
- GLuint texture_id_;
bool auto_autoslab_;
- bool offscreen_flag_;
+ bool offscreen_flag_; // a simple indicator whether in offscreen mode or not
+ OffscreenBuffer* main_offscreen_buffer_; // not null if a main offscreen buffer is present
+ uint old_vp_[2]; // used by the offline rendering code
+ std::string def_shading_mode_;
uint selection_mode_;
@@ -395,23 +446,23 @@ private:
uint blur_count_;
std::vector<boost::shared_array<unsigned char> > blur_buffer_;
- GLuint glow_tex_;
unsigned int stereo_;
bool stereo_inverted_;
unsigned int stereo_eye_;
- float stereo_eye_dist_,stereo_eye_offset_;
+ float stereo_eye_dist_,stereo_eye_off_;
+ unsigned int scene_left_tex_;
+ unsigned int scene_right_tex_;
void set_near(float n);
void set_far(float f);
void update_fog();
- void prep_shadow_map();
void flag_all_dirty();
void prep_glyphs();
void prep_blur();
void stereo_projection(unsigned int view);
- void render_interlaced_stereo();
- void render_quad_buffered_stereo();
- void render_scene_with_glow();
+ void render_scene();
+ void render_glow();
+ void render_stereo();
bool IsNameAvailable(String name);
};
diff --git a/modules/gfx/src/shader.cc b/modules/gfx/src/shader.cc
index e7d1cd5b73ab2d1a57e2d8be2c9d17c11ad8f7b1..db8e0558a4bad9cea19036126ffcc7002ecd82fc 100644
--- a/modules/gfx/src/shader.cc
+++ b/modules/gfx/src/shader.cc
@@ -49,7 +49,11 @@ Shader::Shader():
current_name_(""),
shader_code_map_(),
shader_program_map_()
-{}
+{
+ if(!GLEW_VERSION_2_0) {
+ LOGN_VERBOSE("OpenGL version smaller 2.0, deactivating shader functionality");
+ }
+}
void Shader::PreGLInit()
@@ -76,7 +80,7 @@ bool compile_shader(String shader_name, String shader_code, GLenum shader_type,
GLint sh_compiled;
glGetShaderiv(shader_id, GL_COMPILE_STATUS, &sh_compiled);
if(sh_compiled==GL_TRUE) {
- LOGN_VERBOSE("shader [" << shader_name << "] successfully compiled (" << shader_id << ")");
+ LOGN_DEBUG("shader [" << shader_name << "] successfully compiled (" << shader_id << ")");
} else {
GLint sh_log_length;
glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &sh_log_length);
@@ -93,7 +97,7 @@ bool link_shader(const std::vector<GLuint>& code_list, String pr_name, GLuint& s
shader_pr = glCreateProgram();
for(std::vector<GLuint>::const_iterator it=code_list.begin();it!=code_list.end();++it) {
if(*it == 0) {
- LOGN_VERBOSE("skipping shader [" << pr_name << "] due to missing compiled code");
+ LOGN_DEBUG("skipping shader [" << pr_name << "] due to missing compiled code");
return false;
}
LOGN_DEBUG("attaching compiled shader id " << *it << " to " << shader_pr);
@@ -104,7 +108,7 @@ bool link_shader(const std::vector<GLuint>& code_list, String pr_name, GLuint& s
GLint pr_linked;
glGetProgramiv(shader_pr,GL_LINK_STATUS,&pr_linked);
if(pr_linked==GL_TRUE) {
- LOGN_VERBOSE("shader [" << pr_name << "] sucessfully linked");
+ LOGN_DEBUG("shader [" << pr_name << "] sucessfully linked");
} else {
GLint pr_log_length;
glGetProgramiv(shader_pr, GL_INFO_LOG_LENGTH, &pr_log_length);
@@ -120,6 +124,8 @@ bool link_shader(const std::vector<GLuint>& code_list, String pr_name, GLuint& s
void Shader::Setup()
{
+ if(!GLEW_VERSION_2_0) return;
+
String ost_root = GetSharedDataPath();
bf::path ost_root_dir(ost_root);
bf::path shader_dir(ost_root_dir / "shader");
@@ -129,16 +135,12 @@ void Shader::Setup()
GLenum type;
} shader_list[] = {
//////////////////////////////////////////////////////////////////
- // this is the master list of all shader code in lib/ost/shader
-
- {"basic_lf_vs.glsl", GL_VERTEX_SHADER},
- {"basic_lf_fs.glsl", GL_FRAGMENT_SHADER},
- {"fraglight_lf_vs.glsl", GL_VERTEX_SHADER},
- {"fraglight_lf_fs.glsl", GL_FRAGMENT_SHADER},
- {"basic_lfs_vs.glsl", GL_VERTEX_SHADER},
- {"basic_lfs_fs.glsl", GL_FRAGMENT_SHADER},
- {"fraglight_lfs_vs.glsl", GL_VERTEX_SHADER},
- {"fraglight_lfs_fs.glsl", GL_FRAGMENT_SHADER},
+ // this is the master list of all shader code in shader/
+
+ {"basic_vs.glsl", GL_VERTEX_SHADER},
+ {"basic_fs.glsl", GL_FRAGMENT_SHADER},
+ {"fraglight_vs.glsl", GL_VERTEX_SHADER},
+ {"fraglight_fs.glsl", GL_FRAGMENT_SHADER},
{"basic_hf_vs.glsl", GL_VERTEX_SHADER},
{"selfx_vs.glsl", GL_VERTEX_SHADER},
{"selfx_fs.glsl", GL_FRAGMENT_SHADER},
@@ -151,7 +153,15 @@ void Shader::Setup()
{"iso_fs.glsl", GL_FRAGMENT_SHADER},
{"fast_sphere_vs.glsl", GL_VERTEX_SHADER},
{"fast_sphere_fs.glsl", GL_FRAGMENT_SHADER},
- {"outline_vs.glsl", GL_VERTEX_SHADER}
+ {"outline_vs.glsl", GL_VERTEX_SHADER},
+ {"dumpnorm_vs.glsl", GL_VERTEX_SHADER},
+ {"dumpnorm_fs.glsl", GL_FRAGMENT_SHADER},
+ {"quadpp_vs.glsl", GL_VERTEX_SHADER},
+ {"convolute1_fs.glsl", GL_FRAGMENT_SHADER},
+ {"amboccl_fs.glsl", GL_FRAGMENT_SHADER},
+ {"scenefx_vs.glsl", GL_VERTEX_SHADER},
+ {"scenefx_fs.glsl", GL_FRAGMENT_SHADER},
+ {"beacon_fs.glsl", GL_FRAGMENT_SHADER}
//////////////////////////////////////////////////////////////////
};
@@ -184,36 +194,22 @@ void Shader::Setup()
std::vector<GLuint> shader_program_list;
GLuint shader_program_id;
// basic shader
- shader_program_list.push_back(shader_code_map_["basic_lf_vs.glsl"]);
- shader_program_list.push_back(shader_code_map_["basic_lf_fs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["basic_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["basic_fs.glsl"]);
if(link_shader(shader_program_list,"basic",shader_program_id)) {
shader_program_map_["basic"]=shader_program_id;
}
// fraglight shader
shader_program_list.clear();
- shader_program_list.push_back(shader_code_map_["fraglight_lf_vs.glsl"]);
- shader_program_list.push_back(shader_code_map_["fraglight_lf_fs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["fraglight_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["fraglight_fs.glsl"]);
if(link_shader(shader_program_list,"fraglight",shader_program_id)) {
shader_program_map_["fraglight"]=shader_program_id;
}
- // basic shadow map shader
- shader_program_list.clear();
- shader_program_list.push_back(shader_code_map_["basic_lfs_vs.glsl"]);
- shader_program_list.push_back(shader_code_map_["basic_lfs_fs.glsl"]);
- if(link_shader(shader_program_list,"basic_shadow",shader_program_id)) {
- shader_program_map_["basic_shadow"]=shader_program_id;
- }
- // fraglight shader with shadow map
- shader_program_list.clear();
- shader_program_list.push_back(shader_code_map_["fraglight_lfs_vs.glsl"]);
- shader_program_list.push_back(shader_code_map_["fraglight_lfs_fs.glsl"]);
- if(link_shader(shader_program_list,"fraglight_shadow",shader_program_id)) {
- shader_program_map_["fraglight_shadow"]=shader_program_id;
- }
// basic hemisphere lighting shader
shader_program_list.clear();
shader_program_list.push_back(shader_code_map_["basic_hf_vs.glsl"]);
- shader_program_list.push_back(shader_code_map_["basic_lf_fs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["basic_fs.glsl"]);
if(link_shader(shader_program_list,"hemilight",shader_program_id)) {
shader_program_map_["hemilight"]=shader_program_id;
}
@@ -228,8 +224,8 @@ void Shader::Setup()
shader_program_list.clear();
shader_program_list.push_back(shader_code_map_["toon_vs.glsl"]);
shader_program_list.push_back(shader_code_map_["toon_fs.glsl"]);
- if(link_shader(shader_program_list,"toon",shader_program_id)) {
- shader_program_map_["toon"]=shader_program_id;
+ if(link_shader(shader_program_list,"toon1",shader_program_id)) {
+ shader_program_map_["toon1"]=shader_program_id;
}
// toon2 shader
shader_program_list.clear();
@@ -240,7 +236,7 @@ void Shader::Setup()
}
// line shader
shader_program_list.clear();
- shader_program_list.push_back(shader_code_map_["basic_lf_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["basic_vs.glsl"]);
shader_program_list.push_back(shader_code_map_["aaline_fs.glsl"]);
if(link_shader(shader_program_list,"aaline",shader_program_id)) {
shader_program_map_["aaline"]=shader_program_id;
@@ -259,19 +255,56 @@ void Shader::Setup()
if(link_shader(shader_program_list,"fast_sphere",shader_program_id)) {
shader_program_map_["fast_sphere"]=shader_program_id;
}
- // basic shader
+ // outline shader
shader_program_list.clear();
shader_program_list.push_back(shader_code_map_["outline_vs.glsl"]);
- shader_program_list.push_back(shader_code_map_["basic_lf_fs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["basic_fs.glsl"]);
if(link_shader(shader_program_list,"outline",shader_program_id)) {
shader_program_map_["outline"]=shader_program_id;
}
+ // dumpnorm shader
+ shader_program_list.clear();
+ shader_program_list.push_back(shader_code_map_["dumpnorm_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["dumpnorm_fs.glsl"]);
+ if(link_shader(shader_program_list,"dumpnorm",shader_program_id)) {
+ shader_program_map_["dumpnorm"]=shader_program_id;
+ }
+ // convolute1 shader
+ shader_program_list.clear();
+ shader_program_list.push_back(shader_code_map_["quadpp_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["convolute1_fs.glsl"]);
+ if(link_shader(shader_program_list,"convolute1",shader_program_id)) {
+ shader_program_map_["convolute1"]=shader_program_id;
+ }
+ // amboccl shader
+ shader_program_list.clear();
+ shader_program_list.push_back(shader_code_map_["quadpp_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["amboccl_fs.glsl"]);
+ if(link_shader(shader_program_list,"amboccl",shader_program_id)) {
+ shader_program_map_["amboccl"]=shader_program_id;
+ }
+ // beacon shader
+ shader_program_list.clear();
+ shader_program_list.push_back(shader_code_map_["scenefx_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["beacon_fs.glsl"]);
+ if(link_shader(shader_program_list,"beacon",shader_program_id)) {
+ shader_program_map_["beacon"]=shader_program_id;
+ }
+ // scenefx shader
+ shader_program_list.clear();
+ shader_program_list.push_back(shader_code_map_["scenefx_vs.glsl"]);
+ shader_program_list.push_back(shader_code_map_["scenefx_fs.glsl"]);
+ if(link_shader(shader_program_list,"scenefx",shader_program_id)) {
+ shader_program_map_["scenefx"]=shader_program_id;
+ }
valid_=true;
}
void Shader::Activate(const String& name)
{
+ if(!GLEW_VERSION_2_0) return;
+
if(!name.empty()) {
std::map<String, GLuint>::iterator it = shader_program_map_.find(name);
if(it!=shader_program_map_.end()) {
@@ -280,14 +313,6 @@ void Shader::Activate(const String& name)
current_program_=it->second;
current_name_=name;
- if(name=="basic_shadow" || name=="fraglight_shadow") {
- if(!Scene::Instance().GetShadow())
- Scene::Instance().SetShadow(true);
- } else {
- if(Scene::Instance().GetShadow())
- Scene::Instance().SetShadow(false);
- }
-
UpdateState();
return;
@@ -314,6 +339,7 @@ String Shader::GetCurrentName() const
bool Shader::IsValid() const
{
+ if(!GLEW_VERSION_2_0) return false;
return valid_;
}
@@ -324,11 +350,13 @@ bool Shader::IsActive() const
void Shader::PushProgram()
{
+ if(!GLEW_VERSION_2_0) return;
program_stack_.push(current_name_);
}
void Shader::PopProgram()
{
+ if(!GLEW_VERSION_2_0) return;
if(!program_stack_.empty()) {
current_name_ = program_stack_.top();
program_stack_.pop();
@@ -338,8 +366,9 @@ void Shader::PopProgram()
void Shader::UpdateState()
{
+ if(!GLEW_VERSION_2_0) return;
if(current_program_!=0) {
- // update current lighting and fog settings, valid for all shaders
+ // update all settings
GLint result;
glGetIntegerv(GL_LIGHTING,&result);
LOGN_TRACE("setting lighting flag to " << result);
@@ -352,6 +381,7 @@ void Shader::UpdateState()
LOGN_TRACE("setting fog flag to " << result);
glUniform1i(glGetUniformLocation(current_program_,"fog_flag"),result);
glDisable(GL_COLOR_MATERIAL);
+
} else {
glEnable(GL_COLOR_MATERIAL);
}
diff --git a/modules/gfx/src/shader.hh b/modules/gfx/src/shader.hh
index 054fdc37e1e98c19f27a6d29a17f20085547b895..8715e907cd9375966b3e465f674e7b31a46abab9 100644
--- a/modules/gfx/src/shader.hh
+++ b/modules/gfx/src/shader.hh
@@ -52,7 +52,6 @@ public:
void PopProgram();
void UpdateState();
-
private:
Shader();
diff --git a/modules/gfx/src/shader/amboccl_fs.glsl b/modules/gfx/src/shader/amboccl_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..894290241609d5d894144bafac56509b0d92fa22
--- /dev/null
+++ b/modules/gfx/src/shader/amboccl_fs.glsl
@@ -0,0 +1,74 @@
+uniform sampler2D depth_map;
+uniform sampler2D norm_map;
+uniform sampler1D kernel;
+uniform float step;
+uniform vec2 i_vp;
+uniform vec4 abcd;
+uniform int mode;
+
+vec3 unproject(in vec3 rpos)
+{
+ vec4 coord = gl_TextureMatrix[0]*vec4(rpos.xy*2.0-1.0,rpos.z*2.0-1.0,1.0);
+ return coord.xyz/coord.w;
+}
+
+float ao(in vec2 tab, in float depth_p, in vec3 norm_p, in vec3 t_pos_p)
+{
+ vec2 rpos = gl_TexCoord[0].xy+tab.xy*i_vp;
+ float depth_q = texture2D(depth_map,rpos).r;
+ if(mode==0) {
+ if(depth_q>=depth_p) {
+ return 0.0;
+ } else {
+ return 1.0;
+ }
+ }
+
+ vec3 t_pos_q = unproject(vec3(rpos.xy,depth_q));
+ vec3 diff=t_pos_q-t_pos_p;
+ float nd = dot(normalize(norm_p),normalize(diff));
+
+ if(mode==1) {
+ return 1.6*max(0.0,nd);
+ }
+
+ if(mode==2) {
+ float fac=1.0+dot(diff,diff)/100.0;
+ return 1.6*max(0.0,nd)/fac;
+ }
+
+ if(mode==3) {
+ // radius of imposter at distance depth_q to cover a single pixel
+ vec4 tmpv=gl_TextureMatrix[0]*vec4(-1.0,0.0,depth_q,1.0);
+ float tmpd=tmpv.x/tmpv.w;
+ tmpv=gl_TextureMatrix[0]*vec4(1.0,0.0,depth_q,1.0);
+ // 10.0 is a fudge factor
+ float rad=10.0*i_vp[0]*abs(tmpv.x/tmpv.w-tmpd);
+ float s = 6.283*(1.0-sqrt(1.0-min(1.0,rad*rad/dot(diff,diff))));
+ return s*max(0.0,nd);
+ }
+
+ return 0.0;
+}
+
+void main()
+{
+ float depth_p = texture2D(depth_map,gl_TexCoord[0].xy).r;
+ if(depth_p>=1.0) {
+ gl_FragColor = vec4(0,0,0,1);
+ return;
+ }
+ vec3 norm_p = (texture2D(norm_map,gl_TexCoord[0].xy).xyz-0.5)*2.0;
+ vec3 t_pos_p = unproject(vec3(gl_TexCoord[0].xy,depth_p));
+
+ float i;
+ float sum=0.0;
+ for(i=0.0;i<1.0;i+=step) {
+ vec2 nn=texture1D(kernel,i).xy*40.0-20.0;
+ sum+=ao(nn,depth_p,norm_p,t_pos_p);
+ }
+ sum*=step;
+
+ gl_FragColor.rgb=vec3(sum,sum,sum);
+ gl_FragColor.a=1.0;
+}
diff --git a/modules/gfx/src/shader/basic_fs.glsl b/modules/gfx/src/shader/basic_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..e38a3ada59214e98b001815bf6e9a1bc7f6007ac
--- /dev/null
+++ b/modules/gfx/src/shader/basic_fs.glsl
@@ -0,0 +1,10 @@
+uniform bool fog_flag;
+
+void main()
+{
+ float fog = fog_flag ? clamp((gl_Fog.end-gl_FogFragCoord) * gl_Fog.scale, 0.0, 1.0) : 1.0;
+ gl_FragColor.rgb = mix(gl_Fog.color.rgb, gl_Color.rgb, fog);
+ gl_FragColor.a = gl_Color.a;
+ // gl_FragBuffer[1].rgb=gl_TexCoord[0].stp*0.5+0.5;
+}
+
diff --git a/modules/gfx/src/shader/basic_hf_vs.glsl b/modules/gfx/src/shader/basic_hf_vs.glsl
index 4dbe147a6a9a9261d34038de21107c36efbf8f58..80324bf1d7a4764f719de0bff3f9dc5775b3f6e1 100644
--- a/modules/gfx/src/shader/basic_hf_vs.glsl
+++ b/modules/gfx/src/shader/basic_hf_vs.glsl
@@ -17,7 +17,10 @@ void main()
// hemisphere lighting contribution
vec3 ec_pos = vec3(gl_ModelViewMatrix* gl_Vertex);
if(lighting_flag) {
- vec3 normal = normalize(gl_NormalMatrix * gl_Normal);
+ vec3 normal = vec3(0,0,1);
+ if(dot(gl_Normal,gl_Normal)>0.001) {
+ normal = normalize(gl_NormalMatrix * gl_Normal);
+ }
vec3 l_dir = normalize(gl_LightSource[0].position.xyz); // assume directional vector
float a = 0.5+0.5*dot(normal,l_dir);
gl_FrontColor.rgb = mix(ground_color, sky_color, a).rgb;
diff --git a/modules/gfx/src/shader/basic_lfs_fs.glsl b/modules/gfx/src/shader/basic_lfs_fs.glsl
deleted file mode 100644
index 66d8b04415336972b8553a7146601e67516e6dea..0000000000000000000000000000000000000000
--- a/modules/gfx/src/shader/basic_lfs_fs.glsl
+++ /dev/null
@@ -1,33 +0,0 @@
-uniform sampler2D shadow_map;
-uniform bool shadow_flag;
-uniform float depth_bias;
-uniform float epsilon;
-uniform float shadow_multiplier;
-uniform bool fog_flag;
-
-float CalcShadowFactor(in vec4 coord, in vec2 o)
-{
- // get original depth value of line projected towards light
- float d = texture2D(shadow_map, coord.xy+o*epsilon).x+depth_bias;
- return d<=coord.z ? shadow_multiplier : 1.0;
-}
-
-void main()
-{
- float fog = fog_flag ? clamp((gl_Fog.end-gl_FogFragCoord) * gl_Fog.scale, 0.0, 1.0) : 1.0;
- if(shadow_flag) {
- vec4 coord=gl_TexCoord[1]/gl_TexCoord[1].w;
- float sum = 0.0;
- sum += 0.18*CalcShadowFactor(coord, vec2(-0.7, -0.7));
- sum += 0.18*CalcShadowFactor(coord, vec2(0.7, -0.7));
- sum += 0.18*CalcShadowFactor(coord, vec2(0.7, 0.7));
- sum += 0.18*CalcShadowFactor(coord, vec2(-0.7, 0.7));
- sum += 0.28*CalcShadowFactor(coord, vec2(0, 0));
-
- gl_FragColor = vec4(sum*mix(gl_Fog.color.rgb, gl_Color.rgb, fog),gl_Color.a);
- } else {
- gl_FragColor.rgb = mix(gl_Fog.color.rgb, gl_Color.rgb, fog);
- gl_FragColor.a = gl_Color.a;
- }
-}
-
diff --git a/modules/gfx/src/shader/basic_lfs_vs.glsl b/modules/gfx/src/shader/basic_vs.glsl
similarity index 98%
rename from modules/gfx/src/shader/basic_lfs_vs.glsl
rename to modules/gfx/src/shader/basic_vs.glsl
index 9f43289f6ab97923b819fa89c5fe71d6a6f5f43e..10cdf3a2439b017f7e922544e8f2c558e1038c16 100644
--- a/modules/gfx/src/shader/basic_lfs_vs.glsl
+++ b/modules/gfx/src/shader/basic_vs.glsl
@@ -56,6 +56,7 @@ void main()
vec4 ec_Pos = gl_ModelViewMatrix* gl_Vertex;
vec3 normal = normalize(gl_NormalMatrix * gl_Normal);
+ gl_TexCoord[0].stp = normal;
if(lighting_flag) {
CalcFrontAndBackColor(normal);
diff --git a/modules/gfx/src/shader/beacon_fs.glsl b/modules/gfx/src/shader/beacon_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..c1423640ee10ab4ff9abc34d95c000eb52a45ff6
--- /dev/null
+++ b/modules/gfx/src/shader/beacon_fs.glsl
@@ -0,0 +1,23 @@
+uniform vec3 pos;
+uniform vec3 dir;
+uniform float len;
+uniform float rad;
+uniform sampler2D depth_map;
+
+void main()
+{
+ float depth = texture2D(depth_map,gl_TexCoord[0].xy).r;
+ if(depth>=1.0) {
+ discard;
+ }
+ vec4 pcoord = vec4(gl_TexCoord[0].xy*2.0-1.0,depth*2.0-1.0,1.0);
+ vec4 coord = gl_TextureMatrix[1]*pcoord;
+ coord/=coord.w;
+
+ float d = length(cross(dir,coord.xyz-pos))/len;
+ if(d>rad) {
+ discard;
+ }
+ gl_FragColor.rgb=vec3(0,1.0,0);
+ gl_FragColor.a=min(0.9,mix(3.0,0.0,d/rad));
+}
diff --git a/modules/gfx/src/shader/convolute1_fs.glsl b/modules/gfx/src/shader/convolute1_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..3e1564ecd4662ab159ab0006eec6d1e5d2f0c1c1
--- /dev/null
+++ b/modules/gfx/src/shader/convolute1_fs.glsl
@@ -0,0 +1,25 @@
+uniform sampler2D data;
+uniform sampler1D kernel;
+uniform float step;
+uniform vec2 i_vp;
+
+void main()
+{
+ float i;
+ float sum=0.0;
+ float sum2=0.0;
+ for (i=0.0;i<1.0;i=i+step) {
+ vec3 kvalue = texture1D(kernel,i).xyz;
+ kvalue.xy=(kvalue.xy-0.5)*10.0*i_vp;
+ sum+=kvalue.z*texture2D(data,gl_TexCoord[0].xy+kvalue.xy).r;
+ sum2+=kvalue.z;
+ }
+ sum=sum/sum2;
+ float delta=5.0*(sum-texture2D(data,gl_TexCoord[0].xy).r);
+ if(delta<0.0) {
+ gl_FragColor.rgb=vec3(1.0+delta,1.0+delta,1.0+delta);
+ } else {
+ gl_FragColor.rgb=vec3(1.0,1.0,1.0);
+ }
+ gl_FragColor.a=1.0;
+}
diff --git a/modules/gfx/src/shader/dumpnorm_fs.glsl b/modules/gfx/src/shader/dumpnorm_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..09bee99284fd774c4d5a010f10b31c603d104aa9
--- /dev/null
+++ b/modules/gfx/src/shader/dumpnorm_fs.glsl
@@ -0,0 +1,5 @@
+void main()
+{
+ gl_FragColor.rgb=normalize(gl_TexCoord[0]).stp*0.5+0.5;
+}
+
diff --git a/modules/gfx/src/shader/dumpnorm_vs.glsl b/modules/gfx/src/shader/dumpnorm_vs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..f4cc4a1b43079dbd4ce92c5e101db7cec3d56d47
--- /dev/null
+++ b/modules/gfx/src/shader/dumpnorm_vs.glsl
@@ -0,0 +1,10 @@
+void main()
+{
+ gl_Position = ftransform();
+ vec3 normal = vec3(0,0,1);
+ if(dot(gl_Normal,gl_Normal)>0.001) {
+ normal = gl_NormalMatrix * gl_Normal;
+ }
+ gl_TexCoord[0].stp=normal;
+}
+
diff --git a/modules/gfx/src/shader/fast_sphere_fs.glsl b/modules/gfx/src/shader/fast_sphere_fs.glsl
index f6c47e9befe29c9e0590bd0c95cdd544da405d84..0a18ab1ad324f833e92c7be67e4edc2458b9baf7 100644
--- a/modules/gfx/src/shader/fast_sphere_fs.glsl
+++ b/modules/gfx/src/shader/fast_sphere_fs.glsl
@@ -1,6 +1,7 @@
uniform bool lighting_flag;
uniform bool two_sided_flag;
uniform bool fog_flag;
+uniform bool write_normals;
// copy from basic_fl_vs !
bool DirectionalLight(in vec3 normal,
@@ -32,6 +33,13 @@ void main()
float z1 = gl_TexCoord[0].z*zz;
float z2 = gl_TexCoord[0].w*zz;
+ gl_FragDepth = gl_FragCoord.z+z2;
+
+ if(write_normals) {
+ gl_FragColor.rgb=normal*0.5+0.5;
+ return;
+ }
+
vec4 amb = vec4(0.0);
vec4 diff = vec4(0.0);
vec4 spec = vec4(0.0);
@@ -50,5 +58,4 @@ void main()
gl_FragColor.rgb = color.rgb;
gl_FragColor.a = 1.0;
- gl_FragDepth = gl_FragCoord.z+z2;
}
diff --git a/modules/gfx/src/shader/fraglight_fs.glsl b/modules/gfx/src/shader/fraglight_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..f390283fc59c4f940a4f1203d9f270e043ac01dd
--- /dev/null
+++ b/modules/gfx/src/shader/fraglight_fs.glsl
@@ -0,0 +1,85 @@
+uniform bool lighting_flag;
+uniform bool two_sided_flag;
+uniform bool fog_flag;
+uniform bool occlusion_flag;
+uniform vec2 ambient_weight;
+varying vec4 ambient_color;
+uniform sampler2D depth_map;
+uniform int depth_mode;
+
+// copy from basic_fl_vs !
+bool DirectionalLight(in vec3 normal,
+ in float shin,
+ inout vec4 ambient,
+ inout vec4 diffuse,
+ inout vec4 specular,
+ inout bool lflag)
+{
+ float n_vp = max(0.0, dot(normal, normalize(gl_LightSource[0].position.xyz)));
+
+ float pf = 0.0;
+ lflag = n_vp>0.0;
+ if(n_vp>0.0 && shin>0.0) {
+ float n_hv = max(0.0, dot(normal, normalize(gl_LightSource[0].halfVector.xyz)));
+ pf=pow(n_hv, shin);
+ }
+
+ ambient += gl_LightSource[0].ambient;
+ diffuse += gl_LightSource[0].diffuse * n_vp;
+ specular += gl_LightSource[0].specular * pf;
+
+ return true;
+}
+
+void main()
+{
+ bool lflag=false;
+ if(lighting_flag) {
+ vec3 normal = normalize(gl_TexCoord[0].stp);
+
+ vec4 amb = vec4(0.0);
+ vec4 diff = vec4(0.0);
+ vec4 spec = vec4(0.0);
+
+ vec4 color = gl_Color;
+ if(occlusion_flag) {
+ /*
+ For ambient occlusion and local coloring, two effects are possible.
+ (1) Blending of the original fragment color and the accumulated
+ color of the neighbouring fragments, by ambient_weight[0].
+ (2) Attenuating the resulting color intensity by the ambient occlusion,
+ modulated by ambient_weight[1]
+ Only the rgb values are affected, fragment opacity is unchanged
+ */
+
+ color.rgb = mix(gl_Color.rgb,ambient_color.rgb,ambient_weight[0]);
+ color.rgb = mix(color.rgb,ambient_color.aaa*color.rgb,ambient_weight[1]);
+ }
+
+ if(DirectionalLight(normal, gl_FrontMaterial.shininess, amb, diff, spec,lflag)) {
+
+ color = gl_FrontLightModelProduct.sceneColor +
+ (amb * gl_FrontMaterial.ambient * color) +
+ (diff * gl_FrontMaterial.diffuse * color) +
+ (spec * gl_FrontMaterial.specular);
+ } else {
+ bool dummy;
+ DirectionalLight(-normal, gl_BackMaterial.shininess, amb, diff, spec, dummy);
+
+ color = gl_BackLightModelProduct.sceneColor +
+ (amb * gl_BackMaterial.ambient * color) +
+ (diff * gl_BackMaterial.diffuse * color) +
+ (spec * gl_BackMaterial.specular);
+ }
+
+ gl_FragColor = color;
+
+ } else {
+ gl_FragColor = gl_Color;
+ }
+
+ float fog = fog_flag ? clamp((gl_Fog.end-gl_FogFragCoord) * gl_Fog.scale, 0.0, 1.0) : 1.0;
+ gl_FragColor.rgb = mix(gl_Fog.color.rgb, gl_FragColor.rgb, fog);
+ gl_FragColor.a = gl_Color.a;
+ //gl_FragBuffer[1].rgb=gl_TexCoord[0].stp*0.5+0.5;
+}
diff --git a/modules/gfx/src/shader/fraglight_lf_fs.glsl b/modules/gfx/src/shader/fraglight_lf_fs.glsl
index 7ffec79b80c30e5f4daf458f3cf63bc510d6fc16..ad34b9f401a65f0b43470b519168f35195477b7f 100644
--- a/modules/gfx/src/shader/fraglight_lf_fs.glsl
+++ b/modules/gfx/src/shader/fraglight_lf_fs.glsl
@@ -2,6 +2,7 @@ uniform bool lighting_flag;
uniform bool two_sided_flag;
uniform bool fog_flag;
uniform bool occlusion_flag;
+uniform vec2 ambient_weight;
varying vec4 ambient_color;
// copy from basic_fl_vs !
@@ -34,31 +35,34 @@ void main()
vec4 amb = vec4(0.0);
vec4 diff = vec4(0.0);
vec4 spec = vec4(0.0);
- vec4 color = vec4(0.0);
- /*
- For ambient occlusion, this blends the local ambient color together with
- the fragment color at intensity given my the ambient material settings;
- ambient_color defaults to gl_Color, so for non ambient-occluded scenes,
- this is a noop
- */
- vec4 diff_color = gl_Color;
+ vec4 color = gl_Color;
if(occlusion_flag) {
- diff_color.rgb = mix(gl_Color.rgb,ambient_color.rgb,gl_FrontMaterial.ambient.rgb);
+ /*
+ For ambient occlusion and local coloring, two effects are possible.
+ (1) Blending of the original fragment color and the accumulated
+ color of the neighbouring fragments, by ambient_weight[0].
+ (2) Attenuating the resulting color intensity by the ambient occlusion,
+ modulated by ambient_weight[1]
+ Only the rgb values are affected, fragment opacity is unchanged
+ */
+
+ color.rgb = mix(gl_Color.rgb,ambient_color.rgb,ambient_weight[0]);
+ color.rgb = mix(color.rgb,ambient_color.aaa*color.rgb,ambient_weight[1]);
}
if(DirectionalLight(normal, gl_FrontMaterial.shininess, amb, diff, spec)) {
color = gl_FrontLightModelProduct.sceneColor +
- (amb * gl_FrontMaterial.diffuse * diff_color * ambient_color.a) +
- (diff * gl_FrontMaterial.diffuse * diff_color) +
+ (amb * gl_FrontMaterial.ambient * color) +
+ (diff * gl_FrontMaterial.diffuse * color) +
(spec * gl_FrontMaterial.specular);
} else {
DirectionalLight(-normal, gl_BackMaterial.shininess, amb, diff, spec);
color = gl_BackLightModelProduct.sceneColor +
- (amb * gl_BackMaterial.ambient * diff_color * ambient_color.a) +
- (diff * gl_BackMaterial.diffuse * diff_color) +
+ (amb * gl_BackMaterial.ambient * color) +
+ (diff * gl_BackMaterial.diffuse * color) +
(spec * gl_BackMaterial.specular);
}
diff --git a/modules/gfx/src/shader/fraglight_lfs_fs.glsl b/modules/gfx/src/shader/fraglight_lfs_fs.glsl
deleted file mode 100644
index d6a9580e70c5d735d1be8913be053ab56d19b8c5..0000000000000000000000000000000000000000
--- a/modules/gfx/src/shader/fraglight_lfs_fs.glsl
+++ /dev/null
@@ -1,98 +0,0 @@
-uniform sampler2D shadow_map;
-uniform bool shadow_flag;
-uniform float depth_bias;
-uniform float epsilon;
-uniform float shadow_multiplier;
-uniform bool lighting_flag;
-uniform bool two_sided_flag;
-uniform bool fog_flag;
-
-// copy from basic_lfs_fs !
-float CalcShadowFactor(in vec4 coord, in vec2 o)
-{
- // get original depth value of line projected towards light
- float d = texture2D(shadow_map, coord.xy+o*epsilon).x+depth_bias;
- return d<=coord.z ? shadow_multiplier : 1.0;
-}
-
-// modified copy from basic_fl_vs !
-bool DirectionalLight(in vec3 normal,
- in float shin,
- inout vec4 ambient,
- inout vec4 diffuse,
- inout vec4 specular,
- inout bool lflag)
-{
- float n_vp = max(0.0, dot(normal, normalize(gl_LightSource[0].position.xyz)));
-
- lflag = n_vp>0.0;
- if(n_vp==0.0 && two_sided_flag) return false;
-
- float pf = 0.0;
- if(n_vp>0.0 && shin>0.0) {
- float n_hv = max(0.0, dot(normal, normalize(gl_LightSource[0].halfVector.xyz)));
- pf=pow(n_hv, shin);
- }
-
- ambient += gl_LightSource[0].ambient;
- diffuse += gl_LightSource[0].diffuse * n_vp;
- specular += gl_LightSource[0].specular * pf;
-
- return true;
-}
-
-void main()
-{
- bool lflag=false;
-
- if(lighting_flag) {
- vec3 normal = normalize(gl_TexCoord[0].stp);
-
- vec4 amb = vec4(0.0);
- vec4 diff = vec4(0.0);
- vec4 spec = vec4(0.0);
- vec4 color = vec4(0.0);
-
- if(DirectionalLight(normal, gl_FrontMaterial.shininess, amb, diff, spec,lflag)) {
-
- color = gl_FrontLightModelProduct.sceneColor +
- (amb * gl_FrontMaterial.ambient * gl_Color) +
- (diff * gl_FrontMaterial.diffuse * gl_Color) +
- (spec * gl_FrontMaterial.specular);
- } else {
- bool dummy;
- DirectionalLight(-normal, gl_BackMaterial.shininess, amb, diff, spec, dummy);
-
- color = gl_BackLightModelProduct.sceneColor +
- (amb * gl_BackMaterial.ambient * gl_Color) +
- (diff * gl_BackMaterial.diffuse * gl_Color) +
- (spec * gl_BackMaterial.specular);
-
- }
-
- gl_FragColor = color;
-
- } else {
- gl_FragColor = gl_Color;
- }
-
- float fog = fog_flag ? clamp((gl_Fog.end-gl_FogFragCoord) * gl_Fog.scale, 0.0, 1.0) : 1.0;
- if(shadow_flag) {
- vec4 coord = gl_TexCoord[1]/gl_TexCoord[1].w;
- float sum = 0.0;
- if(lflag) {
- sum += 0.18*CalcShadowFactor(coord, vec2(-0.7, -0.7));
- sum += 0.18*CalcShadowFactor(coord, vec2(0.7, -0.7));
- sum += 0.18*CalcShadowFactor(coord, vec2(0.7, 0.7));
- sum += 0.18*CalcShadowFactor(coord, vec2(-0.7, 0.7));
- sum += 0.28*CalcShadowFactor(coord, vec2(0, 0));
- } else {
- sum = shadow_multiplier;
- }
-
- gl_FragColor = vec4(sum*mix(gl_Fog.color.rgb, gl_FragColor.rgb, fog),gl_FragColor.a);
- } else {
- gl_FragColor.rgb = mix(gl_Fog.color.rgb, gl_FragColor.rgb, fog);
- gl_FragColor.a = gl_Color.a;
- }
-}
diff --git a/modules/gfx/src/shader/fraglight_lfs_vs.glsl b/modules/gfx/src/shader/fraglight_vs.glsl
similarity index 67%
rename from modules/gfx/src/shader/fraglight_lfs_vs.glsl
rename to modules/gfx/src/shader/fraglight_vs.glsl
index 7052797e33abc2ce78b547e54a762d52bd0d9aa4..9b1856d12cd8920f0b87e7306385377f0b6237a4 100644
--- a/modules/gfx/src/shader/fraglight_lfs_vs.glsl
+++ b/modules/gfx/src/shader/fraglight_vs.glsl
@@ -1,3 +1,6 @@
+uniform bool occlusion_flag;
+varying vec4 ambient_color;
+
void main()
{
// transformed position
@@ -14,6 +17,14 @@ void main()
// shadow map projection coords
gl_TexCoord[1] = gl_TextureMatrix[0] * gl_Vertex;
+ if(occlusion_flag) {
+ // ambient occlusion and color terms
+ ambient_color = gl_MultiTexCoord0;
+ } else {
+ ambient_color.rgb = gl_Color.rgb;
+ ambient_color.a = 1.0;
+ }
gl_FrontColor=gl_Color;
gl_BackColor=gl_Color;
}
+
diff --git a/modules/gfx/src/shader/quadpp_vs.glsl b/modules/gfx/src/shader/quadpp_vs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..043c65d69b2d1a4f96d705cc84d12ba9b847d592
--- /dev/null
+++ b/modules/gfx/src/shader/quadpp_vs.glsl
@@ -0,0 +1,6 @@
+void main()
+{
+ gl_Position = ftransform();
+ gl_TexCoord[0] = gl_MultiTexCoord0;
+}
+
diff --git a/modules/gfx/src/shader/scenefx_fs.glsl b/modules/gfx/src/shader/scenefx_fs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..277647ee47f603fa25782d291142f4ec30463231
--- /dev/null
+++ b/modules/gfx/src/shader/scenefx_fs.glsl
@@ -0,0 +1,58 @@
+uniform sampler2D scene_map;
+uniform sampler2D depth_map;
+uniform vec2 i_vp;
+uniform bool shadow_flag;
+uniform sampler2D shadow_map;
+uniform float shadow_weight;
+uniform float shadow_depth_bias;
+uniform float shadow_epsilon;
+uniform float shadow_multiplier;
+uniform bool occl_flag;
+uniform sampler2D occl_map;
+uniform float occl_mult;
+uniform bool dark_flag;
+uniform sampler2D dark_map;
+uniform float dark_mult;
+
+float CalcShadowFactor(in vec4 coord, in vec2 o)
+{
+ // get original depth value of line projected towards light
+ float d = texture2D(shadow_map, coord.xy+o*shadow_epsilon).x+shadow_depth_bias;
+ return d<=coord.z ? shadow_multiplier : 1.0;
+}
+
+void main()
+{
+ float depth = texture2D(depth_map,gl_TexCoord[0].xy).r;
+ if(depth>=1.0) {
+ discard;
+ }
+ vec4 scene_color=texture2D(scene_map,gl_TexCoord[0].xy);
+ gl_FragColor.a = scene_color.a;
+
+ float shadow_factor=1.0;
+ if(shadow_flag) {
+ vec4 pcoord = vec4(gl_TexCoord[0].xy*2.0-1.0,depth*2.0-1.0,1.0);
+ vec4 coord = gl_TextureMatrix[2]*pcoord;
+ coord/=coord.w;
+ shadow_factor = 0.0;
+ shadow_factor += 0.18*CalcShadowFactor(coord, vec2(-0.7, -0.7));
+ shadow_factor += 0.18*CalcShadowFactor(coord, vec2(0.7, -0.7));
+ shadow_factor += 0.18*CalcShadowFactor(coord, vec2(0.7, 0.7));
+ shadow_factor += 0.18*CalcShadowFactor(coord, vec2(-0.7, 0.7));
+ shadow_factor += 0.28*CalcShadowFactor(coord, vec2(0, 0));
+ shadow_factor = mix(1.0, shadow_factor, shadow_weight);
+ }
+
+ float occl_factor=1.0;
+ if(occl_flag) {
+ occl_factor=max(0.0,1.0-occl_mult*texture2D(occl_map,gl_TexCoord[0].xy).r);
+ }
+
+ float dark_factor=1.0;
+ if(dark_flag) {
+ dark_factor=max(0.0,1.0-dark_mult*(1.0-texture2D(dark_map,gl_TexCoord[0].xy).r));
+ }
+
+ gl_FragColor.rgb = shadow_factor*occl_factor*dark_factor*scene_color.rgb;
+}
diff --git a/modules/gfx/src/shader/scenefx_vs.glsl b/modules/gfx/src/shader/scenefx_vs.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..6732327afc56aaee4a7fc353ed0c2e26d58c6f5b
--- /dev/null
+++ b/modules/gfx/src/shader/scenefx_vs.glsl
@@ -0,0 +1,7 @@
+void main()
+{
+ gl_Position = ftransform();
+ // relative screen coordinates
+ gl_TexCoord[0] = gl_MultiTexCoord0;
+}
+
diff --git a/modules/gfx/src/shader/toon_vs.glsl b/modules/gfx/src/shader/toon_vs.glsl
index 1913f445eaf04f43bdce4d9e9dea6a4021777e8c..3eb50da66c4c31edbee7d197fa2e21e8a2b87bf4 100644
--- a/modules/gfx/src/shader/toon_vs.glsl
+++ b/modules/gfx/src/shader/toon_vs.glsl
@@ -7,7 +7,10 @@ void main()
// for some reason, the fog and z coordinate are sign toggled...
gl_FogFragCoord = -ec_Pos.z;
- vec3 normal = normalize(gl_NormalMatrix * gl_Normal);
+ vec3 normal = vec3(0,0,1);
+ if(dot(gl_Normal,gl_Normal)>0.001) {
+ normal = normalize(gl_NormalMatrix * gl_Normal);
+ }
// since a directional light is used, the position is not needed
gl_TexCoord[0].stp=normal;
diff --git a/modules/gfx/src/surface.cc b/modules/gfx/src/surface.cc
index dbf740077238e34c36356fe58e35cdeb473d8b51..6ffae62e6dabef375cac9d900d2b67b9bfcf008e 100644
--- a/modules/gfx/src/surface.cc
+++ b/modules/gfx/src/surface.cc
@@ -43,14 +43,18 @@ Surface::Surface(const String& name, const mol::SurfaceHandle& sh):
recalc_bb_(true)
{
// TODO replace with def mat for this gfx obj type
- SetMat(0.0,1.0,0.2,48.0);
+ SetMatAmb(Color(0,0,0));
+ SetMatDiff(Color(1,1,1));
+ SetMatSpec(Color(0.2,0.2,0.2));
+ SetMatShin(48);
Rebuild();
}
void Surface::CustomRenderGL(RenderPass pass)
{
- if(pass>0) return;
- va_.RenderGL();
+ if(pass==STANDARD_RENDER_PASS) {
+ va_.RenderGL();
+ }
}
void Surface::CustomRenderPov(PovState& pov)
@@ -164,10 +168,11 @@ geom::AlignedCuboid Surface::GetBoundingBox() const
void Surface::CustomPreRenderGL(bool flag)
{
+ va_.FlagRefresh();
if(flag) {
//Rebuild();
} else {
- RefreshVA(va_);
+ //RefreshVA(va_);
}
}
@@ -244,28 +249,30 @@ void Surface::ColorBy(const String& prop,
void Surface::Apply(const gfx::UniformColorOp& op, bool store){
if(store){
- UniformColorOp* op_ptr = new UniformColorOp(op);
+ UniformColorOp* op_ptr = new UniformColorOp(op);
this->AppendColorOp(op_ptr);
}
mol::Query q(op.GetSelection());
gfx::Color col = op.GetColor();
if(op.GetSelection()=="") {
- for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
- va_.SetColor(it->second,col);
- }
+ for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
+ va_.SetColor(it->second,col);
+ }
} else {
- for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
- mol::AtomHandle ah = sh_.GetVertex(it->first).atom;
- if(ah.IsValid()) {
- if(q.IsAtomSelected(ah)) {
- va_.SetColor(it->second,col);
- }
- }
- }
+ for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
+ mol::AtomHandle ah = sh_.GetVertex(it->first).atom;
+ if(ah.IsValid()) {
+ if(q.IsAtomSelected(ah)) {
+ va_.SetColor(it->second,col);
+ }
+ }
+ }
}
FlagRefresh();
}
-void Surface::Apply(const gfx::BasicGradientColorOp& op, bool store){
+
+void Surface::Apply(const gfx::BasicGradientColorOp& op, bool store)
+{
if(store){
BasicGradientColorOp* op_ptr = new BasicGradientColorOp(op);
this->AppendColorOp(op_ptr);
@@ -279,23 +286,24 @@ void Surface::Apply(const gfx::BasicGradientColorOp& op, bool store){
mol::EntityPropertyMapper epm(prop, level);
std::vector<std::pair<VertexID,float> > v2v;
for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
- mol::AtomHandle ah = sh_.GetVertex(it->first).atom;
- if(ah.IsValid()) {
- float v = epm.Get(ah);
- v2v.push_back(std::make_pair(it->second,v));
- minv=std::min(minv,v);
- maxv=std::max(maxv,v);
- }
+ mol::AtomHandle ah = sh_.GetVertex(it->first).atom;
+ if(ah.IsValid()) {
+ float v = epm.Get(ah);
+ v2v.push_back(std::make_pair(it->second,v));
+ minv=std::min(minv,v);
+ maxv=std::max(maxv,v);
+ }
}
-
+
// reuse values for speed optimization
for(std::vector<std::pair<VertexID,float> >::const_iterator it=v2v.begin();it!=v2v.end();++it) {
- va_.SetColor(it->first,gradient.GetColorAt(normalize(it->second,minv,maxv)));
+ va_.SetColor(it->first,gradient.GetColorAt(normalize(it->second,minv,maxv)));
}
FlagRefresh();
}
-void Surface::Apply(const gfx::GradientLevelColorOp& op, bool store){
+void Surface::Apply(const gfx::GradientLevelColorOp& op, bool store)
+{
if(store){
GradientLevelColorOp* op_ptr = new GradientLevelColorOp(op);
this->AppendColorOp(op_ptr);
@@ -309,15 +317,16 @@ void Surface::Apply(const gfx::GradientLevelColorOp& op, bool store){
// for the attached atoms
mol::EntityPropertyMapper epm(prop, level);
for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
- mol::AtomHandle ah = sh_.GetVertex(it->first).atom;
- if(ah.IsValid()) {
- va_.SetColor(it->second,gradient.GetColorAt(normalize(epm.Get(ah),minv,maxv)));
- }
+ mol::AtomHandle ah = sh_.GetVertex(it->first).atom;
+ if(ah.IsValid()) {
+ va_.SetColor(it->second,gradient.GetColorAt(normalize(epm.Get(ah),minv,maxv)));
+ }
}
FlagRefresh();
}
-void Surface::Apply(const gfx::EntityViewColorOp& op, bool store){
+void Surface::Apply(const gfx::EntityViewColorOp& op, bool store)
+{
if(store){
EntityViewColorOp* op_ptr = new EntityViewColorOp(op);
this->AppendColorOp(op_ptr);
@@ -328,14 +337,15 @@ void Surface::Apply(const gfx::EntityViewColorOp& op, bool store){
float minv = op.GetMinV();
float maxv = op.GetMaxV();
for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
- va_.SetColor(it->second,impl::MappedProperty(ev,prop,g,minv,maxv,
- sh_.GetVertex(it->first).position));
+ va_.SetColor(it->second,impl::MappedProperty(ev,prop,g,minv,maxv,
+ sh_.GetVertex(it->first).position));
}
FlagRefresh();
}
-
+
#if OST_IMG_ENABLED
-void Surface::Apply(const gfx::MapHandleColorOp& op, bool store){
+void Surface::Apply(const gfx::MapHandleColorOp& op, bool store)
+{
if(store){
MapHandleColorOp* op_ptr = new MapHandleColorOp(op);
this->AppendColorOp(op_ptr);
@@ -346,17 +356,19 @@ void Surface::Apply(const gfx::MapHandleColorOp& op, bool store){
float minv = op.GetMinV();
float maxv = op.GetMaxV();
for(VMap::const_iterator it=vmap_.begin();it!=vmap_.end();++it) {
- va_.SetColor(it->second,impl::MappedProperty(mh,prop,g,minv,maxv,sh_.GetVertex(it->first).position));
+ va_.SetColor(it->second,impl::MappedProperty(mh,prop,g,minv,maxv,sh_.GetVertex(it->first).position));
}
FlagRefresh();
}
#endif //OST_IMG_ENABLED
-void Surface::CleanColorOps(){
+void Surface::CleanColorOps()
+{
GfxObj::CleanColorOps();
}
-void Surface::ReapplyColorOps(){
+void Surface::ReapplyColorOps()
+{
GfxObj::ReapplyColorOps();
}
diff --git a/modules/gfx/src/vertex_array.cc b/modules/gfx/src/vertex_array.cc
index 970c0988762301883084e992ef948ac4529f4906..3551ab8ada8b31dbc3627604468353b16dfc385e 100644
--- a/modules/gfx/src/vertex_array.cc
+++ b/modules/gfx/src/vertex_array.cc
@@ -31,8 +31,6 @@
#include "vertex_array_helper.hh"
#include "povray.hh"
-#include "impl/calc_ambient.hh"
-
#if OST_SHADER_SUPPORT_ENABLED
#include "shader.hh"
#endif
@@ -77,7 +75,7 @@ IndexedVertexArray::Entry::Entry(const Vec3& vv, const Vec3& nn, const Color& cc
IndexedVertexArray::IndexedVertexArray()
{
initialized_=false;
- Clear(); // replaces ctor initialization list
+ Reset(); // replaces ctor initialization list
}
IndexedVertexArray::~IndexedVertexArray()
@@ -142,7 +140,6 @@ VertexID IndexedVertexArray::Add(const Vec3& vert,
const Color& col)
{
dirty_=true;
- ambient_dirty_=true;
entry_list_.push_back(Entry(vert,norm,col));
return entry_list_.size()-1;
}
@@ -163,7 +160,6 @@ LineID IndexedVertexArray::AddLine(VertexID id0, VertexID id1)
{
assert(id0<entry_list_.size() && id1<entry_list_.size());
dirty_=true;
- ambient_dirty_=true;
line_index_list_.push_back(id0);
line_index_list_.push_back(id1);
return line_index_list_.size()-2;
@@ -173,7 +169,6 @@ TriID IndexedVertexArray::AddTri(VertexID id0, VertexID id1, VertexID id2)
{
assert(id0<entry_list_.size() && id1<entry_list_.size() && id2<entry_list_.size());
dirty_=true;
- ambient_dirty_=true;
tri_index_list_.push_back(id0);
tri_index_list_.push_back(id1);
tri_index_list_.push_back(id2);
@@ -203,7 +198,6 @@ QuadID IndexedVertexArray::AddQuad(VertexID id0, VertexID id1, VertexID id2, Ver
{
assert(id0<entry_list_.size() && id1<entry_list_.size() && id2<entry_list_.size() && id3<entry_list_.size());
dirty_=true;
- ambient_dirty_=true;
quad_index_list_.push_back(id0);
quad_index_list_.push_back(id1);
quad_index_list_.push_back(id2);
@@ -214,7 +208,6 @@ QuadID IndexedVertexArray::AddQuad(VertexID id0, VertexID id1, VertexID id2, Ver
void IndexedVertexArray::AddSphere(const SpherePrim& prim, unsigned int detail)
{
dirty_=true;
- ambient_dirty_=true;
unsigned int level= std::min(VA_SPHERE_MAX_DETAIL,detail);
@@ -235,7 +228,6 @@ void IndexedVertexArray::AddSphere(const SpherePrim& prim, unsigned int detail)
void IndexedVertexArray::AddIcoSphere(const SpherePrim& prim, unsigned int detail)
{
dirty_=true;
- ambient_dirty_=true;
unsigned int level= std::min(VA_ICO_SPHERE_MAX_DETAIL,detail);
@@ -249,43 +241,63 @@ void IndexedVertexArray::AddIcoSphere(const SpherePrim& prim, unsigned int detai
}
}
-void IndexedVertexArray::AddCylinder(const CylinderPrim& prim, unsigned int detail)
+void IndexedVertexArray::AddCylinder(const CylinderPrim& prim, unsigned int detail,bool cap)
{
dirty_=true;
- ambient_dirty_=true;
unsigned int level = std::min(VA_CYL_MAX_DETAIL,detail);
const std::vector<Vec3>& vlist = detail::GetPrebuildCyl(level);
Vec3 off(0.0,0.0,prim.length);
+
+ Vec3 cn0 = cap ? prim.rotmat* geom::Vec3(0.0,0.0,-1.0) : Vec3();
+ Vec3 cn1 = -cn0;
+ VertexID cid0 = cap ? Add(prim.start, cn0 , prim.color1) : 0;
+ VertexID cid7 = cap ? Add(prim.rotmat * off + prim.start, cn1, prim.color2) : 0;
// prepare first vertices to add
std::vector<Vec3>::const_iterator it=vlist.begin();
Vec3 v0 = (*it);
Vec3 n0 = prim.rotmat * v0;
v0*=prim.radius;
- VertexID id1 = Add(prim.rotmat * v0 + prim.start, n0, prim.color);
- VertexID id2 = Add(prim.rotmat * (v0+off) + prim.start, n0, prim.color);
+ VertexID id1 = Add(prim.rotmat * v0 + prim.start, n0, prim.color1);
+ VertexID id2 = Add(prim.rotmat * (v0+off) + prim.start, n0, prim.color2);
+ VertexID cid1 = cap ? Add(prim.rotmat * v0 + prim.start, cn0, prim.color1) : 0;
+ VertexID cid2 = cap ? Add(prim.rotmat * (v0+off) + prim.start, cn1, prim.color2) : 0;
// now for the loop around the circle
VertexID id3=id1;
VertexID id4=id2;
+ VertexID cid3=cid1;
+ VertexID cid4=cid2;
++it;
for(;it!=vlist.end();++it) {
v0 = (*it);
n0 = prim.rotmat * v0;
v0 *= prim.radius;
- VertexID id5 = Add(prim.rotmat * v0 + prim.start, n0, prim.color);
- VertexID id6 = Add(prim.rotmat * (v0+off) + prim.start, n0, prim.color);
+ VertexID id5 = Add(prim.rotmat * v0 + prim.start, n0, prim.color1);
+ VertexID id6 = Add(prim.rotmat * (v0+off) + prim.start, n0, prim.color2);
AddTri(id3,id5,id4);
AddTri(id5,id6,id4);
+ if(cap) {
+ VertexID cid5 = Add(prim.rotmat * v0 + prim.start, cn0, prim.color1);
+ VertexID cid6 = Add(prim.rotmat * (v0+off) + prim.start, cn1, prim.color2);
+ AddTri(cid0,cid5,cid3);
+ AddTri(cid7,cid4,cid6);
+ cid3=cid5;
+ cid4=cid6;
+ }
id3=id5;
id4=id6;
}
// and finally close the circle
AddTri(id3,id1,id4);
AddTri(id1,id2,id4);
+ if(cap) {
+ AddTri(cid0,cid1,cid3);
+ AddTri(cid7,cid4,cid2);
+ }
}
Vec3 IndexedVertexArray::GetVert(VertexID id) const
@@ -340,6 +352,17 @@ void IndexedVertexArray::SetColor(VertexID id, const Color& c)
entry_list_[id].c[3]=c[3];
}
+void IndexedVertexArray::SetOpacity(float o)
+{
+ o=std::max(0.0f,std::min(1.0f,o));
+ // this should really just set a value in the shader...
+ // but we need to support the fixed function pipeline as well
+ for(EntryList::iterator it=entry_list_.begin();it!=entry_list_.end();++it) {
+ it->c[3]=o;
+ }
+ FlagRefresh();
+}
+
void IndexedVertexArray::RenderGL()
{
static bool use_buff=false;
@@ -347,7 +370,9 @@ void IndexedVertexArray::RenderGL()
if(!initialized_) {
LOGN_DUMP("initializing vertex array lists");
#if OST_SHADER_SUPPORT_ENABLED
- glGenBuffers(7,buffer_id_);
+ if(!Scene::Instance().InOffscreenMode()) {
+ glGenBuffers(7,buffer_id_);
+ }
#endif
outline_mat_dlist_=glGenLists(1);
initialized_=true;
@@ -356,11 +381,6 @@ void IndexedVertexArray::RenderGL()
if(dirty_) {
dirty_=false;
#if OST_SHADER_SUPPORT_ENABLED
- if(ambient_dirty_ && use_ambient_) {
- LOGN_DUMP("re-calculating ambient occlusion terms");
- recalc_ambient_occlusion();
- ambient_dirty_=false;
- }
LOGN_DUMP("checking buffer object availability");
if(mode_&0x2 && aalines_flag_) {
@@ -369,6 +389,7 @@ void IndexedVertexArray::RenderGL()
use_buff=prep_buff();
}
if(!use_buff) {
+ LOGN_DUMP("buffer not available");
glBindBuffer(GL_ARRAY_BUFFER,0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
} else {
@@ -441,11 +462,6 @@ void IndexedVertexArray::RenderGL()
} else {
glDisable(GL_CULL_FACE);
}
-#if OST_SHADER_SUPPORT_ENABLED
- if(use_ambient_ && !ambient_data_.empty()) {
- glUniform1i(glGetUniformLocation(Shader::Instance().GetCurrentProgram(),"occlusion_flag"),1);
- }
-#endif
}
if(mode_&0x1) {
@@ -511,12 +527,6 @@ void IndexedVertexArray::RenderGL()
}
}
-#if OST_SHADER_SUPPORT_ENABLED
- if(use_ambient_) {
- glUniform1i(glGetUniformLocation(Shader::Instance().GetCurrentProgram(),"occlusion_flag"),0);
- }
-#endif
-
if(draw_normals_) {
//glColor3f(1,0,0);
glBegin(GL_LINES);
@@ -539,13 +549,16 @@ void IndexedVertexArray::RenderGL()
namespace {
unsigned int col_to_index(float* c)
{
- return static_cast<unsigned int>(c[0]*7.0)*64+static_cast<unsigned int>(c[1]*7.0)*8+static_cast<unsigned int>(c[2]*7.0);
+ // don't look too closely - I am lacking sufficient caffeine to do this more elegantly
+ int ret= std::max(0,std::min<int>(511,static_cast<int>(round(c[0]*7.0f))*64+static_cast<int>(round(c[1]*7.0f))*8+static_cast<unsigned int>(round(c[2]*7.0f))));
+ return static_cast<unsigned int>(ret);
}
}
void IndexedVertexArray::RenderPov(PovState& pov, const std::string& name)
{
if(entry_list_.empty()) return;
+
pov.inc() << "mesh2 {\n";
pov.inc() << " vertex_vectors { " << entry_list_.size() << ",\n";
@@ -607,15 +620,19 @@ void IndexedVertexArray::RenderPov(PovState& pov, const std::string& name)
pov.inc() << "}\n";
}
-void IndexedVertexArray::Clear()
+void IndexedVertexArray::Clear()
{
dirty_=true;
- ambient_dirty_=true;
entry_list_.clear();
quad_index_list_.clear();
tri_index_list_.clear();
line_index_list_.clear();
ntentry_list_.clear();
+}
+
+void IndexedVertexArray::Reset()
+{
+ Clear();
mode_=0x4;
poly_mode_=2;
lighting_=true;
@@ -633,8 +650,6 @@ void IndexedVertexArray::Clear()
outline_exp_factor_=0.1;
outline_exp_color_=Color(0,0,0);
draw_normals_=false;
- use_ambient_=false;
- ambient_data_.clear();
}
void IndexedVertexArray::FlagRefresh()
@@ -907,36 +922,6 @@ void IndexedVertexArray::SmoothVertices(float smoothf)
}
}
-void IndexedVertexArray::UseAmbient(bool f)
-{
- if(use_ambient_==f) return;
- use_ambient_=f;
- FlagRefresh();
-}
-
-Color IndexedVertexArray::GetAmbientColor(VertexID id) const
-{
- Color nrvo;
- if(id*4>=ambient_data_.size()) return nrvo;
- unsigned int offset=id*4;
- nrvo = Color(ambient_data_[offset+0],
- ambient_data_[offset+1],
- ambient_data_[offset+2],
- ambient_data_[offset+3]);
- return nrvo;
-}
-
-void IndexedVertexArray::SetAmbientColor(VertexID id, const Color& c)
-{
- if(id*4>=ambient_data_.size()) return;
- unsigned int offset=id*4;
- ambient_data_[offset+0]=c[0];
- ambient_data_[offset+1]=c[1];
- ambient_data_[offset+2]=c[2];
- ambient_data_[offset+3]=c[3];
-}
-
-
namespace {
uint npatch_tab_id(uint u, uint v, uint N)
@@ -1042,7 +1027,6 @@ void IndexedVertexArray::copy(const IndexedVertexArray& va)
line_index_list_=va.line_index_list_;
ntentry_list_=va.ntentry_list_;
dirty_=true;
- ambient_dirty_=va.ambient_dirty_;
mode_=va.mode_;
poly_mode_=va.poly_mode_;
lighting_=va.lighting_;
@@ -1060,12 +1044,11 @@ void IndexedVertexArray::copy(const IndexedVertexArray& va)
outline_exp_factor_=va.outline_exp_factor_;
outline_exp_color_=va.outline_exp_color_;
draw_normals_=va.draw_normals_;
- use_ambient_=va.use_ambient_;
- ambient_data_=va.ambient_data_;
}
bool IndexedVertexArray::prep_buff()
{
+ if(Scene::Instance().InOffscreenMode()) return false;
#if OST_SHADER_SUPPORT_ENABLED
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
@@ -1130,24 +1113,6 @@ bool IndexedVertexArray::prep_buff()
VERTEX_ARRAY_CHECK_GL_ERROR("set qindex buf");
}
- if(use_ambient_) {
- if(ambient_data_.empty()) {
- LOGN_VERBOSE("ambient data empty");
- glDisableClientState(GL_TEXTURE_COORD_ARRAY);
- } else {
- glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- glBindBuffer(GL_ARRAY_BUFFER, buffer_id_[VA_AMBIENT_BUFFER]);
- VERTEX_ARRAY_CHECK_GL_ERROR("bind ambient buf");
- glBufferData(GL_ARRAY_BUFFER,
- sizeof(float) * ambient_data_.size(),
- &ambient_data_[0],
- GL_STATIC_DRAW);
- VERTEX_ARRAY_CHECK_GL_ERROR("set ambient buf");
- }
- } else {
- glDisableClientState(GL_TEXTURE_COORD_ARRAY);
- }
-
return true;
#else
return false;
@@ -1174,12 +1139,6 @@ void IndexedVertexArray::draw_ltq(bool use_buff)
glInterleavedArrays(GetFormat(),sizeof(Entry),NULL);
#endif
- if(use_ambient_) {
- if(!ambient_data_.empty()) {
- glBindBuffer(GL_ARRAY_BUFFER, buffer_id_[VA_AMBIENT_BUFFER]);
- glTexCoordPointer(4,GL_FLOAT,0,NULL);
- }
- }
glBindBuffer(GL_ARRAY_BUFFER,0);
if(!tri_index_list_.empty() && (mode_ & 0x4)) {
@@ -1410,10 +1369,4 @@ void IndexedVertexArray::draw_line_halo(bool use_buff)
glLineWidth(line_width_);
}
-void IndexedVertexArray::recalc_ambient_occlusion()
-{
- ambient_data_.resize(4*entry_list_.size());
- CalcAmbientTerms(*this);
-}
-
}} // ns
diff --git a/modules/gfx/src/vertex_array.hh b/modules/gfx/src/vertex_array.hh
index eed4d2a7fdc97f4d3f92c3f883ed5caaed50e316..c1916dc7ffe52f091c7a4e7adccedf530f87b9b8 100644
--- a/modules/gfx/src/vertex_array.hh
+++ b/modules/gfx/src/vertex_array.hh
@@ -134,7 +134,7 @@ class DLLEXPORT_OST_GFX IndexedVertexArray {
// add an icosahedral based sphere with the given params to the va
void AddIcoSphere(const SpherePrim& prim, unsigned int detail);
- void AddCylinder(const CylinderPrim& prim, unsigned int detail);
+ void AddCylinder(const CylinderPrim& prim, unsigned int detail,bool cap=false);
geom::Vec3 GetVert(VertexID id) const;
void SetVert(VertexID id, const geom::Vec3& vert);
@@ -145,19 +145,30 @@ class DLLEXPORT_OST_GFX IndexedVertexArray {
Color GetColor(VertexID id) const;
void SetColor(VertexID id, const Color& col);
+ void SetOpacity(float o);
+
// OpenGL rendering call
void RenderGL();
// POVray export
void RenderPov(PovState& pov, const std::string& name);
-
+ // only removes the drawing elements
void Clear();
+ // removes all elements and resets internal state to default
+ void Reset();
+
+ // forces re-calculation of some buffered features
void FlagRefresh();
- void CalcNormals(float smoothf);
+ // for debugging, draw all normals
void DrawNormals(bool f);
+ // NOTE: all methods below could be delegated to the outside,
+ // using the GetEntries() and Get*Indices() member functions
+
+ // experimental, do not use
+ void CalcNormals(float smoothf);
// experimental, do not use
void CalcFullNormals();
// experimental, do not use
@@ -166,17 +177,13 @@ class DLLEXPORT_OST_GFX IndexedVertexArray {
void NPatch();
// experimental, do not use
void SmoothVertices(float smoothf);
- // experimental, do not use
- void UseAmbient(bool f);
+
const EntryList& GetEntries() const {return entry_list_;}
const IndexList& GetQuadIndices() const {return quad_index_list_;}
const IndexList& GetTriIndices() const {return tri_index_list_;}
const IndexList& GetLineIndices() const {return line_index_list_;}
- Color GetAmbientColor(VertexID id) const;
- void SetAmbientColor(VertexID id, const Color& col);
-
private:
bool initialized_;
@@ -211,17 +218,12 @@ class DLLEXPORT_OST_GFX IndexedVertexArray {
unsigned int buffer_id_[7]; // magic number related to the .cc buffer use
- bool use_ambient_;
- bool ambient_dirty_;
- std::vector<float> ambient_data_;
-
void copy(const IndexedVertexArray& va);
bool prep_buff();
void draw_ltq(bool use_buff);
void draw_p(bool use_buff);
void draw_aalines();
void draw_line_halo(bool use_buff);
- void recalc_ambient_occlusion();
};
}} // ns
diff --git a/modules/gui/pymod/export_gosty.cc b/modules/gui/pymod/export_gosty.cc
index 9cd97b7fdabdc80c208a521c47e50b136d5babb1..ba5d47ea36010ffb498672079e3411d604489e56 100644
--- a/modules/gui/pymod/export_gosty.cc
+++ b/modules/gui/pymod/export_gosty.cc
@@ -116,6 +116,7 @@ void export_Gosty()
.def("AddWidgetToApp", &app_add_widget_to_app_b)
.def("GetPerspective", &GostyApp::GetPerspective,
return_value_policy<reference_existing_object>())
+ .def("TryStereo",&GostyApp::TryStereo)
;
register_ptr_to_python<GostyApp*>();
}
diff --git a/modules/gui/pymod/scene/cpk_widget.py b/modules/gui/pymod/scene/cpk_widget.py
index 5f6c7de3c5206bed6490293133b8b6ac69f14221..d57b21591bb56b1ee3f9d71d160502fb66bffd4c 100644
--- a/modules/gui/pymod/scene/cpk_widget.py
+++ b/modules/gui/pymod/scene/cpk_widget.py
@@ -42,7 +42,10 @@ class CPKWidget(RenderModeWidget):
self.sphere_spinbox_ = QtGui.QSpinBox()
self.sphere_spinbox_.setRange(min_sphere_detail, max_sphere_detail)
-
+ cpk_mode_label = QtGui.QLabel("Rendering Mode")
+ self.cpk_mode_ = QtGui.QComboBox()
+ self.cpk_mode_.addItem("Triangles")
+ self.cpk_mode_.addItem("3D Sprites")
cpk_label = QtGui.QLabel(self.text_)
font = cpk_label.font()
font.setBold(True)
@@ -56,14 +59,19 @@ class CPKWidget(RenderModeWidget):
self.setLayout(grid)
QtCore.QObject.connect(self.sphere_spinbox_, QtCore.SIGNAL("valueChanged(int)"), self.UpdateSphereDetail)
+ QtCore.QObject.connect(self.cpk_mode_, QtCore.SIGNAL("currentIndexChanged(int)"), self.UpdateSphereMode)
self.setMinimumSize(250,60)
def UpdateSphereDetail(self, value):
self.GetOptions().SetSphereDetail(value)
+
+ def UpdateSphereMode(self, value):
+ self.GetOptions().SetSphereMode(value)
def UpdateGui(self,options):
self.sphere_spinbox_.setValue(options.GetSphereDetail())
+ self.cpk_mode_.setCurrentIndex(options.GetSphereMode())
def GetText(self):
return self.text_
diff --git a/modules/gui/src/gl_canvas.cc b/modules/gui/src/gl_canvas.cc
index 320cc3d0f129f046c9f52aa5ed775cee31a6d7d4..71923254716df1069a4d2e3d281b30e1bb930e60 100644
--- a/modules/gui/src/gl_canvas.cc
+++ b/modules/gui/src/gl_canvas.cc
@@ -47,14 +47,19 @@ using gfx::Scene;
GLCanvas::GLCanvas(GLWin* gl_win, QWidget* parent, const QGLFormat& f):
QGLWidget(f,parent),
- glwin_(gl_win)
+ glwin_(gl_win),
+ mouse_key_mask_(),
+ refresh_(true),
+ master_timer_(),
+ bench_flag_(false),
+ last_pos_(),
+ scene_menu_(NULL),
+ show_beacon_(false)
{
if(!isValid()) return;
- refresh_=true;
master_timer_.start(10,this);
setFocusPolicy(Qt::StrongFocus);
- bench_flag_=false;
- setMouseTracking(false);
+ setMouseTracking(true);
scene_menu_=new SceneMenu();
this->setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(const QPoint&)), this,
@@ -76,13 +81,6 @@ void GLCanvas::StatusMessage(const String& m)
glwin_->StatusMessage(m);
}
-void GLCanvas::SetStereo(bool s)
-{
- QGLFormat f=this->format();
- f.setStereo(s);
- this->setFormat(f);
-}
-
void GLCanvas::OnTransform(gfx::InputCommand com, int indx,
gfx::TransformTarget trg, Real val)
{
@@ -232,6 +230,10 @@ void GLCanvas::HandleMouseMoveEvent(QMouseEvent* event)
int indx=0;
gfx::TransformTarget trg=gfx::TRANSFORM_VIEW;
+ if(show_beacon_) {
+ Scene::Instance().SetBeacon(event->x(),size().height()-event->y());
+ }
+
QPoint delta=QPoint(event->x(), event->y())-last_pos_;
if (event->buttons() & Qt::LeftButton) {
if (event->buttons() & Qt::MidButton) {
@@ -327,6 +329,12 @@ void GLCanvas::CopySelectionToClipboard()
void GLCanvas::keyPressEvent(QKeyEvent* event)
{
+ if(event->key()==Qt::Key_Space) {
+ show_beacon_=true;
+ Scene::Instance().SetBeacon(last_pos_.x(),size().height()-last_pos_.y());
+ DoRefresh();
+ setCursor(Qt::BlankCursor);
+ }
if((event->modifiers() & Qt::ControlModifier)) {
// Ctrl pressed
if(event->key()==Qt::Key_A) {
@@ -342,35 +350,35 @@ void GLCanvas::keyPressEvent(QKeyEvent* event)
this->CopySelectionToClipboard();
return;
} else if(event->key()==Qt::Key_1) {
- gfx::Scene::Instance().ActivateShader("");
+ gfx::Scene::Instance().SetShadingMode("fallback");
DoRefresh();
return;
} else if(event->key()==Qt::Key_2) {
- gfx::Scene::Instance().ActivateShader("basic");
+ gfx::Scene::Instance().SetShadingMode("basic");
DoRefresh();
return;
} else if(event->key()==Qt::Key_3) {
- gfx::Scene::Instance().ActivateShader("fraglight");
+ gfx::Scene::Instance().SetShadingMode("default");
DoRefresh();
return;
} else if(event->key()==Qt::Key_4) {
- gfx::Scene::Instance().ActivateShader("basic_shadow");
+ gfx::Scene::Instance().SetShadingMode("hf");
DoRefresh();
return;
} else if(event->key()==Qt::Key_5) {
- gfx::Scene::Instance().ActivateShader("fraglight_shadow");
+ gfx::Scene::Instance().SetShadingMode("toon1");
DoRefresh();
return;
} else if(event->key()==Qt::Key_6) {
- gfx::Scene::Instance().ActivateShader("hemilight");
+ gfx::Scene::Instance().SetShadingMode("toon2");
DoRefresh();
return;
- } else if(event->key()==Qt::Key_7) {
- gfx::Scene::Instance().ActivateShader("toon");
+ } else if(event->key()==Qt::Key_0) {
+ gfx::Scene::Instance().SetShadow(!gfx::Scene::Instance().GetShadow());
DoRefresh();
return;
- } else if(event->key()==Qt::Key_8) {
- gfx::Scene::Instance().ActivateShader("toon2");
+ } else if(event->key()==Qt::Key_9) {
+ gfx::Scene::Instance().SetAmbientOcclusion(!gfx::Scene::Instance().GetAmbientOcclusion());
DoRefresh();
return;
}
@@ -380,6 +388,13 @@ void GLCanvas::keyPressEvent(QKeyEvent* event)
void GLCanvas::keyReleaseEvent(QKeyEvent* event)
{
+ if(event->key()==Qt::Key_Space) {
+ show_beacon_=false;
+ Scene::Instance().SetBeaconOff();
+ DoRefresh();
+ setCursor(Qt::ArrowCursor);
+ return;
+ }
if(event->key()==Qt::Key_Alt){
emit ReleaseFocus();
return;
diff --git a/modules/gui/src/gl_canvas.hh b/modules/gui/src/gl_canvas.hh
index 631aa624d9cffc8fd68e20da0477728a5dd7e8fe..e20c3c5ce97bdca8040bbcc9d9fe9496040e0bf3 100644
--- a/modules/gui/src/gl_canvas.hh
+++ b/modules/gui/src/gl_canvas.hh
@@ -54,7 +54,7 @@ public:
virtual void MakeActive();
virtual void DoRefresh();
virtual void StatusMessage(const String& m);
- virtual void SetStereo(bool s);
+ virtual bool HasStereo() const {return format().stereo();};
virtual bool HasMultisample() const {return format().sampleBuffers();}
// central point for sending input to the gfx layer
@@ -102,6 +102,7 @@ private:
bool bench_flag_;
QPoint last_pos_;
SceneMenu* scene_menu_;
+ bool show_beacon_;
};
}} // ns
diff --git a/modules/gui/src/gl_win.cc b/modules/gui/src/gl_win.cc
index 693a9197a821b10e5d9d69d0fc0dd1f755ffa99c..d0ea7f00db3261b3311feda4c08a23ab0c08ad7c 100644
--- a/modules/gui/src/gl_win.cc
+++ b/modules/gui/src/gl_win.cc
@@ -46,29 +46,51 @@
namespace ost { namespace gui {
-GLWin::GLWin(QWidget* p):
- Widget(NULL, p),
- gl_canvas_(NULL)
+GLWin::GLWin(QWidget* p, bool try_stereo):
+Widget(NULL, p),
+gl_canvas_(NULL)
{
QMainWindow* main=new QMainWindow;
- for(int format_id=2;format_id>=0;--format_id) {
- gl_canvas_=new GLCanvas(this, main, GLWin::CreateFormat(format_id));
- if(gl_canvas_->isValid()) {
- break; // format is fine
- } else {
- delete gl_canvas_; // delete this canvas and try a less sophisticated format
+
+ if(try_stereo) {
+ LOGN_VERBOSE("GLCanvas: trying stereo visuals first");
+ for(int format_id=3;format_id>=0;--format_id) {
+ QGLFormat format=GLWin::CreateFormat(format_id);
+ format.setStereo(true);
+ gl_canvas_=new GLCanvas(this, main, format);
+ if(gl_canvas_->isValid() && gl_canvas_->format().stereo()) {
+ break; // format is fine
+ } else {
+ delete gl_canvas_; // delete this canvas and try a less sophisticated format
+ gl_canvas_=0;
+ }
+ }
+ }
+ if(!gl_canvas_) {
+ if(try_stereo) {
+ LOGN_VERBOSE("GLCanvas: no stereo visual found, trying normal ones");
+ }
+ for(int format_id=3;format_id>=0;--format_id) {
+ QGLFormat format=GLWin::CreateFormat(format_id);
+ gl_canvas_=new GLCanvas(this, main, format);
+ if(gl_canvas_->isValid()) {
+ break; // format is fine
+ } else {
+ delete gl_canvas_; // delete this canvas and try a less sophisticated format
+ gl_canvas_=0;
+ }
}
}
- if(!gl_canvas_->isValid()) {
- LOGN_ERROR("no valid GL context found, GL canvas could not be created");
+ if(!gl_canvas_ || !gl_canvas_->isValid()) {
+ LOGN_ERROR("GLCanvas: no valid GL context found, this is pretty fatal");
return;
}
this->SetInternalWidget(main);
gfx::Scene::Instance().AttachObserver(this);
QGLFormat format = gl_canvas_->format();
- LOGN_VERBOSE("GLCanvas created with rbits=" << format.redBufferSize()
+ LOGN_DEBUG("GLCanvas: rbits=" << format.redBufferSize()
<< " gbits=" << format.greenBufferSize()
<< " bbits=" << format.blueBufferSize()
<< " abits=" << format.alphaBufferSize()
@@ -76,6 +98,9 @@ GLWin::GLWin(QWidget* p):
<< " accumbits=" << format.accumBufferSize()
<< " multisample=" << format.sampleBuffers()
<< " with samples=" << format.samples());
+ if(gl_canvas_->format().stereo()) {
+ LOGN_VERBOSE("GLCanvas: using stereo visual");
+ }
main->setCentralWidget(gl_canvas_);
connect(gl_canvas_, SIGNAL(ReleaseFocus()), this, SIGNAL(ReleaseFocus()));
connect(&ToolManager::Instance(), SIGNAL(ActiveToolChanged(Tool*)), this, SLOT(ActiveToolChanged(Tool*)));
@@ -101,7 +126,16 @@ void GLWin::ActiveToolChanged(Tool* t)
QGLFormat GLWin::CreateFormat(int fid)
{
QGLFormat format = QGLFormat::defaultFormat();
- if(fid==2) {
+ if(fid==3) {
+ format.setDepthBufferSize(24);
+ format.setRedBufferSize(8);
+ format.setGreenBufferSize(8);
+ format.setBlueBufferSize(8);
+ format.setAlpha(true);
+ format.setAlphaBufferSize(8);
+ format.setAccum(true);
+ format.setSampleBuffers(true);
+ } else if(fid==2) {
format.setDepthBufferSize(12);
format.setRedBufferSize(8);
format.setGreenBufferSize(8);
diff --git a/modules/gui/src/gl_win.hh b/modules/gui/src/gl_win.hh
index c5d0efb2d46a65f1154384ba3af21bf45b28f25b..08cecfcad2c3c3162d80c4cec561fa485ab6d580 100644
--- a/modules/gui/src/gl_win.hh
+++ b/modules/gui/src/gl_win.hh
@@ -43,7 +43,7 @@ class DLLEXPORT_OST_GUI GLWin: public Widget, public gfx::SceneObserver
{
Q_OBJECT;
public:
- GLWin(QWidget* p);
+ GLWin(QWidget* p, bool try_stereo=false);
~GLWin();
void SetTestMode(bool f);
diff --git a/modules/gui/src/gosty_app.cc b/modules/gui/src/gosty_app.cc
index bf4398b3870c73158b179435fc1ef9fb034b257d..08df5bcba68d4d142f6476c335c793b56535ab15 100644
--- a/modules/gui/src/gosty_app.cc
+++ b/modules/gui/src/gosty_app.cc
@@ -48,7 +48,8 @@ GostyApp::GostyApp():
py_shell_(NULL), w_py_shell_(NULL), gl_win_(NULL), w_gl_win_(NULL),
scene_win_(NULL), w_scene_win_(NULL), seq_viewer_(NULL), seq_viewer_v2_(NULL), tool_options_win_(NULL),
w_tool_options_(NULL), main_(new GostyMainWindow),
- perspective_(NULL), external_widgets_(QMap<QString,WidgetGeomHandler *>())
+ perspective_(NULL), external_widgets_(QMap<QString,WidgetGeomHandler *>()),
+ try_stereo_(false)
{
assert(GostyApp::app_==NULL);
GostyApp::app_=this;
@@ -150,10 +151,10 @@ PythonShell* GostyApp::GetPyShell()
return py_shell_;
}
-GLWin* GostyApp::GetGLWin()
+GLWin* GostyApp::GetGLWin()
{
if (gl_win_==NULL) {
- gl_win_=new GLWin(main_);
+ gl_win_=new GLWin(main_,try_stereo_);
gl_win_->SetDestroyOnClose(false);
}
return gl_win_;
diff --git a/modules/gui/src/gosty_app.hh b/modules/gui/src/gosty_app.hh
index 46381ff1662237a5b60525407d7936eb05bd3eb4..2ed5e693fa53845436ad445064b6c5bacf1eb2eb 100644
--- a/modules/gui/src/gosty_app.hh
+++ b/modules/gui/src/gosty_app.hh
@@ -38,14 +38,10 @@
#include <ost/gui/data_viewer/data_viewer.hh>
#endif
-
-
-
class QMainWindow;
class QMdiArea;
class QWidget;
-
namespace ost { namespace gui {
class PythonShell;
@@ -81,7 +77,7 @@ public:
/// The GL window is initialized when this method is first called. All
/// subsequent calls will return the same GLWin instance.
GLWin* GetGLWin();
-
+
/// \brief get scene menu
///
/// The scene menu window is initialized when this method is first called. All
@@ -140,6 +136,9 @@ public:
/// \param app_title Title that will be displayed in the title bar
void SetAppTitle(const QString& app_title);
+ /// \brief attempt to get a stereo visual upon startup
+ void TryStereo(bool f) {try_stereo_=f;}
+
public slots:
/// \brief This slot must be called when the application is going to be terminated.
void OnQuit();
@@ -167,6 +166,8 @@ private:
QMap<QString,WidgetGeomHandler *> external_widgets_;
+ bool try_stereo_;
+
static GostyApp* app_;
};
diff --git a/modules/mol/base/pymod/wrap_mol.cc b/modules/mol/base/pymod/wrap_mol.cc
index 82a449f681fbe98866c42acb0b8581fefd66d331..202636aff4ae7cf9b0716ca437407a6e46a746d7 100644
--- a/modules/mol/base/pymod/wrap_mol.cc
+++ b/modules/mol/base/pymod/wrap_mol.cc
@@ -63,6 +63,7 @@ BOOST_PYTHON_MODULE(_mol)
export_QueryViewWrapper();
class_<Transform>("Transform", init<>())
+ .def(init<const Transform&>()) // shouldn't this be there automatically ?
.def("GetMatrix",&Transform::GetMatrix)
.def("GetTransposedMatrix",&Transform::GetTransposedMatrix)
.def("SetTrans",&Transform::SetTrans)
diff --git a/modules/mol/base/src/surface_builder.cc b/modules/mol/base/src/surface_builder.cc
index 4fd1a97e4c3610c492fedb4c58bd2a4ed7819b8e..d85db43a5e6c35706dcb1bee6e6f03e97358c792 100644
--- a/modules/mol/base/src/surface_builder.cc
+++ b/modules/mol/base/src/surface_builder.cc
@@ -22,7 +22,6 @@
#include "surface_handle.hh"
#include "entity_view.hh"
-#include "iterator.hh"
namespace ost { namespace mol {
diff --git a/scripts/init.py b/scripts/init.py
index 020a660797852353077ff6c36a8f10834c1dd05a..ed53db5d73b64245d37d5d39e35541de2b4b6de9 100644
--- a/scripts/init.py
+++ b/scripts/init.py
@@ -46,9 +46,10 @@ def _InitPanels(app):
panels.AddWidget(gui.PanelPosition.BOTTOM_PANEL, app.seq_viewer)
panels.AddWidget(gui.PanelPosition.BOTTOM_PANEL, app.py_shell)
-def _InitFrontEnd():
+def _InitFrontEnd(try_stereo):
app=gui.GostyApp.Instance()
app.SetAppTitle("DNG")
+ app.TryStereo(try_stereo)
main_area=app.perspective.main_area
_InitPanels(app)
_InitMenuBar(app)
@@ -130,6 +131,7 @@ parser.add_option("-p", "--pdb_id", dest="pdb_ids", default=[],action="append",
parser.add_option("-b", "--builder", dest="builder", default="HEURISTIC", help="Type of builder used by the progam (either RULE_BASED or HEURISTIC) [default: %default]")
parser.add_option("-c", "--compound_library", dest="complib", default="compounds.chemlib", help="Compound library for the RULE_BASED builder (only used if --builder option is set to RULE_BASED, otherwise ignored [default: %default]")
parser.add_option("-q", "--query", dest="query", default="", help="Selection query to be highlighted automatically upon loading (only used together with -p option or when a PDB file is loaded, otherwise ignored [default: None]")
+parser.add_option("-S","--stereo", dest="try_stereo", default=False, action="store_true",help="try to get a quad-buffer stereo visual")
parser.disable_interspersed_args()
(options, args) = parser.parse_args()
@@ -153,7 +155,7 @@ if options.builder=="RULE_BASED":
conop.Conopology.Instance().SetDefaultBuilder('rbb')
PushVerbosityLevel(options.vlevel)
-_InitFrontEnd()
+_InitFrontEnd(options.try_stereo)
if len(loading_list)!=0 or len(options.pdb_ids)!=0:
_load_files()