public static LightList <int> Tessellate(LightList <float> data, LightList <int> holeIndices, LightList <int> output = null) { bool hasHoles = holeIndices != null && holeIndices.Count > 0; int outerLen = hasHoles ? holeIndices[0] * 2 : data.Count; Node outerNode = LinkedList(data, 0, outerLen, true); output = output ?? new LightList <int>(data.Count / 2); if (outerNode == null) { return(output); } var minX = float.PositiveInfinity; var minY = float.PositiveInfinity; var maxX = float.NegativeInfinity; var maxY = float.NegativeInfinity; var invSize = default(float); if (hasHoles) { outerNode = EliminateHoles(data, holeIndices, outerNode); } // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox if (data.Count > 80 * 2) { for (int i = 0; i < outerLen; i += 2) { float x = data[i]; float y = data[i + 1]; if (x < minX) { minX = x; } if (y < minY) { minY = y; } if (x > maxX) { maxX = x; } if (y > maxY) { maxY = y; } } // minX, minY and invSize are later used to transform coords into integers for z-order calculation invSize = Math.Max(maxX - minX, maxY - minY); invSize = invSize != 0 ? 1 / invSize : 0; } EarcutLinked(outerNode, output, minX, minY, invSize, 0); return(output); }
private bool ParseDeclaration(ref ASTNode node) { AttributeNode attrNode = null; LightList <AttributeNode> attributes = LightList <AttributeNode> .Get(); while (ParseAttribute(ref attrNode)) { attributes.Add(attrNode); if (tokenStream.Current != ExpressionTokenType.ArrayAccessOpen) { break; } } if (attributes.size == 0) { LightList <AttributeNode> .Release(ref attributes); } if (tokenStream.Current != ExpressionTokenType.Identifier) { return(false); } // modifiers? -> returnType -> name -> signature -> openBrace * closeBrace tokenStream.Save(); bool isStatic = false; if (tokenStream.Current == "static") { isStatic = true; tokenStream.Advance(); } ExpressionParser parser = new ExpressionParser(tokenStream); StructList <LambdaArgument> signature = null; TypeLookup typeLookup = default; if (!parser.ParseTypePath(ref typeLookup)) { goto fail; } tokenStream.Set(parser.GetTokenPosition()); parser.Release(false); if (tokenStream.Current != ExpressionTokenType.Identifier) { goto fail; } string name = tokenStream.Current.value; tokenStream.Advance(); // if semi colon then we have a field! if (tokenStream.Current == ExpressionTokenType.SemiColon) { tokenStream.Advance(); node = new FieldNode() { name = name, isStatic = isStatic, attributes = attributes, typeLookup = typeLookup }; return(true); } if (tokenStream.Current != ExpressionTokenType.ParenOpen) { goto fail; } signature = StructList <LambdaArgument> .Get(); if (tokenStream.NextTokenIs(ExpressionTokenType.ParenClose)) { tokenStream.Advance(2); } else { int matchingIndex = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose); if (matchingIndex == -1) { goto fail; } TokenStream subStream = tokenStream.AdvanceAndReturnSubStream(matchingIndex); subStream.Advance(); tokenStream.Advance(); if (!ExpressionParser.ParseSignature(subStream, signature)) { goto fail; } for (int i = 0; i < signature.size; i++) { if (signature.array[i].type == null) { throw new ParseException($"When defining a method you must specify a type for all arguments. Found identifier {signature.array[i].identifier} but no type was given."); } } } if (tokenStream.Current != ExpressionTokenType.ExpressionOpen) { goto fail; } BlockNode block = ParseBlock(); node = new MethodNode() { body = block, returnTypeLookup = typeLookup, attributes = attributes, name = name, isStatic = isStatic, signatureList = signature != null?signature.ToArray() : s_EmptySignature }; StructList <LambdaArgument> .Release(ref signature); parser.Release(false); return(true); fail: { tokenStream.Restore(); parser.Release(false); typeLookup.Release(); signature?.Release(); return(false); } }
/// <summary> /// Render those objects in the transparent pass list which have shadow casting forced on /// </summary> /// <remarks> /// This function is intended to be used to render the shadows of transparent objects which have /// transparency_casts_shadows set to 'on' in their material /// </remarks> /// <param name="list"></param> /// <param name="doLightIteration"></param> /// <param name="manualLightList"></param> protected virtual void RenderTransparentShadowCasterObjects( List<RenderablePass> list, bool doLightIteration, LightList manualLightList ) { // ----- TRANSPARENT LOOP as in RenderTransparentObjects, but changed a bit ----- for ( int i = 0; i < list.Count; i++ ) { RenderablePass rp = list[ i ]; // only render this pass if it's being forced to cast shadows if ( rp.pass.Parent.Parent.TransparencyCastsShadows ) { this.SetPass( rp.pass ); this.RenderSingleObject( rp.renderable, rp.pass, doLightIteration, manualLightList ); } } }
public void AddKeyFrameNode(KeyFrameNode keyFrameNode) { keyframeNodes = keyframeNodes ?? new LightList <KeyFrameNode>(4); keyframeNodes.Add(keyFrameNode); }
/// <summary> /// Overriden from SceneManager. /// </summary> protected override void RenderSingleObject( IRenderable renderable, Pass pass, bool doLightIteration, LightList manualLightList ) { if ( renderable is BspGeometry ) { // Render static level geometry if ( doLightIteration ) { // render all geometry without lights first RenderStaticGeometry(); // render geometry affected by each visible light foreach ( Light l in lightsAffectingFrustum ) { RenderTextureLighting( l ); } } else { if ( manualLightList.Count == 0 ) { if ( illuminationStage == IlluminationRenderStage.RenderReceiverPass ) { // texture shadows RenderTextureShadowOnGeometry(); } else { // ambient stencil pass, render geometry without lights RenderStaticGeometry(); } } else { // render only geometry affected by the provided light foreach ( Light l in manualLightList ) { RenderTextureLighting( l ); } } } } else { base.RenderSingleObject( renderable, pass, doLightIteration, manualLightList ); } }
/// <summary> /// Renders a set of solid objects. /// </summary> protected virtual void RenderSolidObjects( System.Collections.SortedList list, bool doLightIteration, LightList manualLightList ) { // ----- SOLIDS LOOP ----- for ( int i = 0; i < list.Count; i++ ) { RenderableList renderables = (RenderableList)list.GetByIndex( i ); // bypass if this group is empty if ( renderables.Count == 0 ) { continue; } Pass pass = (Pass)list.GetKey( i ); // Give SM a chance to eliminate this pass if ( !this.ValidatePassForRendering( pass ) ) { continue; } // For solids, we try to do each pass in turn Pass usedPass = this.SetPass( pass ); // render each object associated with this rendering pass for ( int r = 0; r < renderables.Count; r++ ) { IRenderable renderable = (IRenderable)renderables[ r ]; // Give SM a chance to eliminate if ( !this.ValidateRenderableForRendering( usedPass, renderable ) ) { continue; } // Render a single object, this will set up auto params if required this.RenderSingleObject( renderable, usedPass, doLightIteration, manualLightList ); } } }
public abstract void OnChildrenChanged(LightList <AwesomeLayoutBox> childList);
/// <summary> /// /// </summary> public void SetCurrentLightList( LightList lightList ) { currentLightList = lightList; }
public static CompiledTemplateData LoadRuntimeTemplates(Type type, TemplateSettings templateSettings) { CompiledTemplateData compiledTemplateData = TemplateCompiler.CompileTemplates(type, templateSettings); // Stopwatch stopwatch = Stopwatch.StartNew(); Func <UIElement, TemplateScope, UIElement>[] templates = new Func <UIElement, TemplateScope, UIElement> [compiledTemplateData.compiledTemplates.size]; Action <UIElement, UIElement>[] bindings = new Action <UIElement, UIElement> [compiledTemplateData.compiledBindings.size]; Func <UIElement, UIElement, TemplateScope, UIElement>[] slots = new Func <UIElement, UIElement, TemplateScope, UIElement> [compiledTemplateData.compiledSlots.size]; TemplateMetaData[] templateMetaData = new TemplateMetaData[compiledTemplateData.compiledTemplates.size]; OrderablePartitioner <Tuple <int, int> > partition; if (templateMetaData.Length < 10) { for (int i = 0; i < templateMetaData.Length; i++) { templates[i] = (Func <UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledTemplates[i].templateFn.Compile(); } } else { partition = Partitioner.Create(0, templateMetaData.Length); Parallel.ForEach(partition, (range, loopState) => { for (int i = range.Item1; i < range.Item2; i++) { templates[i] = (Func <UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledTemplates[i].templateFn.Compile(); } }); } if (compiledTemplateData.compiledSlots.size < 10) { for (int i = 0; i < compiledTemplateData.compiledSlots.size; i++) { slots[i] = (Func <UIElement, UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledSlots[i].templateFn.Compile(); } } else { partition = Partitioner.Create(0, compiledTemplateData.compiledSlots.size); Parallel.ForEach(partition, (range, loopState) => { for (int i = range.Item1; i < range.Item2; i++) { slots[i] = (Func <UIElement, UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledSlots[i].templateFn.Compile(); } }); } if (bindings.Length < 10) { for (int i = 0; i < bindings.Length; i++) { try { bindings[i] = (Action <UIElement, UIElement>)compiledTemplateData.compiledBindings[i].bindingFn.Compile(); } catch (Exception e) { Debug.Log("binding " + compiledTemplateData.compiledBindings[i].bindingFn.ToCSharpCode()); Debug.Log(e); } } } else { partition = Partitioner.Create(0, bindings.Length); Parallel.ForEach(partition, (range, loopState) => { for (int i = range.Item1; i < range.Item2; i++) { try { bindings[i] = (Action <UIElement, UIElement>)compiledTemplateData.compiledBindings[i].bindingFn.Compile(); } catch (Exception e) { Debug.Log("binding " + compiledTemplateData.compiledBindings[i].bindingFn.ToCSharpCode()); Debug.Log(e); } } }); } LightList <UIStyleGroupContainer> styleList = new LightList <UIStyleGroupContainer>(128); StyleSheet[] sheets = compiledTemplateData.styleImporter.GetImportedStyleSheets(); for (int i = 0; i < sheets.Length; i++) { StyleSheet sheet = sheets[i]; styleList.EnsureAdditionalCapacity(sheet.styleGroupContainers.Length); for (int j = 0; j < sheet.styleGroupContainers.Length; j++) { styleList.array[styleList.size++] = sheet.styleGroupContainers[j]; } } for (int i = 0; i < templateMetaData.Length; i++) { templateMetaData[i] = compiledTemplateData.compiledTemplates[i].templateMetaData; templateMetaData[i].styleMap = styleList.array; templateMetaData[i].BuildSearchMap(); } Dictionary <int, Func <ConstructedElement> > constructorFnMap = new Dictionary <int, Func <ConstructedElement> >(37); ConstructorInfo constructedTypeCtor = typeof(ConstructedElement).GetConstructor(new Type[] { typeof(int), typeof(UIElement) }); System.Diagnostics.Debug.Assert(constructedTypeCtor != null, nameof(constructedTypeCtor) + " != null"); compiledTemplateData.bindings = bindings; compiledTemplateData.slots = slots; compiledTemplateData.templates = templates; compiledTemplateData.templateMetaData = templateMetaData; compiledTemplateData.constructorFnMap = constructorFnMap; compiledTemplateData.constructElement = (typeId) => compiledTemplateData.constructorFnMap[typeId].Invoke(); // stopwatch.Stop(); // Debug.Log("Loaded UIForia templates in " + stopwatch.Elapsed.TotalSeconds.ToString("F2") + " seconds"); return(compiledTemplateData); }
public LinqBindingSystem() { this.rootNodes = new LightList <UIElement>(); }
public AnimationSystem() { thisFrame = new LightList <AnimationTask>(); nextFrame = new LightList <AnimationTask>(); }
public static MemberAccessExpressionNode MemberAccessExpressionNode(string identifier, LightList <ASTNode> parts) { MemberAccessExpressionNode accessExpressionNode = s_MemberAccessExpressionPool.Get(); accessExpressionNode.identifier = identifier; accessExpressionNode.parts = parts; return(accessExpressionNode); }
public ListRecordStore() { store = new LightList <T>(16); }
public UITaskGroup() { this.taskStatusPairs = new LightList <TaskStatusPair>(4); }
public override void OnChildrenChanged(LightList <AwesomeLayoutBox> childList) { this.childList = this.childList ?? new LightList <AwesomeLayoutBox>(childList.size); this.childList.AddRange(childList); }
public virtual void SetCurrentLightList( LightList lightList ) { this.currentLightList = lightList; for ( int i = 0; i < lightList.Count && i < Config.MaxSimultaneousLights; ++i ) { this.spotlightViewProjMatrixDirty[ i ] = true; this.spotlightWorldViewProjMatrixDirty[ i ] = true; } }
public StyleNodeContainer() { this.children = new LightList <StyleASTNode>(2); }
public override void UseLights( LightList lightList, int limit ) { var activeDevice = ActiveD3D9Device; var i = 0; // Axiom specific: [indexer] wont create an entry in the map if (!_currentLights.ContainsKey(activeDevice)) _currentLights.Add(activeDevice, 0); for ( ; i < limit && i < lightList.Count; i++ ) { SetD3D9Light( i, lightList[ i ] ); } for (; i < _currentLights[activeDevice]; i++) { SetD3D9Light( i, null ); } _currentLights[activeDevice] = Utility.Min(limit, lightList.Count); }
public StyleSheetCompiler(StyleSheetImporter styleSheetImporter, ResourceManager resourceManager) { this.styleSheetImporter = styleSheetImporter; this.resourceManager = resourceManager; this.scratchGroupList = new LightList <UIStyleGroup>(32); }
/// <summary> /// Render a single shadow volume to the stencil buffer. /// </summary> protected void RenderSingleShadowVolumeToStencil( ShadowRenderable sr, bool zfail, bool stencil2sided, LightList manualLightList, bool isSecondPass ) { // Render a shadow volume here // - if we have 2-sided stencil, one render with no culling // - otherwise, 2 renders, one with each culling method and invert the ops if ( !isSecondPass ) { this.SetShadowVolumeStencilState( false, zfail, stencil2sided ); this.RenderSingleObject( sr, this.shadowStencilPass, false, manualLightList ); } if ( !stencil2sided && isSecondPass ) { // Second pass this.SetShadowVolumeStencilState( true, zfail, false ); this.RenderSingleObject( sr, this.shadowStencilPass, false ); } // Do we need to render a debug shadow marker? if ( this.showDebugShadows && ( isSecondPass || stencil2sided ) ) { // reset stencil & colour ops this.targetRenderSystem.SetStencilBufferParams(); this.SetPass( this.shadowDebugPass ); this.RenderSingleObject( sr, this.shadowDebugPass, false, manualLightList ); this.targetRenderSystem.SetColorBufferWriteEnabled( false, false, false, false ); } }
private AnimationOptions CompileAnimationOptions(AnimationRootNode animNode) { AnimationOptions options = new AnimationOptions(); if (animNode.optionNodes == null) { return(options); } LightList <AnimationOptionNode> optionNodes = animNode.optionNodes; if (optionNodes == null) { return(options); } for (int i = 0; i < optionNodes.Count; i++) { string optionName = optionNodes[i].optionName.ToLower(); StyleASTNode value = optionNodes[i].value; switch (optionName) { case "duration": options.duration = StylePropertyMappers.MapUITimeMeasurement(value, context); break; case "iterations": options.iterations = (int)StylePropertyMappers.MapNumberOrInfinite(value, context); break; case "looptime": options.loopTime = StylePropertyMappers.MapNumber(value, context); break; case "delay": options.delay = StylePropertyMappers.MapUITimeMeasurement(value, context); break; case "direction": options.direction = StylePropertyMappers.MapEnum <AnimationDirection>(value, context); break; case "looptype": options.loopType = StylePropertyMappers.MapEnum <AnimationLoopType>(value, context); break; case "forwardstartdelay": options.forwardStartDelay = (int)StylePropertyMappers.MapNumber(value, context); break; case "reversestartdelay": options.reverseStartDelay = (int)StylePropertyMappers.MapNumber(value, context); break; case "timingfunction": options.timingFunction = StylePropertyMappers.MapEnum <EasingFunction>(value, context); break; default: throw new CompileException(optionNodes[i], "Invalid option argument for animation"); } } return(options); }
/// <summary> /// Render a group with the added complexity of additive stencil shadows. /// </summary> /// <param name="group">Render queue group.</param> protected virtual void RenderAdditiveStencilShadowedQueueGroupObjects( RenderQueueGroup group ) { LightList tempLightList = new LightList(); foreach ( RenderPriorityGroup priorityGroup in group.PriorityGroups.Values ) { // sort the group first priorityGroup.Sort( this.cameraInProgress ); // Clear light list tempLightList.Clear(); // Render all the ambient passes first, no light iteration, no lights this.illuminationStage = IlluminationRenderStage.Ambient; this.RenderSolidObjects( priorityGroup.solidPasses, false, tempLightList ); // Also render any objects which have receive shadows disabled this.renderingNoShadowQueue = true; this.RenderSolidObjects( priorityGroup.solidPassesNoShadow, true ); this.renderingNoShadowQueue = false; // Now iterate per light this.illuminationStage = IlluminationRenderStage.PerLight; foreach ( Light light in lightsAffectingFrustum ) { // Set light state if ( light.CastShadows ) { // Clear stencil this.targetRenderSystem.ClearFrameBuffer( FrameBufferType.Stencil ); this.RenderShadowVolumesToStencil( light, this.cameraInProgress ); // turn stencil check on this.targetRenderSystem.StencilCheckEnabled = true; // NB we render where the stencil is equal to zero to render lit areas this.targetRenderSystem.SetStencilBufferParams( CompareFunction.Equal, 0 ); } // render lighting passes for this light tempLightList.Clear(); tempLightList.Add( light ); this.RenderSolidObjects( priorityGroup.solidPassesDiffuseSpecular, false, tempLightList ); // Reset stencil params this.targetRenderSystem.SetStencilBufferParams(); this.targetRenderSystem.StencilCheckEnabled = false; this.targetRenderSystem.SetDepthBufferParams(); } // for each light // Now render decal passes, no need to set lights as lighting will be disabled this.illuminationStage = IlluminationRenderStage.Decal; this.RenderSolidObjects( priorityGroup.solidPassesDecal, false ); } // for each priority // reset lighting stage this.illuminationStage = IlluminationRenderStage.None; // Iterate again foreach ( RenderPriorityGroup priorityGroup in group.PriorityGroups.Values ) { // Do transparents this.RenderTransparentObjects( priorityGroup.transparentPasses, true ); } // for each priority }
// public StyleSheet Compile(string filePath, string contents) { // return Compile(filePath, StyleParser.Parse(contents)); // } // todo -- deprecate, use other method public StyleSheet Compile(string filePath, LightList <StyleASTNode> rootNodes, MaterialDatabase materialDatabase = default) { try { context = new StyleSheetConstantImporter(styleSheetImporter).CreateContext(rootNodes, materialDatabase); context.resourceManager = resourceManager; // context = new StyleCompileContext(); // todo resolve constants. should be done a per file level, should store all used constants without needing to later reference other files // StyleCompileContext.Create(styleSheetImporter) //new StyleSheetConstantImporter(styleSheetImporter).CreateContext(rootNodes); } catch (CompileException e) { e.SetFileName(filePath); throw; } context.fileName = filePath; // todo add imported style groups rootNodes.Sort((node1, node2) => { int left = (int)node1.type; int right = (int)node2.type; return(left - right); }); int containerCount = 0; int animationCount = 0; int soundCount = 0; for (int index = 0; index < rootNodes.Count; index++) { switch (rootNodes[index]) { case StyleRootNode _: containerCount++; break; case AnimationRootNode _: case SpriteSheetNode _: animationCount++; break; case SoundRootNode _: soundCount++; break; } } StyleSheet styleSheet = new StyleSheet( styleSheetImporter.ImportedStyleSheetCount, context.constants?.ToArray(), containerCount > 0 ? new UIStyleGroupContainer[containerCount] : ArrayPool <UIStyleGroupContainer> .Empty, animationCount > 0 ? new AnimationData[animationCount] : ArrayPool <AnimationData> .Empty, soundCount > 0 ? new UISoundData[soundCount] : ArrayPool <UISoundData> .Empty ); int containerIndex = 0; int animationIndex = 0; int soundIndex = 0; for (int index = 0; index < rootNodes.Count; index++) { switch (rootNodes[index]) { // we sorted the root nodes so all animations run first case SpriteSheetNode spriteSheetNode: styleSheet.animations[animationIndex] = CompileSpriteSheetAnimation(spriteSheetNode, styleSheet.animations, styleSheet.sounds); animationIndex++; break; case AnimationRootNode animNode: styleSheet.animations[animationIndex] = CompileAnimation(animNode, styleSheet.animations, styleSheet.sounds); animationIndex++; break; case SoundRootNode soundRootNode: styleSheet.sounds[soundIndex] = CompileSound(soundRootNode); soundIndex++; break; case StyleRootNode styleRoot: styleSheet.styleGroupContainers[containerIndex] = CompileStyleGroup(styleRoot, styleSheet.animations, styleSheet.sounds); styleSheet.styleGroupContainers[containerIndex].styleSheet = styleSheet; containerIndex++; break; } } context.Release(); return(styleSheet); }
/// <summary> /// Overriden from SceneManager. /// </summary> /// <param name="position">The position at which to evaluate the list of lights</param> /// <param name="radius">The bounding radius to test</param> /// <param name="destList">List to be populated with ordered set of lights; will be cleared by this method before population.</param> protected override void PopulateLightList(Vector3 position, float radius, LightList destList) { BspNode positionNode = level.FindLeaf(position); BspNode[] lightNodes = new BspNode[lightList.Count]; for (int i = 0; i < lightList.Count; i++) { Light light = lightList[i]; lightNodes[i] = (BspNode) level.objectToNodeMap.FindFirst(light); } // Trawl of the lights that are visible from position, then sort destList.Clear(); float squaredRadius = radius * radius; // loop through the scene lights an add ones in range and visible from positionNode for(int i = 0; i < lightList.Count; i++) { TextureLight light = (TextureLight) lightList[i]; if(light.IsVisible && level.IsLeafVisible(positionNode, lightNodes[i])) { if(light.Type == LightType.Directional) { // no distance light.TempSquaredDist = 0.0f; destList.Add(light); } else { light.TempSquaredDist = (light.DerivedPosition - position).LengthSquared; light.TempSquaredDist -= squaredRadius; // only add in-range lights float range = light.AttenuationRange; if(light.TempSquaredDist <= (range * range)) { destList.Add(light); } } } // if } // for // Sort Destination light list. // TODO: Not needed yet since the current LightList is a sorted list under the hood already //destList.Sort(); }
private AnimationOptions CompileSpriteSheetOptions(SpriteSheetNode node) { AnimationOptions options = new AnimationOptions(); LightList <StyleASTNode> spriteSheetProperties = node.children; if (spriteSheetProperties == null) { return(options); } for (int i = 0; i < spriteSheetProperties.Count; i++) { if (spriteSheetProperties[i] is PropertyNode property) { string optionName = property.identifier.ToLower(); StyleASTNode value = property.children[0]; switch (optionName) { case "iterations": options.iterations = (int)StylePropertyMappers.MapNumberOrInfinite(value, context); break; case "delay": options.delay = StylePropertyMappers.MapUITimeMeasurement(value, context); break; case "duration": options.duration = StylePropertyMappers.MapUITimeMeasurement(value, context); break; case "looptype": options.loopType = StylePropertyMappers.MapEnum <AnimationLoopType>(value, context); break; case "direction": options.direction = StylePropertyMappers.MapEnum <AnimationDirection>(value, context); break; case "forwardstartdelay": options.forwardStartDelay = (int)StylePropertyMappers.MapNumber(value, context); break; case "reversestartdelay": options.reverseStartDelay = (int)StylePropertyMappers.MapNumber(value, context); break; case "fps": options.fps = (int)StylePropertyMappers.MapNumber(value, context); break; case "startframe": options.startFrame = (int)StylePropertyMappers.MapNumber(value, context); break; case "endframe": options.endFrame = (int)StylePropertyMappers.MapNumber(value, context); break; case "pathprefix": options.pathPrefix = StylePropertyMappers.MapString(value, context); break; default: throw new CompileException(property, "Invalid option argument for animation"); } } else { throw new CompileException(spriteSheetProperties[i], "Invalid option argument for animation"); } } return(options); }
public abstract void Filter(UIElement origin, int templateId, LightList <UIElement> resultSet);
private void CompileStyleGroups(StyleNodeContainer root, StyleType styleType, LightList <UIStyleGroup> groups, UIStyleGroup targetGroup, AnimationData[] styleSheetAnimations, UISoundData[] uiSoundData) { for (int index = 0; index < root.children.Count; index++) { StyleASTNode node = root.children[index]; switch (node) { case SelectNode selectNode: break; case PropertyNode propertyNode: // add to normal ui style set StylePropertyMappers.MapProperty(targetGroup.normal.style, propertyNode, context); break; case AttributeNodeContainer attribute: if (root is AttributeNodeContainer) { throw new CompileException(attribute, "You cannot nest attribute group definitions."); } UIStyleGroup attributeGroup = new UIStyleGroup(); attributeGroup.normal = UIStyleRunCommand.CreateInstance(); attributeGroup.name = root.identifier; attributeGroup.rule = MapAttributeContainerToRule(attribute); attributeGroup.styleType = styleType; groups.Add(attributeGroup); CompileStyleGroups(attribute, styleType, groups, attributeGroup, styleSheetAnimations, uiSoundData); break; case RunNode runNode: UIStyleRunCommand cmd = new UIStyleRunCommand() { style = targetGroup.normal.style, runCommands = targetGroup.normal.runCommands ?? new LightList <IRunCommand>(4) }; if (runNode.command is AnimationCommandNode animationCommandNode) { MapAnimationCommand(styleSheetAnimations, cmd, animationCommandNode); } else if (runNode.command is SoundCommandNode soundCommandNode) { MapSoundCommand(uiSoundData, cmd, soundCommandNode); } targetGroup.normal = cmd; break; case StyleStateContainer styleContainer: if (styleContainer.identifier == "hover") { UIStyleRunCommand uiStyleRunCommand = targetGroup.hover; uiStyleRunCommand.style = uiStyleRunCommand.style ?? new UIStyle(); MapProperties(styleSheetAnimations, uiSoundData, ref uiStyleRunCommand, styleContainer.children); targetGroup.hover = uiStyleRunCommand; } else if (styleContainer.identifier == "focus") { UIStyleRunCommand uiStyleRunCommand = targetGroup.focused; uiStyleRunCommand.style = uiStyleRunCommand.style ?? new UIStyle(); MapProperties(styleSheetAnimations, uiSoundData, ref uiStyleRunCommand, styleContainer.children); targetGroup.focused = uiStyleRunCommand; } else if (styleContainer.identifier == "active") { UIStyleRunCommand uiStyleRunCommand = targetGroup.active; uiStyleRunCommand.style = uiStyleRunCommand.style ?? new UIStyle(); MapProperties(styleSheetAnimations, uiSoundData, ref uiStyleRunCommand, styleContainer.children); targetGroup.active = uiStyleRunCommand; } else { throw new CompileException(styleContainer, $"Unknown style state '{styleContainer.identifier}'. Please use [hover], [focus] or [active] instead."); } break; default: throw new CompileException(node, $"You cannot have a {node} at this level."); } } }
private bool ParseIfStatement(ref ASTNode node) { if (tokenStream.Current != ExpressionTokenType.If) { return(false); } LightList <ElseIfNode> statements = LightList <ElseIfNode> .Get(); tokenStream.Advance(); ASTNode condition = null; if (!ParseParenExpression(ref condition)) { throw new ParseException("Expected a condition statement wrapped in parentheses but failed."); } BlockNode thenBlock = ParseBlock(); if (thenBlock == null) { throw new ParseException("Expected a block statement following an if statement but failed to parse the block"); } if (tokenStream.Current != ExpressionTokenType.ElseIf && tokenStream.Current != ExpressionTokenType.Else) { node = new IfStatementNode() { // elseIfStatements = statements.ToArray(), condition = condition, thenBlock = thenBlock }; return(true); } while (tokenStream.Current == ExpressionTokenType.ElseIf) { tokenStream.Advance(); ASTNode elseIfCondition = null; if (!ParseParenExpression(ref elseIfCondition)) { throw new ParseException("Expected a condition statement wrapped in parentheses but failed."); } BlockNode block = ParseBlock(); if (block == null) { throw new ParseException("Expected a block statement following an if statement but failed to parse the block"); } statements.Add(new ElseIfNode() { condition = elseIfCondition, thenBlock = block }); } BlockNode elseBlock = null; if (tokenStream.Current == ExpressionTokenType.Else) { tokenStream.Advance(); elseBlock = ParseBlock(); if (elseBlock == null) { throw new ParseException("Expected a block statement following an else statement but failed to parse the block"); } } node = new IfStatementNode() { condition = condition, thenBlock = thenBlock, elseIfStatements = statements.size == 0 ? null : statements.ToArray(), elseBlock = elseBlock }; statements.Release(); return(true); }
public RoutingSystem() { this.m_Routers = new LightList <Router>(); }
internal Enumerator(LightList <T> list) { this.list = list; this.index = 0; this.current = default(T); }
public void PushBlock() { statementStacks.Push(LightList <Expression> .Get()); }
private static Type ResolveBaseTypePath(TypeLookup typeLookup, IReadOnlyList <string> namespaces) { Type retn = ResolveSimpleType(typeLookup.typeName); if (retn != null) { return(retn); } string baseTypeName = "." + typeLookup.GetBaseTypeName(); // save some string concat if (!string.IsNullOrEmpty(typeLookup.namespaceName)) { LightList <Assembly> assemblies = s_NamespaceMap.GetOrDefault(typeLookup.namespaceName); if (assemblies == null) { throw new TypeResolutionException($"No loaded assemblies found for namespace {typeLookup.namespaceName}"); } string typename = typeLookup.namespaceName + baseTypeName; for (int a = 0; a < assemblies.Count; a++) { retn = assemblies[a].GetType(typename); if (retn != null) { return(retn); } } LightList <Assembly> lastDitchAssemblies = s_NamespaceMap.GetOrDefault("null"); if (lastDitchAssemblies != null) { typename = typeLookup.typeName; for (int a = 0; a < lastDitchAssemblies.Count; a++) { retn = lastDitchAssemblies[a].GetType(typename); if (retn != null) { return(retn); } } } } else { if (namespaces != null) { for (int i = 0; i < namespaces.Count; i++) { LightList <Assembly> assemblies = s_NamespaceMap.GetOrDefault(namespaces[i]); if (assemblies == null) { continue; } string typename = namespaces[i] + baseTypeName; for (int a = 0; a < assemblies.Count; a++) { retn = assemblies[a].GetType(typename); if (retn != null) { return(retn); } } } } LightList <Assembly> lastDitchAssemblies = s_NamespaceMap.GetOrDefault("null"); if (lastDitchAssemblies != null) { string typename = typeLookup.typeName; for (int a = 0; a < lastDitchAssemblies.Count; a++) { retn = lastDitchAssemblies[a].GetType(typename); if (retn != null) { return(retn); } } } } if (namespaces != null && namespaces.Count > 0 && namespaces[0] != string.Empty) { string checkedNamespaces = string.Join(",", namespaces.ToArray()); throw new TypeResolutionException($"Unable to resolve type {typeLookup}. Looked in namespaces: {checkedNamespaces}"); } else { throw new TypeResolutionException($"Unable to resolve type {typeLookup}."); } }
/// <summary> /// /// </summary> /// <param name="lightList"></param> /// <param name="limit"></param> public override void UseLights(LightList lightList, int limit) { // save previous modelview matrix Gl.glMatrixMode(Gl.GL_MODELVIEW); Gl.glPushMatrix(); // load the view matrix MakeGLMatrix(ref viewMatrix, tempMatrix); Gl.glLoadMatrixf(tempMatrix); int i = 0; for( ; i < limit && i < lightList.Count; i++) { SetGLLight(i, lightList[i]); lights[i] = lightList[i]; } for( ; i < numCurrentLights; i++) { SetGLLight(i, null); lights[i] = null; } numCurrentLights = (int)MathUtil.Min(limit, lightList.Count); SetLights(); // restore the previous matrix Gl.glPopMatrix(); }
public override void UseLights( LightList lightList, int limit ) { // save previous modelview matrix Gl.glMatrixMode( Gl.GL_MODELVIEW ); Gl.glPushMatrix(); // load the view matrix MakeGLMatrix( ref viewMatrix, _tempMatrix ); Gl.glLoadMatrixf( _tempMatrix ); var i = 0; for ( ; i < limit && i < lightList.Count; i++ ) { SetGLLight( i, lightList[ i ] ); lights[ i ] = lightList[ i ]; } // Disable extra lights for ( ; i < _currentLights; i++ ) { SetGLLight( i, null ); lights[ i ] = null; } _currentLights = Utility.Min( limit, lightList.Count ); SetLights(); // restore the previous matrix Gl.glPopMatrix(); }
public void AddBinding(CompiledBinding binding) { bindings = bindings ?? new LightList <CompiledBinding>(); bindings.Add(binding); }
/// <summary> /// Tells the rendersystem to use the attached set of lights (and no others) /// up to the number specified (this allows the same list to be used with different /// count limits). /// </summary> /// <param name="lightList">List of lights.</param> /// <param name="limit">Max number of lights that can be used from the list currently.</param> public override void UseLights(LightList lights, int limit) { var currentLightCount = lights.Count < limit ? lights.Count : limit; var lightList = new List<Light>(); #if AXIOM_FF_EMULATION _fixedFunctionState.GeneralFixedFunctionState.ResetLightTypeCounts(); for ( int index = 0; index < currentLightCount; index++ ) { Light light = lights[ index ]; lightList.Add( light ); _fixedFunctionState.GeneralFixedFunctionState.IncrementLightTypeCount( light.Type ); } _ffProgramParameters.Lights = lightList; #endif }
public void AddSlot(CompiledSlot slot) { slots = slots ?? new LightList <CompiledSlot>(); slots.Add(slot); }
public VMDFormat(BinaryReader bin, string path, string clip_name) { // 読み込み失敗した場合はだいたいデータがない // 失敗しても読み込み続けることがあるので例外でキャッチして残りはnullにしておく try { this.clip_name = clip_name; this.header = new MMD.VMD.VMDFormat.Header(bin); read_count++; this.motion_list = new MMD.VMD.VMDFormat.MotionList(bin); read_count++; this.skin_list = new MMD.VMD.VMDFormat.SkinList(bin); read_count++; this.camera_list = new MMD.VMD.VMDFormat.CameraList(bin); read_count++; this.light_list = new MMD.VMD.VMDFormat.LightList(bin); read_count++; this.self_shadow_list = new MMD.VMD.VMDFormat.SelfShadowList(bin); read_count++; } catch (EndOfStreamException e) { Debug.Log(e.Message); if (read_count <= 0) this.header = null; if (read_count <= 1 || this.motion_list.motion_count <= 0) this.motion_list = null; if (read_count <= 2 || this.skin_list.skin_count <= 0) this.skin_list = null; if (read_count <= 3 || this.camera_list.camera_count <= 0) this.camera_list = null; if (read_count <= 4 || this.light_list.light_count <= 0) this.light_list = null; if (read_count <= 5 || this.self_shadow_list.self_shadow_count <= 0) this.self_shadow_list = null; } }
public override void OnChildrenChanged(LightList <AwesomeLayoutBox> childList) { }
private void CheckShadowCasters( IList casters, PlaneBoundedVolume nearClipVol, Light light, bool extrudeInSoftware, bool finiteExtrude, bool zfailAlgo, Camera camera, float extrudeDistance, bool stencil2sided, LightList tmpLightList ) { int flags; for ( int i = 0; i < casters.Count; i++ ) { ShadowCaster caster = (ShadowCaster)casters[ i ]; if ( nearClipVol.Intersects( caster.GetWorldBoundingBox() ) ) { // We have a zfail case, we must use zfail for all objects zfailAlgo = true; break; } } for ( int ci = 0; ci < casters.Count; ci++ ) { ShadowCaster caster = (ShadowCaster)casters[ ci ]; flags = 0; if ( light.Type != LightType.Directional ) { extrudeDistance = caster.GetPointExtrusionDistance( light ); } if ( !extrudeInSoftware && !finiteExtrude ) { // hardware extrusion, to infinity (and beyond!) flags |= (int)ShadowRenderableFlags.ExtrudeToInfinity; } if ( zfailAlgo ) { // We need to include the light and / or dark cap // But only if they will be visible if ( camera.IsObjectVisible( caster.GetLightCapBounds() ) ) { flags |= (int)ShadowRenderableFlags.IncludeLightCap; } } // Dark cap (no dark cap for directional lights using // hardware extrusion to infinity) if ( !( ( flags & (int)ShadowRenderableFlags.ExtrudeToInfinity ) != 0 && light.Type == LightType.Directional ) && camera.IsObjectVisible( caster.GetDarkCapBounds( light, extrudeDistance ) ) ) { flags |= (int)ShadowRenderableFlags.IncludeDarkCap; } // get shadow renderables IEnumerator renderables = caster.GetShadowVolumeRenderableEnumerator( this.shadowTechnique, light, this.shadowIndexBuffer, extrudeInSoftware, extrudeDistance, flags ); // If using one-sided stencil, render the first pass of all shadow // renderables before all the second passes for ( int i = 0; i < ( stencil2sided ? 1 : 2 ); i++ ) { if ( i == 1 ) { renderables = caster.GetLastShadowVolumeRenderableEnumerator(); } while ( renderables.MoveNext() ) { ShadowRenderable sr = (ShadowRenderable)renderables.Current; // omit hidden renderables if ( sr.IsVisible ) { // render volume, including dark and (maybe) light caps this.RenderSingleShadowVolumeToStencil( sr, zfailAlgo, stencil2sided, tmpLightList, ( i > 0 ) ); // optionally render separate light cap if ( sr.IsLightCapSeperate && ( ( flags & (int)ShadowRenderableFlags.IncludeLightCap ) ) > 0 ) { // must always fail depth check this.targetRenderSystem.DepthBufferFunction = CompareFunction.AlwaysFail; Debug.Assert( sr.LightCapRenderable != null, "Shadow renderable is missing a separate light cap renderable!" ); this.RenderSingleShadowVolumeToStencil( sr.LightCapRenderable, zfailAlgo, stencil2sided, tmpLightList, ( i > 0 ) ); // reset depth function this.targetRenderSystem.DepthBufferFunction = CompareFunction.Less; } } } } } }
public void SetElements(LightList <UIElement> elements) { this.elements.AddRange(elements); size = elements.size; }
/// <summary> /// Internal utility method for rendering a single object. /// </summary> /// <param name="renderable">The renderable to issue to the pipeline.</param> /// <param name="pass">The pass which is being used.</param> /// <param name="doLightIteration">If true, this method will issue the renderable to /// the pipeline possibly multiple times, if the pass indicates it should be /// done once per light.</param> /// <param name="manualLightList">Only applicable if 'doLightIteration' is false, this /// method allows you to pass in a previously determined set of lights /// which will be used for a single render of this object.</param> protected virtual void RenderSingleObject( IRenderable renderable, Pass pass, bool doLightIteration, LightList manualLightList ) { ushort numMatrices = 0; // grab the current scene detail level PolygonMode camPolyMode = this.cameraInProgress.PolygonMode; // get the world matrices and the count renderable.GetWorldTransforms( this.xform ); numMatrices = renderable.NumWorldTransforms; // set the world matrices in the render system if ( numMatrices > 1 ) { this.targetRenderSystem.SetWorldMatrices( this.xform, numMatrices ); } else { this.targetRenderSystem.WorldMatrix = this.xform[ 0 ]; } // issue view/projection changes (if any) this.UseRenderableViewProjection( renderable ); if ( !this.suppressRenderStateChanges ) { bool passSurfaceAndLightParams = true; if ( pass.IsProgrammable ) { // Tell auto params object about the renderable change this.autoParamDataSource.Renderable = renderable; pass.UpdateAutoParamsNoLights( this.autoParamDataSource ); if ( pass.HasVertexProgram ) { passSurfaceAndLightParams = pass.VertexProgram.PassSurfaceAndLightStates; } } // issue texture units that depend on updated view matrix // reflective env mapping is one case for ( int i = 0; i < pass.TextureUnitStageCount; i++ ) { TextureUnitState texUnit = pass.GetTextureUnitState( i ); if ( texUnit.HasViewRelativeTexCoordGen ) { targetRenderSystem.SetTextureUnitSettings( i, texUnit ); //this.targetRenderSystem.SetTextureUnit( i, texUnit, !pass.HasFragmentProgram ); } } // Normalize normals bool thisNormalize = renderable.NormalizeNormals; if ( thisNormalize != normalizeNormals ) { this.targetRenderSystem.NormalizeNormals = thisNormalize; normalizeNormals = thisNormalize; } // Set up the solid / wireframe override PolygonMode requestedMode = pass.PolygonMode; if ( renderable.PolygonModeOverrideable == true ) { // check camera detial only when render detail is overridable if ( requestedMode > camPolyMode ) { // only downgrade detail; if cam says wireframe we don't go up to solid requestedMode = camPolyMode; } } if ( requestedMode != this.lastPolyMode ) { this.targetRenderSystem.PolygonMode = requestedMode; this.lastPolyMode = requestedMode; } // TODO: Add ClipPlanes to RenderSystem.cs // This is removed in OGRE 1.6.0... no need to port - J. Price //targetRenderSystem.ClipPlanes = renderable.ClipPlanes; // get the renderables render operation op = renderable.RenderOperation; // TODO: Add srcRenderable to RenderOperation.cs //op.srcRenderable = renderable; if ( doLightIteration ) { // Here's where we issue the rendering operation to the render system // Note that we may do this once per light, therefore it's in a loop // and the light parameters are updated once per traversal through the // loop LightList rendLightList = renderable.Lights; bool iteratePerLight = pass.IteratePerLight; int numIterations = iteratePerLight ? rendLightList.Count : 1; LightList lightListToUse = null; for ( int i = 0; i < numIterations; i++ ) { // determine light list to use if ( iteratePerLight ) { localLightList.Clear(); // check whether we need to filter this one out if ( pass.RunOnlyOncePerLightType && pass.OnlyLightType != rendLightList[ i ].Type ) { // skip this one continue; } localLightList.Add( rendLightList[ i ] ); lightListToUse = localLightList; } else { // use complete light list lightListToUse = rendLightList; } if ( pass.IsProgrammable ) { // Update any automatic gpu params for lights // Other bits of information will have to be looked up this.autoParamDataSource.SetCurrentLightList( lightListToUse ); pass.UpdateAutoParamsLightsOnly( this.autoParamDataSource ); UpdateGpuProgramParameters( pass ); } // Do we need to update light states? // Only do this if fixed-function vertex lighting applies if ( pass.LightingEnabled && passSurfaceAndLightParams ) { this.targetRenderSystem.UseLights( lightListToUse, pass.MaxSimultaneousLights ); } this.targetRenderSystem.CurrentPassIterationCount = pass.IterationCount; // issue the render op this.targetRenderSystem.Render( op ); } // iterate per light } else { // do we need to update GPU program parameters? if ( pass.IsProgrammable ) { // do we have a manual light list if ( manualLightList != null ) { // Update any automatic gpu params for lights // Other bits of information will have to be looked up this.autoParamDataSource.SetCurrentLightList( manualLightList ); pass.UpdateAutoParamsLightsOnly( this.autoParamDataSource ); } UpdateGpuProgramParameters( pass ); } // Use manual lights if present, and not using vertex programs if ( manualLightList != null && pass.LightingEnabled && passSurfaceAndLightParams ) { this.targetRenderSystem.UseLights( manualLightList, pass.MaxSimultaneousLights ); } this.targetRenderSystem.CurrentPassIterationCount = pass.IterationCount; // issue the render op this.targetRenderSystem.Render( op ); } } else { // suppressRenderStateChanges // Just render this.targetRenderSystem.CurrentPassIterationCount = 1; this.targetRenderSystem.Render( op ); } // Reset view / projection changes if any this.ResetViewProjectionMode(); }
public StyleStateIndex(StyleState styleState) { this.styleState = styleState; this.elements = new LightList <UIElement>(); }
/// <summary> /// Renders a set of transparent objects. /// </summary> protected virtual void RenderTransparentObjects( List<RenderablePass> list, bool doLightIteration, LightList manualLightList ) { // ----- TRANSPARENT LOOP ----- // This time we render by Z, not by material // The transparent objects set needs to be ordered first for ( int i = 0; i < list.Count; i++ ) { RenderablePass rp = (RenderablePass)list[ i ]; // set the pass first this.SetPass( rp.pass ); // render the transparent object this.RenderSingleObject( rp.renderable, rp.pass, doLightIteration, manualLightList ); } }
public void AddVariableNode(VariableDefinitionNode node) { variableNodes = variableNodes ?? new LightList <VariableDefinitionNode>(4); variableNodes.Add(node); }
/// <summary> /// Render a group with the added complexity of additive texture shadows. /// </summary> /// <param name="group">Render queue group.</param> private void RenderAdditiveTextureShadowedQueueGroupObjects( RenderQueueGroup group ) { LightList tempLightList = new LightList(); foreach ( RenderPriorityGroup priorityGroup in group.PriorityGroups.Values ) { // Sort the queue first priorityGroup.Sort( this.cameraInProgress ); // Clear light list tempLightList.Clear(); // Render all the ambient passes first, no light iteration, no lights this.RenderSolidObjects( priorityGroup.solidPasses, false, tempLightList ); // Also render any objects which have receive shadows disabled this.renderingNoShadowQueue = true; this.RenderSolidObjects( priorityGroup.solidPassesNoShadow, true ); this.renderingNoShadowQueue = false; // only perform this next part if we're in the 'normal' render stage, to avoid // doing it during the render to texture if ( this.illuminationStage == IlluminationRenderStage.None ) { // Iterate over lights, render masked int sti = 0; foreach ( Light light in this.lightsAffectingFrustum ) { // Set light state if ( light.CastShadows && sti < this.shadowTextures.Count ) { Texture shadowTex = this.shadowTextures[ sti ]; // Get camera for current shadow texture Camera camera = shadowTex.GetBuffer().GetRenderTarget().GetViewport( 0 ).Camera; // Hook up receiver texture Pass targetPass = this.shadowTextureCustomReceiverPass != null ? this.shadowTextureCustomReceiverPass : this.shadowReceiverPass; targetPass.GetTextureUnitState( 0 ).SetTextureName( shadowTex.Name ); // Hook up projection frustum targetPass.GetTextureUnitState( 0 ).SetProjectiveTexturing( true, camera ); this.autoParamDataSource.TextureProjector = camera; // Remove any spot fader layer if ( targetPass.TextureUnitStageCount > 1 && targetPass.GetTextureUnitState( 1 ).TextureName == "spot_shadow_fade.png" ) { // remove spot fader layer (should only be there if // we previously used modulative shadows) targetPass.RemoveTextureUnitState( 1 ); } // Set lighting / blending modes targetPass.SetSceneBlending( SceneBlendFactor.One, SceneBlendFactor.One ); targetPass.LightingEnabled = true; targetPass.Load(); // increment shadow texture since used ++sti; this.illuminationStage = IlluminationRenderStage.RenderReceiverPass; } else { this.illuminationStage = IlluminationRenderStage.None; } // render lighting passes for this light tempLightList.Clear(); tempLightList.Add( light ); this.RenderSolidObjects( priorityGroup.solidPassesDiffuseSpecular, false, tempLightList ); } // for each light this.illuminationStage = IlluminationRenderStage.None; // Now render decal passes, no need to set lights as lighting will be disabled this.RenderSolidObjects( priorityGroup.solidPassesDecal, false ); } } // for each priority foreach ( RenderPriorityGroup priorityGroup in group.PriorityGroups.Values ) { // Do transparents this.RenderTransparentObjects( priorityGroup.transparentPasses, true ); } // for each priority }
public void AddOptionNode(AnimationOptionNode optionNode) { optionNodes = optionNodes ?? new LightList <AnimationOptionNode>(4); optionNodes.Add(optionNode); }
/// <summary> /// Populate a light list with an ordered set of the lights which are closest /// </summary> /// <remarks> /// <p> /// Note that since directional lights have no position, they are always considered /// closer than any point lights and as such will always take precedence. /// </p> /// <p> /// Subclasses of the default SceneManager may wish to take into account other issues /// such as possible visibility of the light if that information is included in their /// data structures. This basic scenemanager simply orders by distance, eliminating /// those lights which are out of range. /// </p> /// <p> /// The number of items in the list max exceed the maximum number of lights supported /// by the renderer, but the extraneous ones will never be used. In fact the limit will /// be imposed by Pass::getMaxSimultaneousLights. /// </p> /// </remarks> /// <param name="position">The position at which to evaluate the list of lights</param> /// <param name="radius">The bounding radius to test</param> /// <param name="destList">List to be populated with ordered set of lights; will be cleared by this method before population.</param> public virtual void PopulateLightList( Vector3 position, float radius, LightList destList ) { // Really basic trawl of the lights, then sort // Subclasses could do something smarter destList.Clear(); float squaredRadius = radius * radius; MovableObjectCollection lightList = this.GetMovableObjectCollection( LightFactory.TypeName ); // loop through the scene lights an add ones in range foreach ( Light light in lightList.Values ) { if ( light.IsVisible ) { if ( light.Type == LightType.Directional ) { // no distance light.tempSquaredDist = 0.0f; destList.Add( light ); } else { light.tempSquaredDist = ( light.DerivedPosition - position ).LengthSquared; light.tempSquaredDist -= squaredRadius; // only add in-range lights float range = light.AttenuationRange; if ( light.tempSquaredDist <= ( range * range ) ) { destList.Add( light ); } } } // if } // for // Sort Destination light list. // TODO: Not needed yet since the current LightList is a sorted list under the hood already //destList.Sort(); }
/// <summary> /// Overriden from SceneManager. /// </summary> protected override void RenderSingleObject(IRenderable renderable, Pass pass, bool doLightIteration, LightList manualLightList) { if (renderable is BspGeometry) { // Render static level geometry if (doLightIteration) { // render all geometry without lights first RenderStaticGeometry(); // render geometry affected by each visible light for (int i = 0; i < lightsAffectingFrustum.Count; i++) { int index; // find the index of the light for (index = 0; index < lightList.Count; index++) if (lightList[index] == lightsAffectingFrustum[i]) break; if (index < lightList.Count) { RenderTextureLighting(index); } } } else { if (manualLightList.Count == 0) { if (illuminationStage == IlluminationRenderStage.RenderModulativePass) { // texture shadows RenderTextureShadowOnGeometry(); } else { // ambient stencil pass, render geometry without lights RenderStaticGeometry(); } } else { // render only geometry affected by the provided light for (int i = 0; i < manualLightList.Count; i++) { int index; // find the index of the light for (index = 0; index < lightList.Count; index++) if (lightList[index] == manualLightList[i]) break; if (index < lightList.Count) { RenderTextureLighting(index); } } } } } else { base.RenderSingleObject(renderable, pass, doLightIteration, manualLightList); } }