void SceneWidget::setDefaultAmbient (const osg::Vec4f& colour) { mDefaultAmbient = colour; mHasDefaultAmbient = true; setAmbient(mLighting->getAmbientColour(&mDefaultAmbient)); }
Light::Light(LIGHT_TYPE type) { lights.push_back(this); if(availableLights.size() > 0) { lightNum = availableLights[0]; availableLights.erase(availableLights.begin()); Visible(true); setLightType(type); setPosition(0, 0, 0); setCutoff(45); setExponent(12); setSpotDirection(0, -1, 0); setAmbient(0, 0, 0, 1); setDiffuse(1, 1, 1, 1); setSpecular(1, 1, 1, 1); updateLight(); } else { lightNum = 0; Visible(false); } }
void Lights::create(GLuint lightNum, const Color &ambient, const Color &diffuse, const Vector4f &position) { // the light being defined _lightNumber = lightNum; setAmbient(ambient); setDiffuse(diffuse); setPosition(position); }
Material::Material() { setAmbient(0.2f, 0.2f, 0.2f, 1.0f); setDiffuse(0.8f, 0.8f, 0.8f, 1.0f); setSpecular(0, 0, 0, 1); setEmission(0, 0, 0, 1); shininess = 0; }
LLAudioSourceVO::LLAudioSourceVO(const LLUUID &sound_id, const LLUUID& owner_id, const F32 gain, LLViewerObject *objectp) : LLAudioSource(sound_id, owner_id, gain), mObjectp(objectp), mActualGain(gain) { setAmbient(FALSE); updateGain(); update(); }
void ViewLightGL::moving(int dx, int dy) { int r = __ambient.red()+dy; int g = __ambient.green()+dy; int b = __ambient.blue()+dy; if(r < 255 && r > 0 && g < 255 && g > 0 && b < 255 && b > 0 ) setAmbient(QColor(r,g,b)); emit ambientChanged(__ambient); }
void CSVRender::UnpagedWorldspaceWidget::update() { const CSMWorld::Record<CSMWorld::Cell>& record = dynamic_cast<const CSMWorld::Record<CSMWorld::Cell>&> (mCellsModel->getRecord (mCellId)); Ogre::ColourValue colour; colour.setAsABGR (record.get().mAmbi.mAmbient); setAmbient (colour); /// \todo deal with mSunlight and mFog/mForDensity }
LightSource::LightSource(GLenum number) { _num = number; setPosition(0,0,1.0,1.0); //setDirection(Vector3(0,0,1)); setAmbient(0.0, 0.0, 0.0, 1.0); setDiffuse(1.0, 1.0, 1.0, 1.0); setSpecular(1.0, 1.0, 1.0, 1.0); setState(true); setExponent(0); setCutOff(180); }
Light::Light(bool dynamic_in) : shadowmapTex(0), coneTex(0), has_target(false), has_shadow(false), parent(NULL), has_projector(false), glLightId(0), nearclip(1.0f), farclip(200.0f), sceneObjTarget(NULL) { setType(LIGHT_POINT); setAmbient(RGB(0.0f,0.0f,0.0f)); setDiffuse(RGB(1.0f,1.0f,1.0f)); setSpecular(RGB(0.0f,0.0f,0.0f)); setConstantAttenuation(0.4f); setLinearAttenuation(0.01f); setQuadraticAttenuation(0.001f); dynamic = dynamic_in; }
void SceneWidget::setLighting(Lighting *lighting) { if (mLighting) mLighting->deactivate(); mLighting = lighting; mLighting->activate (mRootNode); osg::Vec4f ambient = mLighting->getAmbientColour(mHasDefaultAmbient ? &mDefaultAmbient : 0); setAmbient(ambient); flagAsModified(); }
iNodeLight::iNodeLight(iNodeLight* node) : iNode() { con_assert(node != nullptr, "zero pointer"); _nodeType = node->_nodeType; _nodeKind = node->_nodeKind; setName(node->getName()); setAmbient(node->getAmbient()); setDiffuse(node->getDiffuse()); setSpecular(node->getSpecular()); setType(node->getType()); }
CGFlight::CGFlight(unsigned int lightid, float* pos, float *dir) { try { id = lightid; position[0] = pos[0]; position[1] = pos[1]; position[2] = pos[2]; position[3] = pos[3]; material = CGFlight::default_light_material; if (dir == NULL) { direction[0] = 0; direction[1] = -1; direction[2] = 0; } else { direction[0] = dir[0]; direction[1] = dir[1]; direction[2] = dir[2]; } float __tmp_1[4] = {CG_GLIGHT_DEFAULT_AMBIENT}; setAmbient(__tmp_1); float __tmp_2[4] = {CG_GLIGHT_DEFAULT_DIFFUSE}; setDiffuse(__tmp_2); float __tmp_3[4] = {CG_GLIGHT_DEFAULT_SPECULAR}; setSpecular(__tmp_3); setKc(CG_GLIGHT_DEFAULT_KC); setKl(CG_GLIGHT_DEFAULT_KL); setKq(CG_GLIGHT_DEFAULT_KQ); update(); } catch (std::exception&) { throw GLexception("CGFlight::constructor failed"); } glu_quadric = gluNewQuadric(); gluQuadricOrientation(glu_quadric, GLU_INSIDE); }
void GraphicEngine::initGL() { // Light init if (game->config->getInt("lighting")) glEnable(GL_LIGHTING); glEnable(GL_COLOR_MATERIAL); glEnable(GL_TEXTURE_2D); setAmbient(MGColor(0.5f, 0.5f, 0.5f, 1.0f)); setClearColor(MGColor(0.0f, 0.0f, 0.0f, 1.0f)); //glPolygonMode(GL_FRONT, GL_LINE); //glPolygonMode(GL_BACK, GL_LINE); glShadeModel (GL_SMOOTH); // ћетод закраски: —√Ћј∆≈Ќџ… glEnable (GL_DEPTH_TEST); // ¬ключаем тест глубины // ¬ Ћ. ј¬“ќћј“»„≈— »… ѕ≈–≈—„≈“ Ќќ–ћјЋ≈… //glEnable (GL_AUTO_NORMAL); glEnable (GL_NORMALIZE); // ¬ Ћ. ќ“—≈„≈Ќ»≈ «јƒЌ»’ √–јЌ≈… glEnable (GL_CULL_FACE); // ¬ключаем отсечение граней glCullFace (GL_BACK); // ”казываем, что отсекать будем задние грани updateScreenSize(); // Init fonts glEnable(GL_BLEND); setBlendFunc(getDefaultBlendFuncS(), getDefaultBlendFuncD()); standart14Normal = FontCache::getInstance()->load("standart_14_normal"); console8Normal = FontCache::getInstance()->load("console_8_normal"); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); GLenum err = glGetError (); if (GL_NO_ERROR != err) Log::error("GraphicEngine::initGL(): OpenGL Error: %s", gluErrorString (err)); Log::info("OpenGL initialized"); }
void ViewLightGL::lightEvent(ViewEvent * event) { if (event->type() == ViewEvent::eLightSet) { ViewLightSetEvent * e = (ViewLightSetEvent *)event; switch(e->def){ case ViewLightSetEvent::ePosition: setPosition(e->position); break; case ViewLightSetEvent::eActivation: setEnabled(e->activation); break; case ViewLightSetEvent::eAmbient: setAmbient(e->ambient); break; case ViewLightSetEvent::eDiffuse: setDiffuse(e->diffuse); break; case ViewLightSetEvent::eSpecular: setSpecular(e->specular); break; } } else if (event->type() == ViewEvent::eLightGet){ ViewLightGetEvent * e = (ViewLightGetEvent *)event; switch(e->def){ case ViewLightSetEvent::ePosition: *e->position = getPosition(); break; case ViewLightSetEvent::eActivation: *e->activation = isEnabled(); break; case ViewLightSetEvent::eAmbient: *e->ambient = __ambient; break; case ViewLightSetEvent::eDiffuse: *e->diffuse = __diffuse; break; case ViewLightSetEvent::eSpecular: *e->specular = __specular; break; } } }
LightSource::LightSource( GLfloat arg1, GLfloat arg2, GLfloat arg3 ) { for( int i = 0; i < GL_MAX_LIGHTS; i++ ) if( lights_used[ i ] == false ) { lights_used[ i ] = true; light_numb = GL_LIGHT0;//;translate( i ); break; } /* Light is not attached to anything initially */ mass = NULL; setAmbient( 0, 0, 0, 1 ); setDiffuse( arg1, arg2, arg3, 1 ); setIntensity( arg1, arg2, arg3, 1 ); enable(); }
DebugDeferredShading::DebugDeferredShading(glm::uvec2 const &screen_size, std::shared_ptr<PaintingManager> const &painter_manager) : ARenderingPipeline(std::string("deferred shading"), painter_manager) { _diffuse = createRenderPassOutput<Texture2D>(screen_size.x, screen_size.y, GL_RGBA8, true); _normal = createRenderPassOutput<Texture2D>(screen_size.x, screen_size.y, GL_RGBA8, true); _specular = createRenderPassOutput<Texture2D>(screen_size.x, screen_size.y, GL_RGBA8, true); _depthStencil = createRenderPassOutput<Texture2D>(screen_size.x, screen_size.y, GL_DEPTH24_STENCIL8, true); // RGB = light color, A = specular power _lightAccumulation = createRenderPassOutput<Texture2D>(screen_size.x, screen_size.y, GL_RGBA8, true); _shinyAccumulation = createRenderPassOutput<Texture2D>(screen_size.x, screen_size.y, GL_RGBA8, true); // We create the render pass _deferredSkybox = std::make_shared<DeferredSkyBox>(screen_size, _painter_manager, _diffuse, _depthStencil, _lightAccumulation); std::shared_ptr<DeferredBasicBuffering> basicBuffering = std::make_shared<DeferredBasicBuffering>(screen_size, _painter_manager, _diffuse, _normal, _specular, _depthStencil); std::shared_ptr<DeferredSpotLightning> spotLightning = std::make_shared<DeferredSpotLightning>(screen_size, _painter_manager, _normal, _depthStencil, _specular, _lightAccumulation, _shinyAccumulation); std::shared_ptr<DeferredShadowBuffering> shadowBuffering = std::make_shared<DeferredShadowBuffering>(glm::uvec2(RESOLUTION_SHADOW_X, RESOLUTION_SHADOW_Y), _painter_manager); std::shared_ptr<DeferredPointLightning> pointLightning = std::make_shared<DeferredPointLightning>(screen_size, _painter_manager, _normal, _depthStencil, _specular, _lightAccumulation, _shinyAccumulation); std::shared_ptr<DeferredDirectionalLightning> directionalLightning = std::make_shared<DeferredDirectionalLightning>(screen_size, _painter_manager, _normal, _depthStencil, _specular, _lightAccumulation, _shinyAccumulation); _deferredMerging = std::make_shared<DeferredMerging>(screen_size, _painter_manager, _diffuse, _lightAccumulation, _shinyAccumulation); std::shared_ptr<DeferredOnScreen> deferredOnScreen = std::make_shared<DeferredOnScreen>(screen_size, _painter_manager, _diffuse); // Debug render passes std::shared_ptr<DebugDrawLines> debugDrawLines = std::make_shared<DebugDrawLines>(screen_size, _painter_manager, _diffuse, _depthStencil); std::shared_ptr<DebugLightBillboards> debugLightBillboards = std::make_shared<DebugLightBillboards>(screen_size, _painter_manager, _diffuse, _depthStencil); // The entry point is the basic buffering pass setAmbient(glm::vec3(0.2f)); setSkyboxLighting(glm::vec3(0.8f)); _rendering_list.emplace_back(shadowBuffering); _rendering_list.emplace_back(basicBuffering); _rendering_list.emplace_back(directionalLightning); _rendering_list.emplace_back(_deferredSkybox); _rendering_list.emplace_back(spotLightning); _rendering_list.emplace_back(pointLightning); _rendering_list.emplace_back(_deferredMerging); _rendering_list.emplace_back(debugLightBillboards); _rendering_list.emplace_back(debugDrawLines); _rendering_list.emplace_back(deferredOnScreen); }
DecorativeObject::DecorativeObject(Ogre::SceneManager *mgr, Ogre::String _entName, Ogre::String _meshName, Ogre::String _nodeName, Ogre::SceneNode* parentNode, Physics* _physics, btVector3 origin, btVector3 scale, btVector3 velocity, btScalar _mass, btScalar _rest, btVector3 _localInertia, btQuaternion *rotation) : GameObject(mgr, _entName, _nodeName, parentNode, _physics, origin, scale, velocity, _mass, _rest, _localInertia, rotation) { entity = mgr->createEntity(_entName, _meshName); entity->setCastShadows(true); node->attachObject(entity); Ogre::MeshPtr meshptr = Ogre::Singleton<Ogre::MeshManager>::getSingletonPtr()->load(_meshName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); MeshStrider *strider = new MeshStrider(meshptr.get()); collisionShape = new btBvhTriangleMeshShape(strider,true,true); addToSimulator(Collisions::CollisionTypes::COL_COLLECTIBLE, 0); setAmbient(0.5,0.0,0.0); setSpecular(0.1,0,0,0.4); if (rotation) rotate(*rotation); }
Light::Light(float r, float g, float b, float a) { handle = lightNumber++; ZeroMemory( &light, sizeof(light) ); setType(D3DLIGHT_POINT); setDiffuse(r, g, b, a); setAmbient(0, 0, 0, 0); setRange((float)sqrt(FLT_MAX)); setSpecular(r, g, b, a); setAttenuation(1, 0, 0); uniSetLightInfo(handle, light); size = 1; int color = ((int)(r * 255) << 16) | ((int)(g * 255) << 8) | ((int)b * 255) | 0xff000000; calc = true; draw = false; // this->sprite = new Sprite(0.6f, color, "lens02"); }
ShaderExplodeVolumesAlpha::ShaderExplodeVolumesAlpha(bool withColorPerFace): m_wcpf(withColorPerFace) { m_nameVS = "ShaderExplodeVolumes_vs"; m_nameFS = "ShaderExplodeVolumes_fs"; m_nameGS = "ShaderExplodeVolumes_gs"; std::string glxvert(*GLSLShader::DEFINES_GL); glxvert.append(vertexShaderText); std::string glxgeom; glxgeom.append(GLSLShader::defines_Geom("lines_witw_adjacency", "triangle_strip", 3)); if (withColorPerFace) glxgeom.append("#define WITH_COLORPF 1\n"); glxgeom.append(geometryShaderText); std::string glxfrag(*GLSLShader::DEFINES_GL); glxfrag.append(fragmentShaderText); loadShadersFromMemory(glxvert.c_str(), glxfrag.c_str(), glxgeom.c_str(), GL_LINES_ADJACENCY_EXT , GL_TRIANGLE_STRIP,4); getLocations(); //Default values m_ambient = Geom::Vec4f(0.05f, 0.05f, 0.1f, 0.0f); m_backColor = Geom::Vec4f(1.0f, 0.1f, 0.1f, 0.0f); m_light_pos = Geom::Vec3f(10.0f, 10.0f, 1000.0f); m_plane = Geom::Vec4f(0.0f, 0.0f, 1000.f, 1000000000000000000000000000.0f); m_depthPeeling = 0; setAmbient(m_ambient); setBackColor(m_backColor); setLightPosition(m_light_pos); setClippingPlane(m_plane); setDepthPeeling(m_depthPeeling); }
void gxScene::setRenderState( const RenderState &rs ){ bool setmat=false; if( memcmp( rs.color,&material.diffuse.r,12 ) ){ memcpy( &material.diffuse.r,rs.color,12 ); memcpy( &material.ambient.r,rs.color,12 ); setmat=true; } if( rs.alpha!=material.diffuse.a ){ material.diffuse.a=rs.alpha; if( rs.fx&FX_ALPHATEST ){ int alpharef=(rs.fx&FX_VERTEXALPHA)?0:128*rs.alpha; setRS( D3DRENDERSTATE_ALPHAREF,alpharef ); } setmat=true; } if( rs.shininess!=shininess ){ shininess=rs.shininess; float t=shininess>0 ? (shininess<1 ? shininess : 1) : 0; material.specular.r=material.specular.g=material.specular.b=t; material.power=shininess*128; setRS( D3DRENDERSTATE_SPECULARENABLE,shininess>0 ? true : false ); setmat=true; } if( rs.blend!=blend ){ blend=rs.blend; switch( blend ){ case BLEND_REPLACE: setRS( D3DRENDERSTATE_ALPHABLENDENABLE,false ); break; case BLEND_ALPHA: setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true ); setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA ); setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA ); break; case BLEND_MULTIPLY: setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true ); setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_DESTCOLOR ); setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ZERO ); break; case BLEND_ADD: setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true ); setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA ); setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ONE ); break; } } if( rs.fx!=fx ){ int t=rs.fx^fx;fx=rs.fx; if( t & (FX_FULLBRIGHT|FX_CONDLIGHT) ){ setLights(); setAmbient(); } if( t&FX_VERTEXCOLOR ){ setRS( D3DRENDERSTATE_COLORVERTEX,fx & FX_VERTEXCOLOR ? true : false ); } if( t&FX_FLATSHADED ){ setRS( D3DRENDERSTATE_SHADEMODE,fx & FX_FLATSHADED ? D3DSHADE_FLAT : D3DSHADE_GOURAUD ); } if( t&FX_NOFOG ){ setFogMode(); } if( t&FX_DOUBLESIDED ){ setTriCull(); } if( t&FX_EMISSIVE ){ //Q3 Hack! int n=fx & FX_EMISSIVE; setRS( D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,n ? D3DMCS_MATERIAL : D3DMCS_COLOR1 ); setRS( D3DRENDERSTATE_AMBIENTMATERIALSOURCE,n ? D3DMCS_MATERIAL : D3DMCS_COLOR1 ); setRS( D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,n ? D3DMCS_COLOR1 : D3DMCS_MATERIAL ); setRS( D3DRENDERSTATE_COLORVERTEX,n ? true : false ); } if( t&FX_ALPHATEST ){ if( fx&FX_ALPHATEST ){ int alpharef=(rs.fx&FX_VERTEXALPHA)?0:128*rs.alpha; setRS( D3DRENDERSTATE_ALPHAREF,alpharef ); } setRS( D3DRENDERSTATE_ALPHATESTENABLE,fx & FX_ALPHATEST ? true : false ); } } if( setmat ){ dir3dDev->SetMaterial( &material ); } n_texs=0; TexState *hw=texstate; for( int k=0;k<MAX_TEXTURES;++k ){ const RenderState::TexState &ts=rs.tex_states[k]; if( !ts.canvas || !ts.blend ) continue; bool settex=false; ts.canvas->getTexSurface(); //force mipmap rebuild if( ts.canvas!=hw->canvas ){ hw->canvas=ts.canvas;settex=true; } if( ts.blend!=hw->blend ){ hw->blend=ts.blend;settex=true; } if( ts.flags!=hw->flags ){ hw->flags=ts.flags;settex=true; } if( ts.matrix || hw->mat_valid ){ if( ts.matrix ){ memcpy( &hw->matrix._11,ts.matrix->elements[0],12 ); memcpy( &hw->matrix._21,ts.matrix->elements[1],12 ); memcpy( &hw->matrix._31,ts.matrix->elements[2],12 ); memcpy( &hw->matrix._41,ts.matrix->elements[3],12 ); hw->mat_valid=true; }else{ hw->mat_valid=false; } settex=true; } if( settex && n_texs<tex_stages ){ setTexState( n_texs,*hw,true ); } ++hw;++n_texs; } if( n_texs<tex_stages && hw->canvas ){ hw->canvas=0; setTSS( n_texs,D3DTSS_COLOROP,D3DTOP_DISABLE ); setTSS( n_texs,D3DTSS_ALPHAOP,D3DTOP_DISABLE ); dir3dDev->SetTexture( n_texs,0 ); } }
void gxScene::setAmbient2( const float rgb[] ){ int n=(int(rgb[0]*255.0f)<<16)|(int(rgb[1]*255.0f)<<8)|int(rgb[2]*255.0f); ambient2=n;setAmbient(); }
gxScene::gxScene( gxGraphics *g,gxCanvas *t ): graphics(g),target(t),dir3dDev( g->dir3dDev ), n_texs(0),tris_drawn(0){ memset( d3d_rs,0x55,sizeof(d3d_rs) ); memset( d3d_tss,0x55,sizeof(d3d_tss) ); //nomalize normals setRS( D3DRENDERSTATE_NORMALIZENORMALS,TRUE ); //vertex coloring setRS( D3DRENDERSTATE_COLORVERTEX,FALSE ); setRS( D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,D3DMCS_COLOR1 ); setRS( D3DRENDERSTATE_AMBIENTMATERIALSOURCE,D3DMCS_COLOR1 ); setRS( D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,D3DMCS_MATERIAL ); setRS( D3DRENDERSTATE_SPECULARMATERIALSOURCE,D3DMCS_MATERIAL ); //Alpha test setRS( D3DRENDERSTATE_ALPHATESTENABLE,false ); setRS( D3DRENDERSTATE_ALPHAFUNC,D3DCMP_GREATER ); setRS( D3DRENDERSTATE_ALPHAREF,128 ); //source/dest blending modes setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA ); setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA ); //suss out caps can_wb=false; hw_tex_stages=1; D3DDEVICEDESC7 devDesc={0}; if( dir3dDev->GetCaps( &devDesc )>=0 ){ DWORD caps=devDesc.dpcTriCaps.dwRasterCaps; //texture stages hw_tex_stages=devDesc.wMaxSimultaneousTextures; //depth buffer mode if( (caps & D3DPRASTERCAPS_WBUFFER) && graphics->zbuffFmt.dwRGBBitCount==16 ) can_wb=true; //fog mode if( (caps&D3DPRASTERCAPS_FOGTABLE)&&(caps&D3DPRASTERCAPS_WFOG) ){ setRS( D3DRENDERSTATE_FOGVERTEXMODE,D3DFOG_NONE ); setRS( D3DRENDERSTATE_FOGTABLEMODE,D3DFOG_LINEAR ); }else{ setRS( D3DRENDERSTATE_FOGTABLEMODE,D3DFOG_NONE ); setRS( D3DRENDERSTATE_FOGVERTEXMODE,D3DFOG_LINEAR ); } } tex_stages=hw_tex_stages; caps_level=100; if( devDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_CUBEMAP ){ caps_level=110; } //default texture states for( int n=0;n<hw_tex_stages;++n ){ setTSS( n,D3DTSS_COLORARG1,D3DTA_TEXTURE ); setTSS( n,D3DTSS_COLORARG2,D3DTA_CURRENT ); setTSS( n,D3DTSS_ALPHAARG1,D3DTA_TEXTURE ); setTSS( n,D3DTSS_ALPHAARG2,D3DTA_CURRENT ); setTSS( n,D3DTSS_MINFILTER,D3DTFN_LINEAR ); setTSS( n,D3DTSS_MAGFILTER,D3DTFG_LINEAR ); setTSS( n,D3DTSS_MIPFILTER,D3DTFP_LINEAR ); } setHWMultiTex( true ); //ATI lighting hack dir3dDev->LightEnable( 0,true ); dir3dDev->LightEnable( 0,false ); //globals sphere_mat._11=.5f;sphere_mat._22=-.5f;sphere_mat._33=.5f; sphere_mat._41=.5f;sphere_mat._42=.5f;sphere_mat._43=.5f; nullmatrix._11=nullmatrix._22=nullmatrix._33=nullmatrix._44=1; //set null renderstate memset(&material,0,sizeof(material)); shininess=0;blend=BLEND_REPLACE;fx=0; for( int k=0;k<MAX_TEXTURES;++k ) memset( &texstate[k],0,sizeof(texstate[k]) ); wbuffer=can_wb; dither=false;setDither( true ); antialias=true;setAntialias( false ); wireframe=true;setWireframe( false ); flipped=true;setFlippedTris( false ); ambient=~0;setAmbient( GRAY ); ambient2=~0;setAmbient2( BLACK ); fogcolor=~0;setFogColor( BLACK ); fogrange_nr=fogrange_fr=0;setFogRange( 1,1000 ); fogmode=FOG_LINEAR;setFogMode( FOG_NONE ); zmode=-1;setZMode( ZMODE_NORMAL ); memset(&projmatrix,0,sizeof(projmatrix)); ortho_proj=true;frustum_nr=frustum_fr=frustum_w=frustum_h=0;setPerspProj( 1,1000,1,1 ); memset(&viewport,0,sizeof(viewport));viewport.dvMaxZ=1;setViewport( 0,0,target->getWidth(),target->getHeight() ); viewmatrix=nullmatrix;setViewMatrix( 0 ); worldmatrix=nullmatrix;setWorldMatrix( 0 ); //set default renderstate blend=fx=~0;shininess=1; RenderState state;memset(&state,0,sizeof(state)); state.color[0]=state.color[1]=state.color[2]=state.alpha=1; state.blend=BLEND_REPLACE; setRenderState( state ); }
int main(int argc, char** argv) { osg::ArgumentParser arguments( &argc, argv ); std::string dbPath; arguments.read("--db_path", dbPath); std::srand ( unsigned ( std::time(0) ) ); auto board = Board(boardDefinition, boardSizeX, boardSizeY, dbPath); auto ghostFactory = GhostFactory(); auto main_obj = make_ref<osg::Group>(); main_obj->addChild(board.draw().get()); auto ghostModel = osgDB::readNodeFile(dbPath + "/cow.osg"); auto ghostCount = 16; while(ghostCount--) { main_obj->addChild(ghostFactory.drawGhost(board, ghostModel).get()); } // init rotate auto init_rotate = make_ref<osg::MatrixTransform>(); init_rotate->setMatrix( osg::Matrix::rotate(osg::PI * 2, osg::Vec3(1.0f, 0.0f, 0.0f)) ); // chain rotates init_rotate->addChild(main_obj); // Root group auto root = make_ref<osg::Group>(); root->addChild(init_rotate); // Setup fog if(FogEnabled) { osg::ref_ptr<osg::Fog> fog = new osg::Fog; fog->setMode( osg::Fog::EXP2 ); fog->setStart( 0.0f ); fog->setEnd(board.getFieldSizeX() * 20); fog->setDensity(0.0135); fog->setColor( osg::Vec4(0., 0., 0., 1.0) ); root->getOrCreateStateSet()->setAttributeAndModes(fog.get()); } // Start viewer osgViewer::Viewer viewer; // Set up flashlight auto lightSource = make_ref<osg::LightSource>(); lightSource->setReferenceFrame(osg::LightSource::ABSOLUTE_RF); auto light = lightSource->getLight(); const osg::Vec3 lightPosition{1.5, -1, -1}; // right, down, front light->setPosition(osg::Vec4{lightPosition, 1}); light->setDirection(osg::Vec3{0, 0, -1} * 30 - lightPosition); light->setSpotExponent(60); light->setSpotCutoff(90); light->setDiffuse(osg::Vec4(1, 1, 1, 1)); light->setAmbient(osg::Vec4(0.6, 0.6, 0.6, 1)); light->setSpecular(osg::Vec4(1, 1, 1, 1)); light->setLinearAttenuation(0.001); light->setConstantAttenuation(0.5); root->addChild(lightSource); double height = std::min(board.getFieldSizeX(), board.getFieldSizeY()) / 1.5; auto fpsManipulator = make_ref<FPSManipulator>(board, viewer, *light); fpsManipulator->setHomePosition( osg::Vec3d(board.getFieldCenterX(1), board.getFieldCenterY(10), height), osg::Vec3d(0.0f, 0.0f, height), osg::Vec3d(0.0f, 0.0f, 1.0f) ); auto keySwitch = make_ref<osgGA::KeySwitchMatrixManipulator>(); keySwitch->addNumberedMatrixManipulator(make_ref<osgGA::OrbitManipulator>()); keySwitch->addNumberedMatrixManipulator(fpsManipulator); viewer.setCameraManipulator(keySwitch); viewer.home(); viewer.setSceneData( root ); osgViewer::Viewer::Windows windows; viewer.getWindows(windows); viewer.getCamera()->setClearColor(osg::Vec4{0, 0, 0, 0}); viewer.getCamera()->getView()->setLightingMode(osg::View::HEADLIGHT); auto defaultLight = viewer.getCamera()->getView()->getLight(); defaultLight->setDiffuse(osg::Vec4(0, 0, 0, 1)); defaultLight->setAmbient(osg::Vec4(0, 0, 0, 1)); defaultLight->setSpecular(osg::Vec4(0, 0, 0, 1)); // Shaders auto program = make_ref<osg::Program>(); auto fragmentObject = make_ref<osg::Shader>(osg::Shader::FRAGMENT); loadShaderSource(fragmentObject, dbPath + "/shader.frag"); auto vertexObject = make_ref<osg::Shader>(osg::Shader::VERTEX); loadShaderSource(vertexObject, dbPath + "/shader.vert"); program->addShader(vertexObject); program->addShader(fragmentObject); root->getOrCreateStateSet()->setAttributeAndModes(program, osg::StateAttribute::ON); root->getOrCreateStateSet()->addUniform(new osg::Uniform("samplerName", TEXTURE_UNIT)); root->getOrCreateStateSet()->addUniform(new osg::Uniform("Shininess", BoardObjectsShininess)); root->getOrCreateStateSet()->addUniform(new osg::Uniform("FogEnabled", FogEnabled)); // Optimize osgUtil::Optimizer optimzer; optimzer.optimize(root); viewer.setUpViewOnSingleScreen(0); return viewer.run(); }
// *************************************************************************** void CMaterial::serial(NLMISC::IStream &f) { /* *********************************************** * WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance * It can be loaded/called through CAsyncFileManager for instance * ***********************************************/ /* Version 9: - Added support for third operand (for Mad operator) Version 8: - Serial _TexCoordGenMode Version 7: - Lightmap color and Mulx2 Version 6: - Texture matrix animation Version 5: - AlphaTest threshold Version 4: - Texture Addressing modes Version 3: - LightMaps. Version 2: - Shininess. Version 1: - texture environement. Version 0: - base version. */ sint ver= f.serialVersion(9); // For the version <=1: nlassert(IDRV_MAT_MAXTEXTURES==4); f.serialEnum(_ShaderType); f.serial(_Flags); f.serialEnum(_SrcBlend); f.serialEnum(_DstBlend); f.serialEnum(_ZFunction); f.serial(_ZBias); f.serial(_Color); f.serial(_Emissive, _Ambient, _Diffuse, _Specular); if(ver>=2) { f.serial(_Shininess); } if(ver>=5) { f.serial(_AlphaTestThreshold); } if(ver>=8) { f.serial(_TexCoordGenMode); } else _TexCoordGenMode = 0; for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++) { // Serial texture descriptor. _Textures[i].serialPolyPtr(f); // Read texture environnement, or setup them. if(ver>=1) { _TexEnvs[i].serial(f, ver >= 9 ? 1 : 0); } else { // Else setup as default behavior, like before... if(f.isReading()) _TexEnvs[i].setDefault(); } } if(ver>=3) { if(ver>=7) { uint32 n; if (f.isReading()) { f.serial(n); _LightMaps.resize(n); } else { n = (uint32)_LightMaps.size(); f.serial(n); } for (uint32 i = 0; i < n; ++i) _LightMaps[i].serial2(f); f.serial(_LightMapsMulx2); } else { f.serialCont(_LightMaps); } } if (ver >= 4) { if (_Flags & IDRV_MAT_TEX_ADDR) { for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++) { f.serial(_TexAddrMode[i]); } } } if(f.isReading()) { // Converte Deprecated DEFMAT to std Mat. if(_Flags & IDRV_MAT_DEFMAT) { setEmissive(CRGBA::Black); setAmbient(CRGBA::White); setDiffuse(CRGBA::White); setSpecular(CRGBA::Black); } // All states of material are modified. _Touched= IDRV_TOUCHED_ALL; if ((_Flags & IDRV_MAT_USER_TEX_MAT_ALL)) // are there user textrue coordinates matrix ? { std::auto_ptr<CUserTexMat> newPtr(new CUserTexMat); // create new //std::swap(_TexUserMat, newPtr); // replace old _TexUserMat = newPtr; } } if (ver >= 6) { for(uint i=0; i < IDRV_MAT_MAXTEXTURES; ++i) { if (isUserTexMatEnabled(i)) { f.serial(_TexUserMat->TexMat[i]); } } } }
CModelFile::CModelFile() : m_currentSet(0) { restoreDefaults(); setAmbient(.5f, .5f, .5f); }
void BasicAmbientMethod::copyFrom(ShadingMethodBase* method) { BasicAmbientMethod* basicAmbientMethod = (BasicAmbientMethod*)method; setAmbient(basicAmbientMethod->getAmbient()); setAmbientColor(basicAmbientMethod->getAmbientColor()); }
//----------------------------------------------------------------------- void Material::setAmbient(Real red, Real green, Real blue) { setAmbient(ColourValue(red, green, blue)); }
void Material::setAmbient(const Color &color) { auto ptr = lock(); if ( ptr ) ptr->setAmbient(color); }
//----------------------------------------------------------------------- void Technique::setAmbient(Real red, Real green, Real blue) { setAmbient(ColourValue(red, green, blue)); }
void Material::setAmbient(float r, float g, float b, float a) { setAmbient(glm::vec4(r, g, b, a)); }