irrlicht/source/Irrlicht/CSkyDomeSceneNode.cpp

291 lines
8.8 KiB
C++

// Copyright (C) 2002-2009 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
// Code for this scene node has been contributed by Anders la Cour-Harbo (alc)
#include "CSkyDomeSceneNode.h"
#include "IVideoDriver.h"
#include "ISceneManager.h"
#include "ICameraSceneNode.h"
#include "IAnimatedMesh.h"
#include "os.h"
namespace irr
{
namespace scene
{
/* horiRes and vertRes:
Controls the number of faces along the horizontal axis (30 is a good value)
and the number of faces along the vertical axis (8 is a good value).
texturePercentage:
Only the top texturePercentage of the image is used, e.g. 0.8 uses the top 80% of the image,
1.0 uses the entire image. This is useful as some landscape images have a small banner
at the bottom that you don't want.
spherePercentage:
This controls how far around the sphere the sky dome goes. For value 1.0 you get exactly the upper
hemisphere, for 1.1 you get slightly more, and for 2.0 you get a full sphere. It is sometimes useful
to use a value slightly bigger than 1 to avoid a gap between some ground place and the sky. This
parameters stretches the image to fit the chosen "sphere-size". */
CSkyDomeSceneNode::CSkyDomeSceneNode(video::ITexture* sky, u32 horiRes, u32 vertRes,
f32 texturePercentage, f32 spherePercentage, f32 radius,
ISceneNode* parent, ISceneManager* mgr, s32 id)
: ISceneNode(parent, mgr, id), Buffer(0),
HorizontalResolution(horiRes), VerticalResolution(vertRes),
TexturePercentage(texturePercentage),
SpherePercentage(spherePercentage), Radius(radius)
{
#ifdef _DEBUG
setDebugName("CSkyDomeSceneNode");
#endif
setAutomaticCulling(scene::EAC_OFF);
Buffer = new SMeshBuffer();
Buffer->Material.Lighting = false;
Buffer->Material.ZBuffer = video::ECFN_NEVER;
Buffer->Material.ZWriteEnable = false;
Buffer->Material.setTexture(0, sky);
Buffer->BoundingBox.MaxEdge.set(0,0,0);
Buffer->BoundingBox.MinEdge.set(0,0,0);
Buffer->Vertices.clear();
Buffer->Indices.clear();
// regenerate the mesh
generateMesh();
}
CSkyDomeSceneNode::~CSkyDomeSceneNode()
{
if (Buffer)
Buffer->drop();
}
void CSkyDomeSceneNode::generateMesh()
{
f32 azimuth;
u32 k;
const f32 azimuth_step = (core::PI * 2.f) / HorizontalResolution;
if (SpherePercentage < 0.f)
SpherePercentage = -SpherePercentage;
if (SpherePercentage > 2.f)
SpherePercentage = 2.f;
const f32 elevation_step = SpherePercentage * core::HALF_PI / (f32)VerticalResolution;
Buffer->Vertices.reallocate( (HorizontalResolution + 1) * (VerticalResolution + 1) );
Buffer->Indices.reallocate(3 * (2*VerticalResolution - 1) * HorizontalResolution);
video::S3DVertex vtx;
vtx.Color.set(255,255,255,255);
vtx.Normal.set(0.0f,-1.f,0.0f);
const f32 tcV = TexturePercentage / VerticalResolution;
for (k = 0, azimuth = 0; k <= HorizontalResolution; ++k)
{
f32 elevation = core::HALF_PI;
const f32 tcU = (f32)k / (f32)HorizontalResolution;
const f32 sinA = sinf(azimuth);
const f32 cosA = cosf(azimuth);
for (u32 j = 0; j <= VerticalResolution; ++j)
{
const f32 cosEr = Radius * cosf(elevation);
vtx.Pos.set(cosEr*sinA, Radius*sinf(elevation), cosEr*cosA);
vtx.TCoords.set(tcU, j*tcV);
vtx.Normal = -vtx.Pos;
vtx.Normal.normalize();
Buffer->Vertices.push_back(vtx);
elevation -= elevation_step;
}
azimuth += azimuth_step;
}
for (k = 0; k < HorizontalResolution; ++k)
{
Buffer->Indices.push_back(VerticalResolution + 2 + (VerticalResolution + 1)*k);
Buffer->Indices.push_back(1 + (VerticalResolution + 1)*k);
Buffer->Indices.push_back(0 + (VerticalResolution + 1)*k);
for (u32 j = 1; j < VerticalResolution; ++j)
{
Buffer->Indices.push_back(VerticalResolution + 2 + (VerticalResolution + 1)*k + j);
Buffer->Indices.push_back(1 + (VerticalResolution + 1)*k + j);
Buffer->Indices.push_back(0 + (VerticalResolution + 1)*k + j);
Buffer->Indices.push_back(VerticalResolution + 1 + (VerticalResolution + 1)*k + j);
Buffer->Indices.push_back(VerticalResolution + 2 + (VerticalResolution + 1)*k + j);
Buffer->Indices.push_back(0 + (VerticalResolution + 1)*k + j);
}
}
}
//! renders the node.
void CSkyDomeSceneNode::render()
{
video::IVideoDriver* driver = SceneManager->getVideoDriver();
scene::ICameraSceneNode* camera = SceneManager->getActiveCamera();
if (!camera || !driver)
return;
if ( !camera->isOrthogonal() )
{
core::matrix4 mat(AbsoluteTransformation);
mat.setTranslation(camera->getAbsolutePosition());
driver->setTransform(video::ETS_WORLD, mat);
driver->setMaterial(Buffer->Material);
driver->drawMeshBuffer(Buffer);
}
// for debug purposes only:
if ( DebugDataVisible )
{
video::SMaterial m;
m.Lighting = false;
driver->setMaterial(m);
if ( DebugDataVisible & scene::EDS_NORMALS )
{
IAnimatedMesh * arrow = SceneManager->addArrowMesh (
"__debugnormal2", 0xFFECEC00,
0xFF999900, 4, 8, 1.f * 40.f, 0.6f * 40.f, 0.05f * 40.f, 0.3f * 40.f);
if ( 0 == arrow )
{
arrow = SceneManager->getMesh ( "__debugnormal2" );
}
IMesh *mesh = arrow->getMesh(0);
// find a good scaling factor
core::matrix4 m2;
// draw normals
const scene::IMeshBuffer* mb = Buffer;
const u32 vSize = video::getVertexPitchFromType(mb->getVertexType());
const video::S3DVertex* v = ( const video::S3DVertex*)mb->getVertices();
for ( u32 i=0; i != mb->getVertexCount(); ++i )
{
// align to v->Normal
core::quaternion quatRot(v->Normal.X, 0.f, -v->Normal.X, 1+v->Normal.Y);
quatRot.normalize();
quatRot.getMatrix(m2, v->Pos);
m2 = AbsoluteTransformation * m2;
driver->setTransform(video::ETS_WORLD, m2);
for (u32 a = 0; a != mesh->getMeshBufferCount(); ++a)
driver->drawMeshBuffer(mesh->getMeshBuffer(a));
v = (const video::S3DVertex*) ( (u8*) v + vSize );
}
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
}
// show mesh
if ( DebugDataVisible & scene::EDS_MESH_WIRE_OVERLAY )
{
m.Wireframe = true;
driver->setMaterial(m);
driver->drawMeshBuffer(Buffer);
}
}
}
//! returns the axis aligned bounding box of this node
const core::aabbox3d<f32>& CSkyDomeSceneNode::getBoundingBox() const
{
return Buffer->BoundingBox;
}
void CSkyDomeSceneNode::OnRegisterSceneNode()
{
if (IsVisible)
{
SceneManager->registerNodeForRendering(this, ESNRP_SKY_BOX );
}
ISceneNode::OnRegisterSceneNode();
}
//! returns the material based on the zero based index i. To get the amount
//! of materials used by this scene node, use getMaterialCount().
//! This function is needed for inserting the node into the scene hirachy on a
//! optimal position for minimizing renderstate changes, but can also be used
//! to directly modify the material of a scene node.
video::SMaterial& CSkyDomeSceneNode::getMaterial(u32 i)
{
return Buffer->Material;
}
//! returns amount of materials used by this scene node.
u32 CSkyDomeSceneNode::getMaterialCount() const
{
return 1;
}
//! Writes attributes of the scene node.
void CSkyDomeSceneNode::serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const
{
ISceneNode::serializeAttributes(out, options);
out->addInt ("HorizontalResolution", HorizontalResolution);
out->addInt ("VerticalResolution", VerticalResolution);
out->addFloat("TexturePercentage", TexturePercentage);
out->addFloat("SpherePercentage", SpherePercentage);
out->addFloat("Radius", Radius);
}
//! Reads attributes of the scene node.
void CSkyDomeSceneNode::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options)
{
HorizontalResolution = in->getAttributeAsInt ("HorizontalResolution");
VerticalResolution = in->getAttributeAsInt ("VerticalResolution");
TexturePercentage = in->getAttributeAsFloat("TexturePercentage");
SpherePercentage = in->getAttributeAsFloat("SpherePercentage");
Radius = in->getAttributeAsFloat("Radius");
ISceneNode::deserializeAttributes(in, options);
// regenerate the mesh
generateMesh();
}
//! Creates a clone of this scene node and its children.
ISceneNode* CSkyDomeSceneNode::clone(ISceneNode* newParent, ISceneManager* newManager)
{
if (!newParent)
newParent = Parent;
if (!newManager)
newManager = SceneManager;
CSkyDomeSceneNode* nb = new CSkyDomeSceneNode(Buffer->Material.TextureLayer[0].Texture, HorizontalResolution, VerticalResolution, TexturePercentage,
SpherePercentage, Radius, newParent, newManager, ID);
nb->cloneMembers(this, newManager);
nb->drop();
return nb;
}
} // namespace scene
} // namespace irr