framework2

1
/*
2
 * ofRendererCollection.cpp
3
 *
4
 *  Created on: Mar 30, 2013
5
 *      Author: arturo
6
 */
7

8
#include "ofRendererCollection.h"
9
#include "ofGLRenderer.h"
10
#include "ofGLProgrammableRenderer.h"
11

12
const std::string ofRendererCollection::TYPE="collection";
13

14
std::shared_ptr<ofBaseGLRenderer> ofRendererCollection::getGLRenderer(){
15
   for(auto renderer: renderers){
16
		 if(renderer->getType()=="GL" || renderer->getType()=="ProgrammableGL"){
17
			 return std::dynamic_pointer_cast<ofBaseGLRenderer>(renderer);
18
		 }
19
   }
20
   #ifndef TARGET_PROGRAMMABLE_GL
21
		return std::shared_ptr<ofGLRenderer>();
22
   #else
23
		return std::shared_ptr<ofGLProgrammableRenderer>();
24
   #endif
25
}
26

27
bool ofRendererCollection::rendersPathPrimitives(){return true;}
28

29
void ofRendererCollection::startRender(){
30
	for(auto renderer: renderers){
31
		renderer->startRender();
32
	}
33
}
34

35
void ofRendererCollection::finishRender(){
36
	for(auto renderer: renderers){
37
		renderer->finishRender();
38
	}
39
}
40

41
void ofRendererCollection::draw(const ofPolyline & poly) const{
42
	for(auto renderer: renderers){
43
		renderer->draw(poly);
44
	}
45
}
46
void ofRendererCollection::draw(const ofPath & shape) const{
47
	for(auto renderer: renderers){
48
		renderer->draw(shape);
49
	}
50
}
51

52
void ofRendererCollection::draw(const ofMesh & vertexData, ofPolyRenderMode mode, bool useColors, bool useTextures, bool useNormals) const{
53
	for(auto renderer: renderers){
54
		renderer->draw(vertexData,mode,useColors,useTextures,useNormals);
55
	}
56
}
57

58
void ofRendererCollection::draw(const  of3dPrimitive& model, ofPolyRenderMode renderType ) const {
59
   for(auto renderer: renderers){
60
	   renderer->draw( model, renderType );
61
   }
62
}
63

64
void ofRendererCollection::draw(const  ofNode& node) const {
65
   for(auto renderer: renderers){
66
	   renderer->draw( node );
67
   }
68
}
69

70
void ofRendererCollection::draw(const ofImage & img, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh) const{
71
   for(auto renderer: renderers){
72
	   renderer->draw(img,x,y,z,w,h,sx,sy,sw,sh);
73
	}
74
}
75

76
void ofRendererCollection::draw(const ofFloatImage & img, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh) const{
77
   for(auto renderer: renderers){
78
	   renderer->draw(img,x,y,z,w,h,sx,sy,sw,sh);
79
   }
80
}
81

82
void ofRendererCollection::draw(const ofShortImage & img, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh) const{
83
   for(auto renderer: renderers){
84
	   renderer->draw(img,x,y,z,w,h,sx,sy,sw,sh);
85
   }
86
}
87

88
void ofRendererCollection::draw(const ofBaseVideoDraws & video, float x, float y, float w, float h) const{
89
   for(auto renderer: renderers){
90
	   renderer->draw(video,x,y,w,h);
91
   }
92
}
93

94
/*void bind(const ofBaseVideoDraws & video) const{
95
   for(int i=0;i<(int)renderers.size();i++){
96
	   renderers[i]->bind(video);
97
   }
98
}
99

100
void unbind(const ofBaseVideoDraws & video) const{
101
   for(int i=0;i<(int)renderers.size();i++){
102
	   renderers[i]->unbind(video);
103
   }
104
}*/
105

106

107
glm::mat4 ofRendererCollection::getCurrentMatrix(ofMatrixMode matrixMode_) const{
108
   if (!renderers.empty()) {
109
	   return renderers.front()->getCurrentMatrix(matrixMode_);
110
   } else {
111
	   ofLogWarning() << "No renderer in renderer collection, but current matrix requested. Returning identity matrix.";
112
	   return glm::mat4(1.0f);
113
   }
114
}
115

116

117
glm::mat4 ofRendererCollection::getCurrentOrientationMatrix() const{
118
   if (!renderers.empty()) {
119
	   return renderers.front()->getCurrentOrientationMatrix();
120
   } else {
121
	   ofLogWarning() << "No renderer in renderer collection, but current matrix requested. Returning identity matrix.";
122
	   return glm::mat4(1.0f);
123
   }
124
}
125

126

127
glm::mat4 ofRendererCollection::getCurrentNormalMatrix() const{
128
   if (!renderers.empty()) {
129
	   return renderers.front()->getCurrentNormalMatrix();
130
   } else {
131
	   ofLogWarning() << "No renderer in renderer collection, but current matrix requested. Returning identity matrix.";
132
	   return glm::mat4(1.0f);
133
   }
134
}
135

136
//--------------------------------------------
137
// transformations
138
void ofRendererCollection::pushView(){
139
	for(auto renderer: renderers){
140
		renderer->pushView();
141
	}
142
}
143

144
void ofRendererCollection::popView(){
145
	for(auto renderer: renderers){
146
		renderer->popView();
147
	}
148
}
149

150
// setup matrices and viewport (upto you to push and pop view before and after)
151
// if width or height are 0, assume windows dimensions (ofGetWidth(), ofGetHeight())
152
// if nearDist or farDist are 0 assume defaults (calculated based on width / height)
153
void ofRendererCollection::viewport(ofRectangle viewport){
154
   for(auto renderer: renderers){
155
	   renderer->viewport(viewport);
156
	}
157
}
158

159
void ofRendererCollection::viewport(float x, float y, float width, float height, bool vflip){
160
	for(auto renderer: renderers){
161
		renderer->viewport(x,y,width,height,vflip);
162
	}
163
}
164

165
void ofRendererCollection::setupScreenPerspective(float width, float height, float fov, float nearDist, float farDist){
166
	for(auto renderer: renderers){
167
		renderer->setupScreenPerspective(width,height,fov,nearDist,farDist);
168
	}
169
}
170

171
void ofRendererCollection::setupScreenOrtho(float width, float height, float nearDist, float farDist){
172
	for(auto renderer: renderers){
173
		renderer->setupScreenOrtho(width,height,nearDist,farDist);
174
	}
175
}
176

177
ofRectangle ofRendererCollection::getCurrentViewport() const{
178
	if(renderers.size()){
179
		return renderers[0]->getCurrentViewport();
180
	}else{
181
		return ofRectangle();
182
	}
183
}
184

185
ofRectangle ofRendererCollection::getNativeViewport() const{
186
	if(renderers.size()){
187
		return renderers[0]->getNativeViewport();
188
	}else{
189
		return ofRectangle();
190
	}
191
}
192

193
int ofRendererCollection::getViewportWidth() const{
194
	if(renderers.size()){
195
		return renderers[0]->getViewportWidth();
196
	}else{
197
		return 0;
198
	}
199
}
200
int ofRendererCollection::getViewportHeight() const{
201
	if(renderers.size()){
202
		return renderers[0]->getViewportHeight();
203
	}else{
204
		return 0;
205
	}
206
}
207

208
void ofRendererCollection::setCoordHandedness(ofHandednessType handedness){
209
	for(auto renderer: renderers){
210
		renderer->setCoordHandedness(handedness);
211
	}
212
}
213
ofHandednessType ofRendererCollection::getCoordHandedness() const{
214
	if(renderers.size()){
215
		return renderers[0]->getCoordHandedness();
216
	}else{
217
		return OF_LEFT_HANDED;
218
	}
219
}
220

221
//our openGL wrappers
222
void ofRendererCollection::pushMatrix(){
223
	for(auto renderer: renderers){
224
		renderer->pushMatrix();
225
	}
226
}
227
void ofRendererCollection::popMatrix(){
228
	for(auto renderer: renderers){
229
		renderer->popMatrix();
230
	}
231
}
232
void ofRendererCollection::translate(float x, float y, float z){
233
	for(auto renderer: renderers){
234
		renderer->translate(x,y,z);
235
	}
236
}
237
void ofRendererCollection::translate(const glm::vec3 & p){
238
	for(auto renderer: renderers){
239
		renderer->translate(p);
240
	}
241
}
242
void ofRendererCollection::scale(float xAmnt, float yAmnt, float zAmnt){
243
	for(auto renderer: renderers){
244
		renderer->scale(xAmnt,yAmnt,zAmnt);
245
	}
246
}
247

248
void ofRendererCollection::rotateDeg(float degrees, float vecX, float vecY, float vecZ){
249
	for(auto renderer: renderers){
250
		renderer->rotateDeg(degrees,vecX,vecY,vecZ);
251
	}
252
}
253
void ofRendererCollection::rotateXDeg(float degrees){
254
	for(auto renderer: renderers){
255
		renderer->rotateXDeg(degrees);
256
	}
257
}
258
void ofRendererCollection::rotateYDeg(float degrees){
259
	for(auto renderer: renderers){
260
		renderer->rotateYDeg(degrees);
261
	}
262
}
263
void ofRendererCollection::rotateZDeg(float degrees){
264
	for(auto renderer: renderers){
265
		renderer->rotateZDeg(degrees);
266
	}
267
}
268
void ofRendererCollection::rotateDeg(float degrees){
269
	for(auto renderer: renderers){
270
		renderer->rotateDeg(degrees);
271
	}
272
}
273

274
void ofRendererCollection::rotateRad(float radians, float vecX, float vecY, float vecZ){
275
	for(auto renderer: renderers){
276
		renderer->rotateRad(radians,vecX,vecY,vecZ);
277
	}
278
}
279
void ofRendererCollection::rotateXRad(float radians){
280
	for(auto renderer: renderers){
281
		renderer->rotateXRad(radians);
282
	}
283
}
284
void ofRendererCollection::rotateYRad(float radians){
285
	for(auto renderer: renderers){
286
		renderer->rotateYRad(radians);
287
	}
288
}
289
void ofRendererCollection::rotateZRad(float radians){
290
	for(auto renderer: renderers){
291
		renderer->rotateZRad(radians);
292
	}
293
}
294
void ofRendererCollection::rotateRad(float radians){
295
	for(auto renderer: renderers){
296
		renderer->rotateRad(radians);
297
	}
298
}
299

300
void ofRendererCollection::loadIdentityMatrix (void){
301
   for(auto renderer: renderers){
302
	   renderer->loadIdentityMatrix();
303
   }
304
}
305

306
void ofRendererCollection::loadMatrix (const glm::mat4 & m){
307
   for(auto renderer: renderers){
308
	   renderer->loadMatrix( m );
309
   }
310
}
311

312
void ofRendererCollection::loadMatrix (const float * m){
313
   for(auto renderer: renderers){
314
	   renderer->loadMatrix( m );
315
   }
316
}
317

318
void ofRendererCollection::multMatrix (const glm::mat4 & m){
319
   for(auto renderer: renderers){
320
	   renderer->multMatrix( m );
321
   }
322
}
323

324
void ofRendererCollection::multMatrix (const float * m){
325
   for(auto renderer: renderers){
326
	   renderer->multMatrix( m );
327
   }
328
}
329

330
void ofRendererCollection::setOrientation(ofOrientation orientation, bool vflip){
331
   for(auto renderer: renderers){
332
	   renderer->setOrientation( orientation, vflip );
333
   }
334
}
335

336
bool ofRendererCollection::isVFlipped() const{
337
   if(!renderers.empty()){
338
	   return renderers.front()->isVFlipped();
339
   }else{
340
	   ofLogWarning() << "No renderer in renderer collection, but vflipped requested returning true.";
341
	   return true;
342
   }
343
}
344

345
void ofRendererCollection::matrixMode(ofMatrixMode mode){
346
   for(auto renderer: renderers){
347
	   renderer->matrixMode( mode );
348
   }
349
}
350

351
void ofRendererCollection::loadViewMatrix(const glm::mat4& m){
352
   for(auto renderer: renderers){
353
	   renderer->loadViewMatrix( m );
354
   }
355
}
356

357
void ofRendererCollection::multViewMatrix(const glm::mat4& m){
358
   for(auto renderer: renderers){
359
	   renderer->multViewMatrix( m );
360
   }
361
}
362

363
glm::mat4 ofRendererCollection::getCurrentViewMatrix() const{
364
   if(!renderers.empty()){
365
	   return renderers.front()->getCurrentViewMatrix();
366
   }else{
367
	   ofLogWarning() << "No renderer in renderer collection, but current view matrix requested. Returning identity matrix.";
368
	   return glm::mat4(1.0);
369
   }
370
}
371

372

373
// screen coordinate things / default gl values
374
void ofRendererCollection::setupGraphicDefaults(){
375
	for(auto renderer: renderers){
376
		renderer->setupGraphicDefaults();
377
   }
378
   path.setMode(ofPath::COMMANDS);
379
   path.setUseShapeColor(false);
380
}
381

382
void ofRendererCollection::setupScreen(){
383
	for(auto renderer: renderers){
384
		renderer->setupScreen();
385
	}
386
}
387

388
// color options
389
void ofRendererCollection::setColor(int r, int g, int b){
390
   for(auto renderer: renderers){
391
	   renderer->setColor(r,g,b);
392
	}
393
}
394

395
void ofRendererCollection::setColor(int r, int g, int b, int a){
396
   for(auto renderer: renderers){
397
	   renderer->setColor(r,g,b,a);
398
	}
399
}
400

401
void ofRendererCollection::setColor(const ofColor & color){
402
   for(auto renderer: renderers){
403
	   renderer->setColor(color);
404
	}
405
}
406

407
void ofRendererCollection::setColor(const ofColor & color, int _a){
408
   for(auto renderer: renderers){
409
	   renderer->setColor(color,_a);
410
	}
411
}
412

413
void ofRendererCollection::setColor(int gray){
414
   for(auto renderer: renderers){
415
	   renderer->setColor(gray);
416
	}
417
}
418

419
void ofRendererCollection::ofRendererCollection::setHexColor( int hexColor ){
420
   for(auto renderer: renderers){
421
	   renderer->setHexColor(hexColor);
422
	}
423
} // hex, like web 0xFF0033;
424

425
// bg color
426
ofColor ofRendererCollection::getBackgroundColor(){
427
	if(renderers.size()){
428
		return renderers[0]->getBackgroundColor();
429
	}else{
430
		return ofColor(200);
431
	}
432
}
433

434
void ofRendererCollection::setBackgroundColor(const ofColor & color){
435
   for(auto renderer: renderers){
436
	   renderer->setBackgroundColor(color);
437
	}
438
}
439

440
bool ofRendererCollection::getBackgroundAuto(){
441
	if(renderers.size()){
442
		return renderers[0]->getBackgroundAuto();
443
	}else{
444
		return true;
445
	}
446
}
447

448
void ofRendererCollection::background(const ofColor & c){
449
   for(auto renderer: renderers){
450
	   renderer->background(c);
451
	}
452
}
453

454
void ofRendererCollection::background(float brightness){
455
   for(auto renderer: renderers){
456
	   renderer->background(brightness);
457
	}
458
}
459

460
void ofRendererCollection::background(int hexColor, float _a){
461
   for(auto renderer: renderers){
462
	   renderer->background(hexColor,_a);
463
	}
464
}
465

466
void ofRendererCollection::background(int r, int g, int b, int a){
467
   for(auto renderer: renderers){
468
	   renderer->background(r,g,b,a);
469
	}
470
}
471

472
void ofRendererCollection::setBackgroundAuto(bool bManual){
473
   for(auto renderer: renderers){
474
	   renderer->setBackgroundAuto(bManual);
475
	}
476
}
477

478
void ofRendererCollection::clear(){
479
   for(auto renderer: renderers){
480
	   renderer->clear();
481
	}
482
}
483

484
void ofRendererCollection::clear(float r, float g, float b, float a){
485
   for(auto renderer: renderers){
486
	   renderer->clear(r,g,b,a);
487
	}
488
}
489

490
void ofRendererCollection::clear(float brightness, float a){
491
   for(auto renderer: renderers){
492
	   renderer->clear(brightness,a);
493
	}
494
}
495

496
void ofRendererCollection::clearAlpha(){
497
   for(auto renderer: renderers){
498
	   renderer->clearAlpha();
499
	}
500
}
501

502
// drawing modes
503
void ofRendererCollection::setRectMode(ofRectMode mode){
504
   for(auto renderer: renderers){
505
	   renderer->setRectMode(mode);
506
	}
507
}
508

509
ofRectMode ofRendererCollection::getRectMode(){
510
   if(renderers.empty()){
511
	   return OF_RECTMODE_CORNER;
512
   }else{
513
	   return renderers[0]->getRectMode();
514
   }
515
}
516

517
void ofRendererCollection::setFillMode(ofFillFlag fill){
518
   for(auto renderer: renderers){
519
	   renderer->setFillMode(fill);
520
	}
521
   if(fill==OF_FILLED){
522
	   path.setFilled(true);
523
	   path.setStrokeWidth(0);
524
   }else{
525
	   path.setFilled(false);
526
	   path.setStrokeWidth(getStyle().lineWidth);
527
   }
528
}
529

530
ofFillFlag ofRendererCollection::getFillMode(){
531
   if(renderers.empty()){
532
	   return OF_FILLED;
533
   }else{
534
	   return renderers[0]->getFillMode();
535
   }
536
}
537

538
void ofRendererCollection::setLineWidth(float lineWidth){
539
   for(auto renderer: renderers){
540
	   renderer->setLineWidth(lineWidth);
541
   }
542
   if(!getStyle().bFill){
543
	   path.setStrokeWidth(lineWidth);
544
   }
545
}
546

547
void ofRendererCollection::setDepthTest(bool depthTest) {
548
   for(auto renderer: renderers){
549
	   renderer->setDepthTest(depthTest);
550
   }
551
}
552

553
void ofRendererCollection::setBlendMode(ofBlendMode blendMode){
554
   for(auto renderer: renderers){
555
	   renderer->setBlendMode(blendMode);
556
	}
557
}
558
void ofRendererCollection::setLineSmoothing(bool smooth){
559
   for(auto renderer: renderers){
560
	   renderer->setLineSmoothing(smooth);
561
	}
562
}
563
void ofRendererCollection::setCircleResolution(int res){
564
   for(auto renderer: renderers){
565
	   renderer->setCircleResolution(res);
566
	}
567
}
568
void ofRendererCollection::enablePointSprites(){
569
   for(auto renderer: renderers){
570
		if(renderer->getType()=="GL" || renderer->getType()=="ProgrammableGL"){
571
			std::dynamic_pointer_cast<ofBaseGLRenderer>(renderer)->enablePointSprites();
572
		}
573
	}
574
}
575
void ofRendererCollection::disablePointSprites(){
576
   for(auto renderer: renderers){
577
		if(renderer->getType()=="GL" || renderer->getType()=="ProgrammableGL"){
578
			std::dynamic_pointer_cast<ofBaseGLRenderer>(renderer)->disablePointSprites();
579
		}
580
	}
581
}
582

583
void ofRendererCollection::enableAntiAliasing(){
584
   for(auto renderer: renderers){
585
	   renderer->enableAntiAliasing();
586
	}
587
}
588

589
void ofRendererCollection::disableAntiAliasing(){
590
   for(auto renderer: renderers){
591
	   renderer->disableAntiAliasing();
592
	}
593
}
594

595
void ofRendererCollection::setBitmapTextMode(ofDrawBitmapMode mode){
596
   for(auto renderer: renderers){
597
	   renderer->setBitmapTextMode(mode);
598
	}
599
}
600

601
ofStyle ofRendererCollection::getStyle() const{
602
   if(renderers.empty()){
603
	   return ofStyle();
604
   }else{
605
	   return renderers[0]->getStyle();
606
   }
607
}
608

609
void ofRendererCollection::pushStyle(){
610
   for(auto renderer: renderers){
611
	   renderer->pushStyle();
612
	}
613
}
614

615
void ofRendererCollection::popStyle(){
616
   for(auto renderer: renderers){
617
	   renderer->popStyle();
618
	}
619
}
620

621
void ofRendererCollection::setStyle(const ofStyle & style){
622
   for(auto renderer: renderers){
623
	   renderer->setStyle(style);
624
	}
625
}
626

627
void ofRendererCollection::setCurveResolution(int res){
628
   for(auto renderer: renderers){
629
	   renderer->setCurveResolution(res);
630
	}
631
	path.setCurveResolution(res);
632
}
633

634
void ofRendererCollection::setPolyMode(ofPolyWindingMode mode){
635
   for(auto renderer: renderers){
636
	   renderer->setPolyMode(mode);
637
	}
638
	path.setPolyWindingMode(mode);
639
}
640

641
// drawing
642
void ofRendererCollection::drawLine(float x1, float y1, float z1, float x2, float y2, float z2) const{
643
   for(auto renderer: renderers){
644
	   renderer->drawLine(x1,y1,z1,x2,y2,z2);
645
	}
646
}
647

648
void ofRendererCollection::drawRectangle(float x, float y, float z, float w, float h) const{
649
   for(auto renderer: renderers){
650
	   renderer->drawRectangle(x,y,z,w,h);
651
	}
652
}
653

654
void ofRendererCollection::drawTriangle(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3) const{
655
   for(auto renderer: renderers){
656
	   renderer->drawTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3);
657
	}
658
}
659

660
void ofRendererCollection::drawCircle(float x, float y, float z, float radius) const{
661
   for(auto renderer: renderers){
662
	   renderer->drawCircle(x,y,z,radius);
663
	}
664
}
665

666
void ofRendererCollection::drawEllipse(float x, float y, float z, float width, float height) const{
667
   for(auto renderer: renderers){
668
	   renderer->drawEllipse(x,y,z,width,height);
669
	}
670
}
671

672
void ofRendererCollection::drawString(std::string text, float x, float y, float z) const{
673
   for(auto renderer: renderers){
674
	   renderer->drawString(text, x,y,z);
675
	}
676
}
677

678
void ofRendererCollection::drawString(const ofTrueTypeFont & font, std::string text, float x, float y) const{
679
   for(auto renderer: renderers){
680
	   renderer->drawString(font, text, x,y);
681
	}
682
}
683

684
void ofRendererCollection::bind(const ofCamera & camera, const ofRectangle & viewport){
685
   for(auto renderer: renderers){
686
	   renderer->bind(camera, viewport);
687
	}
688
}
689
void ofRendererCollection::unbind(const ofCamera & camera){
690
	for(auto renderer: renderers){
691
		renderer->unbind(camera);
692
	}
693
}
694

695
const of3dGraphics & ofRendererCollection::get3dGraphics() const{
696
   return graphics3d;
697
}
698

699
of3dGraphics & ofRendererCollection::get3dGraphics(){
700
   return graphics3d;
701
}
702

703
ofPath & ofRendererCollection::getPath(){
704
   return path;
705
}
706