← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to tests/planeMatrix.cpp

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/planeMatrix.cpp
 
1
// Copyright (C) 2008-2011 Colin MacDonald
 
2
// No rights reserved: this software is in the public domain.
 
3
 
 
4
#include "testUtils.h"
 
5
 
 
6
using namespace irr;
 
7
using namespace core;
 
8
using namespace scene;
 
9
using namespace video;
 
10
using namespace io;
 
11
using namespace gui;
 
12
 
 
13
// There's all sorts of minor and inevitable FP accuracy errors here, so use a sloppy comparison.
 
14
static bool sloppyComparePlanes(const plane3df plane1, const plane3df plane2)
 
15
{
 
16
        return(equals(plane1.D, plane2.D, 0.001f) &&
 
17
                equals(plane1.Normal.X, plane2.Normal.X, 0.001f) &&
 
18
                equals(plane1.Normal.Y, plane2.Normal.Y, 0.001f) &&
 
19
                equals(plane1.Normal.Z, plane2.Normal.Z, 0.001f));
 
20
}
 
21
 
 
22
static bool transformPlane(const vector3df & point, const vector3df & normal,
 
23
                                                   const matrix4 & matrix, const plane3df & expected)
 
24
{
 
25
        plane3df plane(point, vector3df(normal).normalize());
 
26
 
 
27
        logTestString("\n     Pre: (%.3ff,%.3ff,%.3ff), %.3ff\n",
 
28
                plane.Normal.X, plane.Normal.Y, plane.Normal.Z, plane.D);
 
29
 
 
30
        matrix.transformPlane(plane);
 
31
 
 
32
        logTestString("    Post: (%.3ff,%.3ff,%.3ff), %.3ff\n",
 
33
                plane.Normal.X, plane.Normal.Y, plane.Normal.Z, plane.D);
 
34
 
 
35
        logTestString("Expected: (%.3ff,%.3ff,%.3ff), %.3ff\n",
 
36
                expected.Normal.X, expected.Normal.Y, expected.Normal.Z, expected.D);
 
37
 
 
38
        if(!sloppyComparePlanes(plane, expected))
 
39
        {
 
40
                logTestString("Unexpected result\n");
 
41
                assert(false);
 
42
                return false;
 
43
        }
 
44
 
 
45
        return true;
 
46
}
 
47
 
 
48
 
 
49
static bool drawScaledOctree(void)
 
50
{
 
51
        bool result = false;
 
52
        IrrlichtDevice *device = createDevice(video::EDT_BURNINGSVIDEO, dimension2d<u32>(160, 120), 32);
 
53
        if (!device)
 
54
                return false;
 
55
 
 
56
        video::IVideoDriver* driver = device->getVideoDriver();
 
57
        ISceneManager * smgr = device->getSceneManager();
 
58
 
 
59
        bool added = device->getFileSystem()->addFileArchive("../media/map-20kdm2.pk3");
 
60
        assert(added);
 
61
 
 
62
        if(added)
 
63
        {
 
64
                ISceneNode * node = smgr->addOctreeSceneNode(smgr->getMesh("20kdm2.bsp")->getMesh(0), 0, -1, 1024);
 
65
                assert(node);
 
66
 
 
67
                if (node)
 
68
                {
 
69
                        node->setMaterialFlag(EMF_LIGHTING, false);
 
70
                        node->setPosition(core::vector3df(-1300,-820,-1249));
 
71
                        node->setScale(core::vector3df(1, 5, 1));
 
72
 
 
73
                        (void)smgr->addCameraSceneNode(0, core::vector3df(0,0,0), core::vector3df(40,100,30));
 
74
 
 
75
                        driver->beginScene(true, true, video::SColor(255,255,255,0));
 
76
                        smgr->drawAll();
 
77
                        driver->endScene();
 
78
 
 
79
                        result = takeScreenshotAndCompareAgainstReference(driver, "-planeMatrix-scaledClip.png");
 
80
                }
 
81
        }
 
82
 
 
83
        device->closeDevice();
 
84
        device->run();
 
85
        device->drop();
 
86
 
 
87
        return result;
 
88
}
 
89
 
 
90
 
 
91
// Test the ability to transform a plane with a matrix.
 
92
bool planeMatrix(void)
 
93
{
 
94
        matrix4 rotationMatrix;
 
95
        rotationMatrix.setRotationDegrees(vector3df(90, 0, 0));
 
96
 
 
97
        matrix4 translationMatrix;
 
98
        translationMatrix.setTranslation(vector3df(0, 3, 0));
 
99
 
 
100
        matrix4 scaleMatrix;
 
101
        scaleMatrix.setScale(vector3df(1, 2, 3));
 
102
 
 
103
        bool success = true;
 
104
 
 
105
        matrix4 matrix = rotationMatrix;
 
106
        logTestString("\nRotation matrix\n%02.02f %02.02f %02.02f %02.02f"
 
107
                "\n%02.02f %02.02f %02.02f %02.02f"
 
108
                "\n%02.02f %02.02f %02.02f %02.02f"
 
109
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
110
                matrix[0], matrix[1], matrix[2], matrix[3],
 
111
                matrix[4], matrix[5], matrix[6], matrix[7],
 
112
                matrix[8], matrix[9], matrix[10], matrix[11],
 
113
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
114
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-.707f, 0.f, -.707f), 0.f));
 
115
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(.707f, 0.f, .707f), 0.f));
 
116
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-.707f, 0.f, .707f), 0.f));
 
117
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(.707f, 0.f, -.707f), 0.f));
 
118
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-.707f, 0.f, -.707f), .707f));
 
119
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(.707f, 0.f, .707f), -.707f));
 
120
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-.707f, 0.f, .707f), -.707f));
 
121
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(.707f, 0.f, -.707f), .707f));
 
122
 
 
123
 
 
124
        matrix = translationMatrix;
 
125
        logTestString("\nTranslation matrix\n%02.02f %02.02f %02.02f %02.02f"
 
126
                "\n%02.02f %02.02f %02.02f %02.02f"
 
127
                "\n%02.02f %02.02f %02.02f %02.02f"
 
128
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
129
                matrix[0], matrix[1], matrix[2], matrix[3],
 
130
                matrix[4], matrix[5], matrix[6], matrix[7],
 
131
                matrix[8], matrix[9], matrix[10], matrix[11],
 
132
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
133
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,-0.707f,0.000f), 2.121f));
 
134
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,0.707f,0.000f), -2.121f));
 
135
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,0.707f,0.000f), -2.121f));
 
136
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,-0.707f,0.000f), 2.121f));
 
137
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,-0.707f,0.000f), 2.828f));
 
138
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,0.707f,0.000f), -2.828f));
 
139
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,0.707f,0.000f), -2.828f));
 
140
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,-0.707f,0.000f), 2.828f));
 
141
 
 
142
 
 
143
        matrix = scaleMatrix;
 
144
        logTestString("\nScale matrix\n%02.02f %02.02f %02.02f %02.02f"
 
145
                "\n%02.02f %02.02f %02.02f %02.02f"
 
146
                "\n%02.02f %02.02f %02.02f %02.02f"
 
147
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
148
                matrix[0], matrix[1], matrix[2], matrix[3],
 
149
                matrix[4], matrix[5], matrix[6], matrix[7],
 
150
                matrix[8], matrix[9], matrix[10], matrix[11],
 
151
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
152
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,-0.354f,0.000f), -0.000f));
 
153
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,0.354f,0.000f), -0.000f));
 
154
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,0.354f,0.000f), -0.000f));
 
155
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,-0.354f,0.000f), -0.000f));
 
156
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,-0.354f,0.000f), 0.707f));
 
157
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,0.354f,0.000f), -0.707f));
 
158
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,0.354f,0.000f), -0.707f));
 
159
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,-0.354f,0.000f), 0.707f));
 
160
 
 
161
        matrix = rotationMatrix * translationMatrix;
 
162
        logTestString("\nRotation * translation matrix\n%02.02f %02.02f %02.02f %02.02f"
 
163
                "\n%02.02f %02.02f %02.02f %02.02f"
 
164
                "\n%02.02f %02.02f %02.02f %02.02f"
 
165
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
166
                matrix[0], matrix[1], matrix[2], matrix[3],
 
167
                matrix[4], matrix[5], matrix[6], matrix[7],
 
168
                matrix[8], matrix[9], matrix[10], matrix[11],
 
169
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
170
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,0.000f,-0.707f), 2.121f));
 
171
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,-0.000f,0.707f), -2.121f));
 
172
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,-0.000f,0.707f), -2.121f));
 
173
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,0.000f,-0.707f), 2.121f));
 
174
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,0.000f,-0.707f), 2.828f));
 
175
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,-0.000f,0.707f), -2.828f));
 
176
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,-0.000f,0.707f), -2.828f));
 
177
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,0.000f,-0.707f), 2.828f));
 
178
 
 
179
        matrix = rotationMatrix * scaleMatrix;
 
180
        logTestString("\nRotation * scale matrix\n%02.02f %02.02f %02.02f %02.02f"
 
181
                "\n%02.02f %02.02f %02.02f %02.02f"
 
182
                "\n%02.02f %02.02f %02.02f %02.02f"
 
183
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
184
                matrix[0], matrix[1], matrix[2], matrix[3],
 
185
                matrix[4], matrix[5], matrix[6], matrix[7],
 
186
                matrix[8], matrix[9], matrix[10], matrix[11],
 
187
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
188
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,0.000f,-0.354f), -0.000f));
 
189
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,-0.000f,0.354f), -0.000f));
 
190
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,-0.000f,0.354f), -0.000f));
 
191
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,0.000f,-0.354f), -0.000f));
 
192
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,0.000f,-0.354f), 0.707f));
 
193
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,-0.000f,0.354f), -0.707f));
 
194
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,-0.000f,0.354f), -0.707f));
 
195
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,0.000f,-0.354f), 0.707f));
 
196
 
 
197
        matrix = translationMatrix * scaleMatrix;
 
198
        logTestString("\nTranslation * scale matrix\n%02.02f %02.02f %02.02f %02.02f"
 
199
                "\n%02.02f %02.02f %02.02f %02.02f"
 
200
                "\n%02.02f %02.02f %02.02f %02.02f"
 
201
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
202
                matrix[0], matrix[1], matrix[2], matrix[3],
 
203
                matrix[4], matrix[5], matrix[6], matrix[7],
 
204
                matrix[8], matrix[9], matrix[10], matrix[11],
 
205
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
206
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,-0.354f,0.000f), 1.061f));
 
207
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,0.354f,0.000f), -1.061f));
 
208
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,0.354f,0.000f), -1.061f));
 
209
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,-0.354f,0.000f), 1.061f));
 
210
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,-0.354f,0.000f), 1.768f));
 
211
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,0.354f,0.000f), -1.768f));
 
212
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,0.354f,0.000f), -1.768f));
 
213
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,-0.354f,0.000f), 1.768f));
 
214
 
 
215
        matrix = rotationMatrix * translationMatrix * scaleMatrix;
 
216
        logTestString("\nRotation * translation * scale matrix\n%02.02f %02.02f %02.02f %02.02f"
 
217
                "\n%02.02f %02.02f %02.02f %02.02f"
 
218
                "\n%02.02f %02.02f %02.02f %02.02f"
 
219
                "\n%02.02f %02.02f %02.02f %02.02f\n",
 
220
                matrix[0], matrix[1], matrix[2], matrix[3],
 
221
                matrix[4], matrix[5], matrix[6], matrix[7],
 
222
                matrix[8], matrix[9], matrix[10], matrix[11],
 
223
                matrix[12], matrix[13], matrix[14], matrix[15]);
 
224
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,0.000f,-0.354f), 1.061f));
 
225
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,-0.000f,0.354f), -1.061f));
 
226
        success &= transformPlane(vector3df(0, 0, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,-0.000f,0.354f), -1.061f));
 
227
        success &= transformPlane(vector3df(0, 0, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,0.000f,-0.354f), 1.061f));
 
228
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, -1, 0), matrix, plane3df(vector3df(-0.707f,0.000f,-0.354f), 1.768f));
 
229
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, 1, 0), matrix, plane3df(vector3df(0.707f,-0.000f,0.354f), -1.768f));
 
230
        success &= transformPlane(vector3df(0, 1, 0), vector3df(-1, 1, 0), matrix, plane3df(vector3df(-0.707f,-0.000f,0.354f), -1.768f));
 
231
        success &= transformPlane(vector3df(0, 1, 0), vector3df(1, -1, 0), matrix, plane3df(vector3df(0.707f,0.000f,-0.354f), 1.768f));
 
232
 
 
233
        success &= drawScaledOctree();
 
234
 
 
235
        return success;
 
236
}
 
237