pSprite Sprite::init(pObject const& parent, int const& w, int const& h)
{
if( name_.size() < 1 ) {
Object::init(parent);
return std::tr1::static_pointer_cast<Sprite>(shared_from_this());
}
setupSceneAndManager(parent);
std::ostringstream oss;
oss << Conf::i().expand("rc/texture/") << name_ << ".png";
video::IVideoDriver* driver = smgr_->getVideoDriver();
size_.Width = w;
size_.Height = h;
SMaterial mat = create_std_material_for_sprite();
mat.setTexture(0, driver->getTexture(oss.str().c_str()));
setupMeshAndNode(thismesh_, body_, parent, size_, center_, name_);
body_->grab(); //added so its d'tor order is consistent with view::Object.
body_->getMaterial(0) = mat;
pSprite self = static_pointer_cast<Sprite>( shared_from_this() );
scene()->addPickMapping( body_, self );
return self;
}
SMaterial Sprite::create_std_material_for_sprite()
{
SMaterial mat;
mat.setFlag(video::EMF_LIGHTING, true);
mat.setFlag(video::EMF_ZWRITE_ENABLE, false);
mat.setFlag(video::EMF_NORMALIZE_NORMALS, true);
//This is important for material usage in cubeat.
//ColorMaterial is a added feature in Irrlicht 1.7 so that Vertex Color can be used as
//Material colors when doing blending. But if you want the ordinary material color
//to be used and not vertex color, this must be set to ECM_NONE.
//I think it is a bad naming because you cannot understand the meaning by just looking
//at the "ColorMaterial" name...
mat.ColorMaterial = video::ECM_NONE;
mat.MaterialType = video::EMT_TRANSPARENT_MODULATE;
mat.MaterialTypeParam = 0.01f;
mat.DiffuseColor.set(255, 255, 255, 255);
return mat;
}
void Stage::createBackground()
{
dimension2d<u32> screenSize = _game->getDevice(
)->getVideoDriver()->getScreenSize();
dimension2d<f32> screenSizeF32 = dimension2d<f32>(
(f32) screenSize.Width, (f32) screenSize.Height);
ISceneManager* scene = _game->getDevice()->getSceneManager();
const IGeometryCreator* geometry = scene->getGeometryCreator();
SMaterial material;
material.MaterialType = EMT_TRANSPARENT_ALPHA_CHANNEL;
dimension2d<u32> textureSize = _stageConfig.BackgroundTexture->getSize();
dimension2d<f32> textureRepeats = dimension2d<f32>(
screenSizeF32.Width/textureSize.Width,
screenSizeF32.Height/textureSize.Height);
material.setTexture(0, _stageConfig.BackgroundTexture);
scene->addMeshSceneNode(geometry->createPlaneMesh(
screenSizeF32, dimension2d<u32>(1, 1), &material, textureRepeats),
_rootNode);
}
pSpriteMovie SpriteMovie::init(pObject const& parent, int const& w, int const& h)
{
setupSceneAndManager(parent);
size_.Width = w;
size_.Height = h;
avi = new AVIVideo(Conf::i().expand(name_.c_str()));
/////////////// I'll keep this part for future reference /////////////////
SMaterial mat;
mat.setFlag(video::EMF_LIGHTING, true);
mat.setFlag(video::EMF_ZWRITE_ENABLE, false);
mat.setTexture(0, avi->getTexture());
mat.MaterialType = video::EMT_ONETEXTURE_BLEND;
mat.MaterialTypeParam =
video::pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X);
mat.DiffuseColor.set(255,255,255,255);
/////////////// End of this part /////////////////////////////////////////
setupMeshAndNode(thismesh_, body_, parent, size_, center_, name_);
body_->grab(); //added so its d'tor order is consistent with view::Object.
body_->getMaterial(0) = mat;
//test
body_->grab();
dimension2di avi_actual_size = avi->getSize();
adjust_texcoord_for_hand_made_texture( thismesh_, avi_actual_size.Width, avi_actual_size.Height );
pSpriteMovie self = static_pointer_cast<SpriteMovie>( shared_from_this() );
scene()->addPickMapping( body_, self );
return self;
}
/*!
Constructs button as a plane node and text node with shared root node.
@param game Game instance.
@param config Configuration (texture, size, etc).
@param index Index of the button (from 0 to count - 1).
*/
Button(Game* game, const MenuConfig& config, s32 index)
{
ISceneManager* scene = game->getDevice()->getSceneManager();
Root = scene->addEmptySceneNode();
scene->addTextSceneNode(
config.Font,
config.Buttons[index].Text.c_str(),
config.FontColor,
Root)->setPosition(vector3df(0, 10, 0));
SMaterial material;
material.MaterialType = EMT_TRANSPARENT_ALPHA_CHANNEL;
material.setTexture(0, config.ButtonTextures.Default);
Plane = scene->addMeshSceneNode(
scene->getGeometryCreator()->createPlaneMesh(
dimension2df(
(f32) config.ButtonSize.Width,
(f32) config.ButtonSize.Height),
dimension2du(1, 1), &material, dimension2df(1, 1)
), Root);
};
void COpenGLCgMaterialRenderer::OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services)
{
Material = material;
if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)
{
if (VertexProgram)
{
cgGLEnableProfile(VertexProfile);
cgGLBindProgram(VertexProgram);
}
if (FragmentProgram)
{
cgGLEnableProfile(FragmentProfile);
cgGLBindProgram(FragmentProgram);
}
if (GeometryProgram)
{
cgGLEnableProfile(GeometryProfile);
cgGLBindProgram(GeometryProgram);
}
if (BaseMaterial)
BaseMaterial->OnSetMaterial(material, material, true, this);
}
if (CallBack)
CallBack->OnSetMaterial(material);
for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
Driver->setActiveTexture(i, material.getTexture(i));
Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);
}
// ----------------------------------------------------------------------------
void Track::build()
{
IrrlichtDevice* device = Editor::getEditor()->getDevice();
PHYSFS_setWriteDir(Editor::getEditor()->getTrackDir().c_str());
PHYSFS_mkdir(m_file_name.c_str());
path p = Editor::getEditor()->getTrackDir() + m_file_name;
CMeshBuffer<S3DVertex2TCoords>* mb = m_terrain->build(p);
SMesh smesh;
smesh.addMeshBuffer(mb);
for (u32 i = 1; i < m_roads.size(); i++)
{
IRoad* r = m_roads[i];
if (r->getSpline()->getPointNum()>1)
smesh.addMeshBuffer(((Road*)r)->getMeshBuffer());
}
B3DMeshWriter* writer = new B3DMeshWriter(device->getFileSystem());
IWriteFile *file;
file = device->getFileSystem()->createAndWriteFile((p + "/track.b3d").c_str());
writer->writeMesh(file, &smesh);
file->drop();
delete writer;
m_driveline->build(p);
std::ofstream mat;
mat.open((p + "/materials.xml").c_str());
mat << "<materials>\n";
mat << " <material name=\"splatt.png\" graphical-effect=\"splatting\"";
SMaterial m = m_terrain->getMaterial(0);
for (int i = 1; i < 5; i++)
{
mat << " splatting-texture-" << i << "=\"";
mat << Editor::toRelative(m.getTexture(i+1)->getName()).c_str();
mat << "\"";
}
mat << "/>\n";
if (m_gravity_road)
{
for (u32 i = 1; i < m_roads.size(); i++)
{
stringc tex = m_roads[i]->getTexName();
if (tex.size()>0)
{
mat << " <material name=\"";
mat << tex.c_str();
mat << "\" has-gravity=\"yes\" />\n";
}
} // roads
} // gravity road mode
mat <<"</materials>\n";
mat.close();
stringw track;
track += "<track name = \"";
track += m_track_name + L"\"\n";
track += " version = \"5\"\n";
track += " groups = \"made-by-STK-TE\"\n";
track += " designer = \"";
track += m_designer + "\"\n";
track += " music = \"";
track += m_music.c_str();
track += "\"\n";
track += " screenshot = \"screenshot.jpg\"\n";
track += " smooth-normals = \"true\"\n";
track += " reverse = \"Y\"\n>\n";
track += "</track>\n";
PHYSFS_uint64 len = 4 * track.size();
char* dst = new char[len];
#ifdef _WIN32
PHYSFS_utf8FromUcs2((PHYSFS_uint16*)track.c_str(),dst,len);
#else
PHYSFS_utf8FromUcs4((PHYSFS_uint32*)track.c_str(), dst, len);
#endif
FILE* f;
f = fopen((p + "/track.xml").c_str(), "wb");
fwrite(dst, sizeof(char), strlen(dst), f);
fclose(f);
delete[] dst;
std::ofstream scene;
scene.open((p + "/scene.xml").c_str());
scene << "<scene>\n";
scene << " <track model=\"track.b3d\" x=\"0\" y=\"0\" z=\"0\">\n";
exportElements(scene, true);
scene << " </track>\n";
exportElements(scene, false);
ISceneManager* sm = Editor::getEditor()->getSceneManager();
ISceneNode* node;
int i = 1;
stringc name;
while ((node = sm->getSceneNodeFromId(MAGIC_NUMBER + i)))
{
name = node->getName();
vector3df pos;
if (node->isVisible() && (name == "banana" || name == "item"
|| name == "small-nitro" || name == "big-nitro"))
{
pos = node->getPosition();
scene << " <" << name.c_str() << " x=\"" << pos.X << "\" y=\"" << pos.Y
<< "\" z=\"" << pos.Z << "\" />\n";
}
i++;
}
scene << Viewport::get()->getSky()->getXmlString().c_str();
Viewport::get()->printCheckLine(&scene);
scene << " <default-start karts-per-row = \"3\"\n";
scene << " forwards-distance =\"1.50\"\n";
scene << " sidewards-distance=\"3.00\"\n";
scene << " upwards-distance =\"0.10\"/>\n";
scene << "</scene>\n";
scene.close();
MsgWndw::get()->showMsg(_("Track exported!"));
} // build
void COGLES2FixedPipelineShader::setMaterial(const SMaterial &material)
{
if (Fog != static_cast<int>(material.FogEnable))
{
Fog = material.FogEnable;
setUniform(FOG, &Fog);
}
if (Lighting != static_cast<int>(material.Lighting))
{
Lighting = material.Lighting;
setUniform(LIGHTING, &Lighting);
}
if (Normalize != static_cast<float>(material.NormalizeNormals))
{
Normalize = material.NormalizeNormals;
setUniform(NORMALIZE, &Normalize);
}
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
{
UseTexture[i] = material.getTexture(i) != 0;
if (UseTexture[i])
{
UseTexMatrix[i] = false;
const core::matrix4& texMat = material.getTextureMatrix(i);
if (!texMat.isIdentity())
{
UseTexMatrix[i] = true;
memcpy(&TextureMatrix[i], texMat.pointer(), sizeof(mat4));
}
}
}
if (ColorMaterial != material.ColorMaterial)
{
ColorMaterial = material.ColorMaterial;
setUniform(COLOR_MATERIAL, &ColorMaterial);
}
if (MaterialAmbient != material.AmbientColor)
{
MaterialAmbient = material.AmbientColor;
setUniform(MATERIAL_AMBIENT, &MaterialAmbient);
}
if (MaterialEmission != material.EmissiveColor)
{
MaterialEmission = material.EmissiveColor;
setUniform(MATERIAL_EMISSION, &MaterialEmission);
}
if (MaterialDiffuse != material.DiffuseColor)
{
MaterialDiffuse = material.DiffuseColor;
setUniform(MATERIAL_DIFFUSE, &MaterialDiffuse);
}
if (MaterialSpecular != material.SpecularColor)
{
MaterialSpecular = material.SpecularColor;
setUniform(MATERIAL_SPECULAR, &MaterialSpecular);
}
if (MaterialShininess != material.Shininess)
{
MaterialShininess = material.Shininess;
setUniform(MATERIAL_SHININESS, &MaterialShininess);
}
}
