Here is attached code ... Would really appreciate if some take couple of
minutes to have a look
Thanks a lot
Nick
http://www.linkedin.com/in/tnick
Sent from Devlet, Ankara, Turkey
On Sat, Jan 23, 2010 at 11:44 PM, Trajce Nikolov
<[email protected]>wrote:
> I am also getting this warning
> Warning: detected OpenGL error 'invalid operation' at after
> RenderBin::draw(..)
>
> Nick
>
> http://www.linkedin.com/in/tnick
> Sent from Devlet, Ankara, Turkey
>
> On Sat, Jan 23, 2010 at 9:50 PM, Trajce Nikolov
> <[email protected]>wrote:
>
>> Hi guys,
>>
>> this might sound stupid but., I am trying to mix two values in the
>> fragment shader. Can not blend them together no mater what. I try "manual"
>> blending, but still the results are as for only 1 and 0 blend factor.
>> NOthing in between,
>>
>> Here is the shader. Any clue?
>>
>> "varying vec4 uv; \n" //
>> "uniform sampler2D colorMap; \n" //
>> "uniform samplerCube cubeMap; \n" //
>> "const float reflect_factor = 0.5; \n" //
>> "void main( void ) \n" //
>> "{ \n" //
>> " vec3 base_color = texture2D(colorMap, gl_TexCoord[0].xy).rgb; \n" //
>> " vec3 cube_color = textureCube(cubeMap, uv.xyz).rgb; \n" //
>> " gl_FragColor = vec4( mix(base_color, cube_color, reflect_factor), 1.0); \n"
>> //
>> "}
>>
>> Nick
>>
>> http://www.linkedin.com/in/tnick
>> Sent from Devlet, Ankara, Turkey
>>
>
>
/* OpenSceneGraph example, osgprerendercubemap.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <osgViewer/Viewer>
#include <osg/Projection>
#include <osg/Geometry>
#include <osg/Texture>
#include <osg/TexGen>
#include <osg/Geode>
#include <osg/ShapeDrawable>
#include <osg/PolygonOffset>
#include <osg/CullFace>
#include <osg/TextureCubeMap>
#include <osg/TexMat>
#include <osg/MatrixTransform>
#include <osg/Light>
#include <osg/LightSource>
#include <osg/PolygonOffset>
#include <osg/CullFace>
#include <osg/Material>
#include <osg/PositionAttitudeTransform>
#include <osg/ArgumentParser>
#include <osgDB/ReadFile>
#include <osgUtil/SmoothingVisitor>
#include <osg/Camera>
#include <osg/TexGenNode>
#include <osg/Texture2D>
#include <iostream>
using namespace osg;
unsigned int numTextures = 6;
ref_ptr<Group> _create_scene()
{
ref_ptr<Group> scene = new Group;
ref_ptr<Geode> geode_1 = new Geode;
scene->addChild(geode_1.get());
ref_ptr<Geode> geode_2 = new Geode;
ref_ptr<MatrixTransform> transform_2 = new MatrixTransform;
transform_2->addChild(geode_2.get());
transform_2->setUpdateCallback(new osg::AnimationPathCallback(Vec3(0, 0, 0),
Z_AXIS, inDegrees(45.0f)));
scene->addChild(transform_2.get());
ref_ptr<Geode> geode_3 = new Geode;
ref_ptr<MatrixTransform> transform_3 = new MatrixTransform;
transform_3->addChild(geode_3.get());
transform_3->setUpdateCallback(new osg::AnimationPathCallback(Vec3(0, 0, 0),
Z_AXIS, inDegrees(-22.5f)));
scene->addChild(transform_3.get());
const float radius = 0.8f;
const float height = 1.0f;
ref_ptr<TessellationHints> hints = new TessellationHints;
hints->setDetailRatio(2.0f);
ref_ptr<ShapeDrawable> shape;
shape = new ShapeDrawable(new Box(Vec3(0.0f, 0.0f, -2.0f), 10, 10.f, 0.1),
hints.get());
shape->setColor(Vec4(0.5f, 0.5f, 0.7f, 1.0f));
geode_1->addDrawable(shape.get());
shape = new ShapeDrawable(new Sphere(Vec3(-3.0f, 0.0f, 0.0f), radius),
hints.get());
shape->setColor(Vec4(0.6f, 0.8f, 0.8f, 1.0f));
geode_2->addDrawable(shape.get());
shape = new ShapeDrawable(new Box(Vec3(3.0f, 0.0f, 0.0f), 2 * radius),
hints.get());
shape->setColor(Vec4(0.4f, 0.9f, 0.3f, 1.0f));
geode_2->addDrawable(shape.get());
#if 0
shape = new ShapeDrawable(new Cone(Vec3(0.0f, 0.0f, -3.0f), radius, height),
hints.get());
shape->setColor(Vec4(0.2f, 0.5f, 0.7f, 1.0f));
geode_2->addDrawable(shape.get());
#endif
shape = new ShapeDrawable(new Cylinder(Vec3(0.0f, 0.0f, 3.0f), radius,
height), hints.get());
shape->setColor(Vec4(1.0f, 0.3f, 0.3f, 1.0f));
geode_2->addDrawable(shape.get());
shape = new ShapeDrawable(new Box(Vec3(0.0f, 3.0f, 0.0f), 2, 0.1f, 2),
hints.get());
shape->setColor(Vec4(0.8f, 0.8f, 0.4f, 1.0f));
geode_3->addDrawable(shape.get());
// material
ref_ptr<Material> matirial = new Material;
matirial->setColorMode(Material::DIFFUSE);
matirial->setAmbient(Material::FRONT_AND_BACK, Vec4(0, 0, 0, 1));
matirial->setSpecular(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
matirial->setShininess(Material::FRONT_AND_BACK, 64.0f);
scene->getOrCreateStateSet()->setAttributeAndModes(matirial.get(),
StateAttribute::ON);
return scene;
}
osg::NodePath createReflector()
{
osg::PositionAttitudeTransform* pat = new osg::PositionAttitudeTransform;
pat->setPosition(osg::Vec3(0.0f,0.0f,0.0f));
pat->setAttitude(osg::Quat(osg::inDegrees(0.0f),osg::Vec3(0.0f,0.0f,1.0f)));
#if 1
Geode* node = new Geode;
const float radius = 0.8f;
ref_ptr<TessellationHints> hints = new TessellationHints;
hints->setDetailRatio(2.0f);
ShapeDrawable* shape = new ShapeDrawable(new Sphere(Vec3(0.0f, 0.0f, 0.0f),
radius * 1.5f), hints.get());
shape->setColor(Vec4(0.8f, 0.8f, 0.8f, 1.0f));
node->addDrawable(shape);
#else
osg::Node* file = osgDB::readNodeFile("D:\\dev\\POTSIM3D\\DATA\\B700.ive");
osgUtil::SmoothingVisitor sv;
file->accept(sv);
osg::MatrixTransform* node = new osg::MatrixTransform;
node->addChild(file);
node->setMatrix(osg::Matrix::scale(osg::Vec3(0.25,0.25,0.25)));
#endif
pat->addChild(node);
osg::NodePath nodeList;
nodeList.push_back(pat);
nodeList.push_back(node);
//nodeList.push_back(file);
return nodeList;
}
class UpdateCameraAndTexGenCallback : public osg::NodeCallback
{
public:
typedef std::vector< osg::ref_ptr<osg::Camera> > CameraList;
UpdateCameraAndTexGenCallback(osg::NodePath& reflectorNodePath,
CameraList& Cameras):
_reflectorNodePath(reflectorNodePath),
_Cameras(Cameras)
{
}
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
{
// first update subgraph to make sure objects are all moved into
position
traverse(node,nv);
// compute the position of the center of the reflector subgraph
osg::Matrixd worldToLocal =
osg::computeWorldToLocal(_reflectorNodePath);
osg::BoundingSphere bs = _reflectorNodePath.back()->getBound();
osg::Vec3 position = bs.center();
typedef std::pair<osg::Vec3, osg::Vec3> ImageData;
const ImageData id[] =
{
ImageData( osg::Vec3( 1, 0, 0), osg::Vec3( 0, -1, 0) ), // +X
ImageData( osg::Vec3(-1, 0, 0), osg::Vec3( 0, -1, 0) ), // -X
ImageData( osg::Vec3( 0, 1, 0), osg::Vec3( 0, 0, 1) ), // +Y
ImageData( osg::Vec3( 0, -1, 0), osg::Vec3( 0, 0, -1) ), // -Y
ImageData( osg::Vec3( 0, 0, 1), osg::Vec3( 0, -1, 0) ), // +Z
ImageData( osg::Vec3( 0, 0, -1), osg::Vec3( 0, -1, 0) ) // -Z
};
for(unsigned int i=0;
i<numTextures && i<_Cameras.size();
++i)
{
osg::Matrix localOffset;
localOffset.makeLookAt(position,position+id[i].first,id[i].second);
osg::Matrix viewMatrix = worldToLocal*localOffset;
_Cameras[i]->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
_Cameras[i]->setProjectionMatrixAsFrustum(-1.0,1.0,-1.0,1.0,1.0,10000.0);
_Cameras[i]->setViewMatrix(viewMatrix);
}
}
protected:
virtual ~UpdateCameraAndTexGenCallback() {}
osg::NodePath _reflectorNodePath;
CameraList _Cameras;
};
class TexMatCullCallback : public osg::NodeCallback
{
public:
TexMatCullCallback(osg::TexMat* texmat):
_texmat(texmat)
{
}
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
{
// first update subgraph to make sure objects are all moved into
position
traverse(node,nv);
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);
if (cv)
{
osg::Quat q =
osg::Matrix::inverse(*cv->getModelViewMatrix()).getRotate();
float yaw2 = asin(-2.0f*(q.x()*q.z() -
q.w()*q.y()));
osg::Matrixd mxY;
mxY.makeRotate(yaw2,osg::Vec3(0,0,1));
osg::Matrixd mx = mxY;
_texmat->setMatrix(mx);
}
}
protected:
osg::ref_ptr<TexMat> _texmat;
};
class UpdateCameraPosUniformCallback : public osg::Uniform::Callback
{
public:
UpdateCameraPosUniformCallback(osg::Camera* camera)
: mCamera(camera)
{
}
virtual void operator () (osg::Uniform* u, osg::NodeVisitor*)
{
osg::Vec3 eye;
osg::Vec3 center;
osg::Vec3 up;
mCamera->getViewMatrixAsLookAt(eye,center,up);
u->set(eye);
}
protected:
osg::Camera* mCamera;
};
osg::Group* createShadowedScene(osg::Node* reflectedSubgraph, osg::NodePath
reflectorNodePath, unsigned int unit, const osg::Vec4& clearColor, unsigned
tex_width, unsigned tex_height, osg::Camera::RenderTargetImplementation
renderImplementation, osg::Camera* camera = 0)
{
osg::Group* group = new osg::Group;
osg::TextureCubeMap* texture = new osg::TextureCubeMap;
texture->setTextureSize(tex_width, tex_height);
texture->setInternalFormat(GL_RGB);
texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
texture->setWrap(osg::Texture::WRAP_R, osg::Texture::CLAMP_TO_EDGE);
texture->setFilter(osg::TextureCubeMap::MIN_FILTER,osg::TextureCubeMap::LINEAR);
texture->setFilter(osg::TextureCubeMap::MAG_FILTER,osg::TextureCubeMap::LINEAR);
// set up the render to texture cameras.
UpdateCameraAndTexGenCallback::CameraList Cameras;
for(unsigned int i=0; i<numTextures; ++i)
{
// create the camera
osg::Camera* camera = new osg::Camera;
camera->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
camera->setClearColor(clearColor);
// set viewport
camera->setViewport(0,0,tex_width,tex_height);
// set the camera to render before the main camera.
camera->setRenderOrder(osg::Camera::PRE_RENDER);
// tell the camera to use OpenGL frame buffer object where supported.
camera->setRenderTargetImplementation(renderImplementation);
// attach the texture and use it as the color buffer.
camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, i);
// add subgraph to render
camera->addChild(reflectedSubgraph);
group->addChild(camera);
Cameras.push_back(camera);
}
#if 1
// create the texgen node to project the tex coords onto the subgraph
osg::TexGenNode* texgenNode = new osg::TexGenNode;
texgenNode->getTexGen()->setMode(osg::TexGen::REFLECTION_MAP);
texgenNode->setTextureUnit(unit);
group->addChild(texgenNode);
// set the reflected subgraph so that it uses the texture and tex gen
settings.
osg::Node* reflectorNode = reflectorNodePath.front();
{
group->addChild(reflectorNode);
osg::StateSet* stateset = reflectorNode->getOrCreateStateSet();
stateset->setTextureAttributeAndModes(unit,texture,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
stateset->setTextureMode(unit,GL_TEXTURE_GEN_S,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
stateset->setTextureMode(unit,GL_TEXTURE_GEN_T,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
stateset->setTextureMode(unit,GL_TEXTURE_GEN_R,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
stateset->setTextureMode(unit,GL_TEXTURE_GEN_Q,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
osg::TexMat* texmat = new osg::TexMat;
stateset->setTextureAttributeAndModes(unit,texmat,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
reflectorNode->setCullCallback(new TexMatCullCallback(texmat));
}
osg::StateSet* ss = reflectorNode->getOrCreateStateSet();
ss->setTextureAttributeAndModes(unit,texture,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
const char* microshaderVertSource =
"uniform mat4 osg_ViewMatrixInverse; \n"
"uniform vec3 CameraPos;
\n" //
"mat3 GetLinearPart( mat4 m )
\n" //
"{
\n" //
" mat3 result;
\n" //
"
\n" //
" result[0][0] = m[0][0];
\n" //
" result[0][1] = m[0][1];
\n" //
" result[0][2] = m[0][2];
\n" //
"
\n" //
" result[1][0] = m[1][0];
\n" //
" result[1][1] = m[1][1];
\n" //
" result[1][2] = m[1][2];
\n" //
"
\n" //
" result[2][0] = m[2][0];
\n" //
" result[2][1] = m[2][1];
\n" //
" result[2][2] = m[2][2];
\n" //
"
\n" //
" return result;
\n" //
"}
\n" //
"
\n" //
"void main()
\n" //
"{
\n" //
" gl_Position = ftransform();
\n" //
"
\n" //
" gl_TexCoord[0] = gl_MultiTexCoord0;
\n" //
" mat4 ModelWorld4x4 = osg_ViewMatrixInverse
* gl_ModelViewMatrix; \n" //
"
\n" //
" mat3 ModelWorld3x3 = GetLinearPart(
ModelWorld4x4 ); \n" //
"
\n" //
" vec4 WorldPos = ModelWorld4x4 *
gl_Vertex; \n" //
"
\n" //
" vec3 N = normalize( ModelWorld3x3 *
gl_Normal ); \n" //
"
\n" //
" vec3 E = normalize( WorldPos.xyz -
CameraPos.xyz ); \n" //
"
\n" //
" gl_TexCoord[1].xyz = reflect( E, N );
\n" //
"}
\n" //
;
const char* microshaderFragSource =
"uniform samplerCube cubeMap;
\n"
"uniform sampler2D colorMap;
\n"
"
\n"
"const float reflect_factor = 0.5;
\n"
"
\n"
"void main (void)
\n"
"{
\n"
" vec3 base_color = texture2D(colorMap,
gl_TexCoord[0].xy).rgb; \n"
"
\n"
" vec3 cube_color = textureCube(cubeMap,
gl_TexCoord[1].xyz).rgb; \n"
"
\n"
" gl_FragColor = vec4( mix(cube_color,
base_color, reflect_factor).rgb, 1.0); \n"
"}
\n"
;
osg::Program* program = new osg::Program;
program->setName( "microshader" );
program->addShader( new osg::Shader( osg::Shader::VERTEX,
microshaderVertSource ) );
program->addShader( new osg::Shader( osg::Shader::FRAGMENT,
microshaderFragSource ) );
ss->setAttributeAndModes( program, osg::StateAttribute::ON );
ss->addUniform( new osg::Uniform("cubeMap", unit) );
ss->addUniform( new osg::Uniform("colorMap",0) );
{
osg::Uniform* u = new osg::Uniform("CameraPos",osg::Vec3());
u->setUpdateCallback( new UpdateCameraPosUniformCallback(
camera ) );
ss->addUniform( u );
}
#endif
osg::Texture2D * texture0 = new
osg::Texture2D(osgDB::readImageFile("Images/skymap.jpg") );
ss->setTextureAttributeAndModes( 0, texture0, osg::StateAttribute::ON );
// add the reflector scene to draw just as normal
group->addChild(reflectedSubgraph);
// set an update callback to keep moving the camera and tex gen in the
right direction.
group->setUpdateCallback(new
UpdateCameraAndTexGenCallback(reflectorNodePath, Cameras));
return group;
}
int main(int argc, char** argv)
{
// use an ArgumentParser object to manage the program arguments.
ArgumentParser arguments(&argc, argv);
// set up the usage document, in case we need to print out how to use this
program.
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()
+ " is the example which demonstrates using of GL_ARB_shadow extension
implemented in osg::Texture class");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName());
arguments.getApplicationUsage()->addCommandLineOption("-h or --help",
"Display this information");
arguments.getApplicationUsage()->addCommandLineOption("--fbo","Use Frame
Buffer Object for render to texture, where supported.");
arguments.getApplicationUsage()->addCommandLineOption("--fb","Use
FrameBuffer for render to texture.");
arguments.getApplicationUsage()->addCommandLineOption("--pbuffer","Use
Pixel Buffer for render to texture, where supported.");
arguments.getApplicationUsage()->addCommandLineOption("--window","Use a
separate Window for render to texture.");
arguments.getApplicationUsage()->addCommandLineOption("--width","Set the
width of the render to texture");
arguments.getApplicationUsage()->addCommandLineOption("--height","Set the
height of the render to texture");
// construct the viewer.
osgViewer::Viewer viewer;
// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
arguments.getApplicationUsage()->write(std::cout);
return 1;
}
unsigned tex_width = 256;
unsigned tex_height = 256;
while (arguments.read("--width", tex_width)) {}
while (arguments.read("--height", tex_height)) {}
osg::Camera::RenderTargetImplementation renderImplementation =
osg::Camera::FRAME_BUFFER_OBJECT;
while (arguments.read("--fbo")) { renderImplementation =
osg::Camera::FRAME_BUFFER_OBJECT; }
while (arguments.read("--pbuffer")) { renderImplementation =
osg::Camera::PIXEL_BUFFER; }
while (arguments.read("--fb")) { renderImplementation =
osg::Camera::FRAME_BUFFER; }
while (arguments.read("--window")) { renderImplementation =
osg::Camera::SEPERATE_WINDOW; }
// any option left unread are converted into errors to write out later.
arguments.reportRemainingOptionsAsUnrecognized();
// report any errors if they have occurred when parsing the program
arguments.
if (arguments.errors())
{
arguments.writeErrorMessages(std::cout);
return 1;
}
ref_ptr<MatrixTransform> scene = new MatrixTransform;
scene->setMatrix(osg::Matrix::rotate(osg::DegreesToRadians(0.f),1.0,0.0,0.0));
ref_ptr<Group> reflectedSubgraph = _create_scene();
if (!reflectedSubgraph.valid()) return 1;
ref_ptr<Group> reflectedScene = createShadowedScene(
reflectedSubgraph.get(),
createReflector(),
1,
viewer.getCamera()->getClearColor(),
tex_width,
tex_height,
renderImplementation,
viewer.getCamera());
scene->addChild(reflectedScene.get());
viewer.setSceneData(scene.get());
return viewer.run();
}
_______________________________________________
osg-users mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
