Alvaro Cassinelli / Mbed 2 deprecated laserUI

Laser Sensing Display for UI interfaces in the real world

Dependencies:   mbed

Fork of skinGames_forktest by Alvaro Cassinelli

LaserRenderer.cpp@47:199042980678, 2014-04-17 (annotated)

Committer:
mbedalvaro
Date:
Thu Apr 17 08:04:14 2014 +0000
Revision:
47:199042980678
Parent:
45:5ef809480c12 
publishing for sharing with Ken Iwasaki

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbedalvaro 40:3ba2b0ea9f33 1 #include "LaserRenderer.h"
mbedalvaro 40:3ba2b0ea9f33 2 using namespace std;
mbedalvaro 40:3ba2b0ea9f33 3
mbedalvaro 40:3ba2b0ea9f33 4 LaserRenderer lsr; // THIS WILL BE A GLOBAL OBJECT (declared extern in the header file).
mbedalvaro 40:3ba2b0ea9f33 5
mbedalvaro 40:3ba2b0ea9f33 6 // ======================================================================================================================================
mbedalvaro 40:3ba2b0ea9f33 7
mbedalvaro 40:3ba2b0ea9f33 8 LaserRenderer::LaserRenderer()
mbedalvaro 40:3ba2b0ea9f33 9 {
mbedalvaro 40:3ba2b0ea9f33 10 init();
mbedalvaro 40:3ba2b0ea9f33 11 }
mbedalvaro 40:3ba2b0ea9f33 12
mbedalvaro 40:3ba2b0ea9f33 13 LaserRenderer::~LaserRenderer()
mbedalvaro 40:3ba2b0ea9f33 14 {
mbedalvaro 40:3ba2b0ea9f33 15 // myScene.clear(); // this should be done explicitly, because objects are stored as an array of pointers... for all the other iVars, this is not necessary.
mbedalvaro 40:3ba2b0ea9f33 16 // Deactivate the display ISR routine?
mbedalvaro 40:3ba2b0ea9f33 17 close();
mbedalvaro 40:3ba2b0ea9f33 18 }
mbedalvaro 40:3ba2b0ea9f33 19
mbedalvaro 40:3ba2b0ea9f33 20 void LaserRenderer::init()
mbedalvaro 40:3ba2b0ea9f33 21 {
mbedalvaro 40:3ba2b0ea9f33 22 // Initialization of others things that are not set in the constructor:
mbedalvaro 40:3ba2b0ea9f33 23 setIdentityPose();
mbedalvaro 40:3ba2b0ea9f33 24 EXTRINSICS=RT; // set the Extrinsics too as identity
mbedalvaro 40:3ba2b0ea9f33 25 setIdentityProjection();
mbedalvaro 40:3ba2b0ea9f33 26
mbedalvaro 40:3ba2b0ea9f33 27 setColor(0x04); // RGB ON
mbedalvaro 40:3ba2b0ea9f33 28
mbedalvaro 40:3ba2b0ea9f33 29 // In particular, this method is called when the scene is built - or re-built - and we are ready to go.
mbedalvaro 40:3ba2b0ea9f33 30 // Ativate the laser sensing display ISR? NO, this is done in WRAPPER FUNCTIONS?
mbedalvaro 40:3ba2b0ea9f33 31 // lsd.setSceneToDisplay(&myScene);
mbedalvaro 40:3ba2b0ea9f33 32 // ATTACH THE ISR: unfortunately, I cannot do it here!
mbedalvaro 40:3ba2b0ea9f33 33 // lsd.startFullDisplay();
mbedalvaro 40:3ba2b0ea9f33 34 }
mbedalvaro 40:3ba2b0ea9f33 35
mbedalvaro 40:3ba2b0ea9f33 36
mbedalvaro 40:3ba2b0ea9f33 37 void LaserRenderer::close()
mbedalvaro 40:3ba2b0ea9f33 38 {
mbedalvaro 40:3ba2b0ea9f33 39 // this should deactivate the laser sensing display ISR, as well as free all memory.
mbedalvaro 40:3ba2b0ea9f33 40 // (1) deactivate laser display:
mbedalvaro 40:3ba2b0ea9f33 41 // ...
mbedalvaro 40:3ba2b0ea9f33 42 // (2) clear the whole scene (free memory), if we want (this is done in the destructor anyway...)
mbedalvaro 40:3ba2b0ea9f33 43 // myScene.clear();
mbedalvaro 40:3ba2b0ea9f33 44 }
mbedalvaro 40:3ba2b0ea9f33 45
mbedalvaro 40:3ba2b0ea9f33 46
mbedalvaro 40:3ba2b0ea9f33 47
mbedalvaro 40:3ba2b0ea9f33 48 // Load the MODELVIEW matrix from data sent by the computer:
mbedalvaro 40:3ba2b0ea9f33 49 void LaserRenderer::loadPoseMatrix(float m[12]) // note: m is in "row/column" format (first row, then columns)
mbedalvaro 40:3ba2b0ea9f33 50 {
mbedalvaro 40:3ba2b0ea9f33 51 RT.set(m);
mbedalvaro 40:3ba2b0ea9f33 52 }
mbedalvaro 40:3ba2b0ea9f33 53
mbedalvaro 40:3ba2b0ea9f33 54 // Load the EXTRINSICS matrix from data sent by the computer:
mbedalvaro 40:3ba2b0ea9f33 55 void LaserRenderer::loadExtrinsicsMatrix(float m[12])
mbedalvaro 40:3ba2b0ea9f33 56 {
mbedalvaro 40:3ba2b0ea9f33 57 EXTRINSICS.set(m);
mbedalvaro 40:3ba2b0ea9f33 58 }
mbedalvaro 40:3ba2b0ea9f33 59
mbedalvaro 40:3ba2b0ea9f33 60 void LaserRenderer::setIdentityPose(void)
mbedalvaro 40:3ba2b0ea9f33 61 {
mbedalvaro 40:3ba2b0ea9f33 62 RT.setIdentity();
mbedalvaro 40:3ba2b0ea9f33 63 }
mbedalvaro 40:3ba2b0ea9f33 64
mbedalvaro 40:3ba2b0ea9f33 65 void LaserRenderer::setExtrinsicsPose(void) // this is faster than first loading the identity, then multiplying by the extrinsics...
mbedalvaro 40:3ba2b0ea9f33 66 {
mbedalvaro 40:3ba2b0ea9f33 67 RT=EXTRINSICS; //note: I am not using here a copy CONSTRUCTOR, but a copy method of my own. RT must be allocated first.
mbedalvaro 40:3ba2b0ea9f33 68 }
mbedalvaro 40:3ba2b0ea9f33 69
mbedalvaro 40:3ba2b0ea9f33 70 void LaserRenderer::setIdentityProjection(void)
mbedalvaro 40:3ba2b0ea9f33 71 {
mbedalvaro 40:3ba2b0ea9f33 72 K.setIdentity();
mbedalvaro 40:3ba2b0ea9f33 73 scaleFactorProjector=1.0;
mbedalvaro 40:3ba2b0ea9f33 74 }
mbedalvaro 40:3ba2b0ea9f33 75
mbedalvaro 40:3ba2b0ea9f33 76 void LaserRenderer::setOrthoProjection()
mbedalvaro 40:3ba2b0ea9f33 77 {
mbedalvaro 40:3ba2b0ea9f33 78 K.setIdentity();
mbedalvaro 40:3ba2b0ea9f33 79 K.at[2][2]=0;
mbedalvaro 40:3ba2b0ea9f33 80 scaleFactorProjector=1.0;
mbedalvaro 40:3ba2b0ea9f33 81 }
mbedalvaro 40:3ba2b0ea9f33 82
mbedalvaro 40:3ba2b0ea9f33 83 // Load the projection matrix from data sent by the computer opr from a file (note: last row is always {0 0 1} and is not loaded)
mbedalvaro 40:3ba2b0ea9f33 84 void LaserRenderer::loadProjMatrix(float m[6], float _scaleFactorProjector=1.0) // note: m is in "row/column" format (first row, then columns)
mbedalvaro 40:3ba2b0ea9f33 85 {
mbedalvaro 40:3ba2b0ea9f33 86 K.set(m);
mbedalvaro 40:3ba2b0ea9f33 87 // Also, specify the scale factor in case we computed the intrinsics by laser scanning with different resolution:
mbedalvaro 40:3ba2b0ea9f33 88 scaleFactorProjector=_scaleFactorProjector;
mbedalvaro 40:3ba2b0ea9f33 89 }
mbedalvaro 40:3ba2b0ea9f33 90
mbedalvaro 40:3ba2b0ea9f33 91 void LaserRenderer::translate(float x, float y, float z)
mbedalvaro 40:3ba2b0ea9f33 92 {
mbedalvaro 40:3ba2b0ea9f33 93 float trans[] = {1, 0, 0, x,
mbedalvaro 40:3ba2b0ea9f33 94 0, 1, 0, y,
mbedalvaro 40:3ba2b0ea9f33 95 0, 0, 1, z
mbedalvaro 40:3ba2b0ea9f33 96 };
mbedalvaro 40:3ba2b0ea9f33 97
mbedalvaro 40:3ba2b0ea9f33 98 multPoseMatrix(trans); // result in RT
mbedalvaro 40:3ba2b0ea9f33 99 }
mbedalvaro 40:3ba2b0ea9f33 100
mbedalvaro 40:3ba2b0ea9f33 101 void LaserRenderer::rotateX(float thetadeg) // in degrees
mbedalvaro 40:3ba2b0ea9f33 102 {
mbedalvaro 40:3ba2b0ea9f33 103 float thetarad=PI/180.0*thetadeg;
mbedalvaro 40:3ba2b0ea9f33 104 float rotX[] = {1, 0, 0, 0,
mbedalvaro 40:3ba2b0ea9f33 105 0, cos(thetarad), -sin(thetarad), 0,
mbedalvaro 40:3ba2b0ea9f33 106 0, sin(thetarad), cos(thetarad), 0
mbedalvaro 40:3ba2b0ea9f33 107 };
mbedalvaro 40:3ba2b0ea9f33 108
mbedalvaro 40:3ba2b0ea9f33 109 multPoseMatrix(rotX); // result in RT
mbedalvaro 40:3ba2b0ea9f33 110 }
mbedalvaro 40:3ba2b0ea9f33 111
mbedalvaro 40:3ba2b0ea9f33 112 void LaserRenderer::rotateY(float thetadeg)
mbedalvaro 40:3ba2b0ea9f33 113 {
mbedalvaro 40:3ba2b0ea9f33 114 float thetarad=PI/180.0*thetadeg;
mbedalvaro 40:3ba2b0ea9f33 115 float rotY[] = {cos(thetarad), 0, -sin(thetarad), 0,
mbedalvaro 40:3ba2b0ea9f33 116 0, 1, 0, 0,
mbedalvaro 40:3ba2b0ea9f33 117 sin(thetarad), 0, cos(thetarad), 0
mbedalvaro 40:3ba2b0ea9f33 118 };
mbedalvaro 40:3ba2b0ea9f33 119
mbedalvaro 40:3ba2b0ea9f33 120 multPoseMatrix(rotY);// result in RT
mbedalvaro 40:3ba2b0ea9f33 121 }
mbedalvaro 40:3ba2b0ea9f33 122
mbedalvaro 40:3ba2b0ea9f33 123 void LaserRenderer::rotateZ(float thetadeg)
mbedalvaro 40:3ba2b0ea9f33 124 {
mbedalvaro 40:3ba2b0ea9f33 125 float thetarad=PI/180.0*thetadeg;
mbedalvaro 40:3ba2b0ea9f33 126 float rotZ[] = {cos(thetarad), -sin(thetarad), 0, 0,
mbedalvaro 40:3ba2b0ea9f33 127 sin(thetarad), cos(thetarad), 0, 0,
mbedalvaro 40:3ba2b0ea9f33 128 0, 0, 1, 0
mbedalvaro 40:3ba2b0ea9f33 129 };
mbedalvaro 40:3ba2b0ea9f33 130
mbedalvaro 40:3ba2b0ea9f33 131 multPoseMatrix(rotZ);// result in RT
mbedalvaro 40:3ba2b0ea9f33 132 }
mbedalvaro 40:3ba2b0ea9f33 133
mbedalvaro 40:3ba2b0ea9f33 134 void LaserRenderer::flipX()
mbedalvaro 40:3ba2b0ea9f33 135 {
mbedalvaro 40:3ba2b0ea9f33 136 // float flipX[] = { -1, 0, 0, 0,
mbedalvaro 40:3ba2b0ea9f33 137 // 0, 1, 0, 0,
mbedalvaro 40:3ba2b0ea9f33 138 // 0, 0, 1, 0
mbedalvaro 40:3ba2b0ea9f33 139 // };
mbedalvaro 40:3ba2b0ea9f33 140 // multPoseMatrix(flipX);// result in RT
mbedalvaro 40:3ba2b0ea9f33 141 // Easier way to do this (but less code-clear):
mbedalvaro 40:3ba2b0ea9f33 142 RT.at[0][0]*=-1;
mbedalvaro 40:3ba2b0ea9f33 143 }
mbedalvaro 40:3ba2b0ea9f33 144 void LaserRenderer::flipY()
mbedalvaro 40:3ba2b0ea9f33 145 {
mbedalvaro 40:3ba2b0ea9f33 146 RT.at[1][1]*=-1;
mbedalvaro 40:3ba2b0ea9f33 147 }
mbedalvaro 40:3ba2b0ea9f33 148 void LaserRenderer::flipZ()
mbedalvaro 40:3ba2b0ea9f33 149 {
mbedalvaro 40:3ba2b0ea9f33 150 RT.at[2][2]*=-1;
mbedalvaro 40:3ba2b0ea9f33 151 }
mbedalvaro 40:3ba2b0ea9f33 152
mbedalvaro 40:3ba2b0ea9f33 153 void LaserRenderer::resize(float rx, float ry, float rz) // multiplies the current RT matrix by a diagonal resizing matrix
mbedalvaro 40:3ba2b0ea9f33 154 {
mbedalvaro 40:3ba2b0ea9f33 155 float ResizeMat[] = {rx, 0, 0, 0,
mbedalvaro 40:3ba2b0ea9f33 156 0, ry, 0, 0,
mbedalvaro 40:3ba2b0ea9f33 157 0, 0, rz, 0
mbedalvaro 40:3ba2b0ea9f33 158 };
mbedalvaro 40:3ba2b0ea9f33 159 multPoseMatrix(ResizeMat);// result in RT
mbedalvaro 40:3ba2b0ea9f33 160 }
mbedalvaro 40:3ba2b0ea9f33 161
mbedalvaro 40:3ba2b0ea9f33 162
mbedalvaro 40:3ba2b0ea9f33 163 void LaserRenderer::multPoseMatrix(const Mat44 M) // this does: RT=RTxM
mbedalvaro 40:3ba2b0ea9f33 164 {
mbedalvaro 40:3ba2b0ea9f33 165 RT*=M;
mbedalvaro 40:3ba2b0ea9f33 166 }
mbedalvaro 45:5ef809480c12 167 void LaserRenderer::multPoseMatrix(const float m[12]) // this does: RT=RTxm, assuming m[12] in column/row format, and adding {0,0,0,1} as last row
mbedalvaro 40:3ba2b0ea9f33 168 {
mbedalvaro 40:3ba2b0ea9f33 169 RT*=m;
mbedalvaro 40:3ba2b0ea9f33 170 }
mbedalvaro 40:3ba2b0ea9f33 171
mbedalvaro 40:3ba2b0ea9f33 172 void LaserRenderer::pushPoseMatrix(void)
mbedalvaro 40:3ba2b0ea9f33 173 {
mbedalvaro 40:3ba2b0ea9f33 174 RT_Stack.push_back(RT); // this is ok, because RT is a class or struct, not an array
mbedalvaro 40:3ba2b0ea9f33 175 }
mbedalvaro 40:3ba2b0ea9f33 176 void LaserRenderer::popPoseMatrix(void)
mbedalvaro 40:3ba2b0ea9f33 177 {
mbedalvaro 40:3ba2b0ea9f33 178 // First, load RT with the "back" element in the list:
mbedalvaro 40:3ba2b0ea9f33 179 RT = RT_Stack.back(); // This uses the copy method for matrices
mbedalvaro 40:3ba2b0ea9f33 180
mbedalvaro 40:3ba2b0ea9f33 181 // Finally, delete the object in the vector array:
mbedalvaro 40:3ba2b0ea9f33 182 RT_Stack.pop_back();
mbedalvaro 40:3ba2b0ea9f33 183 }
mbedalvaro 40:3ba2b0ea9f33 184
mbedalvaro 40:3ba2b0ea9f33 185 void LaserRenderer::pushProjMatrix(void)
mbedalvaro 40:3ba2b0ea9f33 186 {
mbedalvaro 40:3ba2b0ea9f33 187 K_Stack.push_back(K);
mbedalvaro 40:3ba2b0ea9f33 188 scaleFactor_Stack.push_back(scaleFactorProjector);
mbedalvaro 40:3ba2b0ea9f33 189 }
mbedalvaro 40:3ba2b0ea9f33 190
mbedalvaro 40:3ba2b0ea9f33 191 void LaserRenderer::popProjMatrix(void)
mbedalvaro 40:3ba2b0ea9f33 192 {
mbedalvaro 40:3ba2b0ea9f33 193 K=K_Stack.back();
mbedalvaro 40:3ba2b0ea9f33 194 K_Stack.pop_back();
mbedalvaro 40:3ba2b0ea9f33 195 scaleFactorProjector=scaleFactor_Stack.back();
mbedalvaro 40:3ba2b0ea9f33 196 scaleFactor_Stack.pop_back();
mbedalvaro 40:3ba2b0ea9f33 197 }
mbedalvaro 40:3ba2b0ea9f33 198
mbedalvaro 40:3ba2b0ea9f33 199 void LaserRenderer::pushColor(void)
mbedalvaro 40:3ba2b0ea9f33 200 {
mbedalvaro 40:3ba2b0ea9f33 201 color_Stack.push_back(color);
mbedalvaro 40:3ba2b0ea9f33 202 }
mbedalvaro 40:3ba2b0ea9f33 203 void LaserRenderer::popColor(void)
mbedalvaro 40:3ba2b0ea9f33 204 {
mbedalvaro 40:3ba2b0ea9f33 205 color=color_Stack.back();
mbedalvaro 40:3ba2b0ea9f33 206 color_Stack.pop_back();
mbedalvaro 40:3ba2b0ea9f33 207 }
mbedalvaro 40:3ba2b0ea9f33 208
mbedalvaro 40:3ba2b0ea9f33 209 // other rendering attributes (we could have a render attributes struct, and do push and pop too):
mbedalvaro 40:3ba2b0ea9f33 210 // ... TO DO
mbedalvaro 40:3ba2b0ea9f33 211
mbedalvaro 40:3ba2b0ea9f33 212 // ======================================================================================================================================
mbedalvaro 40:3ba2b0ea9f33 213 // QUESTION: we may have render methods that belongs to the LaserRenderer class, or use instead Scene/BaseObject methods.
mbedalvaro 40:3ba2b0ea9f33 214 // Both methodologies can be argued for (is rendering a method of a BaseObject, taking parameters from the global state machine lsr, or
mbedalvaro 40:3ba2b0ea9f33 215 // is rendering a method of the lsr applied to an object?). Therefore I will make them both available.
mbedalvaro 40:3ba2b0ea9f33 216 // NOTE: it is important to realize that these methods (belonging to lsr or the Scene/BaseObject class) do NOT properly disable the lsd display engine: this is done in WRAPPER FUNCTIONS.
mbedalvaro 40:3ba2b0ea9f33 217
mbedalvaro 40:3ba2b0ea9f33 218 void LaserRenderer::renderObject(BaseObject* ptObject)
mbedalvaro 40:3ba2b0ea9f33 219 {
mbedalvaro 40:3ba2b0ea9f33 220 // IMPORTANT: when rendering the object, I first CLEAR the projected points and add them again. This is ok, because things work differentl from the current
mbedalvaro 40:3ba2b0ea9f33 221 // OpenGL implementation: rendering is done ONLY once (after we create an object or modify the modelview and re-render). Perhaps a slightly more optimized
mbedalvaro 40:3ba2b0ea9f33 222 // implementation is to check if the number of points in the lsdTrajectory is differerent from the current number of 3d points (in vertexArray). This will be very
mbedalvaro 40:3ba2b0ea9f33 223 // useful when transforming an object already created:
mbedalvaro 40:3ba2b0ea9f33 224 if (ptObject->vertexArray.size()!=ptObject->displaySensingBuffer.lsdTrajectory.size()) {
mbedalvaro 40:3ba2b0ea9f33 225 // Then we clear the display sensing buffer, and ADD 2d points:
mbedalvaro 40:3ba2b0ea9f33 226 ptObject->displaySensingBuffer.lsdTrajectory.clear();
mbedalvaro 40:3ba2b0ea9f33 227 if (K.at[2][2]!=0) // this means normal PROJECTION
mbedalvaro 40:3ba2b0ea9f33 228 // Note: perhaps slightly more efficient using object iterator (actually, a pointer, using pointer aritmetics to increment...)
mbedalvaro 40:3ba2b0ea9f33 229 // Also, I am going to use the renderPointProj/Raw methods which are inline (but... can I be sure the compiler is gonna expand it?)
mbedalvaro 40:3ba2b0ea9f33 230 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++) {
mbedalvaro 40:3ba2b0ea9f33 231 LaserPoint newLp=renderPointProj(ptObject->vertexArray[i]);
mbedalvaro 40:3ba2b0ea9f33 232 // Set per-vertex color too? No, for the time being one color per object (and this is checked in the laserSensingDisplay display engine)
mbedalvaro 40:3ba2b0ea9f33 233 // newLp.myColor=color;
mbedalvaro 40:3ba2b0ea9f33 234 ptObject->displaySensingBuffer.lsdTrajectory.push_back(newLp);
mbedalvaro 40:3ba2b0ea9f33 235 }
mbedalvaro 40:3ba2b0ea9f33 236 else // this means ORTHOGRAPHIC PROJECTION
mbedalvaro 40:3ba2b0ea9f33 237 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++) {
mbedalvaro 40:3ba2b0ea9f33 238 LaserPoint newLp=renderPointOrth(ptObject->vertexArray[i]);
mbedalvaro 40:3ba2b0ea9f33 239 // Set per-vertex color too? No, for the time being one color per object...
mbedalvaro 40:3ba2b0ea9f33 240 // newLp.myColor=color;
mbedalvaro 40:3ba2b0ea9f33 241 ptObject->displaySensingBuffer.lsdTrajectory.push_back(newLp);
mbedalvaro 40:3ba2b0ea9f33 242 }
mbedalvaro 40:3ba2b0ea9f33 243 } else { // This means that the number of vertices in the object, and the projected 2d points in its lsdTrajectory are the same: we don't need to clear anything nor add,
mbedalvaro 40:3ba2b0ea9f33 244 // just transform (but attention: do not modify the sensed data, so we cannot use the copy constructor for vectors V2, but a special setter setCoord()):
mbedalvaro 40:3ba2b0ea9f33 245 if (K.at[2][2]!=0) // this means normal PROJECTION
mbedalvaro 40:3ba2b0ea9f33 246 for ( unsigned short i=0; i<ptObject->vertexArray.size(); i++)
mbedalvaro 40:3ba2b0ea9f33 247 ptObject->displaySensingBuffer.lsdTrajectory[i].setCoord(renderPointProj(ptObject->vertexArray[i]));
mbedalvaro 40:3ba2b0ea9f33 248 else // this means ORTHOGRAPHIC PROJECTION
mbedalvaro 40:3ba2b0ea9f33 249 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++)
mbedalvaro 40:3ba2b0ea9f33 250 ptObject->displaySensingBuffer.lsdTrajectory[i].setCoord(renderPointOrth(ptObject->vertexArray[i]));
mbedalvaro 40:3ba2b0ea9f33 251 }
mbedalvaro 40:3ba2b0ea9f33 252 }
mbedalvaro 40:3ba2b0ea9f33 253
mbedalvaro 40:3ba2b0ea9f33 254 // Render, but adding a supplementary transformation (this will NOT modify the current stored 3d points in the object):
mbedalvaro 40:3ba2b0ea9f33 255 // NOTE: I could have made an optional argument to this method: (..., Mat44& moreRT=ID44), but this means that I have to declare ID44, and also that when not using the transformation, there
mbedalvaro 40:3ba2b0ea9f33 256 // will be a supplementary call to the matrix product method for each rendered point... conclusion: I prefer to overload the function.
mbedalvaro 40:3ba2b0ea9f33 257 void LaserRenderer::renderObject(BaseObject* ptObject, Mat44& moreRT)
mbedalvaro 40:3ba2b0ea9f33 258 {
mbedalvaro 40:3ba2b0ea9f33 259 if (ptObject->vertexArray.size()!=ptObject->displaySensingBuffer.lsdTrajectory.size()) {
mbedalvaro 40:3ba2b0ea9f33 260 ptObject->displaySensingBuffer.lsdTrajectory.clear();
mbedalvaro 40:3ba2b0ea9f33 261 if (K.at[2][2]!=0) // this means normal PROJECTION
mbedalvaro 40:3ba2b0ea9f33 262 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++) {
mbedalvaro 40:3ba2b0ea9f33 263 LaserPoint newLp=renderPointProj(moreRT*ptObject->vertexArray[i]);
mbedalvaro 40:3ba2b0ea9f33 264 ptObject->displaySensingBuffer.lsdTrajectory.push_back(newLp);
mbedalvaro 40:3ba2b0ea9f33 265 }
mbedalvaro 40:3ba2b0ea9f33 266 else // this means ORTHOGRAPHIC PROJECTION
mbedalvaro 40:3ba2b0ea9f33 267 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++) {
mbedalvaro 40:3ba2b0ea9f33 268 LaserPoint newLp=renderPointOrth(moreRT*ptObject->vertexArray[i]);
mbedalvaro 40:3ba2b0ea9f33 269 ptObject->displaySensingBuffer.lsdTrajectory.push_back(newLp);
mbedalvaro 40:3ba2b0ea9f33 270 }
mbedalvaro 40:3ba2b0ea9f33 271 } else { // this means that the number of points in the object did not change. We don't have to create a new laser point, otherwise
mbedalvaro 40:3ba2b0ea9f33 272 // we will be affecting the previous sensed trajectory... only modify the point coordinates!
mbedalvaro 40:3ba2b0ea9f33 273 if (K.at[2][2]!=0) // this means normal PROJECTION
mbedalvaro 40:3ba2b0ea9f33 274 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++)
mbedalvaro 40:3ba2b0ea9f33 275 ptObject->displaySensingBuffer.lsdTrajectory[i].setCoord(renderPointProj(moreRT*ptObject->vertexArray[i]));
mbedalvaro 40:3ba2b0ea9f33 276 else // this means ORTHOGRAPHIC PROJECTION
mbedalvaro 40:3ba2b0ea9f33 277 for (unsigned short i=0; i<ptObject->vertexArray.size(); i++)
mbedalvaro 40:3ba2b0ea9f33 278 ptObject->displaySensingBuffer.lsdTrajectory[i].setCoord(renderPointOrth(moreRT*ptObject->vertexArray[i]));
mbedalvaro 40:3ba2b0ea9f33 279 }
mbedalvaro 40:3ba2b0ea9f33 280 }
mbedalvaro 40:3ba2b0ea9f33 281
mbedalvaro 40:3ba2b0ea9f33 282 void LaserRenderer::renderScene(Scene* ptr_scene)
mbedalvaro 40:3ba2b0ea9f33 283 {
mbedalvaro 40:3ba2b0ea9f33 284 for (int i=0; i<ptr_scene->totalObjects(); i++) renderObject(ptr_scene->objectArray[i]);
mbedalvaro 40:3ba2b0ea9f33 285 //Another way: Scene.objectArray[i]->render();
mbedalvaro 40:3ba2b0ea9f33 286 }
mbedalvaro 40:3ba2b0ea9f33 287
mbedalvaro 40:3ba2b0ea9f33 288
mbedalvaro 40:3ba2b0ea9f33 289 void LaserRenderer::renderScene(Scene* ptr_scene, Mat44& moreRT)
mbedalvaro 40:3ba2b0ea9f33 290 {
mbedalvaro 40:3ba2b0ea9f33 291 for (int i=0; i<ptr_scene->totalObjects(); i++) renderObject(ptr_scene->objectArray[i], moreRT);
mbedalvaro 40:3ba2b0ea9f33 292 //Another way: Scene.objectArray[i]->render();
mbedalvaro 40:3ba2b0ea9f33 293 }
mbedalvaro 40:3ba2b0ea9f33 294