1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303

package org.papervision3d.render
{
	
	/**
	 * @Author Ralph Hauwert
	 */
	import flash.geom.Point;
	
	import org.papervision3d.core.clipping.DefaultClipping;
	import org.papervision3d.core.proto.CameraObject3D;
	import org.papervision3d.core.proto.SceneObject3D;
	import org.papervision3d.core.render.AbstractRenderEngine;
	import org.papervision3d.core.render.IRenderEngine;
	import org.papervision3d.core.render.command.IRenderListItem;
	import org.papervision3d.core.render.command.RenderableListItem;
	import org.papervision3d.core.render.data.RenderHitData;
	import org.papervision3d.core.render.data.RenderSessionData;
	import org.papervision3d.core.render.data.RenderStatistics;
	import org.papervision3d.core.render.filter.BasicRenderFilter;
	import org.papervision3d.core.render.filter.IRenderFilter;
	import org.papervision3d.core.render.material.MaterialManager;
	import org.papervision3d.core.render.project.BasicProjectionPipeline;
	import org.papervision3d.core.render.project.ProjectionPipeline;
	import org.papervision3d.core.render.sort.BasicRenderSorter;
	import org.papervision3d.core.render.sort.IRenderSorter;
	import org.papervision3d.core.utils.StopWatch;
	import org.papervision3d.events.RendererEvent;
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.view.layer.ViewportLayer;
	
	/**
	 * <code>BasicRenderEngine</code> links <code>Viewport3D</code>s, 
	 * <code>Scene3D</code>, and <code>Camera3D</code>s together
	 *  by gathering in all of their data, rendering the data, then calling the 
	 *  necessary functions to update from the rendered data
	 */	
	public class BasicRenderEngine extends AbstractRenderEngine implements IRenderEngine
	{
		/**
		 * The type of projection pipeline used for projecting and culling. Defaults
		 * to BasicProjectionPipeline
		 * 
		 * @see org.papervision3d.core.render.project.BasicProjectionPipeline
		 */
		public var projectionPipeline:ProjectionPipeline;
		/**
		 * The type of z-sorting to be used with the rendered data based on 
		 * their respective screen depth. Defaults to <code>BasicRenderSorter</code>.
		 * 
		 * @see org.papervision3d.core.render.sort.BasicRenderSorter
		 */
		public var sorter:IRenderSorter;
		
		public var clipping:DefaultClipping;
		
		/**
		 * A filter (such as FogFilter) to be used in the renderList. Defaults to 
		 * <code>BasicRenderFilter</code>
		 * 
		 * @see org.papervision3d.core.render.filter.BasicRenderFilter
		 * @see org.papervision3d.core.render.filter.FogFilter
		 */
		public var filter:IRenderFilter;
		/** @private */
		protected var renderDoneEvent:RendererEvent;
		/** @private */
		protected var projectionDoneEvent:RendererEvent;
		/** @private */
		protected var renderStatistics:RenderStatistics;
		/** @private */
		protected var renderList:Array;
		/** @private */
		protected var renderSessionData:RenderSessionData;
		/** @private */
		protected var cleanRHD:RenderHitData = new RenderHitData();
		/** @private */
		protected var stopWatch:StopWatch;
		
		
	
		/**
		 * Creates and prepares all the objects and events needed for rendering
		 */
		public function BasicRenderEngine():void
		{
			init();			 
		}
		
		/**
		 * Destroys all of <code>BasicRenderEngine</code>'s objects for Garbage Collection purposes.
		 */
		public function destroy():void
		{
			renderDoneEvent = null;
			projectionDoneEvent = null;
			projectionPipeline = null;
			sorter = null;
			filter = null;
			renderStatistics = null;
			renderList = null;
			renderSessionData.destroy();
			renderSessionData = null;
			cleanRHD = null;
			stopWatch = null;
			clipping = null;
		}
		/** @private */
		protected function init():void
		{
			renderStatistics = new RenderStatistics();
			
			projectionPipeline = new BasicProjectionPipeline();
			
			stopWatch = new StopWatch();
				
			sorter = new BasicRenderSorter();
			filter = new BasicRenderFilter();
			
			renderList = new Array();
			clipping = null;
			
			renderSessionData = new RenderSessionData();
			renderSessionData.renderer = this;
			
			projectionDoneEvent = new RendererEvent(RendererEvent.PROJECTION_DONE, renderSessionData);
			renderDoneEvent = new RendererEvent(RendererEvent.RENDER_DONE, renderSessionData);
		}
		
		/**
		 * Takes the data from the scene, camera, and viewport, renders it, then updates the viewport
		 * 
		 * @param camera			The <code>CameraObject3D</code> looking at the scene
		 * @param scene				The <code>Scene3D</code> holding the <code>DisplayObject3D</code>'s you want rendered
		 * @param viewPort			The <code>Viewport3D</code> that will display your scene
		 * 
		 * @return RenderStatistics		The <code>RenderStatistics</code> objectholds all the data from the last render
		 */
		override public function renderScene(scene:SceneObject3D, camera:CameraObject3D, viewPort:Viewport3D):RenderStatistics
		{
			// Set the camera's viewport so it can resize its frustum.
			camera.viewport = viewPort.sizeRectangle;
			
			//Update the renderSessionData object.
			renderSessionData.scene = scene;
			renderSessionData.camera = camera;
			renderSessionData.viewPort = viewPort;
			renderSessionData.container = viewPort.containerSprite;
			renderSessionData.triangleCuller = viewPort.triangleCuller;
			renderSessionData.particleCuller = viewPort.particleCuller;
			renderSessionData.renderObjects = scene.objects;
			renderSessionData.renderLayers = null;
			renderSessionData.renderStatistics.clear();
			renderSessionData.clipping = clipping;
			
			if(clipping)
				clipping.reset(renderSessionData);
			
			//Clear the viewport.
			viewPort.updateBeforeRender(renderSessionData);
			
			//Project the Scene (this will fill up the renderlist).
			projectionPipeline.project(renderSessionData);
			if(hasEventListener(RendererEvent.PROJECTION_DONE)){
				dispatchEvent(projectionDoneEvent);
			}
			
			//Render the Scene. TODO: delete null if layers is deleted from doRender
			doRender(renderSessionData, null);
			if(hasEventListener(RendererEvent.RENDER_DONE)){
				dispatchEvent(renderDoneEvent);
			}
			
			return renderSessionData.renderStatistics;
		}
		
		/**
		 * Works similarly to <code>renderScene</code>, but also takes an array 
		 * of specific <code>ViewportLayer3D</code>'s to
		 * render
		 * 
		 * @param camera				The <code>CameraObject3D</code> looking at the scene
		 * @param scene					The <code>Scene3D</code> holding the <code>DisplayObject3D</code>'s you want rendered
		 * @param viewPort				The <code>Viewport3D</code> that will display your scene
		 * 
		 * @return RenderStatistics		The <code>RenderStatistics</code> objectholds all the data from the last render
		 * 
		 * @see #renderScene
		 */
		public function renderLayers(scene:SceneObject3D, camera:CameraObject3D, viewPort:Viewport3D, layers:Array = null):RenderStatistics
		{
			//Update the renderSessionData object.
			renderSessionData.scene = scene;
			renderSessionData.camera = camera;
			renderSessionData.viewPort = viewPort;
			renderSessionData.container = viewPort.containerSprite;
			renderSessionData.triangleCuller = viewPort.triangleCuller;
			renderSessionData.particleCuller = viewPort.particleCuller;
			renderSessionData.renderObjects = getLayerObjects(layers);
			renderSessionData.renderLayers = layers;
			renderSessionData.renderStatistics.clear();
			renderSessionData.clipping = clipping;

			//Clear the viewport.
		
			viewPort.updateBeforeRender(renderSessionData);
			
			//Project the Scene (this will fill up the renderlist).
			projectionPipeline.project(renderSessionData);
			if(hasEventListener(RendererEvent.PROJECTION_DONE)){
				dispatchEvent(projectionDoneEvent);
			}
			
			//Render the Scene.
			doRender(renderSessionData);
			if(hasEventListener(RendererEvent.RENDER_DONE)){
				dispatchEvent(renderDoneEvent);
			}
			
			return renderSessionData.renderStatistics;
		}
		
		/** @private */
		private function getLayerObjects(layers:Array):Array{
			var array:Array = new Array();
			
			for each (var vpl:ViewportLayer in layers){
				array = array.concat(vpl.getLayerObjects());
			}
			return array;
		}
		
		//TODO: layers parameter isn't used. Delete?
		/** @private */
		protected function doRender(renderSessionData:RenderSessionData, layers:Array = null):RenderStatistics
		{
			stopWatch.reset();
			stopWatch.start();
			
			//Update Materials.
			MaterialManager.getInstance().updateMaterialsBeforeRender(renderSessionData);

			//Filter the list
			filter.filter(renderList);
			
			//Sort entire list.
			sorter.sort(renderList);
			
			var rc:RenderableListItem;
			var viewport:Viewport3D = renderSessionData.viewPort;
			var vpl:ViewportLayer;

			while(rc = renderList.pop())
			{
				
				vpl = viewport.accessLayerFor(rc, true);
				rc.render(renderSessionData, vpl.graphicsChannel);
				viewport.lastRenderList.push(rc);
				vpl.processRenderItem(rc);
			}
			
			//Update Materials
			MaterialManager.getInstance().updateMaterialsAfterRender(renderSessionData);
			
			renderSessionData.renderStatistics.renderTime = stopWatch.stop();
			renderSessionData.viewPort.updateAfterRender(renderSessionData);
			return renderStatistics;
		}
		
		//TODO: Redundant? Someone please tell me a use case scenario: John L.
		/**
		 * @private
		 */
		public function hitTestPoint2D(point:Point, viewPort3D:Viewport3D):RenderHitData
		{
			return viewPort3D.hitTestPoint2D(point);
		}
		
		/**
		 * Adds a <code>renderCommand</code> to the <code>renderList</code>
		 * 
		 * @param renderCommand		A command to be used in the <code>renderList</code>
		 * 
		 * @return int				An integer representing the length of the <code>renderList</code>
		 */
		override public function addToRenderList(renderCommand:RenderableListItem):int
		{
			return renderList.push(renderCommand);
		}
		
		/**
		 * Removes a <code>renderCommand</code> from the <code>renderList</code>
		 * 
		 * @param renderCommand		A command to be removed from the <code>renderList</code>
		 * 
		 * @return int				An integer representing the length of the <code>renderList</code>
		 */
		override public function removeFromRenderList(renderCommand:IRenderListItem):int
		{
			return renderList.splice(renderList.indexOf(renderCommand),1);
		}

	}
}