void WaterPlane::innerRender( SceneRenderState *state )
{
GFXDEBUGEVENT_SCOPE( WaterPlane_innerRender, ColorI( 255, 0, 0 ) );
const Point3F &camPosition = state->getCameraPosition();
Point3F rvec, fvec, uvec, pos;
const MatrixF &objMat = getTransform(); //getRenderTransform();
const MatrixF &camMat = state->getCameraTransform();
MatrixF renderMat( true );
camMat.getColumn( 1, &fvec );
uvec.set( 0, 0, 1 );
rvec = mCross( fvec, uvec );
rvec.normalize();
fvec = mCross( uvec, rvec );
pos = camPosition;
pos.z = objMat.getPosition().z;
renderMat.setColumn( 0, rvec );
renderMat.setColumn( 1, fvec );
renderMat.setColumn( 2, uvec );
renderMat.setColumn( 3, pos );
setRenderTransform( renderMat );
// Setup SceneData
SceneData sgData = setupSceneGraphInfo( state );
// set the material
S32 matIdx = getMaterialIndex( camPosition );
if ( !initMaterial( matIdx ) )
return;
BaseMatInstance *mat = mMatInstances[matIdx];
WaterMatParams matParams = mMatParamHandles[matIdx];
// render the geometry
if ( mat )
{
// setup proj/world transform
mMatrixSet->restoreSceneViewProjection();
mMatrixSet->setWorld(getRenderTransform());
setShaderParams( state, mat, matParams );
while( mat->setupPass( state, sgData ) )
{
mat->setSceneInfo(state, sgData);
mat->setTransforms(*mMatrixSet, state, sgData);
setCustomTextures( matIdx, mat->getCurPass(), matParams );
// set vert/prim buffer
GFX->setVertexBuffer( mVertBuff );
GFX->setPrimitiveBuffer( mPrimBuff );
GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, mVertCount, 0, mPrimCount );
}
}
}
osg::Node* EnWater::setupWater()
{
osg::Node* p_node = NULL;
// check if a water mesh is given, if so load it and place it into level
if ( _meshFile.length() )
{
p_node = yaf3d::LevelManager::get()->loadMesh( _meshFile );
if ( !p_node )
{
log_warning << "could not load water mesh file: " << _meshFile << ", in '" << getInstanceName() << "'" << std::endl;
log_warning << " creating a simple plane for water mesh." << std::endl;
}
setPosition( _position );
}
// create a simple quadratic water plane if no mesh given
if ( !p_node )
{
osg::Geode* p_geode = new osg::Geode;
osg::Vec3f coords[] =
{
osg::Vec3( _position.x() - _sizeX * 0.5f, _position.y() + _sizeY * 0.5f, _position.z() ),
osg::Vec3( _position.x() - _sizeX * 0.5f, _position.y() - _sizeY * 0.5f, _position.z() ),
osg::Vec3( _position.x() + _sizeX * 0.5f, _position.y() - _sizeY * 0.5f, _position.z() ),
osg::Vec3( _position.x() + _sizeX * 0.5f, _position.y() + _sizeY * 0.5f, _position.z() )
};
osg::Vec3f normals[] =
{
osg::Vec3( 0.0f, 0.0f, 1.0f ),
osg::Vec3( 0.0f, 0.0f, 1.0f ),
osg::Vec3( 0.0f, 0.0f, 1.0f ),
osg::Vec3( 0.0f, 0.0f, 1.0f )
};
osg::Geometry* p_polyGeom = new osg::Geometry;
p_polyGeom->setVertexArray( new osg::Vec3Array( 4, coords ) );
p_polyGeom->setNormalArray( new osg::Vec3Array( 4, normals ) );
osg::DrawArrays* p_drawarray = new osg::DrawArrays( osg::PrimitiveSet::QUADS, 0, 4 );
p_polyGeom->addPrimitiveSet( p_drawarray );
p_geode->addDrawable( p_polyGeom );
p_node = p_geode;
}
// check if glsl is supported before setting up the shaders ( gl context 0 is assumed )
if ( !yaf3d::isGlslAvailable() )
return p_node;
// create skybox cube map texture
std::vector< std::string > texfiles;
texfiles.push_back( _cubeMapTextures[ 0 ] );
texfiles.push_back( _cubeMapTextures[ 1 ] );
texfiles.push_back( _cubeMapTextures[ 2 ] );
texfiles.push_back( _cubeMapTextures[ 3 ] );
texfiles.push_back( _cubeMapTextures[ 4 ] );
texfiles.push_back( _cubeMapTextures[ 5 ] );
_reflectmap = vrc::gameutils::readCubeMap( texfiles );
// setup the shaders and uniforms, share the stateset
if ( !s_stateSet.valid() )
{
s_stateSet = new osg::StateSet;
osg::Program* p_program = new osg::Program;
p_program->setName( "_waterShaderGLSL_" );
p_program->addShader( new osg::Shader( osg::Shader::VERTEX, glsl_vp ) );
p_program->addShader( new osg::Shader( osg::Shader::FRAGMENT, glsl_fp ) );
s_stateSet->setAttributeAndModes( p_program, osg::StateAttribute::ON );
s_fadeBias = new osg::Uniform( "fadeBias", _fadeBias );
s_waveSpeed = new osg::Uniform( "waveSpeed", _waveSpeed );
s_fadeExp = new osg::Uniform( "fadeExp", _fadeExp );
s_noiseSpeed = new osg::Uniform( "noiseSpeed", _noiseSpeed );
s_waterColor = new osg::Uniform( "waterColor", osg::Vec4f( _waterColor, 1.0f ) );
s_scale = new osg::Uniform( "scale", osg::Vec4f( _scale, 1.0f ) );
s_trans = new osg::Uniform( "transparency", _transparency );
s_stateSet->addUniform( s_fadeBias );
s_stateSet->addUniform( s_waveSpeed );
s_stateSet->addUniform( s_fadeExp );
s_stateSet->addUniform( s_scale );
s_stateSet->addUniform( s_noiseSpeed );
s_stateSet->addUniform( s_waterColor );
s_stateSet->addUniform( s_trans );
osg::Uniform* p_viewPosition = new osg::Uniform( "viewPosition", osg::Vec4f() );
s_stateSet->addUniform( p_viewPosition );
p_viewPosition->setUpdateCallback( new ViewPositionUpdateCallback() ); // set time view position update callback for the shader
osg::Uniform* p_uniformDeltaWave = new osg::Uniform( "deltaWave", 0.0f );
s_stateSet->addUniform( p_uniformDeltaWave );
p_uniformDeltaWave->setUpdateCallback( new DeltaWaveUpdateCallback( this ) ); // set time update callback for the shader
osg::Uniform* p_uniformDeltaNoise = new osg::Uniform( "deltaNoise", 0.0f );
s_stateSet->addUniform( p_uniformDeltaNoise );
p_uniformDeltaNoise->setUpdateCallback( new DeltaNoiseUpdateCallback( this ) ); // set time update callback for the shader
// create a noise texture
osg::Texture3D* p_noiseTexture = new osg::Texture3D;
p_noiseTexture->setFilter( osg::Texture3D::MIN_FILTER, osg::Texture3D::LINEAR );
p_noiseTexture->setFilter( osg::Texture3D::MAG_FILTER, osg::Texture3D::LINEAR );
p_noiseTexture->setWrap( osg::Texture3D::WRAP_S, osg::Texture3D::REPEAT );
p_noiseTexture->setWrap( osg::Texture3D::WRAP_T, osg::Texture3D::REPEAT );
p_noiseTexture->setWrap( osg::Texture3D::WRAP_R, osg::Texture3D::REPEAT );
p_noiseTexture->setImage( make3DNoiseImage( 32 ) );
s_stateSet->setTextureAttribute( LOCATION_NOISE_SAMPLER, p_noiseTexture );
s_stateSet->addUniform( new osg::Uniform( "samplerNoise", LOCATION_NOISE_SAMPLER ) );
s_stateSet->setTextureAttribute( LOCATION_CUBEMAP_SAMPLER, _reflectmap.get() );
s_stateSet->addUniform( new osg::Uniform( "samplerSkyBox", LOCATION_CUBEMAP_SAMPLER ) );
// set lighting and culling
s_stateSet->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
s_stateSet->setMode( GL_CULL_FACE, osg::StateAttribute::OFF );
// disable depth test
s_stateSet->setMode( GL_DEPTH, osg::StateAttribute::OFF );
// set up transparency
s_stateSet->setMode( GL_BLEND, osg::StateAttribute::ON );
s_stateSet->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
// make sure that the water is rendered at first, then all other transparent primitives
s_stateSet->setBinNumber( WATER_RENDERBIN_NUMBER );
// append state set to geode
p_node->setStateSet( s_stateSet.get() );
}
// set shader parameters
setShaderParams( p_node );
// disable culling
p_node->setCullingActive( false );
return p_node;
}
void D3DFontShader::render(RaccoonData::ShaderParamType params)
{
setShaderParams(params);
renderShader(params.dc, params.indexCount);
}
void ofxObject::predraw()
{
//float r = ofRandom(1);
//shader->setUniform1f("time", ofGetElapsedTimef());
//shaderParams = (void*) shader->setUniform1f("percentX", r);
// Start shader if there is one
if (shaderEnabled){
if (shader!=NULL){
if(shader->isLoaded()){
// Bind the shader
shader->begin();
setShaderParams();
}
}
}else{
}
glPushName(id);
ofSetColor(drawMaterial->color.r, drawMaterial->color.g, drawMaterial->color.b, drawMaterial->color.a); //v4.0
//update lighting
if (isLit != prevLit) {
if (isLit) glEnable(GL_LIGHTING);
else glDisable(GL_LIGHTING);
prevLit = isLit;
}
glLoadMatrixf(matrix);
/*
//Older way of doing transformations.
ofPushMatrix();
ofTranslate(xyz.x, xyz.y, xyz.z);
//ofScale(scale.x, scale.y, scale.z);
ofRotateX(xyzRot.x);
ofRotateY(xyzRot.y);
ofRotateZ(xyzRot.z);
ofScale(scale.x, scale.y, scale.z);
*/
//if(id==1)
//printf("matrix:\n%f\t%f\t%f\t%f\n%f\t%f\t%f\t%f\n%f\t%f\t%f\t%f\n%f\t%f\t%f\t%f\n",
// matrix[0], matrix[1], matrix[2], matrix[3],
// matrix[4], matrix[5], matrix[6], matrix[7],
// matrix[8], matrix[9], matrix[10], matrix[11],
// matrix[12], matrix[13], matrix[14], matrix[15]);
}
