public override void UpdateRenderQueue( RenderQueue queue ) { // Notify need to calculate light list when our sending to render queue this.mLightListDirty = true; //if ( !added ) { queue.AddRenderable( this, renderQueueID ); this.added = true; } }
private void WalkOctree( PCZCamera camera, ref List<PCZSceneNode> visibleNodeList, RenderQueue queue, Octree octant, VisibleObjectsBoundsInfo visibleBounds, bool foundvisible, bool onlyShadowCasters, bool displayNodes, bool showBoundingBoxes ) { //return immediately if nothing is in the node. if ( octant.NunodeList == 0 ) return; Visibility v = Visibility.None; if ( foundvisible ) { v = Visibility.Full; } else if ( octant == rootOctree ) { v = Visibility.Partial; } else { AxisAlignedBox box = octant.Box; v = camera.GetVisibility( box ); } // if the octant is visible, or if it's the root node... if ( v != Visibility.None ) { //Add stuff to be rendered; bool vis = true; foreach ( PCZSceneNode sn in octant.NodeList.Values ) { // if the scene node is already visible, then we can skip it if ( sn.LastVisibleFrame != mLastVisibleFrame || sn.LastVisibleFromCamera != camera ) { // if this octree is partially visible, manually cull all // scene nodes attached directly to this level. if ( v == Visibility.Partial ) { vis = camera.IsObjectVisible( sn.WorldAABB ); } if ( vis ) { // add the node to the render queue sn.AddToRenderQueue( camera, queue, onlyShadowCasters, visibleBounds ); // add it to the list of visible nodes visibleNodeList.Add( sn ); // if we are displaying nodes, add the node renderable to the queue if ( displayNodes ) { queue.AddRenderable( sn.GetDebugRenderable() ); } // if the scene manager or the node wants the bounding box shown, add it to the queue if ( sn.ShowBoundingBox || showBoundingBoxes ) { sn.AddBoundingBoxToQueue( queue ); } // flag the node as being visible this frame sn.LastVisibleFrame = mLastVisibleFrame; sn.LastVisibleFromCamera = camera; } } } Octree child; bool childfoundvisible = ( v == Visibility.Full ); if ( ( child = octant.Children[ 0, 0, 0 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 1, 0, 0 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 0, 1, 0 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 1, 1, 0 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 0, 0, 1 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 1, 0, 1 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 0, 1, 1 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( ( child = octant.Children[ 1, 1, 1 ] ) != null ) WalkOctree( camera, ref visibleNodeList, queue, child, visibleBounds, childfoundvisible, onlyShadowCasters, displayNodes, showBoundingBoxes ); } }
/// <summary> /// /// </summary> /// <param name="queue"></param> public override void UpdateRenderQueue(RenderQueue queue) { // Manual LOD sub entities if (meshLodIndex > 0 && mesh.IsLodManual) { Debug.Assert(meshLodIndex - 1 < lodEntityList.Count, "No LOD EntityList - did you build the manual LODs after creating the entity?"); Entity lodEnt = lodEntityList[meshLodIndex - 1]; // index - 1 as we skip index 0 (original LOD) if (this.HasSkeleton && lodEnt.HasSkeleton) { // Copy the animation state set to lod entity, we assume the lod // entity only has a subset animation states copyAnimationMeter.Enter(); CopyAnimationStateSubset(lodEnt.animationState, animationState); copyAnimationMeter.Exit(); } lodEnt.UpdateRenderQueue(queue); return; } // add all visible sub entities to the render queue Camera camera = sceneMgr.CameraInProgress; bool performSubMeshCulling = false; // bool performSubMeshCulling = CullSubMeshes; for(int i = 0; i < subEntityList.Count; i++) { SubEntity subEntity = subEntityList[i]; if (!subEntity.IsVisible) continue; if (performSubMeshCulling && !camera.IsObjectVisible(subEntity.WorldAABB)) continue; queue.AddRenderable(subEntity, RenderQueue.DEFAULT_PRIORITY, renderQueueID); } // Since we know we're going to be rendered, take this opportunity to // update the animation if(HasSkeleton || mesh.HasVertexAnimation) { updateAnimationMeter.Enter(); if (MeterManager.Collecting) MeterManager.AddInfoEvent("Updating animation for mesh {0}, skeleton {1}", mesh.Name, mesh.SkeletonName); UpdateAnimationInternal(); updateAnimationMeter.Exit(); // Update render queue with child objects (tag points) for(int i = 0; i < childObjectList.Count; i++) { MovableObject child = childObjectList[i]; if (child.IsVisible) { updateChildMeter.Enter(); child.UpdateRenderQueue(queue); updateChildMeter.Exit(); } } } }
public void UpdateRenderQueue( RenderQueue queue ) { if ( IsRenderedAtCurrentLod ) { queue.AddRenderable( this.mRend, this.mTerrain.RenderQueueGroupID ); } }
public override void UpdateRenderQueue( RenderQueue queue ) { this.UpdateIndexBuffer(); if ( this.indexData.indexCount > 0 ) { queue.AddRenderable( this ); } }
/* // Recursively walk the zones, adding all visible SceneNodes to the list of visible nodes. */ public override void FindVisibleNodes( PCZCamera camera, ref List<PCZSceneNode> visibleNodeList, RenderQueue queue, VisibleObjectsBoundsInfo visibleBounds, bool onlyShadowCasters, bool displayNodes, bool showBoundingBoxes ) { //return immediately if nothing is in the zone. if ( mHomeNodeList.Count == 0 && mVisitorNodeList.Count == 0 && mPortals.Count == 0 ) return; // Else, the zone is automatically assumed to be visible since either // it is the camera the zone is in, or it was reached because // a connecting portal was deemed visible to the camera. // enable sky if called to do so for this zone if ( HasSky ) { // enable sky mPCZSM.EnableSky( true ); } // find visible nodes at home in the zone bool vis; foreach ( PCZSceneNode pczsn in mHomeNodeList ) { //PCZSceneNode pczsn = *it; // if the scene node is already visible, then we can skip it if ( pczsn.LastVisibleFrame != mLastVisibleFrame || pczsn.LastVisibleFromCamera != camera ) { FrustumPlane fPlane; // for a scene node, check visibility using AABB vis = camera.IsObjectVisible( pczsn.WorldAABB, out fPlane ); if ( vis ) { // add it to the list of visible nodes visibleNodeList.Add( pczsn ); // add the node to the render queue pczsn.AddToRenderQueue( camera, queue, onlyShadowCasters, visibleBounds ); // if we are displaying nodes, add the node renderable to the queue if ( displayNodes ) { queue.AddRenderable( pczsn.GetDebugRenderable() ); } // if the scene manager or the node wants the bounding box shown, add it to the queue if ( pczsn.ShowBoundingBox || showBoundingBoxes ) { pczsn.AddBoundingBoxToQueue( queue ); } // flag the node as being visible this frame pczsn.LastVisibleFrame = mLastVisibleFrame; pczsn.LastVisibleFromCamera = camera; } } } // find visible visitor nodes foreach ( PCZSceneNode pczsn in mVisitorNodeList ) { // if the scene node is already visible, then we can skip it if ( pczsn.LastVisibleFrame != mLastVisibleFrame || pczsn.LastVisibleFromCamera != camera ) { FrustumPlane fPlane; // for a scene node, check visibility using AABB vis = camera.IsObjectVisible( pczsn.WorldAABB, out fPlane ); if ( vis ) { // add it to the list of visible nodes visibleNodeList.Add( pczsn ); // add the node to the render queue pczsn.AddToRenderQueue( camera, queue, onlyShadowCasters, visibleBounds ); // if we are displaying nodes, add the node renderable to the queue if ( displayNodes ) { queue.AddRenderable( pczsn.GetDebugRenderable() ); } // if the scene manager or the node wants the bounding box shown, add it to the queue if ( pczsn.ShowBoundingBox || showBoundingBoxes ) { pczsn.AddBoundingBoxToQueue( queue ); } // flag the node as being visible this frame pczsn.LastVisibleFrame = mLastVisibleFrame; pczsn.LastVisibleFromCamera = camera; } } } // find visible portals in the zone and recurse into them foreach ( Portal portal in mPortals ) { FrustumPlane fPlane; // for portal, check visibility using world bounding sphere & direction vis = camera.IsObjectVisible( portal, out fPlane ); if ( vis ) { // portal is visible. Add the portal as extra culling planes to camera int planes_added = camera.AddPortalCullingPlanes( portal ); // tell target zone it's visible this frame portal.getTargetZone().LastVisibleFrame = mLastVisibleFrame; portal.getTargetZone().LastVisibleFromCamera = camera; // recurse into the connected zone portal.getTargetZone().FindVisibleNodes( camera, ref visibleNodeList, queue, visibleBounds, onlyShadowCasters, displayNodes, showBoundingBoxes ); if ( planes_added > 0 ) { // Then remove the extra culling planes added before going to the next portal in this zone. camera.RemovePortalCullingPlanes( portal ); } } } }
/// <summary> /// Add children to the render queue /// </summary> /// <param name="queue"> </param> /// <param name="group"> </param> /// <param name="camSquaredDistance"> </param> public void AddRenderables( RenderQueue queue, RenderQueueGroupID group, float camSquaredDistance ) { // Determine the current material technique mTechnique = mMaterial.GetBestTechnique( mMaterial.GetLodIndex( camSquaredDistance ) ); foreach ( GeometryBucket iter in mGeometryBucketList ) { queue.AddRenderable( iter, group ); } }
public override void UpdateRenderQueue(RenderQueue queue) { Debug.Assert(inBoundary); if (isVisible) { queue.AddRenderable(this); } }
public void AddRenderables(RenderQueue queue, RenderQueueGroupID group, float camDistanceSquared) { if (material != null) { // determine the current material technique technique = material.GetBestTechnique(material.GetLodIndexSquaredDepth(camDistanceSquared)); foreach (GeometryBucket gbucket in geometryBucketList) queue.AddRenderable(gbucket, RenderQueue.DEFAULT_PRIORITY, group); } }
public void QueuePatches(RenderQueue queue) { var idx = 0; for (var i = 0; i < Levels; i++) { var level = _levels[i]; var mask = i == 0 ? PatchLocations.PatchSelection.Everything :PatchLocations.PatchSelection.Outer; if (i != 0) mask |= PatchLocations.PatchSelection.OuterDegenerated; mask |= level.Bottom ? PatchLocations.PatchSelection.InteriorBottom : PatchLocations.PatchSelection.InteriorTop; mask |= level.Left ? PatchLocations.PatchSelection.InteriorLeft : PatchLocations.PatchSelection.InteriorRight; var subX = level.Position.X.Fraction * 2.0f - 1.0f; var intX = level.Position.X.Integer; var subY = level.Position.Y.Fraction * 2.0f - 1.0f; var intY = level.Position.Y.Integer; var texX = (intX * 2) & N; var texY = (intY * 2) & N; foreach (var p in Locations.Select(mask)) { PatchRenderable pp; if (_queueCache.Count <= idx) { pp = new PatchRenderable(p.Patch, _shader); _queueCache.Add(pp); } else pp = _queueCache[idx]; idx++; // queue the patch for rendering pp.ScaleFactor = new Vector4(p.X + subX, p.Y + subY, level.Scale, level.Scale); pp.FineBlockOrigin = new Vector4(p.X - Hx - texX, p.Y - Hx - texY, (float)InverseD, (float)InverseD); pp.Level = level; queue.AddRenderable(pp); } } }
/// <summary> /// Overriden from Panel. /// </summary> /// <param name="queue"></param> public override void UpdateRenderQueue( RenderQueue queue ) { // Add self twice to the queue // Have to do this to allow 2 materials if ( isVisible ) { // add border first queue.AddRenderable( this.borderRenderable, (ushort)zOrder, RenderQueueGroupID.Overlay ); // do inner last so the border artifacts don't overwrite the children // Add inner base.UpdateRenderQueue( queue ); } }
public override void UpdateRenderQueue(RenderQueue queue) { #if _VisibilityCheck if ( mustRender == false ) { return; } #endif if ( inUse && isLoaded && inFrustum) { RenderableManager.Instance.AddVisible(); queue.AddRenderable( this ); } }
/// <summary> /// /// </summary> /// <param name="queue"></param> public override void UpdateRenderQueue(RenderQueue queue) { // add ourself to the render queue // we render late, since most of the ocean will be rendered over by terrain, and // we will benefit from early out in the pixel shader due to z-test queue.AddRenderable(this, 1, RenderQueueGroupID.Nine); }
public override void UpdateRenderQueue(RenderQueue queue) { if ( isVisible ) { if (tile.Hilight) { material = tile.HilightMaterial; } else { material = normalMaterial; } if ( renderOp.vertexData == null ) { // the object is visible so we had better make sure it has vertex and index buffers renderOp.vertexData = buildVertexData(); renderOp.indexData = IndexBufferManager.Instance.GetTileIndexBuffer(numSamples); } if ( WorldManager.Instance.DrawTiles ) { queue.AddRenderable( this ); } if ( stitchRenderable == null ) { tile.Stitch(); } if ( WorldManager.Instance.DrawStitches && ( stitchRenderable != null ) ) { queue.AddRenderable( stitchRenderable ); } } }
/// <summary> /// Internal method which locates any visible objects attached to this node and adds them to the passed in queue. /// </summary> /// <param name="camera">Active camera.</param> /// <param name="queue">Queue to which these objects should be added.</param> /// <param name="includeChildren">If true, cascades down to all children.</param> /// <param name="displayNodes">Renders the local axes for the node.</param> /// <param name="onlyShadowCasters"></param> public virtual void FindVisibleObjects( Camera camera, RenderQueue queue, bool includeChildren, bool displayNodes, bool onlyShadowCasters ) { // if we aren't visible, then quit now // TODO: Make sure sphere is calculated properly for all objects, then switch to cull using that if ( !camera.IsObjectVisible( worldAABB ) ) return; // add visible objects to the render queue //objectListMeter.Enter(); foreach ( MovableObject obj in objectList.Values ) { // tell attached object about current camera in case it wants to know //notifyCameraMeter.Enter(); obj.NotifyCurrentCamera( camera ); //notifyCameraMeter.Exit(); // if this object is visible, add it to the render queue if ( obj.IsVisible && ( !onlyShadowCasters || obj.CastShadows ) ) { //updateQueueMeter.Enter(); obj.UpdateRenderQueue( queue ); //updateQueueMeter.Exit(); } } //objectListMeter.Exit(); //childListMeter.Enter(); if ( includeChildren ) { // ask all child nodes to update the render queue with visible objects foreach ( SceneNode childNode in childNodes.Values ) { if ( childNode.IsVisible ) childNode.FindVisibleObjects( camera, queue, includeChildren, displayNodes, onlyShadowCasters ); } } //childListMeter.Exit(); // if we wanna display nodes themself.. if ( displayNodes ) { // hey, lets just add ourself right to the render queue queue.AddRenderable( GetDebugRenderable() ); } // do we wanna show our beautiful bounding box? // do it if either we want it, or the SceneManager dictates it if ( showBoundingBox || ( creator != null && creator.ShowBoundingBoxes ) ) { AddBoundingBoxToQueue( queue ); } }
public override void UpdateRenderQueue(RenderQueue queue) { if (isVisible) { if (TerrainManager.Instance.DrawTerrain) { if (renderOp.vertexData == null) { // the object is visible so we had better make sure it has vertex and index buffers buildVertexData(); } // put terrain in its own render queue for easier profiling queue.AddRenderable(this, RenderQueue.DEFAULT_PRIORITY, RenderQueueGroupID.Main); } } }
/// <summary> /// Adds this nodes bounding box (wireframe) to the RenderQueue. /// </summary> /// <param name="queue"></param> public void AddBoundingBoxToQueue( RenderQueue queue ) { if ( wireBox == null ) wireBox = new WireBoundingBox(); // add the wire bounding box to the render queue wireBox.BoundingBox = worldAABB; queue.AddRenderable( wireBox ); }
/// <summary> /// /// </summary> /// <param name="queue"></param> public override void UpdateRenderQueue(RenderQueue queue) { // add ourself to the render queue queue.AddRenderable(this, RenderQueueGroup); }
public void AddRenderables( RenderQueue queue, RenderQueueGroupID group, Real lodValue ) { // Get batch instance #warning OGRE-1.6 BatchInstance Implementation //BatchInstance batchInstance = Parent.Parent; // Get material lod strategy var materialLodStrategy = Material.LodStrategy; // If material strategy doesn't match, recompute lod value with correct strategy #warning OGRE-1.6 BatchInstance Implementation needed //if ( materialLodStrategy != batchInstance.LodStrategy ) // lodValue = materialLodStrategy.GetValue( batchInstance, batchInstance.Camera ); // determine the current material technique this.technique = this.material.GetBestTechnique( this.material.GetLodIndex( lodValue ) ); foreach ( var gbucket in this.geometryBucketList ) { queue.AddRenderable( gbucket, RenderQueue.DEFAULT_PRIORITY, group ); } }
/// <summary> /// Internal method to put the contents onto the render queue. /// </summary> /// <param name="queue">Current render queue.</param> public virtual void UpdateRenderQueue( RenderQueue queue ) { if ( isVisible ) { queue.AddRenderable( this, (ushort)zOrder, RenderQueueGroupID.Overlay ); } }
public override void UpdateRenderQueue( RenderQueue queue ) { queue.AddRenderable( this ); }
/// <summary> /// /// </summary> /// <param name="queue"></param> public override void UpdateRenderQueue( RenderQueue queue ) { // Manual LOD sub entities if ( this.meshLodIndex > 0 && this.mesh.IsLodManual ) { Debug.Assert( this.meshLodIndex - 1 < this.lodEntityList.Count, "No LOD EntityList - did you build the manual LODs after creating the entity?" ); var lodEnt = this.lodEntityList[ this.meshLodIndex - 1 ]; // index - 1 as we skip index 0 (original LOD) if ( HasSkeleton && lodEnt.HasSkeleton ) { // Copy the animation state set to lod entity, we assume the lod // entity only has a subset animation states CopyAnimationStateSubset( lodEnt.animationState, this.animationState ); } lodEnt.UpdateRenderQueue( queue ); return; } // add all visible sub entities to the render queue foreach ( var se in this.subEntityList ) { if ( se.IsVisible ) { queue.AddRenderable( se, RenderQueue.DEFAULT_PRIORITY, renderQueueID ); } } // Since we know we're going to be rendered, take this opportunity to // update the animation if ( HasSkeleton || this.mesh.HasVertexAnimation ) { UpdateAnimation(); // Update render queue with child objects (tag points) foreach ( var child in this.childObjectList.Values ) { if ( child.IsVisible ) { child.UpdateRenderQueue( queue ); } } } }
/// <summary> /// /// </summary> /// <param name="queue"></param> public override void UpdateRenderQueue(RenderQueue queue) { // add ourself to the render queue queue.AddRenderable(this); }