static Program make(void)
{
Program result;
VertexShader vs;
vs.Source(
"#version 330\n"
"#define side 128\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, LightProjMatrix, LightMatrix;"
"uniform vec3 CameraPos, LightPos;"
"uniform float Fade;"
"uniform sampler2D Offsets;"
"uniform sampler2D Heights;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec4 vertShadowCoord;"
"out vec3 vertViewDir;"
"out vec3 vertLightDir;"
"out vec3 vertNormal;"
"out float vertLight;"
"void main(void)"
"{"
" ivec2 Coord = ivec2(gl_InstanceID%side, gl_InstanceID/side);"
" vec2 Offs = texelFetch(Offsets, Coord, 0).xy;"
" float Depth = texelFetch(Heights, Coord, 0).r;"
" float Height = 1.0-Depth;"
" gl_Position = Position;"
" gl_Position.xz += Offs;"
" float l = (1.0-dot(Normal, vec3(0,1,0))*0.5)*0.8;"
" vertLight = (1.0-gl_Position.y*l)*sign(Height)*Fade;"
" gl_Position.y *= max(Height*Fade*side/2, 0.5);"
" vertViewDir = CameraPos - gl_Position.xyz;"
" vertLightDir = LightPos - gl_Position.xyz;"
" vertShadowCoord = LightProjMatrix * LightMatrix * gl_Position;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
" vertNormal = Normal;"
"}"
).Compile();
FragmentShader fs;
fs.Source(
"#version 330\n"
"uniform sampler2DShadow Shadows;"
"const vec3 LightDir = normalize(vec3(1, 0.3, 1));"
"const vec3 BarColor = vec3(0.4, 0.4, 0.4);"
"in vec4 vertShadowCoord;"
"in vec3 vertViewDir;"
"in vec3 vertLightDir;"
"in vec3 vertNormal;"
"in float vertLight;"
"out vec3 fragColor;"
"void main(void)"
"{"
" vec3 Normal = normalize(vertNormal);"
" vec3 ViewDir = normalize(vertViewDir);"
" vec3 LightDir = normalize(vertLightDir);"
" vec3 LightRefl = reflect(-LightDir, Normal);"
" vec3 ShadowCoord = (vertShadowCoord.xyz/vertShadowCoord.w)*0.5 + 0.5;"
" float shdw = texture(Shadows, ShadowCoord);"
" float ambi = 0.15;"
" float diff = pow(max(dot(Normal, LightDir)+0.1, 0.0),2.0)*0.9;"
" float spec = pow(max(dot(ViewDir, LightRefl), 0.0), 32.0)*0.4;"
" float emis = pow(vertLight, 2.0)*0.7;"
" fragColor = "
" BarColor * (diff*shdw+ambi)+"
" vec3(1.0, 1.0, 1.0)*spec*shdw+"
" vec3(0.1, 1.0, 0.3)*emis;"
"}"
).Compile();
result.AttachShader(vs).AttachShader(fs);
result.Link().Validate().Use();
return std::move(result);
}
//-----------------------------------------------------------------------
bool FFPTexturing::resolveUniformParams(TextureUnitParams* textureUnitParams, ProgramSet* programSet)
{
Program* vsProgram = programSet->getCpuVertexProgram();
Program* psProgram = programSet->getCpuFragmentProgram();
// Resolve texture sampler parameter.
textureUnitParams->mTextureSampler = psProgram->resolveParameter(textureUnitParams->mTextureSamplerType, textureUnitParams->mTextureSamplerIndex, (uint16)GPV_GLOBAL, "gTextureSampler");
if (textureUnitParams->mTextureSampler.get() == NULL)
return false;
// Resolve texture matrix parameter.
if (needsTextureMatrix(textureUnitParams->mTextureUnitState))
{
textureUnitParams->mTextureMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_TEXTURE_MATRIX, textureUnitParams->mTextureSamplerIndex);
if (textureUnitParams->mTextureMatrix.get() == NULL)
return false;
}
switch (textureUnitParams->mTexCoordCalcMethod)
{
case TEXCALC_NONE:
break;
// Resolve World + View matrices.
case TEXCALC_ENVIRONMENT_MAP:
case TEXCALC_ENVIRONMENT_MAP_PLANAR:
case TEXCALC_ENVIRONMENT_MAP_NORMAL:
mWorldITMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, 0);
if (mWorldITMatrix.get() == NULL)
return false;
mViewMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_VIEW_MATRIX, 0);
if (mViewMatrix.get() == NULL)
return false;
break;
case TEXCALC_ENVIRONMENT_MAP_REFLECTION:
mWorldMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_WORLD_MATRIX, 0);
if (mWorldMatrix.get() == NULL)
return false;
mWorldITMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, 0);
if (mWorldITMatrix.get() == NULL)
return false;
mViewMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_VIEW_MATRIX, 0);
if (mViewMatrix.get() == NULL)
return false;
break;
case TEXCALC_PROJECTIVE_TEXTURE:
mWorldMatrix = vsProgram->resolveAutoParameterInt(GpuProgramParameters::ACT_WORLD_MATRIX, 0);
if (mWorldMatrix.get() == NULL)
return false;
textureUnitParams->mTextureViewProjImageMatrix = vsProgram->resolveParameter(GCT_MATRIX_4X4, -1, (uint16)GPV_LIGHTS, "gTexViewProjImageMatrix");
if (textureUnitParams->mTextureViewProjImageMatrix.get() == NULL)
return false;
const TextureUnitState::EffectMap& effectMap = textureUnitParams->mTextureUnitState->getEffects();
TextureUnitState::EffectMap::const_iterator effi;
for (effi = effectMap.begin(); effi != effectMap.end(); ++effi)
{
if (effi->second.type == TextureUnitState::ET_PROJECTIVE_TEXTURE)
{
textureUnitParams->mTextureProjector = effi->second.frustum;
break;
}
}
if (textureUnitParams->mTextureProjector == NULL)
return false;
break;
}
return true;
}
bool Execute(const AnyString& commandLine, uint timeout)
{
Program program;
program.commandLine(commandLine);
return (program.execute(timeout)) ? (0 == program.wait()) : false;
}
PoolTilesExample()
: make_plane(
Vec3f(), Vec3f(7.0f, 0.0f, 0.0f), Vec3f(0.0f, 0.0f, -7.0f), 48, 48)
, plane_instr(make_plane.Instructions())
, plane_indices(make_plane.Indices())
, make_shape()
, shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, plane_vs(ObjectDesc("Plane vertex"))
, shape_vs(ObjectDesc("Shape vertex"))
, plane_fs(ObjectDesc("Plane fragment"))
, shape_fs(ObjectDesc("Shape fragment"))
, plane_camera_matrix(plane_prog, "CameraMatrix")
, shape_camera_matrix(shape_prog, "CameraMatrix")
, plane_camera_position(plane_prog, "CameraPosition")
, width(800)
, height(600)
, refl_tex_side(width > height ? height : width)
, tile_tex_side(64) {
gl.RequireAtLeast(LimitQuery::MaxCombinedTextureImageUnits, 5);
plane_vs.Source(
"#version 140\n"
"uniform vec3 LightPosition;"
"uniform vec3 CameraPosition;"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec3 vertLightDir;"
"out vec3 vertViewDir;"
"out vec4 vertReflTexCoord;"
"out vec2 vertTileTexCoord;"
"void main()"
"{"
" gl_Position = ModelMatrix* Position;"
" vertLightDir = normalize(LightPosition - gl_Position.xyz);"
" vertViewDir = normalize(CameraPosition - gl_Position.xyz);"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
" vertReflTexCoord = gl_Position;"
" vertTileTexCoord = TexCoord;"
"}");
plane_vs.Compile();
plane_fs.Source(
"#version 140\n"
"uniform sampler2D RandTex, PictTex, TileTex, NormTex;"
"uniform sampler2D ReflectTex;"
"uniform uint TileCount;"
"uniform float Aspect;"
"in vec3 vertLightDir;"
"in vec3 vertViewDir;"
"in vec4 vertReflTexCoord;"
"in vec2 vertTileTexCoord;"
"out vec4 fragColor;"
"void main()"
"{"
" vec3 Normal = texture("
" NormTex, "
" vertTileTexCoord * TileCount"
" ).rgb;"
" vec3 LightRefl = reflect("
" -normalize(vertLightDir),"
" normalize(Normal)"
" );"
" float Diffuse = max(dot("
" Normal, "
" vertLightDir"
" ), 0.0);"
" float Specular = max(dot("
" LightRefl,"
" vertViewDir"
" ), 0.0);"
" float PlasterLight = 0.3 + max(Diffuse, 0.0);"
" float TileLight = 0.3 + pow(Diffuse, 2.0)*0.9 + pow(Specular, "
"4.0)*2.5;"
" vec2 ReflCoord = vertReflTexCoord.xy;"
" ReflCoord /= vertReflTexCoord.w;"
" ReflCoord *= 0.5;"
" ReflCoord += vec2(Aspect*0.5, 0.5);"
" ReflCoord += vec2(Normal.x, Normal.z)*0.5;"
" vec3 ReflColor = texture("
" ReflectTex, "
" ReflCoord"
" ).rgb;"
" vec3 TileProps = texture("
" TileTex, "
" vertTileTexCoord * TileCount"
" ).rgb;"
" float Pict = texture(PictTex, vertTileTexCoord).r;"
" float Rand = texture(RandTex, vertTileTexCoord).r;"
" float LightVsDark = "
" mix( 0.1, 0.9, Pict)+"
" mix(-0.1, 0.1, Rand);"
" vec3 TileColor = mix("
" vec3(0.1, 0.1, 0.5),"
" vec3(0.4, 0.4, 0.9),"
" LightVsDark "
" );"
" vec3 PlasterColor = vec3(0.9, 0.9, 0.9);"
" fragColor = vec4("
" mix("
" PlasterColor * PlasterLight,"
" TileColor * TileLight, "
" TileProps.b"
" ) +"
" ReflColor * TileProps.g * 0.6,"
" 1.0"
" );"
"}");
plane_fs.Compile();
plane_prog.AttachShader(plane_vs);
plane_prog.AttachShader(plane_fs);
plane_prog.Link();
plane_prog.Use();
Vec3f lightPos(3.0f, 2.5f, 2.0f);
Uniform<Vec3f>(plane_prog, "LightPosition").Set(lightPos);
Uniform<GLuint>(plane_prog, "TileCount").Set(tile_tex_side);
Uniform<Mat4f>(plane_prog, "ModelMatrix")
.Set(ModelMatrixf::Translation(0.0f, -0.5f, 0.0f));
std::vector<GLfloat> data;
GLuint n_per_vertex;
n_per_vertex = make_plane.Positions(data);
plane_verts.Data(data);
DSAVertexArrayAttribEXT(plane, plane_prog, "Position")
.Setup<GLfloat>(plane_verts, n_per_vertex)
.Enable();
n_per_vertex = make_plane.TexCoordinates(data);
plane_texcoords.Data(data);
DSAVertexArrayAttribEXT(plane, plane_prog, "TexCoord")
.Setup<GLfloat>(plane_texcoords, n_per_vertex)
.Enable();
//
rand_tex.target = Texture::Target::_2D;
rand_tex.Image2D(images::RandomRedUByte(tile_tex_side, tile_tex_side));
rand_tex.Filter(TextureFilter::Nearest);
rand_tex.Wrap(TextureWrap::Repeat);
Texture::Active(0);
UniformSampler(plane_prog, "RandTex").Set(0);
rand_tex.Bind();
//
pict_tex.target = Texture::Target::_2D;
pict_tex.Image2D(images::LoadTexture("pool_pictogram"));
pict_tex.Filter(TextureFilter::Linear);
pict_tex.Wrap(TextureWrap::Repeat);
Texture::Active(1);
UniformSampler(plane_prog, "PictTex").Set(1);
pict_tex.Bind();
//
auto tile_image = images::LoadTexture("small_tile");
//
tile_tex.target = Texture::Target::_2D;
tile_tex.Image2D(tile_image);
tile_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
tile_tex.MagFilter(TextureMagFilter::Linear);
tile_tex.Wrap(TextureWrap::Repeat);
tile_tex.GenerateMipmap();
Texture::Active(2);
UniformSampler(plane_prog, "TileTex").Set(2);
tile_tex.Bind();
//
norm_tex.target = Texture::Target::_2D;
norm_tex.Image2D(images::TransformComponents<GLfloat, 3>(
images::NormalMap(tile_image),
Mat4d(
Vec4d(1.0, 0.0, 0.0, 0.0),
Vec4d(0.0, 0.0, 1.0, 0.0),
Vec4d(0.0, -1.0, 0.0, 0.0),
Vec4d(0.0, 0.0, 0.0, 1.0))));
norm_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
norm_tex.MagFilter(TextureMagFilter::Linear);
norm_tex.Wrap(TextureWrap::Repeat);
norm_tex.GenerateMipmap();
Texture::Active(3);
UniformSampler(plane_prog, "NormTex").Set(3);
norm_tex.Bind();
//
reflect_tex.target = Texture::Target::_2D;
reflect_tex.Image2D(
0,
PixelDataInternalFormat::RGB,
refl_tex_side,
refl_tex_side,
0,
PixelDataFormat::RGB,
PixelDataType::UnsignedByte,
nullptr);
reflect_tex.Filter(TextureFilter::Linear);
reflect_tex.Wrap(TextureWrap::ClampToEdge);
Texture::Active(4);
UniformSampler(plane_prog, "ReflectTex").Set(4);
reflect_tex.Bind();
rbo.Storage(
PixelDataInternalFormat::DepthComponent,
refl_tex_side,
refl_tex_side);
fbo.target = Framebuffer::Target::Draw;
fbo.AttachTexture(FramebufferAttachment::Color, reflect_tex, 0);
fbo.AttachRenderbuffer(FramebufferAttachment::Depth, rbo);
shape_vs.Source(
"#version 140\n"
"uniform vec3 LightPosition;"
"uniform mat4 ProjectionMatrix, ModelMatrix, CameraMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"out vec3 vertLightDir;"
"out vec3 vertLightRefl;"
"out vec3 vertViewDir;"
"out vec3 vertViewRefl;"
"out vec3 vertColor;"
"void main()"
"{"
" gl_Position = "
" ModelMatrix *"
" Position;"
" vertLightDir = LightPosition - gl_Position.xyz;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLightRefl = reflect("
" -normalize(vertLightDir),"
" normalize(vertNormal)"
" );"
" vertViewDir = ("
" vec4(0.0, 0.0, 1.0, 1.0)*"
" CameraMatrix"
" ).xyz;"
" vertViewRefl = reflect("
" -normalize(vertViewDir),"
" normalize(vertNormal)"
" );"
" vertColor = vec3(0.3, 0.3, 0.7);"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" gl_Position;"
"}");
shape_vs.Compile();
shape_fs.Source(
"#version 140\n"
"uniform sampler2D PictTex, TileTex;"
"uniform uint TileCount;"
"in vec3 vertNormal;"
"in vec3 vertLightDir;"
"in vec3 vertLightRefl;"
"in vec3 vertViewDir;"
"in vec3 vertViewRefl;"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main()"
"{"
" float LtDist = length(vertLightDir);"
" float Diffuse = dot("
" normalize(vertNormal), "
" normalize(vertLightDir)"
" ) / LtDist;"
" float Specular = dot("
" normalize(vertLightRefl),"
" normalize(vertViewDir)"
" );"
" vec3 LightColor = vec3(1.0, 1.0, 1.0);"
" vec2 ReflTexCoord = -vec2("
" vertViewRefl.x,"
" vertViewRefl.z "
" );"
" ReflTexCoord *= 0.25;"
" ReflTexCoord += vec2(0.5, 0.5);"
" float Pict = texture(PictTex, ReflTexCoord).r;"
" float LightVsDark = mix( 0.1, 0.9, Pict);"
" vec3 TileColor = mix("
" vec3(0.2, 0.2, 0.6),"
" vec3(0.5, 0.5, 0.9),"
" LightVsDark"
" );"
" vec3 PlasterColor = vec3(0.7, 0.7, 0.7);"
" vec3 FloorColor = mix("
" PlasterColor, "
" TileColor, "
" texture(TileTex, ReflTexCoord*TileCount).b"
" );"
" vec3 ReflColor = mix("
" vec3(0.5, 0.5, 0.4), "
" FloorColor, "
" pow(max((-vertViewRefl.y-0.5)*2.0, 0.0), 2.0)"
" );"
" fragColor = vec4("
" vertColor * 0.4 + "
" ReflColor * 0.3 + "
" (LightColor + vertColor)*pow(max(2.5*Diffuse, 0.0), 3) + "
" LightColor * pow(max(Specular, 0.0), 64), "
" 1.0"
" );"
"}");
shape_fs.Compile();
shape_prog.AttachShader(shape_vs);
shape_prog.AttachShader(shape_fs);
shape_prog.Link();
shape_prog.Use();
Uniform<Vec3f>(shape_prog, "LightPosition").Set(lightPos);
Uniform<Mat4f>(shape_prog, "ModelMatrix")
.Set(ModelMatrixf::Translation(0.0f, 0.6f, 0.0f));
UniformSampler(shape_prog, "PictTex").Set(0);
UniformSampler(shape_prog, "TileTex").Set(1);
Uniform<GLuint>(shape_prog, "TileCount").Set(tile_tex_side);
n_per_vertex = make_shape.Positions(data);
shape_verts.Data(data);
DSAVertexArrayAttribEXT(shape, shape_prog, "Position")
.Setup<GLfloat>(shape_verts, n_per_vertex)
.Enable();
n_per_vertex = make_shape.Normals(data);
shape_normals.Data(data);
DSAVertexArrayAttribEXT(shape, shape_prog, "Normal")
.Setup<GLfloat>(shape_normals, n_per_vertex)
.Enable();
//
gl.ClearColor(0.5f, 0.5f, 0.4f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
TessellationExample(void)
: prog()
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
{
VertexShader vert(ObjectDesc("Vertex"));
vert.Source(StrLit(
"#version 330\n"
"uniform mat4 CameraMatrix;"
"in vec4 Position;"
"out vec4 vertPosition;"
"void main(void)"
"{"
" vertPosition = CameraMatrix * Position;"
"}"
));
vert.Compile();
prog << vert;
TessControlShader teco(ObjectDesc("TessControl"));
teco.Source(StrLit(
"#version 330\n"
"#extension ARB_tessellation_shader: enable\n"
"layout(vertices = 16) out;"
"in vec4 vertPosition[];"
"patch out vec3 tecoPosition[16];"
"void main(void)"
"{"
" if(gl_InvocationID == 0)"
" {"
" int tl = 1-int(100.0 / vertPosition[gl_InvocationID].z);"
" gl_TessLevelInner[0] = tl;"
" gl_TessLevelInner[1] = tl;"
" gl_TessLevelOuter[0] = tl;"
" gl_TessLevelOuter[1] = tl;"
" gl_TessLevelOuter[2] = tl;"
" gl_TessLevelOuter[3] = tl;"
" }"
" tecoPosition[gl_InvocationID] = "
" vertPosition[gl_InvocationID].xyz;"
"}"
));
teco.Compile();
prog << teco;
TessEvaluationShader teev(ObjectDesc("TessEvaluation"));
teev.Source(StrLit(
"#version 330\n"
"#extension ARB_tessellation_shader: enable\n"
"layout(quads, equal_spacing, ccw) in;"
"uniform mat4 ProjectionMatrix;"
"patch in vec3 tecoPosition[16];"
"const mat4 B = mat4("
" -1, 3,-3, 1,"
" 3,-6, 3, 0,"
" -3, 3, 0, 0,"
" 1, 0, 0, 0 "
");"
"mat4 Px, Py, Pz;"
"void main(void)"
"{"
" float u = gl_TessCoord.x, v = gl_TessCoord.y;"
" for(int j=0; j!=4; ++j)"
" for(int i=0; i!=4; ++i)"
" {"
" int k = j*4+i;"
" Px[j][i] = tecoPosition[k].x;"
" Py[j][i] = tecoPosition[k].y;"
" Pz[j][i] = tecoPosition[k].z;"
" }"
" mat4 Cx = B * Px * B;"
" mat4 Cy = B * Py * B;"
" mat4 Cz = B * Pz * B;"
" vec4 up = vec4(u*u*u, u*u, u, 1);"
" vec4 vp = vec4(v*v*v, v*v, v, 1);"
" vec4 tempPosition = vec4(dot(Cx * vp, up), dot(Cy * vp, up), dot(Cz * vp, up), 1.0);"
" gl_Position = ProjectionMatrix * tempPosition;"
"}"
));
teev.Compile();
prog << teev;
FragmentShader frag(ObjectDesc("Fragment"));
frag.Source(StrLit(
"#version 330\n"
"out vec3 fragColor;"
"void main(void)"
"{"
" fragColor = vec3(0.1, 0.1, 0.1);"
"}"
));
frag.Compile();
prog << frag;
prog.Link();
prog.Use();
vao.Bind();
GLfloat patch_cp_pos[16*3] = {
-2.0f, 0.0f, -2.0f,
-1.0f, 0.0f, -3.0f,
1.0f, 0.0f, -5.0f,
2.0f, 0.0f, -2.0f,
-1.0f, 0.0f, -1.0f,
0.0f, 4.0f, -1.0f,
1.0f, 4.0f, -1.0f,
3.0f, 0.0f, -1.0f,
-1.0f, 0.0f, 1.0f,
-1.0f, 4.0f, 1.0f,
0.0f, 4.0f, 1.0f,
1.0f, 0.0f, 1.0f,
-2.0f, 0.0f, 2.0f,
-1.0f, 0.0f, 5.0f,
1.0f, 0.0f, 3.0f,
2.0f, 0.0f, 2.0f
};
positions.Bind(Buffer::Target::Array);
Buffer::Data(Buffer::Target::Array, 16*3, patch_cp_pos);
VertexAttribArray position_attr(prog, "Position");
position_attr.Setup<Vec3f>();
position_attr.Enable();
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.PolygonMode(PolygonMode::Line);
gl.PatchParameter(PatchParameter::PatchVertices, 16);
}
TessellationExample(void)
: shape_instr(make_shape.Instructions(PrimitiveType::Patches))
, shape_indices(make_shape.Indices())
, vs(ObjectDesc("Vertex"))
, cs(ObjectDesc("Tessellation Control"))
, es(ObjectDesc("Tessellation Evaluation"))
, gs(ObjectDesc("Geometry"))
, fs(ObjectDesc("Fragment"))
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
, offset(prog, "Offset")
, view_position(prog, "ViewPosition")
, viewport_dimensions(prog, "ViewportDimensions")
{
vs.Source(
"#version 410\n"
"uniform vec3 ViewPosition;"
"in vec3 Position;"
"out vec3 vertPosition;"
"out float vertDistance;"
"void main(void)"
"{"
" vertPosition = Position;"
" vertDistance = length(ViewPosition - vertPosition);"
"}"
);
vs.Compile();
cs.Source(
"#version 410\n"
"layout(vertices = 3) out;"
"in vec3 vertPosition[];"
"in float vertDistance[];"
"out vec3 tecoPosition[];"
"int tessLevel(float dist)"
"{"
" return int(9.0 / sqrt(dist+0.1));"
"}"
"void main(void)"
"{"
" tecoPosition[gl_InvocationID] ="
" vertPosition[gl_InvocationID];"
" if(gl_InvocationID == 0)"
" {"
" gl_TessLevelInner[0] = tessLevel(("
" vertDistance[0]+"
" vertDistance[1]+"
" vertDistance[2] "
" )*0.333);"
" gl_TessLevelOuter[0] = tessLevel(("
" vertDistance[1]+"
" vertDistance[2] "
" )*0.5);"
" gl_TessLevelOuter[1] = tessLevel(("
" vertDistance[2]+"
" vertDistance[0] "
" )*0.5);"
" gl_TessLevelOuter[2] = tessLevel(("
" vertDistance[0]+"
" vertDistance[1] "
" )*0.5);"
" }"
"}"
);
cs.Compile();
es.Source(
"#version 410\n"
"layout(triangles, equal_spacing, ccw) in;"
"const vec3 LightPosition = vec3(12.0, 10.0, 7.0);"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec3 tecoPosition[];"
"out vec3 teevNormal;"
"out vec3 teevLightDir;"
"void main(void)"
"{"
" vec3 p0 = gl_TessCoord.x * tecoPosition[0];"
" vec3 p1 = gl_TessCoord.y * tecoPosition[1];"
" vec3 p2 = gl_TessCoord.z * tecoPosition[2];"
" vec4 tempPosition = vec4(normalize(p0+p1+p2), 0.0);"
" teevNormal = (ModelMatrix * tempPosition).xyz;"
" tempPosition.w = 1.0;"
" tempPosition = ModelMatrix * tempPosition;"
" teevLightDir = LightPosition - tempPosition.xyz;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" tempPosition;"
"}"
);
es.Compile();
gs.Source(
"#version 410\n"
"layout (triangles) in;"
"layout (triangle_strip, max_vertices = 3) out;"
"uniform vec3 Offset;"
"uniform vec2 ViewportDimensions;"
"in vec3 teevNormal[], teevLightDir[];"
"noperspective out vec3 geomDist;"
"flat out vec3 geomNormal;"
"out vec3 geomColor;"
"out vec3 geomLightDir;"
"void main(void)"
"{"
" geomNormal = normalize("
" teevNormal[0]+"
" teevNormal[1]+"
" teevNormal[2]"
" );"
" vec2 ScreenPos[3];"
" for(int i=0; i!=3; ++i)"
" {"
" ScreenPos[i] = "
" ViewportDimensions*"
" gl_in[i].gl_Position.xy/"
" gl_in[i].gl_Position.w;"
" }"
" vec2 TmpVect[3];"
" for(int i=0; i!=3; ++i)"
" {"
" TmpVect[i] = "
" ScreenPos[(i+2)%3]-"
" ScreenPos[(i+1)%3];"
" }"
" const vec3 EdgeMask[3] = vec3[3]("
" vec3(1.0, 0.0, 0.0),"
" vec3(0.0, 1.0, 0.0),"
" vec3(0.0, 0.0, 1.0) "
" );"
" for(int i=0; i!=3; ++i)"
" {"
" float Dist = abs("
" TmpVect[(i+1)%3].x*TmpVect[(i+2)%3].y-"
" TmpVect[(i+1)%3].y*TmpVect[(i+2)%3].x "
" ) / length(TmpVect[i]);"
" vec3 DistVect = vec3(Dist, Dist, Dist);"
" gl_Position = gl_in[i].gl_Position;"
" geomColor = normalize(abs("
" vec3(2.0, 2.0, 2.0)-"
" teevNormal[i]-"
" Offset"
" ));"
" geomLightDir = teevLightDir[i];"
" geomDist = EdgeMask[i] * DistVect;"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
);
gs.Compile();
fs.Source(
"#version 410\n"
"noperspective in vec3 geomDist;"
"flat in vec3 geomNormal;"
"in vec3 geomColor;"
"in vec3 geomLightDir;"
"out vec3 fragColor;"
"void main(void)"
"{"
" float MinDist = min(min(geomDist.x,geomDist.y),geomDist.z);"
" float EdgeAlpha = exp2(-pow(MinDist, 2.0));"
" const float Ambient = 0.8;"
" float Diffuse = max(dot("
" normalize(geomNormal),"
" normalize(geomLightDir)"
" ), 0.0);"
" vec3 FaceColor = geomColor * (Diffuse + Ambient);"
" const vec3 EdgeColor = vec3(0.0, 0.0, 0.0);"
" fragColor = mix(FaceColor, EdgeColor, EdgeAlpha);"
"}"
);
fs.Compile();
prog.AttachShader(vs);
prog.AttachShader(cs);
prog.AttachShader(es);
prog.AttachShader(gs);
prog.AttachShader(fs);
prog.Link();
prog.Use();
shape.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
indices.Bind(Buffer::Target::ElementArray);
Buffer::Data(Buffer::Target::ElementArray, shape_indices);
shape_indices.clear();
}
//
gl.ClearColor(0.8f, 0.8f, 0.8f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
prog.Use();
}
TorusExample(void)
: make_torus(1.0, 0.5, 18, 36)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, vs(ObjectDesc("Vertex"))
, gs(ObjectDesc("Geometry"))
, face_fs(ObjectDesc("Face fragment"))
, frame_fs(ObjectDesc("Frame fragment"))
, transf_prog(ObjectDesc("Transformation"))
, face_prog(ObjectDesc("Face"))
, frame_prog(ObjectDesc("Frame"))
, projection_matrix(transf_prog, "ProjectionMatrix")
, camera_matrix(transf_prog, "CameraMatrix")
, model_matrix(transf_prog, "ModelMatrix")
, transf_time(transf_prog, "Time")
{
vs.Source(
"#version 330\n"
"uniform mat4 ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out gl_PerVertex {"
" vec4 gl_Position;"
"};"
"out vec3 vertNormal;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = (ModelMatrix*vec4(Normal,0.0)).xyz;"
" vertTexCoord = TexCoord;"
"}"
);
vs.Compile();
gs.Source(
"#version 330\n"
"layout(triangles) in;"
"layout(triangle_strip, max_vertices = 15) out;"
"uniform mat4 CameraMatrix, ProjectionMatrix;"
"uniform vec3 LightPos;"
"uniform float Time;"
"in gl_PerVertex {"
" vec4 gl_Position;"
"} gl_in[];"
"in vec3 vertNormal[];"
"in vec2 vertTexCoord[];"
"out gl_PerVertex {"
" vec4 gl_Position;"
"};"
"out vec3 geomNormal;"
"out vec3 geomLight;"
"out float geomGlow;"
"flat out int geomTop;"
"void main(void)"
"{"
" vec3 FaceNormal = normalize("
" vertNormal[0]+"
" vertNormal[1]+"
" vertNormal[2] "
" );"
" vec2 FaceCoord = 0.33333 * ("
" vertTexCoord[0]+"
" vertTexCoord[1]+"
" vertTexCoord[2] "
" );"
" float Offs = (sin((FaceCoord.s + Time/10.0)* 3.14 * 2.0 * 10)*0.5 + 0.5)*0.4;"
" Offs *= cos(FaceCoord.t * 3.1415 * 2.0)*0.5 + 0.51;"
" vec3 pos[3], norm[3];"
" for(int i=0; i!=3; ++i)"
" pos[i] = gl_in[i].gl_Position.xyz;"
" for(int i=0; i!=3; ++i)"
" norm[i] = cross("
" FaceNormal, "
" normalize(pos[(i+1)%3] - pos[i])"
" );"
" vec3 pofs = FaceNormal * Offs;"
" geomTop = 0;"
" for(int i=0; i!=3; ++i)"
" {"
" geomNormal = norm[i];"
" for(int j=0; j!=2; ++j)"
" {"
" vec3 tpos = pos[(i+j)%3];"
" geomLight = LightPos-tpos;"
" geomGlow = 1.0;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" vec4(tpos, 1.0);"
" EmitVertex();"
" geomGlow = 0.7;"
" geomLight = LightPos-tpos+pofs;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" vec4(tpos + pofs, 1.0);"
" EmitVertex();"
" }"
" EndPrimitive();"
" }"
" geomGlow = 0.0;"
" geomTop = 1;"
" for(int i=0; i!=3; ++i)"
" {"
" geomLight = LightPos - (pos[i]+pofs);"
" geomNormal = vertNormal[i];"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" vec4(pos[i] + pofs, 1.0);"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
);
gs.Compile();
transf_prog.AttachShader(vs);
transf_prog.AttachShader(gs);
transf_prog.MakeSeparable();
transf_prog.Link();
transf_prog.Use();
ProgramUniform<Vec3f>(transf_prog, "LightPos").Set(4, 4, -8);
torus.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(transf_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(transf_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(transf_prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
face_fs.Source(
"#version 330\n"
"in vec3 geomNormal;"
"in vec3 geomLight;"
"in float geomGlow;"
"flat in int geomTop;"
"uniform vec3 TopColor, SideColor;"
"const vec3 LightColor = vec3(1.0, 1.0, 1.0);"
"out vec4 fragColor;"
"void main(void)"
"{"
" float d = max(dot("
" normalize(geomLight),"
" normalize(geomNormal)"
" ), 0.0);"
" vec3 color;"
" if(geomTop != 0)"
" {"
" color = TopColor * d +"
" LightColor * pow(d, 8.0);"
" }"
" else"
" {"
" color = SideColor * geomGlow +"
" LightColor *"
" pow(d, 2.0) * 0.2;"
" }"
" fragColor = vec4(color, 1.0);"
"}"
);
face_fs.Compile();
face_prog.AttachShader(face_fs);
face_prog.MakeSeparable();
face_prog.Link();
ProgramUniform<Vec3f>(face_prog, "TopColor").Set(0.2f, 0.2f, 0.2f);
ProgramUniform<Vec3f>(face_prog, "SideColor").Set(0.9f, 0.9f, 0.2f);
face_pp.Bind();
face_prog.Use();
face_pp.UseStages(transf_prog).Vertex().Geometry();
face_pp.UseStages(face_prog).Fragment();
frame_fs.Source(
"#version 330\n"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(0.2, 0.1, 0.0, 1.0);"
"}"
);
frame_fs.Compile();
frame_prog.AttachShader(frame_fs);
frame_prog.MakeSeparable();
frame_prog.Link();
frame_pp.Bind();
frame_prog.Use();
frame_pp.UseStages(transf_prog).Vertex().Geometry();
frame_pp.UseStages(frame_prog).Fragment();
ProgramPipeline::Unbind();
Program::UseNone();
gl.ClearColor(0.7f, 0.6f, 0.5f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.DepthFunc(CompareFn::Less);
gl.FrontFace(make_torus.FaceWinding());
}
void Computer::executeInstruction()
{
const auto& i = program[programCounter];
switch (i.op)
{
case Opcode::cpy:
{
auto v = evalOperand(i.x);
if(i.y.value < 0 || i.y.value>=registers.registerCount())
throw runtime_error("Invalid register");
registers.registerValues[i.y.value] = v;
programCounter++;
break;
}
case Opcode::inc:
{
if(i.x.value<0||i.x.value>=registers.registerCount())
throw runtime_error("Invalid register");
registers.registerValues[i.x.value]++;
programCounter++;
break;
}
case Opcode::dec:
{
if(i.x.value<0||i.x.value>=registers.registerCount())
throw runtime_error("Invalid register");
registers.registerValues[i.x.value]--;
programCounter++;
break;
}
case Opcode::jnz:
{
auto vx = evalOperand(i.x);
auto vy = evalOperand(i.y);
programCounter += (vx != 0 ? vy : 1);
break;
}
case Opcode::tgl:
{
auto v = evalOperand(i.x);
auto tglAddr = programCounter + v;
if(tglAddr>=0&&tglAddr<program.size())
{
auto& tglInstr = program[tglAddr];
switch(tglInstr.op)
{
case Opcode::cpy:
tglInstr.op = Opcode::jnz;
break;
case Opcode::inc:
tglInstr.op = Opcode::dec;
break;
case Opcode::dec:
tglInstr.op = Opcode::inc;
break;
case Opcode::jnz:
tglInstr.op = Opcode::cpy;
break;
case Opcode::tgl:
tglInstr.op = Opcode::inc;
break;
}
}
programCounter++;
break;
}
case Opcode::out:
{
auto v = evalOperand(i.x);
if(outFn)
{
outFn(v);
}
programCounter++;
break;
}
}
}
Program parseInstructions(const vector<string>& instructionsInText)
{
regex cpyRgx("cpy ([a-d]|[+-]?\\d+) ([a-d])");
regex incRgx("inc ([a-d])");
regex decRgx("dec ([a-d])");
regex jnzRgx("jnz ([a-d]|[+-]?\\d+) ([a-d]|[+-]?\\d+)");
regex tglRgx("tgl ([a-z])");
regex tglOut("out ([a-z])");
Program p;
for (const auto& i : instructionsInText)
{
Instruction instr;
smatch m;
if (regex_match(i, m, cpyRgx))
{
auto m1 = m[1].str();
auto m2 = m[2].str();
instr.op = Opcode::cpy;
instr.x = parseOperand(m1);
instr.y = parseOperand(m2);
} else if (regex_match(i, m, incRgx))
{
auto m1 = m[1].str();
instr.op = Opcode::inc;
instr.x = parseOperand(m1);
} else if (regex_match(i, m, decRgx))
{
auto m1 = m[1].str();
instr.op = Opcode::dec;
instr.x = parseOperand(m1);
}
else if (regex_match(i, m, jnzRgx))
{
auto m1 = m[1].str();
auto m2 = m[2].str();
instr.op = Opcode::jnz;
instr.x = parseOperand(m1);
instr.y = parseOperand(m2);
}
else if(regex_match(i, m, tglRgx))
{
auto m1 = m[1].str();
instr.op = Opcode::tgl;
instr.x = parseOperand(m1);
}
else if(regex_match(i, m, tglOut))
{
auto m1 = m[1].str();
instr.op = Opcode::out;
instr.x = parseOperand(m1);
}
else
{
assert(0);
throw runtime_error("Invalid instruction");
}
p.push_back(move(instr));
}
return p;
}
extern void ImportSoftware::importData()
{
QStringList args;
args << "-listsoftware";
Program process;
process.setArguments(args);
QXmlStreamReader xml;
xml.setDevice(&process);
if(process.open(QIODevice::ReadOnly)){
QMap<QString,QString> map;
QString machine;
while(!process.state()==QProcess::NotRunning){
if (process.atEnd())
process.waitForReadyRead();
xml.readNextStartElement();
if(xml.isStartElement()){
if(xml.name()=="softwarelist")
machine=xml.attributes().value("name").toString();
else if(xml.name()=="software"){
map.insert("machine",machine);
QXmlStreamAttributes attributes=xml.attributes();
foreach(QXmlStreamAttribute attribute,attributes.toList())
map.insert(attribute.name().toString(),attribute.value().toString());
}
else if(xml.name()=="description"){
QString description=xml.readElementText();
if(description.contains("(")){
int index=description.indexOf("(");
map.insert("version",description.mid(index+1,description.size()-index-2));
description.truncate(index-1);
}
if(description.contains(" / ")){
int index=description.indexOf(" / ");
description.truncate(index);
}
if(description.contains(" - ")){
int index=description.indexOf(" - ");
map.insert("subtitle",description.mid(index+3));
description.truncate(index);
}
else if(description.contains(": ")){
int index=description.indexOf(": ");
map.insert("subtitle",description.mid(index+2));
description.truncate(index);
}
map.insert("title",description);
}
else if(xml.name()=="year"){
map.insert("year",xml.readElementText());
}
else if(xml.name()=="publisher"){
map.insert("developer",xml.readElementText());
}
}
else if(xml.isEndElement() && xml.name()=="software"){
dataTable.append(map);
map.clear();
}
}
}
}
int main(void)
{
GLFWwindow* window;
// Initialize the library
if (!glfwInit())
return -1;
// Activate supersampling
glfwWindowHint(GLFW_SAMPLES, 8);
// Ensure that we get at least a 3.2 context
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
// On apple we have to load a core profile with forward compatibility
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
// Create a windowed mode window and its OpenGL context
window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}
// Make the window's context current
glfwMakeContextCurrent(window);
#ifndef __APPLE__
glewExperimental = true;
GLenum err = glewInit();
if(GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
glGetError(); // pull and savely ignonre unhandled errors like GL_INVALID_ENUM
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
#endif
int major, minor, rev;
major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
rev = glfwGetWindowAttrib(window, GLFW_CONTEXT_REVISION);
printf("OpenGL version recieved: %d.%d.%d\n", major, minor, rev);
printf("Supported OpenGL is %s\n", (const char*)glGetString(GL_VERSION));
printf("Supported GLSL is %s\n", (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
// Initialize the VAO
// A Vertex Array Object (or VAO) is an object that describes how the vertex
// attributes are stored in a Vertex Buffer Object (or VBO). This means that
// the VAO is not the actual object storing the vertex data,
// but the descriptor of the vertex data.
VertexArrayObject VAO;
VAO.init();
VAO.bind();
// Initialize the VBO with the vertices data
// A VBO is a data container that lives in the GPU memory
VBO.init();
V.resize(2,6);
V <<
0, 0.5, -0.5, 0.1, 0.6, -0.4,
0.5, -0.5, -0.5, 0.6, -0.4, -0.4;
VBO.update(V);
// Initialize the OpenGL Program
// A program controls the OpenGL pipeline and it must contains
// at least a vertex shader and a fragment shader to be valid
Program program;
const GLchar* vertex_shader =
"#version 150 core\n"
"in vec2 position;"
"void main()"
"{"
" gl_Position = vec4(position, 0.0, 1.0);"
"}";
const GLchar* fragment_shader =
"#version 150 core\n"
"out vec4 outColor;"
"uniform vec4 triangleColor;"
"void main()"
"{"
" outColor = vec4(triangleColor);"
"}";
// Compile the two shaders and upload the binary to the GPU
// Note that we have to explicitly specify that the output "slot" called outColor
// is the one that we want in the fragment buffer (and thus on screen)
program.init(vertex_shader,fragment_shader,"outColor");
program.bind();
// The vertex shader wants the position of the vertices as an input.
// The following line connects the VBO we defined above with the position "slot"
// in the vertex shader
program.bindVertexAttribArray("position",VBO);
// Register the keyboard callback
glfwSetKeyCallback(window, key_callback);
// Register the mouse callback
glfwSetMouseButtonCallback(window, mouse_button_callback);
// Update viewport
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
// Loop until the user closes the window
while (!glfwWindowShouldClose(window))
{
// Bind your VAO (not necessary if you have only one)
VAO.bind();
// Bind your program
program.bind();
// Clear the framebuffer
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Enable blending test
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Draw a triangle (red)
glUniform4f(program.uniform("triangleColor"), 1.0f, 0.0f, 0.0f, 1.0f);
glDrawArrays(GL_TRIANGLES, 0, 3);
// Draw a triangle (green)
glUniform4f(program.uniform("triangleColor"), 0.0f, 1.0f, 0.0f, 0.5f);
glDrawArrays(GL_TRIANGLES, 3, 3);
// Swap front and back buffers
glfwSwapBuffers(window);
// Poll for and process events
glfwPollEvents();
}
// Deallocate opengl memory
program.free();
VAO.free();
VBO.free();
// Deallocate glfw internals
glfwTerminate();
return 0;
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog)
, camera_matrix(prog)
{
// Set the vertex shader source and compile it
vs.Source(
"#version 330\n"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = Position;"
"}"
).Compile();
// Set the geometry shader source and compile it
gs.Source(
"#version 330\n"
"layout(triangles) in;"
"layout(triangle_strip, max_vertices = 108) out;"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"out vec3 vertColor;"
"void main(void)"
"{"
" for(int c=0; c!=36; ++c)"
" {"
" float angle = c * 10 * 2 * 3.14159 / 360.0;"
" float cx = cos(angle);"
" float sx = sin(angle);"
" mat4 ModelMatrix = mat4("
" cx, 0.0, sx, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" -sx, 0.0, cx, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ) * mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" 0.0, 0.0, 1.0, 0.0,"
" 12.0, 0.0, 0.0, 1.0 "
" );"
" for(int v=0; v!=gl_in.length(); ++v)"
" {"
" vec4 vert = gl_in[v].gl_Position;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" vert;"
" vertColor = abs(normalize(ModelMatrix*vert)).xzy;"
" EmitVertex();"
" }"
" EndPrimitive();"
" }"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 1.0);"
"}"
).Compile();
// attach the shaders to the program
prog << vs << gs << fs;
// link and use it
prog.Link().Use();
projection_matrix.BindTo("ProjectionMatrix");
camera_matrix.BindTo("CameraMatrix");
// bind the VAO for the cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex).Enable();
}
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
PVR_ERROR DVBLinkClient::GetEPGForChannel(ADDON_HANDLE handle, const PVR_CHANNEL& channel, time_t iStart, time_t iEnd)
{
PVR_ERROR result = PVR_ERROR_FAILED;
PLATFORM::CLockObject critsec(m_mutex);
Channel * c = m_channelMap[channel.iUniqueId];
EpgSearchResult epgSearchResult;
if (DoEPGSearch(epgSearchResult,c->GetID(), iStart, iEnd))
{
for (std::vector<ChannelEpgData*>::iterator it = epgSearchResult.begin(); it < epgSearchResult.end(); it++)
{
ChannelEpgData* channelEpgData = (ChannelEpgData*)*it;
EpgData& epgData = channelEpgData->GetEpgData();
for (std::vector<Program*>::iterator pIt = epgData.begin(); pIt < epgData.end(); pIt++)
{
Program* p = (Program*)*pIt;
EPG_TAG broadcast;
memset(&broadcast, 0, sizeof(EPG_TAG));
broadcast.iUniqueBroadcastId = p->GetStartTime();
broadcast.strTitle = p->GetTitle().c_str();
broadcast.iChannelNumber = channel.iChannelNumber;
broadcast.startTime = p->GetStartTime();
broadcast.endTime = p->GetStartTime() + p->GetDuration();
broadcast.strPlot = p->ShortDescription.c_str();
broadcast.strCast = p->Actors.c_str();
broadcast.strDirector = p->Directors.c_str();
broadcast.strWriter = p->Writers.c_str();
broadcast.iYear = p->Year;
broadcast.strIconPath = p->Image.c_str();
broadcast.iGenreType = 0;
broadcast.iGenreSubType = 0;
broadcast.strGenreDescription = "";
broadcast.firstAired = 0;
broadcast.iParentalRating = 0;
broadcast.iStarRating = p->Rating;
broadcast.bNotify = false;
broadcast.iSeriesNumber = p->SeasonNumber;
broadcast.iEpisodeNumber = p->EpisodeNumber;
broadcast.iEpisodePartNumber = 0;
broadcast.strEpisodeName = p->SubTitle.c_str();
broadcast.strIMDBNumber = NULL; // unused
broadcast.strOriginalTitle = NULL; // unused
broadcast.strPlotOutline = NULL;
int genre_type, genre_subtype;
SetEPGGenre(*p, genre_type, genre_subtype);
broadcast.iGenreType = genre_type;
if (genre_type == EPG_GENRE_USE_STRING)
broadcast.strGenreDescription = p->Keywords.c_str();
else
broadcast.iGenreSubType = genre_subtype;
broadcast.iFlags = EPG_TAG_FLAG_UNDEFINED;
PVR->TransferEpgEntry(handle, &broadcast);
}
}
result = PVR_ERROR_NO_ERROR;
}
else
{
XBMC->Log(LOG_NOTICE, "Not EPG data found for channel : %s with id : %i", channel.strChannelName, channel.iUniqueId);
}
return result;
}
TorusExample(void)
: make_torus(1.0, 0.5, 72, 48)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"out vec3 vertViewDir;"
"void main(void)"
"{"
" vertNormal = Normal;"
" vertViewDir = ("
" vec4(0.0, 0.0, 1.0, 1.0)*"
" CameraMatrix"
" ).xyz;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"in vec3 vertNormal;"
"in vec3 vertViewDir;"
"out vec4 fragColor;"
"uniform vec3 LightPos[3];"
"void main(void)"
"{"
" float amb = 0.2;"
" float diff = 0.0;"
" float spec = 0.0;"
" for(int i=0;i!=3;++i)"
" {"
" diff += max("
" dot(vertNormal, LightPos[i])/"
" dot(LightPos[i], LightPos[i]),"
" 0.0"
" );"
" float k = dot(vertNormal, LightPos[i]);"
" vec3 r = 2.0*k*vertNormal - LightPos[i];"
" spec += pow(max("
" dot(normalize(r), vertViewDir),"
" 0.0"
" ), 32.0 * dot(r, r));"
" }"
" fragColor = "
" vec4(1.0, 0.1, 0.3, 1.0)*(amb+diff)+"
" vec4(1.0, 1.0, 1.0, 1.0)*spec;"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the torus
torus.Bind();
// bind the VBO for the torus vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
// bind the VBO for the torus normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "Normal");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
// set the light positions
Uniform<Vec3f> light_pos(prog, "LightPos");
light_pos[0].Set(Vec3f(2.0f,-1.0f, 0.0f));
light_pos[1].Set(Vec3f(0.0f, 3.0f, 0.0f));
light_pos[2].Set(Vec3f(0.0f,-1.0f, 4.0f));
//
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_torus.FaceWinding());
gl.CullFace(Face::Back);
}
//Está un poco fuzzy, habrá que estructurarlo y tal, pero correcto
void SVMachine::quadraticSolution() {
int n = C_trainingSet.size();
int m = 1; // Entiendo que es el numero de restricciones
Program qp (CGAL::EQUAL);
// Obtengo la X
// Utils::scalation(C_trainingSet); // Escalado de parámetros
std::cout << "n vale: " << n << std::endl;
std::cout << "nFeatures vale: " << C_nFeatures << std::endl;
C_X = arma::mat(n, C_nFeatures);
for(int i = 0; i < n; i++){
for(int j = 0; j < C_nFeatures; j++){
C_X(i,j) = C_trainingSet[i].getInput()[j];
}
}
std::cout << "X vale: " << std::endl << C_X;
// Obtengo la Y
C_y = arma::mat(n, 1);
std::cout << "n vale: " << n << std::endl;
for(int i = 0; i < n; i++){
C_y(i) = C_trainingSet[i].getResult()[0];
}
std::cout << "Y vale: " << std::endl << C_y;
// Seteo la restriccion
for(int i = 0; i < n; i++){
qp.set_a(i,0,ET(C_y.at(i)));
qp.set_l(i,true,ET(0));
qp.set_u(i,false);
qp.set_c(i,ET(-1));
// std::cout << "y(" << i << "): " << y.at(i) << std::endl;
}
qp.set_b(0,ET(0));
qp.set_r(0,CGAL::EQUAL);
qp.set_c0(ET(0));
// Seteo la symmetric positive-semidefinite matrix
for(int i = 0; i < n; i++){
for(int j = 0; j<=i; j++){
ET ip = C_kernel->K(C_X.row(i).t(),C_X.row(j).t());
// std::cout << "El kernel para " << i << "," << j << " nos dice que el innerproduct es: " << ip << std::endl;
ET daux = ip*ET(C_y.at(i))*ET(C_y.at(j));
std::cout << "El producto de " << i << "," << j << ": " << daux << std::endl;
qp.set_d(i,j,daux);
// std::cout << "La matriz auxiliar vale:" << daux << std::endl;
}
}
// solve the program, using ET as the exact type
Solution s = CGAL::solve_quadratic_program(qp, ET());
// print basic constraint indices (we know that there is only one: 1)
std::cout << "Y la solución es: " << s << std::endl;
// arma::mat W = arma::mat(n,1);
C_SupportVectors = arma::mat(n,1);
ET sumaB(0.0);
if(s.is_optimal()) { // we know that, don't we?
int i = 0;
for (Solution::Variable_value_iterator it = s.variable_values_begin(); it != s.variable_values_end(); ++it){
C_SupportVectors(i) = CGAL::to_double(*it);
if(C_SupportVectors.at(i) != 0.0){
C_m = i; // Esto lo hago para obtener un sv que me resuelva la b
}
i++;
}
// Calculo la b
for(int i=0; i<n; i++)
if(C_SupportVectors.at(i) != 0.0)
sumaB += ET(C_SupportVectors.at(i))*ET(C_y.at(i))*C_kernel->K(C_X.row(i).t(), C_X.row(C_m).t());
C_b = ET(C_y(C_m)) - sumaB;
std::cout << "Y el valor de b es: "<< C_b << std::endl;
} else std::cout << "No es optima, vete tu a saber por qué...\n";
// int pausa; std::cin >> pausa;
}
SphereExample(void)
: sphere_instr(make_sphere.Instructions())
, sphere_indices(make_sphere.Indices())
, hole_count(50)
, hole_diameter(0.30f)
{
// This shader will be used in transform fedback mode
// to transform the vertices used to "cut out the holes"
// the same way the sphere is transformed
vs_tfb.Source(
"#version 330\n"
"uniform mat4 CameraMatrix, ModelMatrix;"
"uniform float Diameter;"
"in vec3 Hole;"
"out vec3 vertTransfHole;"
"void main(void)"
"{"
" vertTransfHole = ("
" CameraMatrix *"
" ModelMatrix *"
" vec4(Hole * (1.0 + 0.5 * Diameter), 0.0)"
" ).xyz;"
"}"
);
// compile, setup transform feedback output variables
// link and use the program
vs_tfb.Compile();
prog_tfb.AttachShader(vs_tfb);
const GLchar* var_name = "vertTransfHole";
prog_tfb.TransformFeedbackVaryings(
1, &var_name,
TransformFeedbackMode::InterleavedAttribs
);
prog_tfb.Link();
prog_tfb.Use();
Uniform<GLfloat> diameter(prog_tfb, "Diameter");
diameter.Set(hole_diameter);
// bind the VAO for the holes
holes.Bind();
// bind the VBO for the hole vertices
hole_verts.Bind(Buffer::Target::Array);
// and the VBO for the transformed hole vertices captured by tfb
transf_hole_verts.Bind(Buffer::Target::TransformFeedback);
{
std::vector<GLfloat> data;
make_hole_data(data, hole_count);
Buffer::Data(Buffer::Target::TransformFeedback, data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog_tfb, "Hole");
attr.Setup<Vec3f>();
attr.Enable();
}
transf_hole_verts.BindBase(
Buffer::IndexedTarget::TransformFeedback,
0
);
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"const vec3 LightPos = vec3(2.0, 3.0, 3.0);"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos-gl_Position.xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"out vec4 fragColor;"
"const int HoleCount = 50;"
"uniform vec3 TransfHole[50];"
"uniform float Diameter;"
"void main(void)"
"{"
" int imax = 0;"
" float dmax = -1.0;"
" for(int i=0; i!=HoleCount; ++i)"
" {"
" float d = dot(vertNormal, TransfHole[i]);"
" if(dmax < d)"
" {"
" dmax = d;"
" imax = i;"
" }"
" }"
" float l = length(vertLight);"
" vec3 FragDiff = TransfHole[imax] - vertNormal;"
" vec3 FinalNormal = "
" length(FragDiff) > Diameter?"
" vertNormal:"
" normalize(FragDiff+vertNormal*Diameter);"
" float i = (l > 0.0) ? dot("
" FinalNormal, "
" normalize(vertLight)"
" ) / l : 0.0;"
" i = 0.2+max(i*2.5, 0.0);"
" fragColor = vec4(i, i, i, 1.0);"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
diameter.Set(hole_diameter);
// bind the VAO for the sphere
sphere.Bind();
// bind the VBO for the sphere vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_sphere.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the sphere normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_sphere.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
/***************************************************************
* Function: ANIMCreateVirtualSphere()
*
***************************************************************/
void ANIMCreateVirtualSphere(osg::PositionAttitudeTransform** xformScaleFwd,
osg::PositionAttitudeTransform** xformScaleBwd)
{
// create sphere geometry
*xformScaleFwd = new PositionAttitudeTransform;
*xformScaleBwd = new PositionAttitudeTransform;
Geode* sphereGeode = new Geode();
Sphere* virtualSphere = new Sphere();
Drawable* sphereDrawable = new ShapeDrawable(virtualSphere);
virtualSphere->setRadius(ANIM_VIRTUAL_SPHERE_RADIUS);
sphereGeode->addDrawable(sphereDrawable);
(*xformScaleFwd)->addChild(sphereGeode);
(*xformScaleBwd)->addChild(sphereGeode);
osg::StateSet* stateset;
// highlights
/* Sphere* highlightSphere = new Sphere();
ShapeDrawable* highlightDrawable = new ShapeDrawable(highlightSphere);
Geode* highlightGeode = new Geode();
highlightSphere->setRadius(ANIM_VIRTUAL_SPHERE_RADIUS * 1.3);
highlightDrawable->setColor(osg::Vec4(0,0,1,0.3));
highlightGeode->addDrawable(highlightDrawable);
(*xformScaleFwd)->addChild(highlightGeode);
(*xformScaleBwd)->addChild(highlightGeode);
stateset = highlightDrawable->getOrCreateStateSet();
stateset->setMode(GL_BLEND, StateAttribute::ON);
stateset->setMode(GL_CULL_FACE, StateAttribute::ON);
stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
*/
// set up the forward / backward scale animation path
AnimationPath* animationPathScaleFwd = new AnimationPath;
AnimationPath* animationPathScaleBwd = new AnimationPath;
animationPathScaleFwd->setLoopMode(AnimationPath::NO_LOOPING);
animationPathScaleBwd->setLoopMode(AnimationPath::NO_LOOPING);
osg::Vec3 pos(-1.5, 0, 0);
Vec3 scaleFwd, scaleBwd;
float step = 1.f / ANIM_VIRTUAL_SPHERE_NUM_SAMPS;
for (int i = 0; i < ANIM_VIRTUAL_SPHERE_NUM_SAMPS + 1; i++)
{
float val = i * step;
scaleFwd = Vec3(val, val, val);
scaleBwd = Vec3(1-val, 1-val, 1-val);
animationPathScaleFwd->insert(val, AnimationPath::ControlPoint(pos, Quat(), scaleFwd));
animationPathScaleBwd->insert(val, AnimationPath::ControlPoint(pos, Quat(), scaleBwd));
}
AnimationPathCallback *animCallbackFwd = new AnimationPathCallback(animationPathScaleFwd,
0.0, 1.f / ANIM_VIRTUAL_SPHERE_LAPSE_TIME);
AnimationPathCallback *animCallbackBwd = new AnimationPathCallback(animationPathScaleBwd,
0.0, 1.f / ANIM_VIRTUAL_SPHERE_LAPSE_TIME);
(*xformScaleFwd)->setUpdateCallback(animCallbackFwd);
(*xformScaleBwd)->setUpdateCallback(animCallbackBwd);
/* apply shaders to geode stateset */
stateset = new StateSet();
stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
//sphereGeode->setStateSet(stateset);
sphereDrawable->setStateSet(stateset);
Program* shaderProg = new Program;
stateset->setAttribute(shaderProg);
shaderProg->addShader(Shader::readShaderFile(Shader::VERTEX, ANIMDataDir() + "Shaders/VirtualSphere.vert"));
shaderProg->addShader(Shader::readShaderFile(Shader::FRAGMENT, ANIMDataDir() + "Shaders/VirtualSphere.frag"));
Image* envMap = osgDB::readImageFile(ANIMDataDir() + "Textures/EnvMap.JPG");
Texture2D* envTex = new Texture2D(envMap);
stateset->setTextureAttributeAndModes(0, envTex, StateAttribute::ON);
Uniform* envMapSampler = new Uniform("EnvMap", 0);
stateset->addUniform(envMapSampler);
Uniform* baseColorUniform = new Uniform("BaseColor", Vec3(0.2, 1.0, 0.2));
stateset->addUniform(baseColorUniform);
Uniform* lightPosUniform = new Uniform("LightPos", Vec4(1.0, 0.0, 0.2, 0.0));
stateset->addUniform(lightPosUniform);
}
Program* ProgramManager::CreateFromDescriptor( ProgramDescriptor* descriptor )
{
int id;
string name;
string description;
DescriptorsUtil::GetIntProperty( descriptor->Properties, "Id", &id );
DescriptorsUtil::GetStringProperty( descriptor->Properties, "Name", &name );
DescriptorsUtil::GetStringProperty( descriptor->Properties, "Description",
&description );
Program* program = new Program( id, name, description );
string deviceType;
// ------ Initialize Devices:
list<DeviceDescriptor>::iterator deviceIt;
for ( deviceIt = descriptor->Devices.begin(); deviceIt
!= descriptor->Devices.end(); deviceIt++ )
{
BaseDevice* device = DeviceManager::Instance()->CreateFromDescriptor(
*deviceIt );
if( device == NULL )
return NULL;
program->AddDevice( device );
}
// ------- Initialize Wires:
list<WireDescriptor>::iterator wireIt;
list<WireConnectionPointDescriptor>::iterator cpIt; //connectionPointsIt
for ( wireIt = descriptor->Wires.begin(); wireIt != descriptor->Wires.end(); wireIt++ )
{
Wire* wire = new Wire();
for ( cpIt = ( *wireIt ).WireConnectionPoints.begin(); cpIt
!= ( *wireIt ).WireConnectionPoints.end(); cpIt++ )
{
BaseDevice* device = program->GetDevice(
( *cpIt ).DeviceDescriptorId );
ConnectionPoint* cp = device->GetConnectionPoint(
( *cpIt ).ConnectionPointDescriptorId );
wire->Attach( cp );
}
program->AddWire( wire );
}
// ------ Initialize the program's Power Wire:
list<WireConnectionPointDescriptor>* stratupPoints =
&descriptor->PowerWire.WireConnectionPoints;
for ( cpIt = stratupPoints->begin(); cpIt != stratupPoints->end(); cpIt++ )
{
int* startUpValue = new int( 1 );
BaseDevice* device = program->GetDevice( ( *cpIt ).DeviceDescriptorId );
ConnectionPoint* cp = device->GetConnectionPoint(
( *cpIt ).ConnectionPointDescriptorId );
InConnectionPoint* inConnectionPoint = (InConnectionPoint*) cp;
inConnectionPoint->SetValue( startUpValue );
program->PowerWire()->Attach( inConnectionPoint );
}
return program;
}
int FullTree::breed(System* system, Population* src, vector<Program>* newpop, int index)
{
Program* newp;
newpop->push_back(Program(system));
newp=&newpop->back();
newp->functions.assign(system->adf.begin(), system->adf.end());
newp->branch.push_back(vector<TreeNode>());
// Push the main program branch on
fulltree(system, system->returntype, TreeNodeIter(&newp->branch[0], 0), (maxdepth<=mindepth?0:(rand()%(maxdepth-mindepth+1)))+mindepth);
// Need to add ADF branches
for (int i=0;i<system->adf.size();++i)
newp->branch.push_back(vector<TreeNode>());
ADF* curfunc;
for (int i=system->adf.size()-1;i>=0;--i)
{
curfunc = (ADF*)(system->adf[i]);
// Remove current function from list
if (system->recursiveDepth<=0)
{
#ifdef DEBUG
if (system->functions[curfunc->arg_type[0]].back()!=curfunc)
throw runtime_error("Function being popped off of system does not match last adf entry");
#endif
system->functions[curfunc->arg_type[0]].pop_back();
}
// Push function arguments
for (int j=1;j<curfunc->arg_type.size();++j)
system->functions[curfunc->arg_type[j]].push_back(curfunc->args[j-1]);
// Generate tree
fulltree(system, curfunc->arg_type[0], TreeNodeIter(&newp->branch[i+1], 0), (maxdepth<=mindepth?0:(rand()%(maxdepth-mindepth+1)))+mindepth);
// Pop function arguments
for (int j=curfunc->arg_type.size()-1;j>=1;--j)
{
system->functions[curfunc->arg_type[j]].pop_back();
}
}
if (system->recursiveDepth<=0)
{
for (int i=0;i<system->adf.size();++i)
{
curfunc = (ADF*)system->adf[i];
system->functions[curfunc->arg_type[0]].push_back(curfunc);
}
}
#ifdef DEBUG
if (!newp->checkConsistency())
{
throw runtime_error("Invalid produced program");
}
#endif
return 1;
}
void program_2(int a, int b) {
Program qp (CGAL::SMALLER, false, 0, true, 0);
const int X = 0;
const int Y = 1;
const int Z = 2;
qp.set_l(Z, 0);
qp.set_u(Z, false);
// minimize a*x^2 + b*y + z^4
qp.set_d(X, X, 2*a);
qp.set_d(Z, Z, 2*1); // by convention: we multiply value by 2.
qp.set_c(Y, b);
qp.set_a(X, 0, 1);
qp.set_a(Y, 0, 1);
qp.set_b(0, -4);
qp.set_r(0, CGAL::LARGER);
qp.set_a(X, 1, 4);
qp.set_a(Y, 1, 2);
qp.set_a(Z, 1, 1);
qp.set_b(1, -1*a*b);
qp.set_r(1, CGAL::LARGER);
qp.set_a(X, 2, -1);
qp.set_a(Y, 2, 1);
qp.set_b(2, -1);
qp.set_r(2, CGAL::LARGER);
qp.set_a(Z, 3, 1);
qp.set_b(3, 0);
qp.set_r(3, CGAL::LARGER);
Solution s = CGAL::solve_quadratic_program(qp, ET());
assert(s.solves_quadratic_program(qp));
if(s.is_optimal()) {
double result = ceil(CGAL::to_double(s.objective_value()));
cout << result << "\n";
}
else if(s.is_unbounded())
cout << "unbounded\n";
else if(s.is_infeasible())
cout << "no\n";
}
RectangleExample(void)
: vs(ShaderType::Vertex)
, fs(ShaderType::Fragment)
{
// this could be any istream
std::stringstream vs_source(
"#version 330\n"
"in vec2 Position;"
"in vec3 Color;"
"out vec3 vertColor;"
"void main(void)"
"{"
" vertColor = Color;"
" gl_Position = vec4(Position, 0.0, 1.0);"
"}"
);
// set the vertex shader source
vs.Source(GLSLSource::FromStream(vs_source));
// compile it
vs.Compile();
std::stringstream fs_source(
"#version 330\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 1.0);"
"}"
);
// set the fragment shader source
fs.Source(GLSLSource::FromStream(fs_source));
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the rectangle
rectangle.Bind();
GLfloat rectangle_verts[8] = {
-1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, -1.0f,
1.0f, 1.0f
};
// bind the VBO for the rectangle vertices
verts.Bind(Buffer::Target::Array);
// upload the data
Buffer::Data(Buffer::Target::Array, 8, rectangle_verts);
// setup the vertex attribs array for the vertices
VertexAttribArray vert_attr(prog, "Position");
vert_attr.Setup<Vec2f>().Enable();
GLfloat rectangle_colors[12] = {
1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
};
// bind the VBO for the rectangle colors
colors.Bind(Buffer::Target::Array);
// upload the data
Buffer::Data(Buffer::Target::Array, 12, rectangle_colors);
// setup the vertex attribs array for the vertices
VertexAttribArray color_attr(prog, "Color");
color_attr.Setup<Vec3f>().Enable();
//
gl.Disable(Capability::DepthTest);
}
CubeMapExample(void)
: shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out vec3 vertNormal;"
"out vec3 vertLightDir;"
"out vec3 vertLightRefl;"
"out vec3 vertViewDir;"
"out vec3 vertViewRefl;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLightDir = LightPos - gl_Position.xyz;"
" vertLightRefl = reflect("
" -normalize(vertLightDir),"
" normalize(vertNormal)"
" );"
" vertViewDir = ("
" vec4(0.0, 0.0, 1.0, 1.0)*"
" CameraMatrix"
" ).xyz;"
" vertViewRefl = reflect("
" normalize(vertViewDir),"
" normalize(vertNormal)"
" );"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform samplerCube TexUnit;"
"in vec3 vertNormal;"
"in vec3 vertLightDir;"
"in vec3 vertLightRefl;"
"in vec3 vertViewDir;"
"in vec3 vertViewRefl;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = length(vertLightDir);"
" float d = dot("
" normalize(vertNormal), "
" normalize(vertLightDir)"
" ) / l;"
" float s = dot("
" normalize(vertLightRefl),"
" normalize(vertViewDir)"
" );"
" vec3 lt = vec3(1.0, 1.0, 1.0);"
" vec3 env = texture(TexUnit, vertViewRefl).rgb;"
" fragColor = vec4("
" env * 0.4 + "
" (lt + env) * 1.5 * max(d, 0.0) + "
" lt * pow(max(s, 0.0), 64), "
" 1.0"
" );"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the shape
shape.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
{
GLuint tex_side = 256;
auto image = images::NewtonFractal(
tex_side, tex_side,
Vec3f(0.3f, 0.1f, 0.2f),
Vec3f(1.0f, 0.8f, 0.9f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X4Minus1(),
images::NewtonFractal::DefaultMixer()
);
auto tex_target = Texture::Target::CubeMap;
// texture syntax sugar
tex << tex_target;
tex_target << TextureMinFilter::Linear;
tex_target << TextureMagFilter::Linear;
tex_target << TextureWrap::ClampToEdge;
for(int i=0; i!=6; ++i)
{
Texture::CubeMapFace(i) << image;
}
}
// typechecked uniform with the exact sampler type
// on compilers supporting strongly typed enums
// you can use:
//Typechecked<Uniform<SLtoCpp<SLDataType::SamplerCube>>>(prog, "TexUnit").Set(0);
// without strongly typed enums you need to do:
typedef SLtoCpp<OGLPLUS_CONST_ENUM_VALUE(SLDataType::SamplerCube)> GLSLsamplerCube;
Typechecked<Uniform<GLSLsamplerCube>>(prog, "TexUnit").Set(0);
//
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(3.0f, 5.0f, 4.0f));
//
gl.ClearColor(0.2f, 0.05f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
gl.CullFace(Face::Back);
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"in vec4 Position;"
"out vec3 vertColor;"
"void main(void)"
"{"
" float angle = gl_InstanceID * 10 * 2 * 3.14159 / 360.0;"
" float cx = cos(angle);"
" float sx = sin(angle);"
" mat4 ModelMatrix = mat4("
" cx, 0.0, sx, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" -sx, 0.0, cx, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ) * mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" 0.0, 0.0, 1.0, 0.0,"
" 12.0, 0.0, 0.0, 1.0 "
" );"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
" vertColor = abs(normalize((ModelMatrix*Position).xyz));"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 1.0);"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
//
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
void rsi_ProgramBindConstants(Context *rsc, RsProgram vp, uint32_t slot, RsAllocation constants) {
Program *p = static_cast<Program *>(vp);
p->bindAllocation(rsc, static_cast<Allocation *>(constants), slot);
}
//-----------------------------------------------------------------------
bool FFPTexturing::resolveFunctionsParams(TextureUnitParams* textureUnitParams, ProgramSet* programSet)
{
Program* vsProgram = programSet->getCpuVertexProgram();
Program* psProgram = programSet->getCpuFragmentProgram();
Function* vsMain = vsProgram->getEntryPointFunction();
Function* psMain = psProgram->getEntryPointFunction();
Parameter::Content texCoordContent = Parameter::SPC_UNKNOWN;
switch (textureUnitParams->mTexCoordCalcMethod)
{
case TEXCALC_NONE:
// Resolve explicit vs input texture coordinates.
if (textureUnitParams->mTextureMatrix.get() == NULL)
texCoordContent = Parameter::Content(Parameter::SPC_TEXTURE_COORDINATE0 + textureUnitParams->mTextureUnitState->getTextureCoordSet());
textureUnitParams->mVSInputTexCoord = vsMain->resolveInputParameter(Parameter::SPS_TEXTURE_COORDINATES,
textureUnitParams->mTextureUnitState->getTextureCoordSet(),
Parameter::Content(Parameter::SPC_TEXTURE_COORDINATE0 + textureUnitParams->mTextureUnitState->getTextureCoordSet()),
textureUnitParams->mVSInTextureCoordinateType);
if (textureUnitParams->mVSInputTexCoord.get() == NULL)
return false;
break;
case TEXCALC_ENVIRONMENT_MAP:
case TEXCALC_ENVIRONMENT_MAP_PLANAR:
case TEXCALC_ENVIRONMENT_MAP_NORMAL:
// Resolve vertex normal.
mVSInputNormal = vsMain->resolveInputParameter(Parameter::SPS_NORMAL, 0, Parameter::SPC_NORMAL_OBJECT_SPACE, GCT_FLOAT3);
if (mVSInputNormal.get() == NULL)
return false;
break;
case TEXCALC_ENVIRONMENT_MAP_REFLECTION:
// Resolve vertex normal.
mVSInputNormal = vsMain->resolveInputParameter(Parameter::SPS_NORMAL, 0, Parameter::SPC_NORMAL_OBJECT_SPACE, GCT_FLOAT3);
if (mVSInputNormal.get() == NULL)
return false;
// Resolve vertex position.
mVSInputPos = vsMain->resolveInputParameter(Parameter::SPS_POSITION, 0, Parameter::SPC_POSITION_OBJECT_SPACE, GCT_FLOAT4);
if (mVSInputPos.get() == NULL)
return false;
break;
case TEXCALC_PROJECTIVE_TEXTURE:
// Resolve vertex position.
mVSInputPos = vsMain->resolveInputParameter(Parameter::SPS_POSITION, 0, Parameter::SPC_POSITION_OBJECT_SPACE, GCT_FLOAT4);
if (mVSInputPos.get() == NULL)
return false;
break;
}
// Resolve vs output texture coordinates.
textureUnitParams->mVSOutputTexCoord = vsMain->resolveOutputParameter(Parameter::SPS_TEXTURE_COORDINATES,
-1,
texCoordContent,
textureUnitParams->mVSOutTextureCoordinateType);
if (textureUnitParams->mVSOutputTexCoord.get() == NULL)
return false;
// Resolve ps input texture coordinates.
textureUnitParams->mPSInputTexCoord = psMain->resolveInputParameter(Parameter::SPS_TEXTURE_COORDINATES,
textureUnitParams->mVSOutputTexCoord->getIndex(),
textureUnitParams->mVSOutputTexCoord->getContent(),
textureUnitParams->mVSOutTextureCoordinateType);
if (textureUnitParams->mPSInputTexCoord.get() == NULL)
return false;
const ShaderParameterList& inputParams = psMain->getInputParameters();
const ShaderParameterList& localParams = psMain->getLocalParameters();
mPSDiffuse = psMain->getParameterByContent(inputParams, Parameter::SPC_COLOR_DIFFUSE, GCT_FLOAT4);
if (mPSDiffuse.get() == NULL)
{
mPSDiffuse = psMain->getParameterByContent(localParams, Parameter::SPC_COLOR_DIFFUSE, GCT_FLOAT4);
if (mPSDiffuse.get() == NULL)
return false;
}
mPSSpecular = psMain->getParameterByContent(inputParams, Parameter::SPC_COLOR_SPECULAR, GCT_FLOAT4);
if (mPSSpecular.get() == NULL)
{
mPSSpecular = psMain->getParameterByContent(localParams, Parameter::SPC_COLOR_SPECULAR, GCT_FLOAT4);
if (mPSSpecular.get() == NULL)
return false;
}
mPSOutDiffuse = psMain->resolveOutputParameter(Parameter::SPS_COLOR, 0, Parameter::SPC_COLOR_DIFFUSE, GCT_FLOAT4);
if (mPSOutDiffuse.get() == NULL)
return false;
return true;
}
void rsi_ProgramBindTexture(Context *rsc, RsProgram vpf, uint32_t slot, RsAllocation a) {
Program *p = static_cast<Program *>(vpf);
p->bindTexture(rsc, slot, static_cast<Allocation *>(a));
}
void SetProjection(const Mat4f& projection)
{
prog.Use();
projection_matrix.Set(projection);
}
void rsi_ProgramBindSampler(Context *rsc, RsProgram vpf, uint32_t slot, RsSampler s) {
Program *p = static_cast<Program *>(vpf);
p->bindSampler(rsc, slot, static_cast<Sampler *>(s));
}
void ocl_main(UArg arg0, UArg arg1)
{
int argc = (int) arg0;
char **argv = (char **) arg1;
#else
#define RETURN(x) return x
int main(int argc, char *argv[])
{
#endif
cl_int err = CL_SUCCESS;
int bufsize = sizeof(Golden);
int num_errors = 0;
const int print_nerrors = 12;
for (int i=0; i < NumElements; ++i)
{
srcA[i] = i * 1.0;
srcB[i] = ((i+7) % 257 )* 1.0;
Golden[i] = srcA[i] + srcB[i];
}
try
{
Context context(CL_DEVICE_TYPE_ACCELERATOR);
std::vector<Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
int d = 0;
std::string str;
devices[d].getInfo(CL_DEVICE_NAME, &str);
cout << "DEVICE: " << str << endl << endl;
Buffer bufA (context, CL_MEM_READ_ONLY, bufsize);
Buffer bufB (context, CL_MEM_READ_ONLY, bufsize);
Buffer bufDst (context, CL_MEM_WRITE_ONLY, bufsize);
#ifndef _TI_RTOS
ifstream t("vadd_wrapper.cl");
if (!t)
{
std::cout << "Could not open Kernel Source file ([file].cl)\n";
exit(-1);
}
std::string kSrc((istreambuf_iterator<char>(t)),
istreambuf_iterator<char>());
Program::Sources source(1, make_pair(kSrc.c_str(), kSrc.length()));
Program program = Program(context, source);
program.build(devices, "vadd_openmp.obj");
#else
Program::Binaries binary(1, make_pair(vadd_wrapper_dsp_bin,
sizeof(vadd_wrapper_dsp_bin)));
Program program = Program(context, devices, binary);
program.build(devices);
#endif
Kernel kernel(program, "vadd_wrapper");
kernel.setArg(0, bufA);
kernel.setArg(1, bufB);
kernel.setArg(2, bufDst);
kernel.setArg(3, NumChunks);
kernel.setArg(4, ChunkSize);
Event ev1,ev2,ev3,ev4, ev5, ev6,ev7,ev8;
// In Order Command Queue, only one kernel pushed to device at a time
// OpenMP c code should use: In Order Command Queue + Task
CommandQueue InO_Q(context, devices[d], CL_QUEUE_PROFILING_ENABLE);
InO_Q.enqueueWriteBuffer(bufA, CL_FALSE, 0, bufsize, srcA, NULL, &ev1);
InO_Q.enqueueWriteBuffer(bufB, CL_FALSE, 0, bufsize, srcB, NULL, &ev2);
std::vector<Event> vec_ev5(1);
InO_Q.enqueueTask(kernel, NULL, &vec_ev5[0]);
InO_Q.enqueueReadBuffer(bufDst, CL_TRUE, 0, bufsize, dst, &vec_ev5, &ev6);
for (int i=0; i < NumElements; ++i)
{
if (Golden[i] - dst[i] < -EPISILON || Golden[i] - dst[i] > EPISILON)
{
if((num_errors += 1) < print_nerrors)
printf("Error %d: %f <==> %f\n", i, Golden[i], dst[i]);
}
}
ocl_event_times(ev1, "Write BufA ");
ocl_event_times(ev2, "Write BufB ");
ocl_event_times(vec_ev5[0], "Kernel ");
ocl_event_times(ev6, "Read BufDst");
}
catch (Error err)
{ cerr << "ERROR: " << err.what() << "(" << err.err() << ")" << endl; }
if (num_errors > 0)
{
cout << "FAIL with " << num_errors << " errors!\n";
RETURN (-1);
}
else cout << "PASS!" << endl;
RETURN (0);
}
//-----------------------------------------------------------------------
bool FFPFog::addFunctionInvocations(ProgramSet* programSet)
{
if (mFogMode == FOG_NONE)
return true;
Program* vsProgram = programSet->getCpuVertexProgram();
Program* psProgram = programSet->getCpuFragmentProgram();
Function* vsMain = vsProgram->getEntryPointFunction();
Function* psMain = psProgram->getEntryPointFunction();
FunctionInvocation* curFuncInvocation = NULL;
int internalCounter;
// Per pixel fog.
if (mCalcMode == CM_PER_PIXEL)
{
internalCounter = 0;
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_PIXELFOG_DEPTH, FFP_VS_FOG, internalCounter++);
curFuncInvocation->pushOperand(mWorldViewProjMatrix, Operand::OPS_IN);
curFuncInvocation->pushOperand(mVSInPos, Operand::OPS_IN);
curFuncInvocation->pushOperand(mVSOutDepth, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
internalCounter = 0;
switch (mFogMode)
{
case FOG_LINEAR:
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_PIXELFOG_LINEAR, FFP_PS_FOG, internalCounter++);
break;
case FOG_EXP:
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_PIXELFOG_EXP, FFP_PS_FOG, internalCounter++);
break;
case FOG_EXP2:
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_PIXELFOG_EXP2, FFP_PS_FOG, internalCounter++);
break;
case FOG_NONE:
default:
break;
}
curFuncInvocation->pushOperand(mPSInDepth, Operand::OPS_IN);
curFuncInvocation->pushOperand(mFogParams, Operand::OPS_IN);
curFuncInvocation->pushOperand(mFogColour, Operand::OPS_IN);
curFuncInvocation->pushOperand(mPSOutDiffuse, Operand::OPS_IN);
curFuncInvocation->pushOperand(mPSOutDiffuse, Operand::OPS_OUT);
psMain->addAtomInstance(curFuncInvocation);
}
// Per vertex fog.
else
{
internalCounter = 0;
switch (mFogMode)
{
case FOG_LINEAR:
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_VERTEXFOG_LINEAR, FFP_VS_FOG, internalCounter++);
break;
case FOG_EXP:
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_VERTEXFOG_EXP, FFP_VS_FOG, internalCounter++);
break;
case FOG_EXP2:
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_VERTEXFOG_EXP2, FFP_VS_FOG, internalCounter++);
break;
case FOG_NONE:
default:
break;
}
curFuncInvocation->pushOperand(mWorldViewProjMatrix, Operand::OPS_IN);
curFuncInvocation->pushOperand(mVSInPos, Operand::OPS_IN);
curFuncInvocation->pushOperand(mFogParams, Operand::OPS_IN);
curFuncInvocation->pushOperand(mVSOutFogFactor, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
internalCounter = 0;
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_LERP, FFP_PS_FOG, internalCounter++);
curFuncInvocation->pushOperand(mFogColour, Operand::OPS_IN);
curFuncInvocation->pushOperand(mPSOutDiffuse, Operand::OPS_IN);
curFuncInvocation->pushOperand(mPSInFogFactor, Operand::OPS_IN);
curFuncInvocation->pushOperand(mPSOutDiffuse, Operand::OPS_OUT);
psMain->addAtomInstance(curFuncInvocation);
}
return true;
}