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));
}
