Laser Sensing Display for UI interfaces in the real world
Fork of skinGames_forktest by
LaserRenderer.cpp@45:5ef809480c12, 2013-12-23 (annotated)
- Committer:
- mbedalvaro
- Date:
- Mon Dec 23 18:04:07 2013 +0000
- Revision:
- 45:5ef809480c12
- Parent:
- 40:3ba2b0ea9f33
This is the latest version of the "laser terminal", now evolving into something using interactive UIs that are quearable - Model View Controller model for Spatial AR
Who changed what in which revision?
User | Revision | Line number | New 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 |