MyCaveGeneratorTestLoop(Window *w) : SDLLoop(w)
{
cout << "Initializing glew\n";
glewInit();
cout << "Binding program\n";
program.addShader(Shader(GL_VERTEX_SHADER, "functional/phong/shader.vp"));
program.addShader(Shader(GL_FRAGMENT_SHADER, "functional/phong/shader.fp"));
program.link();
program.bind();
cout << "Getting locations of shader parameters\n";
vertexLocation = program.getAttributeLocation("vPosition");
texCoordLocation = program.getAttributeLocation("uv");
vertexColorLocation = program.getAttributeLocation("vColor");
samplerLocation = program.getUniformLocation("image");
modelLocation = program.getUniformLocation("model");
perspectiveLocation= program.getUniformLocation("perspective");
normalLocation = program.getAttributeLocation("Normal");
ambientProductLocation = program.getUniformLocation("ambientProduct");
diffuseProductLocation = program.getUniformLocation("diffuseProduct");
specularProductLocation = program.getUniformLocation("specularProduct");
lightPositionLocation = program.getUniformLocation("LightPosition");
shininessLocation = program.getUniformLocation("shininess");
program.enableAttributeArray(vertexLocation);
program.enableAttributeArray(texCoordLocation);
program.enableAttributeArray(vertexColorLocation);
program.enableAttributeArray(normalLocation);
signal = new PerlinSignal;
signal->addFrequency(2, 0.2);
signal->addFrequency(16, 0.01);
}
MyArray3DLayeredHeightfieldTestLoop(Window *w) : SDLLoop(w)
{
cout << "Initializing glew\n";
glewInit();
cout << "Binding program\n";
program.addShader(Shader(GL_VERTEX_SHADER, "functional/phong/shader.vp"));
program.addShader(Shader(GL_FRAGMENT_SHADER, "functional/phong/shader.fp"));
program.link();
program.bind();
cout << "Getting locations of shader parameters\n";
vertexLocation = program.getAttributeLocation("vPosition");
texCoordLocation = program.getAttributeLocation("uv");
vertexColorLocation = program.getAttributeLocation("vColor");
samplerLocation = program.getUniformLocation("image");
modelLocation = program.getUniformLocation("model");
perspectiveLocation= program.getUniformLocation("perspective");
normalLocation = program.getAttributeLocation("Normal");
ambientProductLocation = program.getUniformLocation("ambientProduct");
diffuseProductLocation = program.getUniformLocation("diffuseProduct");
specularProductLocation = program.getUniformLocation("specularProduct");
lightPositionLocation = program.getUniformLocation("LightPosition");
shininessLocation = program.getUniformLocation("shininess");
program.enableAttributeArray(vertexLocation);
program.enableAttributeArray(texCoordLocation);
program.enableAttributeArray(vertexColorLocation);
program.enableAttributeArray(normalLocation);
signal = new PerlinSignal;
signal->addFrequency(2, 0.5);
signal->addFrequency(16, 0.01);
generator = new MyLayeredVoxeledHeightfield(signal);
voxels = new Array3D<bool>(128, 128, 128);
generator->populateArray(voxels, 128);
for (int j = 0; j<5; j++) make_hole(*voxels);
for (int i =0; i<10; i++) (*voxels).copy(erode(*voxels));
adapter = new Array3DLayeredHeightfieldAdapter(*voxels);
adapter->generate();
h = adapter->getField();
cout << "Number of levels " << h->levelCount() << endl;
}
MyVoxeledTerrainTestLoop(Window *w) : SDLLoop(w)
{
cout << "Initializing glew\n";
glewInit();
cout << "Binding program\n";
program.addShader(Shader(GL_VERTEX_SHADER, "functional/scene/shader.vp"));
program.addShader(Shader(GL_FRAGMENT_SHADER, "functional/scene/shader.fp"));
program.link();
program.bind();
cout << "Getting locations of shader parameters\n";
vertexLocation = program.getAttributeLocation("vPosition");
texCoordLocation = program.getAttributeLocation("uv");
vertexColorLocation = program.getAttributeLocation("vColor");
samplerLocation = program.getUniformLocation("image");
modelLocation = program.getUniformLocation("model");
perspectiveLocation= program.getUniformLocation("perspective");
normalLocation = program.getAttributeLocation("Normal");
ambientProductLocation = program.getUniformLocation("ambientProduct");
diffuseProductLocation = program.getUniformLocation("diffuseProduct");
specularProductLocation = program.getUniformLocation("specularProduct");
lightPositionLocation = program.getUniformLocation("LightPosition");
shininessLocation = program.getUniformLocation("shininess");
cout << program.getAttributeLocation("vPosition")<< endl;
cout << program.getAttributeLocation("uv")<< endl;
cout << program.getAttributeLocation("vColor")<< endl;
cout << program.getUniformLocation("image")<< endl;
cout << program.getUniformLocation("model")<< endl;
cout << program.getUniformLocation("perspective")<< endl;
cout << program.getAttributeLocation("Normal")<< endl;
cout << program.getUniformLocation("ambientProduct")<< endl;
cout << program.getUniformLocation("diffuseProduct")<< endl;
cout << program.getUniformLocation("specularProduct")<< endl;
cout << program.getUniformLocation("LightPosition")<< endl;
cout << program.getUniformLocation("shininess")<< endl;
cout << "Normal location: " << normalLocation << endl;
program.enableAttributeArray(vertexLocation);
program.enableAttributeArray(texCoordLocation);
program.enableAttributeArray(vertexColorLocation);
program.enableAttributeArray(normalLocation);
}
bool
Scene::load_shaders_from_strings(Program &program,
const std::string &vtx_shader,
const std::string &frg_shader,
const std::string &vtx_shader_filename,
const std::string &frg_shader_filename)
{
program.init();
Log::debug("Loading vertex shader from file %s:\n%s",
vtx_shader_filename.c_str(), vtx_shader.c_str());
program.addShader(GL_VERTEX_SHADER, vtx_shader);
if (!program.valid()) {
Log::error("Failed to add vertex shader from file %s:\n %s\n",
vtx_shader_filename.c_str(),
program.errorMessage().c_str());
program.release();
return false;
}
Log::debug("Loading fragment shader from file %s:\n%s",
frg_shader_filename.c_str(), frg_shader.c_str());
program.addShader(GL_FRAGMENT_SHADER, frg_shader);
if (!program.valid()) {
Log::error("Failed to add fragment shader from file %s:\n %s\n",
frg_shader_filename.c_str(),
program.errorMessage().c_str());
program.release();
return false;
}
program.build();
if (!program.ready()) {
Log::error("Failed to link program created from files %s and %s: %s\n",
vtx_shader_filename.c_str(),
frg_shader_filename.c_str(),
program.errorMessage().c_str());
program.release();
return false;
}
return true;
}
void ShaderManager::addFragmentShaderToProgram(std::string programName, std::string fileName)
{
Program* shader = loadProgram(programName);
std::string fragName = osgDB::findDataFile(fileName);
if(fragName != "")
{
Shader* moreShades = new Shader(Shader::FRAGMENT);
moreShades->setName(fragName.c_str());
moreShades->setShaderSource(loadAndProcessFile(fragName));
shader->addShader(moreShades);
}
else printf("Couldn't find the shader file %s\n", fileName.c_str());
}
Resource *Loader::loadProgram(const conftree::Node &node, const string &name)
{
Program *pr = Program::make(name);
const conftree::Node &shaders = node.at("shaders");
for(unsigned int i=0;i<shaders.items();++i) {
const conftree:: Node &n = shaders.at(i);
Resource *sr = load(n.value());
if(!sr) {
Resources::getInstance().unloadResource(pr->name());
return nullptr;
} else if(!dynamic_cast<Shader*>(sr)) {
throw ResourceException(m_datafile.name(), sr->name(), "resource is not a shader!");
}
pr->addShader(static_cast<Shader*>(sr));
}
pr->link();
return pr;
}
/***************************************************************
* Function: ANIMCreateRefSkyDome()
*
***************************************************************/
MatrixTransform *ANIMCreateRefSkyDome(StateSet **stateset)
{
/* sky dome geometry */
Sphere *skyShape = new Sphere();
ShapeDrawable* skyDrawable = new ShapeDrawable(skyShape);
Geode* skyGeode = new Geode();
MatrixTransform *skyDomeTrans = new MatrixTransform;
//osg::Matrix m;
//m.makeRotate(osg::Quat(M_PI/2, osg::Vec3(0, 1, 0)));
//skyDomeTrans->setMatrix(m);
skyShape->setRadius(ANIM_SKYDOME_RADIUS);
skyGeode->addDrawable(skyDrawable);
skyDomeTrans->addChild(skyGeode);
// apply simple colored materials
Material* material = new Material;
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1.0f, 1.0f, 1.0f, 1.0f));
material->setAlpha(Material::FRONT_AND_BACK, 1.0f);
(*stateset) = new StateSet();
(*stateset)->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON);
(*stateset)->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
(*stateset)->setRenderingHint(StateSet::TRANSPARENT_BIN);
skyGeode->setStateSet(*stateset);
// skyGeode->setNodeMask(0xFFFFFF & ~(0x2 | 0x3));
// load sky dome shader
Uniform* sunrUniform = new Uniform("hazeRadisuMin", 0.975f);
(*stateset)->addUniform(sunrUniform);
Uniform* sunRUniform = new Uniform("hazeRadisuMax", 0.995f);
(*stateset)->addUniform(sunRUniform);
Uniform* sunDirUniform = new Uniform("sundir", Vec4(0.0, 0.0, 1.0, 1.0));
(*stateset)->addUniform(sunDirUniform);
Uniform* suncolorUniform = new Uniform("suncolor", Vec4(1.0, 1.0, 1.0, 1.0));
(*stateset)->addUniform(suncolorUniform);
Uniform* skycolorUniform = new Uniform("skycolor", Vec4(0.5, 0.5, 1.0, 1.0));
(*stateset)->addUniform(skycolorUniform);
Uniform* skyfadingcolorUniform = new Uniform("skyfadingcolor", Vec4(0.8, 0.8, 0.8, 1.0));
(*stateset)->addUniform(skyfadingcolorUniform);
Uniform* skymaskingcolorUniform = new Uniform("skymaskingcolor", Vec4(1.0, 1.0, 1.0, 1.0));
(*stateset)->addUniform(skymaskingcolorUniform);
Uniform *matShaderToWorldUniform = new Uniform("shaderToWorldMat", Matrixd());
(*stateset)->addUniform(matShaderToWorldUniform);
Image* imageSky = osgDB::readImageFile(ANIMDataDir() + "Textures/NightSky.JPG");
Texture2D* textureSky = new Texture2D(imageSky);
(*stateset)->setTextureAttributeAndModes(0, textureSky, StateAttribute::ON);
Image* imagePara = osgDB::readImageFile(ANIMDataDir() + "Textures/Paramounts/Paramount00.JPG");
Texture2D* texturePara = new Texture2D(imagePara);
(*stateset)->setTextureAttributeAndModes(1, texturePara, StateAttribute::ON);
Uniform* skyNightSampler = new Uniform("texNightSky", 0);
(*stateset)->addUniform(skyNightSampler);
Uniform* paraImageTextureSampler = new Uniform("texParamount", 1);
(*stateset)->addUniform(paraImageTextureSampler);
Program* programSky = new Program;
(*stateset)->setAttribute(programSky);
programSky->addShader(Shader::readShaderFile(Shader::VERTEX, ANIMDataDir() + "Shaders/EnvSky.vert"));
programSky->addShader(Shader::readShaderFile(Shader::FRAGMENT, ANIMDataDir() + "Shaders/EnvSky.frag"));
return skyDomeTrans;
}
Renderer() {
Program program;
std::shared_ptr<Shader> vertexShader(new Shader(ShaderType::VERTEX));
vertexShader->source("void main(void) {\nvec4 a = gl_Vertex;\ngl_Position = gl_ModelViewProjectionMatrix * a;\n}");
program.addShader(vertexShader);
}
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
if (arguments.argc() <= 1) {
cerr << "Need a scene.\n";
return 1;
}
osg::ref_ptr<osg::Node> loadedModel = osgDB::readRefNodeFiles(arguments);
if (!loadedModel) {
cerr << "couldn't load " << argv[1] << "\n";
return 1;
}
osgUtil::Optimizer optimizer;
optimizer.optimize(loadedModel.get());
const BoundingSphere bound = loadedModel->getBound();
const float displacement = 2.25 * bound.radius();
Group* scene = new Group;
StateSet* rootSS = scene->getOrCreateStateSet();
Shader* vertexShader = new Shader(Shader::VERTEX);
vertexShader->setShaderSource(vertexShaderSource);
Shader* fragmentShader = new Shader(Shader::FRAGMENT);
fragmentShader->setShaderSource(fragmentShaderSource);
Program* prog = new Program;
prog->addShader(vertexShader);
prog->addShader(fragmentShader);
prog->addBindUniformBlock("colors0", 0);
rootSS->setAttributeAndModes(prog, StateAttribute::ON);
// Place 3 instances of the loaded model with different uniform
// blocks for each.
//
// The blocksize is known because of the std140 format.
const unsigned blockSize = 20 * sizeof(GLfloat);
ref_ptr<FloatArray> colorArray
= new FloatArray(&colors1[0],
&colors1[sizeof(colors1) / sizeof(GLfloat)]);
ref_ptr<UniformBufferObject> ubo = new UniformBufferObject;
colorArray->setBufferObject(ubo.get());
Group* group1 = new Group;
StateSet* ss1 = group1->getOrCreateStateSet();
group1->addChild(loadedModel.get());
scene->addChild(group1);
ref_ptr<UniformBufferBinding> ubb1
= new UniformBufferBinding(0, ubo.get(), 0, blockSize);
ss1->setAttributeAndModes(ubb1.get(), StateAttribute::ON);
ref_ptr<FloatArray> colorArray2
= new FloatArray(&colors2[0],
&colors2[sizeof(colors2) / sizeof(GLfloat)]);
ref_ptr<UniformBufferObject> ubo2 = new UniformBufferObject;
colorArray2->setBufferObject(ubo2.get());
MatrixTransform* group2 = new MatrixTransform;
Matrix mat2 = Matrix::translate(-displacement, 0.0, 0.0);
group2->setMatrix(mat2);
StateSet* ss2 = group2->getOrCreateStateSet();
group2->addChild(loadedModel.get());
scene->addChild(group2);
ref_ptr<UniformBufferBinding> ubb2
= new UniformBufferBinding(0, ubo2.get(), 0, blockSize);
ss2->setAttributeAndModes(ubb2.get(), StateAttribute::ON);
ref_ptr<FloatArray> colorArray3
= new FloatArray(&colors2[0],
&colors2[sizeof(colors2) / sizeof(GLfloat)]);
ref_ptr<UniformBufferObject> ubo3 = new UniformBufferObject;
colorArray3->setBufferObject(ubo3.get());
MatrixTransform* group3 = new MatrixTransform;
Matrix mat3 = Matrix::translate(displacement, 0.0, 0.0);
group3->setMatrix(mat3);
StateSet* ss3 = group3->getOrCreateStateSet();
group3->addChild(loadedModel.get());
scene->addChild(group3);
ref_ptr<UniformBufferBinding> ubb3
= new UniformBufferBinding(0, ubo3.get(), 0, blockSize);
ubb3->setUpdateCallback(new UniformBufferCallback);
ubb3->setDataVariance(Object::DYNAMIC);
ss3->setAttributeAndModes(ubb3.get(), StateAttribute::ON);
viewer.setSceneData(scene);
viewer.realize();
return viewer.run();
}
/***************************************************************
* 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);
}
