//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Clipping::onInitialize()
{
createAndPublishProperties();
ref<ModelBasicList> myModel = new ModelBasicList;
ref<DrawableGeo> geo;
WavefrontObjImport imp;
imp.readFile(m_testDataDir + "dragon_10k.obj");
//imp.readFile(m_testDataDir + "teapot.obj");
GeometryBuilderDrawableGeo builder;
imp.buildGeometry(&builder);
geo = builder.drawableGeo();
geo->weldVertices(0.00001);
geo->computeNormals();
ref<Part> part = new Part;
part->setDrawable(geo.p());
m_clipPlaneSet = new ClipPlaneSet;
m_renderSequence->firstRendering()->addDynamicUniformSet(m_clipPlaneSet.p());
configureClipPlaneSetFromProperties();
ref<Effect> eff = createClippingFixedHeadlightEffect(Color3f(Color3::SKY_BLUE));
part->setEffect(eff.p());
myModel->addPart(part.p());
m_renderSequence->firstRendering()->scene()->addModel(myModel.p());
myModel->updateBoundingBoxesRecursive();
BoundingBox bb = myModel->boundingBox();
if (bb.isValid())
{
m_camera->fitView(bb, -Vec3d::Z_AXIS, Vec3d::Y_AXIS);
}
m_renderSequence->firstRendering()->addOverlayItem(new OverlayAxisCross(m_camera.p(), new FixedAtlasFont(FixedAtlasFont::STANDARD)));
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool EnvironmentMapping::onInitialize()
{
ref<ModelBasicList> myModel = new ModelBasicList;
m_modelTransformMatrix = new Transform;
m_lastAnimUpdateTimeStamp = 0;
// Part with static texture
//ref<TextureImage> img = cvfu::ImageJpeg::loadImage(m_testDataDir + "spheremap_uffizi_gallery.jpg");
ref<TextureImage> img = cvfu::ImageJpeg::loadImage(m_testDataDir + "spheremap_metal.jpg");
ref<Texture> envTexture = new Texture(img.p());
ref<cvf::Sampler> sampler = new cvf::Sampler;
sampler->setWrapMode(Sampler::CLAMP_TO_EDGE);
sampler->setMinFilter(Sampler::LINEAR);
sampler->setMagFilter(Sampler::LINEAR);
ref<cvf::RenderStateTextureBindings> texBind = new cvf::RenderStateTextureBindings;
texBind->addBinding(envTexture.p(), sampler.p(), "u_texture2D");
// The 'main' geometry
{
ref<DrawableGeo> geo;
WavefrontObjImport imp;
imp.readFile(m_testDataDir + "teapot.obj");
GeometryBuilderDrawableGeo builder;
imp.buildGeometry(&builder);
geo = builder.drawableGeo();
geo->weldVertices(0.00001);
geo->computeNormals();
ref<Part> part = new Part;
part->setDrawable(geo.p());
ShaderProgramGenerator gen("EnvironmentMapping", ShaderSourceProvider::instance());
gen.addVertexCode(ShaderSourceRepository::vs_EnvironmentMapping);
gen.addFragmentCode(ShaderSourceRepository::src_Texture);
gen.addFragmentCode(ShaderSourceRepository::light_SimpleHeadlight);
gen.addFragmentCode(ShaderSourceRepository::fs_Standard);
ref<ShaderProgram> prog = gen.generate();
// Link and show log to see any warnings
prog->linkProgram(m_openGLContext.p());
if (!prog->programInfoLog(m_openGLContext.p()).isEmpty()) Trace::show(prog->programInfoLog(m_openGLContext.p()));
ref<Effect> eff = new Effect;
eff->setRenderState(texBind.p());
eff->setShaderProgram(prog.p());
part->setEffect(eff.p());
part->setTransform(m_modelTransformMatrix.p());
myModel->addPart(part.p());
}
m_renderSequence->firstRendering()->scene()->addModel(myModel.p());
myModel->updateBoundingBoxesRecursive();
BoundingBox bb = myModel->boundingBox();
if (bb.isValid())
{
m_camera->fitView(bb, -Vec3d::Z_AXIS, Vec3d::Y_AXIS);
}
m_renderSequence->firstRendering()->addOverlayItem(new OverlayAxisCross(m_camera.p(), new FixedAtlasFont(FixedAtlasFont::STANDARD)), OverlayItem::BOTTOM_LEFT, OverlayItem::HORIZONTAL);
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool PointSprites::onInitialize()
{
ref<ModelBasicList> model = new ModelBasicList;
bool useShaders = true;
{
GeometryBuilderDrawableGeo builder;
GeometryUtils::createSphere(1, 10, 10, &builder);
ref<DrawableGeo> geo = builder.drawableGeo();
ref<Effect> eff = new Effect;
if (useShaders)
{
cvf::ShaderProgramGenerator gen("SimpleHeadlight", cvf::ShaderSourceProvider::instance());
gen.configureStandardHeadlightColor();
ref<ShaderProgram> prog = gen.generate();
eff->setShaderProgram(prog.p());
eff->setUniform(new UniformFloat("u_color", Color4f(Color3::YELLOW)));
}
else
{
eff->setRenderState(new RenderStateMaterial_FF(RenderStateMaterial_FF::PURE_YELLOW));
}
ref<Part> part = new Part;
part->setDrawable(geo.p());
part->setEffect(eff.p());
model->addPart(part.p());
}
{
ref<Vec3fArray> vertices = new Vec3fArray;
vertices->reserve(10);
vertices->add(Vec3f(0, 0, 0));
vertices->add(Vec3f(-3, 0, 0));
vertices->add(Vec3f(3, 0, 0));
ref<UIntArray> indices = new UIntArray(vertices->size());
indices->setConsecutive(0);
ref<PrimitiveSetIndexedUInt> primSet = new PrimitiveSetIndexedUInt(PT_POINTS);
primSet->setIndices(indices.p());
ref<DrawableGeo> geo = new DrawableGeo;
geo->setVertexArray(vertices.p());
geo->addPrimitiveSet(primSet.p());
ref<Effect> eff = new Effect;
if (useShaders)
{
bool useTextureSprite = true;
cvf::ShaderProgramGenerator gen("PointSprites", cvf::ShaderSourceProvider::instance());
gen.addVertexCode(ShaderSourceRepository::vs_DistanceScaledPoints);
if (useTextureSprite) gen.addFragmentCode(ShaderSourceRepository::src_TextureFromPointCoord);
else gen.addFragmentCode(ShaderSourceRepository::src_Color);
gen.addFragmentCode(ShaderSourceRepository::fs_CenterLitSpherePoints);
ref<cvf::ShaderProgram> prog = gen.generate();
eff->setShaderProgram(prog.p());
eff->setUniform(new UniformFloat("u_pointRadius", 1.0f));
if (useTextureSprite)
{
ref<Texture> tex = createTexture();
ref<Sampler> sampler = new Sampler;
sampler->setMinFilter(Sampler::LINEAR);
sampler->setMagFilter(Sampler::NEAREST);
sampler->setWrapModeS(Sampler::REPEAT);
sampler->setWrapModeT(Sampler::REPEAT);
ref<RenderStateTextureBindings> texBind = new RenderStateTextureBindings(tex.p(), sampler.p(), "u_texture2D");
eff->setRenderState(texBind.p());
}
else
{
eff->setUniform(new UniformFloat("u_color", Color4f(Color3::RED)));
}
ref<RenderStatePoint> point = new RenderStatePoint(RenderStatePoint::PROGRAM_SIZE);
point->enablePointSprite(true);
eff->setRenderState(point.p());
}
else
{
eff->setRenderState(new RenderStateLighting_FF(false));
eff->setRenderState(new RenderStateMaterial_FF(RenderStateMaterial_FF::PURE_MAGENTA));
ref<RenderStatePoint> point = new RenderStatePoint(RenderStatePoint::FIXED_SIZE);
point->enablePointSprite(true);
point->setSize(600.0f);
eff->setRenderState(point.p());
}
ref<Part> part = new Part;
part->setDrawable(geo.p());
part->setEffect(eff.p());
model->addPart(part.p());
}
model->updateBoundingBoxesRecursive();
m_renderSequence->firstRendering()->scene()->addModel(model.p());
BoundingBox bb = model->boundingBox();
if (bb.isValid())
{
m_camera->fitView(bb, -Vec3d::Z_AXIS, Vec3d::Y_AXIS);
if (m_usePerspective)
{
m_camera->setProjectionAsPerspective(m_fovScale*40.0, m_nearPlane, m_camera->farPlane());
}
else
{
m_camera->setProjectionAsOrtho(m_fovScale*bb.extent().length(), m_nearPlane, m_camera->farPlane());
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool ShaderUniforms::onInitialize()
{
m_propGlobalUniformSet = new PropertyBool("Use global uniform set", true);
m_propertyPublisher->publishProperty(m_propGlobalUniformSet.p());
// Create the single shader program with default uniforms
ref<ShaderProgram> shaderProg;
{
ShaderProgramGenerator shaderGen("ShaderUniforms", ShaderSourceProvider::instance());
shaderGen.addVertexCodeFromFile("ShaderUniforms_Vert");
shaderGen.addFragmentCode(ShaderSourceRepository::light_SimpleHeadlight);
shaderGen.addFragmentCodeFromFile("ShaderUniforms_Frag");
shaderProg = shaderGen.generate();
shaderProg->setDefaultUniform(new UniformFloat("u_color0", Color3f(Color3::WHITE)));
shaderProg->setDefaultUniform(new UniformFloat("u_color1", Color3f(Color3::MAGENTA)));
shaderProg->setDefaultUniform(new UniformFloat("u_colorMixFactor", 1.0f));
}
// No uniforms, relies only on the shader program defaults
m_effNoUniforms = new Effect;
m_effNoUniforms->setShaderProgram(shaderProg.p());
// Effect with only mix factor set (uses colors from default)
m_effWithSomeUniforms = new Effect;
m_effWithSomeUniforms->setShaderProgram(shaderProg.p());
m_effWithSomeUniforms->setUniform(new UniformFloat("u_colorMixFactor", 0));
// Fully specified uniforms
m_effWithAllUniforms = new Effect;
m_effWithAllUniforms->setShaderProgram(shaderProg.p());
m_effWithAllUniforms->setUniform(new UniformFloat("u_color0", Color3f(Color3::BLACK)));
m_effWithAllUniforms->setUniform(new UniformFloat("u_color1", Color3f(Color3::GREEN)));
m_effWithAllUniforms->setUniform(new UniformFloat("u_colorMixFactor", 1.0f));
// Box part
ref<Part> boxPart = new Part;
{
BoxGenerator gen;
gen.setCenterAndExtent(Vec3d(-2, 0, 0), Vec3d(2, 2, 2));
GeometryBuilderDrawableGeo builder;
gen.generate(&builder);
boxPart->setDrawable(builder.drawableGeo().p());
}
// Sphere part
ref<Part> spherePart = new Part;
{
GeometryBuilderDrawableGeo builder;
GeometryUtils::createSphere(1, 10, 10, &builder);
spherePart->setDrawable(builder.drawableGeo().p());
}
// Cylinder part
ref<Part> cylinderPart = new Part;
{
GeometryBuilderDrawableGeo builder;
GeometryUtils::createObliqueCylinder(1, 1, 2, 0, 0, 10, true, true, true, 1, &builder);
ref<DrawableGeo> geo = builder.drawableGeo();
geo->transform(Mat4d::fromTranslation(Vec3d(2, 0, -1)));
cylinderPart->setDrawable(geo.p());
}
ref<ModelBasicList> myModel = new ModelBasicList;
boxPart->setEffect(m_effNoUniforms.p());
spherePart->setEffect(m_effWithSomeUniforms.p());
cylinderPart->setEffect(m_effWithAllUniforms.p());
myModel->addPart(boxPart.p());
myModel->addPart(spherePart.p());
myModel->addPart(cylinderPart.p());
myModel->updateBoundingBoxesRecursive();
m_renderSequence->firstRendering()->scene()->addModel(myModel.p());
BoundingBox bb = myModel->boundingBox();
if (bb.isValid())
{
m_camera->fitView(bb, Vec3d::Y_AXIS, Vec3d::Z_AXIS);
}
applyCurrentProperties();
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool VertexColoring::onInitialize()
{
ref<ModelBasicList> myModel = new ModelBasicList;
// Create the fixed function effect
{
m_fixedFuncEffect = new Effect;
ref<RenderStateMaterial_FF> mat = new RenderStateMaterial_FF(Color3::BLUE);
mat->enableColorMaterial(true);
m_fixedFuncEffect->setRenderState(mat.p());
ref<RenderStateLighting_FF> lighting = new RenderStateLighting_FF;
m_fixedFuncEffect->setRenderState(lighting.p());
}
// Create effect with shader program
{
m_shaderEffect = new Effect;
ShaderProgramGenerator gen("PerVertexColor", ShaderSourceProvider::instance());
gen.addVertexCode(ShaderSourceRepository::vs_Standard);
gen.addFragmentCode(ShaderSourceRepository::src_VaryingColorGlobalAlpha);
gen.addFragmentCode(ShaderSourceRepository::light_SimpleHeadlight);
gen.addFragmentCode(ShaderSourceRepository::fs_Standard);
m_shaderProg = gen.generate();
m_shaderProg->setDefaultUniform(new cvf::UniformFloat("u_alpha", 1.0f));
m_shaderEffect->setShaderProgram(m_shaderProg.p());
}
ref<Effect> effectToUse = m_useShaders ? m_shaderEffect : m_fixedFuncEffect;
// Lower left: "Normal" geometry
{
GeometryBuilderDrawableGeo builder;
GeometryUtils::createBox(Vec3f(0,0,0), 2.0, 2.0, 2.0, &builder);
ref<DrawableGeo> geo = builder.drawableGeo();
geo->computeNormals();
ref<Part> part = new Part;
part->setDrawable(geo.p());
part->setEffect(effectToUse.p());
myModel->addPart(part.p());
}
// Lower right: Geometry with per vertex colors
// Results in one color per face of the cube
{
GeometryBuilderDrawableGeo builder;
GeometryUtils::createBox(Vec3f(3,0,0), 2.0, 2.0, 2.0, &builder);
ref<DrawableGeo> geo = builder.drawableGeo();
geo->computeNormals();
const Color3ub colorTable[] =
{
Color3ub(Color3::ORANGE),
Color3ub(Color3::FOREST_GREEN),
Color3ub(Color3::SKY_BLUE),
Color3ub(Color3::ORCHID),
Color3ub(Color3::BROWN),
Color3ub(Color3::DARK_RED)
};
const int colorTableSize = sizeof(colorTable)/sizeof(Color3ub);
size_t vertexCount = geo->vertexCount();
ref<Color3ubArray> colorArray = new Color3ubArray;
colorArray->resize(vertexCount);
colorArray->setAll(Color3::WHITE);
size_t i;
for (i = 0; i < vertexCount; i++)
{
Color3ub c = colorTable[(i/4) % colorTableSize];
colorArray->set(i, c);
}
geo->setColorArray(colorArray.p());
ref<Part> part = new Part;
part->setDrawable(geo.p());
part->setEffect(effectToUse.p());
myModel->addPart(part.p());
}
// Upper right: Geometry with per vertex colors (using ScalarToColorMapper)
{
BoxGenerator gen;
gen.setMinMax(Vec3d(2,-1,2), Vec3d(4, 1, 4));
gen.setSubdivisions(10, 10, 10);
GeometryBuilderDrawableGeo builder;
gen.generate(&builder);
ref<DrawableGeo> geo = builder.drawableGeo();
geo->computeNormals();
cvf::Color3ubArray colors;
colors.reserve(4);
colors.add(Color3::BLUE);
colors.add(Color3::CYAN);
colors.add(Color3::YELLOW);
colors.add(Color3::RED);
ScalarMapperUniformLevels mapper;
mapper.setColors(colors);
mapper.setRange(0, 3);
size_t vertexCount = geo->vertexCount();
ref<Color3ubArray> colorArray = new Color3ubArray;
colorArray->resize(vertexCount);
colorArray->setAll(Color3::WHITE);
size_t i;
for (i = 0; i < vertexCount; i++)
{
Vec3f v = geo->vertexArray()->get(i);
float dist = v.pointDistance(Vec3f(2, -1, 2));
Color3ub c = mapper.mapToColor(dist);
colorArray->set(i, c);
}
geo->setColorArray(colorArray.p());
ref<Part> part = new Part;
part->setDrawable(geo.p());
part->setEffect(effectToUse.p());
myModel->addPart(part.p());
}
// Upper left: Geometry without normals
{
GeometryBuilderDrawableGeo builder;
GeometryUtils::createBox(Vec3f(0,0,3), 2.0, 2.0, 2.0, &builder);
ref<DrawableGeo> geo = builder.drawableGeo();
geo->setNormalArray(NULL);
ref<Part> part = new Part;
part->setDrawable(geo.p());
part->setEffect(effectToUse.p());
myModel->addPart(part.p());
}
myModel->updateBoundingBoxesRecursive();
m_renderSequence->firstRendering()->scene()->addModel(myModel.p());
m_renderSequence->firstRendering()->addOverlayItem(new OverlayAxisCross(m_camera.p(), new FixedAtlasFont(FixedAtlasFont::STANDARD)));
BoundingBox bb = m_renderSequence->boundingBox();
if (bb.isValid())
{
m_camera->fitView(bb, Vec3d::Y_AXIS, Vec3d::Z_AXIS);
}
addEdgesRendering();
return true;
}
