diff options
author | David Walter Seikel | 2014-01-13 19:47:58 +1000 |
---|---|---|
committer | David Walter Seikel | 2014-01-13 19:47:58 +1000 |
commit | f9158592e1478b2013afc7041d9ed041cf2d2f4a (patch) | |
tree | b16e389d7988700e21b4c9741044cefa536dcbae /libraries/irrlicht-1.8/source/Irrlicht/CSkyDomeSceneNode.cpp | |
parent | Libraries readme updated with change markers and more of the Irrlicht changes. (diff) | |
download | SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.zip SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.tar.gz SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.tar.bz2 SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.tar.xz |
Update Irrlicht to 1.8.1. Include actual change markers this time. lol
Diffstat (limited to '')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CSkyDomeSceneNode.cpp | 264 |
1 files changed, 0 insertions, 264 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CSkyDomeSceneNode.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CSkyDomeSceneNode.cpp deleted file mode 100644 index 4545f04..0000000 --- a/libraries/irrlicht-1.8/source/Irrlicht/CSkyDomeSceneNode.cpp +++ /dev/null | |||
@@ -1,264 +0,0 @@ | |||
1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt | ||
2 | // This file is part of the "Irrlicht Engine". | ||
3 | // For conditions of distribution and use, see copyright notice in irrlicht.h | ||
4 | // Code for this scene node has been contributed by Anders la Cour-Harbo (alc) | ||
5 | |||
6 | #include "CSkyDomeSceneNode.h" | ||
7 | #include "IVideoDriver.h" | ||
8 | #include "ISceneManager.h" | ||
9 | #include "ICameraSceneNode.h" | ||
10 | #include "IAnimatedMesh.h" | ||
11 | #include "os.h" | ||
12 | |||
13 | namespace irr | ||
14 | { | ||
15 | namespace scene | ||
16 | { | ||
17 | |||
18 | /* horiRes and vertRes: | ||
19 | Controls the number of faces along the horizontal axis (30 is a good value) | ||
20 | and the number of faces along the vertical axis (8 is a good value). | ||
21 | |||
22 | texturePercentage: | ||
23 | Only the top texturePercentage of the image is used, e.g. 0.8 uses the top 80% of the image, | ||
24 | 1.0 uses the entire image. This is useful as some landscape images have a small banner | ||
25 | at the bottom that you don't want. | ||
26 | |||
27 | spherePercentage: | ||
28 | This controls how far around the sphere the sky dome goes. For value 1.0 you get exactly the upper | ||
29 | hemisphere, for 1.1 you get slightly more, and for 2.0 you get a full sphere. It is sometimes useful | ||
30 | to use a value slightly bigger than 1 to avoid a gap between some ground place and the sky. This | ||
31 | parameters stretches the image to fit the chosen "sphere-size". */ | ||
32 | |||
33 | CSkyDomeSceneNode::CSkyDomeSceneNode(video::ITexture* sky, u32 horiRes, u32 vertRes, | ||
34 | f32 texturePercentage, f32 spherePercentage, f32 radius, | ||
35 | ISceneNode* parent, ISceneManager* mgr, s32 id) | ||
36 | : ISceneNode(parent, mgr, id), Buffer(0), | ||
37 | HorizontalResolution(horiRes), VerticalResolution(vertRes), | ||
38 | TexturePercentage(texturePercentage), | ||
39 | SpherePercentage(spherePercentage), Radius(radius) | ||
40 | { | ||
41 | #ifdef _DEBUG | ||
42 | setDebugName("CSkyDomeSceneNode"); | ||
43 | #endif | ||
44 | |||
45 | setAutomaticCulling(scene::EAC_OFF); | ||
46 | |||
47 | Buffer = new SMeshBuffer(); | ||
48 | Buffer->Material.Lighting = false; | ||
49 | Buffer->Material.ZBuffer = video::ECFN_NEVER; | ||
50 | Buffer->Material.ZWriteEnable = false; | ||
51 | Buffer->Material.AntiAliasing = video::EAAM_OFF; | ||
52 | Buffer->Material.setTexture(0, sky); | ||
53 | Buffer->BoundingBox.MaxEdge.set(0,0,0); | ||
54 | Buffer->BoundingBox.MinEdge.set(0,0,0); | ||
55 | |||
56 | // regenerate the mesh | ||
57 | generateMesh(); | ||
58 | } | ||
59 | |||
60 | |||
61 | CSkyDomeSceneNode::~CSkyDomeSceneNode() | ||
62 | { | ||
63 | if (Buffer) | ||
64 | Buffer->drop(); | ||
65 | } | ||
66 | |||
67 | |||
68 | void CSkyDomeSceneNode::generateMesh() | ||
69 | { | ||
70 | f32 azimuth; | ||
71 | u32 k; | ||
72 | |||
73 | Buffer->Vertices.clear(); | ||
74 | Buffer->Indices.clear(); | ||
75 | |||
76 | const f32 azimuth_step = (core::PI * 2.f) / HorizontalResolution; | ||
77 | if (SpherePercentage < 0.f) | ||
78 | SpherePercentage = -SpherePercentage; | ||
79 | if (SpherePercentage > 2.f) | ||
80 | SpherePercentage = 2.f; | ||
81 | const f32 elevation_step = SpherePercentage * core::HALF_PI / (f32)VerticalResolution; | ||
82 | |||
83 | Buffer->Vertices.reallocate( (HorizontalResolution + 1) * (VerticalResolution + 1) ); | ||
84 | Buffer->Indices.reallocate(3 * (2*VerticalResolution - 1) * HorizontalResolution); | ||
85 | |||
86 | video::S3DVertex vtx; | ||
87 | vtx.Color.set(255,255,255,255); | ||
88 | vtx.Normal.set(0.0f,-1.f,0.0f); | ||
89 | |||
90 | const f32 tcV = TexturePercentage / VerticalResolution; | ||
91 | for (k = 0, azimuth = 0; k <= HorizontalResolution; ++k) | ||
92 | { | ||
93 | f32 elevation = core::HALF_PI; | ||
94 | const f32 tcU = (f32)k / (f32)HorizontalResolution; | ||
95 | const f32 sinA = sinf(azimuth); | ||
96 | const f32 cosA = cosf(azimuth); | ||
97 | for (u32 j = 0; j <= VerticalResolution; ++j) | ||
98 | { | ||
99 | const f32 cosEr = Radius * cosf(elevation); | ||
100 | vtx.Pos.set(cosEr*sinA, Radius*sinf(elevation), cosEr*cosA); | ||
101 | vtx.TCoords.set(tcU, j*tcV); | ||
102 | |||
103 | vtx.Normal = -vtx.Pos; | ||
104 | vtx.Normal.normalize(); | ||
105 | |||
106 | Buffer->Vertices.push_back(vtx); | ||
107 | elevation -= elevation_step; | ||
108 | } | ||
109 | azimuth += azimuth_step; | ||
110 | } | ||
111 | |||
112 | for (k = 0; k < HorizontalResolution; ++k) | ||
113 | { | ||
114 | Buffer->Indices.push_back(VerticalResolution + 2 + (VerticalResolution + 1)*k); | ||
115 | Buffer->Indices.push_back(1 + (VerticalResolution + 1)*k); | ||
116 | Buffer->Indices.push_back(0 + (VerticalResolution + 1)*k); | ||
117 | |||
118 | for (u32 j = 1; j < VerticalResolution; ++j) | ||
119 | { | ||
120 | Buffer->Indices.push_back(VerticalResolution + 2 + (VerticalResolution + 1)*k + j); | ||
121 | Buffer->Indices.push_back(1 + (VerticalResolution + 1)*k + j); | ||
122 | Buffer->Indices.push_back(0 + (VerticalResolution + 1)*k + j); | ||
123 | |||
124 | Buffer->Indices.push_back(VerticalResolution + 1 + (VerticalResolution + 1)*k + j); | ||
125 | Buffer->Indices.push_back(VerticalResolution + 2 + (VerticalResolution + 1)*k + j); | ||
126 | Buffer->Indices.push_back(0 + (VerticalResolution + 1)*k + j); | ||
127 | } | ||
128 | } | ||
129 | Buffer->setHardwareMappingHint(scene::EHM_STATIC); | ||
130 | } | ||
131 | |||
132 | |||
133 | //! renders the node. | ||
134 | void CSkyDomeSceneNode::render() | ||
135 | { | ||
136 | video::IVideoDriver* driver = SceneManager->getVideoDriver(); | ||
137 | scene::ICameraSceneNode* camera = SceneManager->getActiveCamera(); | ||
138 | |||
139 | if (!camera || !driver) | ||
140 | return; | ||
141 | |||
142 | if ( !camera->isOrthogonal() ) | ||
143 | { | ||
144 | core::matrix4 mat(AbsoluteTransformation); | ||
145 | mat.setTranslation(camera->getAbsolutePosition()); | ||
146 | |||
147 | driver->setTransform(video::ETS_WORLD, mat); | ||
148 | |||
149 | driver->setMaterial(Buffer->Material); | ||
150 | driver->drawMeshBuffer(Buffer); | ||
151 | } | ||
152 | |||
153 | // for debug purposes only: | ||
154 | if ( DebugDataVisible ) | ||
155 | { | ||
156 | video::SMaterial m; | ||
157 | m.Lighting = false; | ||
158 | driver->setMaterial(m); | ||
159 | |||
160 | if ( DebugDataVisible & scene::EDS_NORMALS ) | ||
161 | { | ||
162 | // draw normals | ||
163 | const f32 debugNormalLength = SceneManager->getParameters()->getAttributeAsFloat(DEBUG_NORMAL_LENGTH); | ||
164 | const video::SColor debugNormalColor = SceneManager->getParameters()->getAttributeAsColor(DEBUG_NORMAL_COLOR); | ||
165 | driver->drawMeshBufferNormals(Buffer, debugNormalLength, debugNormalColor); | ||
166 | } | ||
167 | |||
168 | // show mesh | ||
169 | if ( DebugDataVisible & scene::EDS_MESH_WIRE_OVERLAY ) | ||
170 | { | ||
171 | m.Wireframe = true; | ||
172 | driver->setMaterial(m); | ||
173 | |||
174 | driver->drawMeshBuffer(Buffer); | ||
175 | } | ||
176 | } | ||
177 | } | ||
178 | |||
179 | |||
180 | //! returns the axis aligned bounding box of this node | ||
181 | const core::aabbox3d<f32>& CSkyDomeSceneNode::getBoundingBox() const | ||
182 | { | ||
183 | return Buffer->BoundingBox; | ||
184 | } | ||
185 | |||
186 | |||
187 | void CSkyDomeSceneNode::OnRegisterSceneNode() | ||
188 | { | ||
189 | if (IsVisible) | ||
190 | { | ||
191 | SceneManager->registerNodeForRendering(this, ESNRP_SKY_BOX ); | ||
192 | } | ||
193 | |||
194 | ISceneNode::OnRegisterSceneNode(); | ||
195 | } | ||
196 | |||
197 | |||
198 | //! returns the material based on the zero based index i. To get the amount | ||
199 | //! of materials used by this scene node, use getMaterialCount(). | ||
200 | //! This function is needed for inserting the node into the scene hirachy on a | ||
201 | //! optimal position for minimizing renderstate changes, but can also be used | ||
202 | //! to directly modify the material of a scene node. | ||
203 | video::SMaterial& CSkyDomeSceneNode::getMaterial(u32 i) | ||
204 | { | ||
205 | return Buffer->Material; | ||
206 | } | ||
207 | |||
208 | |||
209 | //! returns amount of materials used by this scene node. | ||
210 | u32 CSkyDomeSceneNode::getMaterialCount() const | ||
211 | { | ||
212 | return 1; | ||
213 | } | ||
214 | |||
215 | |||
216 | //! Writes attributes of the scene node. | ||
217 | void CSkyDomeSceneNode::serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const | ||
218 | { | ||
219 | ISceneNode::serializeAttributes(out, options); | ||
220 | |||
221 | out->addInt ("HorizontalResolution", HorizontalResolution); | ||
222 | out->addInt ("VerticalResolution", VerticalResolution); | ||
223 | out->addFloat("TexturePercentage", TexturePercentage); | ||
224 | out->addFloat("SpherePercentage", SpherePercentage); | ||
225 | out->addFloat("Radius", Radius); | ||
226 | } | ||
227 | |||
228 | |||
229 | //! Reads attributes of the scene node. | ||
230 | void CSkyDomeSceneNode::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) | ||
231 | { | ||
232 | HorizontalResolution = in->getAttributeAsInt ("HorizontalResolution"); | ||
233 | VerticalResolution = in->getAttributeAsInt ("VerticalResolution"); | ||
234 | TexturePercentage = in->getAttributeAsFloat("TexturePercentage"); | ||
235 | SpherePercentage = in->getAttributeAsFloat("SpherePercentage"); | ||
236 | Radius = in->getAttributeAsFloat("Radius"); | ||
237 | |||
238 | ISceneNode::deserializeAttributes(in, options); | ||
239 | |||
240 | // regenerate the mesh | ||
241 | generateMesh(); | ||
242 | } | ||
243 | |||
244 | //! Creates a clone of this scene node and its children. | ||
245 | ISceneNode* CSkyDomeSceneNode::clone(ISceneNode* newParent, ISceneManager* newManager) | ||
246 | { | ||
247 | if (!newParent) | ||
248 | newParent = Parent; | ||
249 | if (!newManager) | ||
250 | newManager = SceneManager; | ||
251 | |||
252 | CSkyDomeSceneNode* nb = new CSkyDomeSceneNode(Buffer->Material.TextureLayer[0].Texture, HorizontalResolution, VerticalResolution, TexturePercentage, | ||
253 | SpherePercentage, Radius, newParent, newManager, ID); | ||
254 | |||
255 | nb->cloneMembers(this, newManager); | ||
256 | |||
257 | if ( newParent ) | ||
258 | nb->drop(); | ||
259 | return nb; | ||
260 | } | ||
261 | |||
262 | |||
263 | } // namespace scene | ||
264 | } // namespace irr | ||