public static bool ConvertPdfToTiff(string sourceFile, string outputFile, float dpi, RenderType type, bool rotateLandscapePages, bool shrinkToLetter, int maxSizeInPdfPixels, string pdfPassword) { bool output = false; if (string.IsNullOrEmpty(sourceFile) || string.IsNullOrEmpty(outputFile)) throw new ArgumentNullException(); using (MuPDF pdfDoc = new MuPDF(sourceFile, pdfPassword)) { using (FileStream outputStream = new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { ImageCodecInfo info = null; foreach (ImageCodecInfo ice in ImageCodecInfo.GetImageEncoders()) if (ice.MimeType == "image/tiff") info = ice; Bitmap saveTif = null; pdfDoc.AntiAlias = false; for (int i = 1; i <= pdfDoc.PageCount; i++) { pdfDoc.Page = i; Bitmap FirstImage = pdfDoc.GetBitmap(0, 0, dpi, dpi, 0, type, rotateLandscapePages, shrinkToLetter, maxSizeInPdfPixels); if (FirstImage == null) throw new Exception("Unable to convert pdf to tiff!"); using (EncoderParameters ep = new EncoderParameters(2)) { ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.SaveFlag, (long)EncoderValue.MultiFrame); ep.Param[1] = new EncoderParameter(System.Drawing.Imaging.Encoder.Compression, (long)EncoderValue.CompressionLZW); if (type == RenderType.Monochrome) { ep.Param[1] = new EncoderParameter(System.Drawing.Imaging.Encoder.Compression, (long)EncoderValue.CompressionCCITT4); } if (i == 1) { saveTif = FirstImage; saveTif.Save(outputStream, info, ep); } else { ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.SaveFlag, (long)EncoderValue.FrameDimensionPage); saveTif.SaveAdd(FirstImage, ep); FirstImage.Dispose(); } if (i == pdfDoc.PageCount) { ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.SaveFlag, (long)EncoderValue.Flush); saveTif.SaveAdd(ep); saveTif.Dispose(); } } } } if (File.Exists(outputFile)) output = true; } return output; }
public override void OnInspectorGUI() { GUILayout.Space(6f); EditorGUIUtility.labelWidth = 120f; MyTweenColor tw = target as MyTweenColor; GUI.changed = false; Color from = EditorGUILayout.ColorField("From", tw.from); Color to = EditorGUILayout.ColorField("To", tw.to); RenderType renderType = (RenderType)EditorGUILayout.EnumPopup("RenderType", tw.renderType); if (renderType == RenderType.ShaderColor) { tw.shaderColorName = EditorGUILayout.TextField("RenderType", tw.shaderColorName); } if (GUI.changed) { MyEditorTool.RegisterUndo("Tween Change", tw); tw.from = from; tw.to = to; tw.renderType = renderType; MyEditorTool.SetDirty(tw); } DrawCommonProperties(); }
private void UpdateFromBlendMode() { switch (m_alphaMode) { case AlphaMode.Opaque: { m_renderType = RenderType.Opaque; m_renderQueue = RenderQueue.Geometry; } break; case AlphaMode.Masked: { m_renderType = RenderType.TransparentCutout; m_renderQueue = RenderQueue.AlphaTest; } break; case AlphaMode.Fade: case AlphaMode.Transparent: { m_renderType = RenderType.Transparent; m_renderQueue = RenderQueue.Transparent; } break; } }
protected virtual void _CollectMesh(Matrix4 transMat, int w, int h, RenderType rt, List <IPosLight> lights, AddPixelHandler handler) { Camera camera = Camera.Default; if (null == camera) { return; } Vertex vertex1, vertex2; Vertex2D point1, point2; int pointCount = _pointList.Count - 1; for (int i = 0; i < pointCount; ++i) { vertex1 = _pointList[i]; vertex2 = _pointList[i + 1]; // 将3d坐标投影到2d空间; point1 = GraphPragma.BuildVertex2D(vertex1, transMat, camera.Pos, lights, w, h); point2 = GraphPragma.BuildVertex2D(vertex2, transMat, camera.Pos, lights, w, h); // 计算线段; Line.DrawLine(point1, point2, handler, DrawLineType.Bresenham, SoftDevice.Default.ZTest); } vertex1 = _pointList[_pointList.Count - 1]; vertex2 = _pointList[0]; point1 = GraphPragma.BuildVertex2D(vertex1, transMat, camera.Pos, lights, w, h); point2 = GraphPragma.BuildVertex2D(vertex2, transMat, camera.Pos, lights, w, h); Line.DrawLine(point1, point2, handler, DrawLineType.Bresenham, SoftDevice.Default.ZTest); }
public OverlayMaterialConfig(RenderType type, int color, int opacity, int texture) { Type = type; Color = color; Opacity = opacity; Texture = texture; }
public FormField GetField(string clientid, string formid, RenderType renderType) { if (renderType == RenderType.SELECTION) { return(new Selection(clientid, formid)); } else if (renderType == RenderType.BOOLEAN) { return(new FormFields.Boolean(clientid, formid)); } else if (renderType == RenderType.TEXT) { return(new FormFields.Text(clientid, formid)); } else if (renderType == RenderType.PICKER) { return(new FormFields.Date(clientid, formid)); } else if (renderType == RenderType.UPLOAD) { return(new FormFields.Upload(clientid, formid)); } else if (renderType == RenderType.NUMBER) { return(new FormFields.Numeric(clientid, formid)); } else { return(null); } }
/// <summary> /// Gets the render color of the specific value in the input raster layer. /// </summary> /// <param name="value"></param> /// <param name="rasterLayer"></param> /// <returns></returns> public static IColor GetRenderColor(IRasterLayer rasterLayer, double value) { RenderType renderType = GetRenderType(rasterLayer); IColor renderColor = null; switch (renderType) { case RenderType.Classified: renderColor = GetRenderColor_Classified(rasterLayer, value); break; case RenderType.DiscreteColor: renderColor = GetRenderColor_DiscreteColor(rasterLayer, value); break; case RenderType.Stretched: renderColor = GetRenderColor_Stretched(rasterLayer, value); break; case RenderType.UniqueValues: renderColor = GetRenderColor_UniqueValues(rasterLayer, value); break; default: break; } return(renderColor); }
public bool HasRenderInfo(ref RenderType renderType, ref RenderQueue renderQueue) { if (!m_validData) { return(false); } bool foundRenderType = false; bool foundRenderQueue = false; int count = m_availableTags.Count; for (int i = 0; i < count; i++) { if (m_availableTags[i].TagName.Equals(RenderTypeHelperStr)) { if (TemplateHelperFunctions.StringToRenderType.ContainsKey(m_availableTags[i].TagValue)) { renderType = TemplateHelperFunctions.StringToRenderType[m_availableTags[i].TagValue]; foundRenderType = true; } } else if (m_availableTags[i].TagName.Equals(RenderQueueHelperStr)) { if (TemplateHelperFunctions.StringToRenderQueue.ContainsKey(m_availableTags[i].TagValue)) { renderQueue = TemplateHelperFunctions.StringToRenderQueue[m_availableTags[i].TagValue]; foundRenderQueue = true; } } } return(foundRenderType && foundRenderQueue); }
public void Set(UIPanel m_panel, UIWidget m_target, RenderType _RenderType) { this.mPanel = m_panel; this.mTarget = m_target; this.mRenderType = _RenderType; AddToPanel(); }
private void RenderOthers(List <RenderCore> list, RenderType filter, IRenderContext context, IDeviceContextPool deviceContextPool, ref RenderParameter parameter, CommandList[] commandsArray, int idx) { var deviceContext = deviceContextPool.Get(); SetRenderTargets(deviceContext, ref parameter); bool hasValue = false; for (int i = 0; i < list.Count; ++i) { if (list[i].RenderType == filter) { list[i].Render(context, deviceContext); hasValue = true; } } if (hasValue) { commandsArray[idx] = deviceContext.DeviceContext.FinishCommandList(true); } else { commandsArray[idx] = null; } deviceContextPool.Put(deviceContext); }
public static ImageBuffer Generate(IObject3D loadedItem, RenderType renderType, int width, int height, bool allowMultiThreading = true) { // Skip generation for invalid items if ((loadedItem.Children.Count == 0 && loadedItem.Mesh == null) || !loadedItem.VisibleMeshes().Any()) { // check again in case it got loaded if (!loadedItem.VisibleMeshes().Any()) { return(null); } } switch (renderType) { case RenderType.RAY_TRACE: { var tracer = new ThumbnailTracer(loadedItem, width, height) { MultiThreaded = allowMultiThreading }; tracer.TraceScene(); tracer.destImage?.SetRecieveBlender(new BlenderPreMultBGRA()); return(tracer.destImage); } case RenderType.PERSPECTIVE: { var tracer = new ThumbnailTracer(loadedItem, width, height); var thumbnail = new ImageBuffer(width, height); var graphics2D = thumbnail.NewGraphics2D(); foreach (IObject3D item in loadedItem.Children) { double minZ = double.MaxValue; double maxZ = double.MinValue; tracer.GetMinMaxZ(item.Mesh, ref minZ, ref maxZ); tracer.RenderPerspective(graphics2D, item.Mesh, Color.White, minZ, maxZ); } thumbnail.SetRecieveBlender(new BlenderPreMultBGRA()); return(thumbnail); } case RenderType.NONE: case RenderType.ORTHOGROPHIC: default: { var thumbnail = BuildImageFromMeshGroups(loadedItem, width, height); // Force to all white and return return(thumbnail.AllWhite()); } } }
public Bitmap Render(RenderType type) { var bitmap = new Bitmap(TOTAL_WIDTH, TOTAL_HEIGHT, PixelFormat.Format32bppArgb); using (Graphics g = Graphics.FromImage(bitmap)) { RenderPianoRoll(bitmap, 42, TOTAL_HEIGHT - 1); /* * // Render octave toggle buttons for active octaves * for (int i = 0; i < 8; i++) { * if (OCTAVE_ACTIVE[i]) { * g.DrawImage(octaveBtn, 0, bitmap.Height - (i * 36) - 36); * } * } */ if (type == RenderType.FFTWindow) { RenderFFTWindow(bitmap); } else if (type == RenderType.FFTSpectrum) { RenderFFTSpectrum(bitmap); } else if (type == RenderType.FFTSpectrogram) { RenderFFTSpectrogram(bitmap); } else if (type == RenderType.MidiSong) { RenderMidiSong(bitmap); } else if (type == RenderType.MidiPeaks) { RenderMidiPeaks(bitmap); } else { RenderMidiPeaks(bitmap); } // Update progress bar if (IsLoaded()) { //if (audio.isPlaying()) if (false) { double percentComplete = audioPosition / (double)audioLength * 100; //sliderProgress.Value = audioPosition; //sliderProgress.setValueLabel(nf(round(percentComplete), 2) + "%"); } } else { //sliderProgress.setValueLabel("NO FILE LOADED"); } } return(bitmap); }
public static IDictionary <int, byte[]> ConvertPdfToPng(byte[] pdfBytes, RenderType type, int pageNumber, bool antiAlias = false, float dpi = 150, Size size = new Size(), string password = "") { if (pdfBytes == null || pdfBytes.Length.Equals(0)) { throw new ArgumentNullException(nameof(pdfBytes)); } var output = new ConcurrentDictionary <int, byte[]>(); var pageStart = pageNumber; var pageEnd = pageNumber + 1; using (MuPDF pdfDoc = new MuPDF(pdfBytes, password)) { pdfDoc.Page = pageNumber; pdfDoc.AntiAlias = antiAlias && !type.Equals(RenderType.Monochrome); // no point in anti-alias-ing with Monochrome using (MemoryStream outputStream = new MemoryStream()) { var width = 0; var height = 0; var maxSize = 1000; using (var bitmap = ResizeImage(size, pdfDoc.GetBitmap(width, height, dpi, dpi, 0, type, false, false, maxSize))) { bitmap.Save(outputStream, ImageFormat.Png); output.TryAdd(pageNumber, outputStream.ToArray()); } } } return(output.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)); }
/// <summary> /// Populates the subnode array /// </summary> public void createSubNodes(RenderType type) { if (LOD == 0) { return; } if (subNodes[0] != null) { for (int i = 0; i < 8; i++) { if (subNodes[i].renderType != type) { subNodes[i].setRenderType(type); } subNodes[i].disposed = false; } return; } for (int i = 0; i < 8; i++) { if (subNodes[i] == null) { subNodes[i] = new Node(this, NodeManager.getOffsetPosition(this, i), i, LOD - 1, type); } } }
public void BeginUI() { if (renderType == RenderType.World) { // Complete world rendering Flush(); worldBuffer.Unbind(); // Render the world buffer into the UI buffer screenBuffer.Bind(); var scale = Window.EffectiveWindowScale; var bufferSize = new Size((int)(screenSprite.Bounds.Width / scale), (int)(-screenSprite.Bounds.Height / scale)); SpriteRenderer.SetAntialiasingPixelsPerTexel(Window.SurfaceSize.Height * 1f / worldSprite.Bounds.Height); RgbaSpriteRenderer.DrawSprite(worldSprite, float3.Zero, new float2(bufferSize)); Flush(); SpriteRenderer.SetAntialiasingPixelsPerTexel(0); } else { // World rendering was skipped BeginFrame(); screenBuffer.Bind(); } renderType = RenderType.UI; }
public Node(Node parent, Vector3 position, int subNodeID, int LOD, RenderType renderType) { densityChangeData = new DensityData(); this.parent = parent; this.position = position; this.subNodeID = subNodeID; this.LOD = LOD; float chunkWidth = (NodeManager.LODSize[LOD] * NodeManager.nodeSize) / 2f; center = new Vector3(position.x + chunkWidth, position.y + chunkWidth, position.z + chunkWidth); setRenderType(renderType); if (parent != null && parent.permanent) permanent = true; NodeManager.nodeCount[LOD]++; float nWidth = NodeManager.LODSize[LOD] * NodeManager.nodeSize; chunkPos.x = (int)(center.x / nWidth); chunkPos.y = (int)(center.y / nWidth); chunkPos.z = (int)(center.z / nWidth); if (LOD == 0) { string dir = getDirectory(); if (Directory.Exists(dir) && File.Exists(dir + "\\densities.txt")) MeshFactory.requestLoad(this); } regenReq = true; MeshFactory.requestMesh(this); }
protected void _update() { if (parent != null) { _dvisible = parent.visible; _dalpha = parent.alpha; _rendertype = parent.getRenderType(); if (!isDisplayed && parent.isDisplayed) { _isDisplayed = true; dispatchEvent(new Event(this, Event.ADDED_TO_STAGE)); } else if (isDisplayed && !parent.isDisplayed) { _isDisplayed = false; dispatchEvent(new Event(this, Event.REMOVED_FROM_STAGE)); } } else { if (isDisplayed) { _isDisplayed = false; dispatchEvent(new Event(this, Event.REMOVED_FROM_STAGE)); } } }
/// <summary> /// RenderType extension to check compatible version </summary> /// <remarks> /// The version of the installed look must be greater or equal to the version returned or an error will be logged and the look will probabaly not work. </remarks> public static Version CompatibleVersion(this RenderType value) { switch (value) { case RenderType.Photo: { return(new Version(0, 1, 0)); } #if DK_USING_ZERODAYSLOOK case RenderType.ZeroDays: { return(new Version(0, 1, 0)); } #endif #if DK_USING_MULTIPERSPECTIVE case RenderType.MultiPerspective: { return(new Version(0, 1, 0)); } #endif #if DK_USING_SIMPLE_COMPUTE case RenderType.SimpleCompute: { return(new Version(0, 1, 0)); } #endif default: return(new Version(0, 0, 0)); } }
static void Check(RenderType type) { // Switch on the flags. switch (type) { case RenderType.ContentPage | RenderType.DataUri | RenderType.GZip: { Console.WriteLine("content, datauri, gzip"); break; } case RenderType.ContentPage | RenderType.GZip: // < first match { Console.WriteLine("content, gzip"); break; } case RenderType.ContentPage: { Console.WriteLine("content"); break; } case RenderType.ViewPage | RenderType.DataUri | RenderType.GZip: // < second match { Console.WriteLine("view, datauri, gzip"); break; } case RenderType.ViewPage | RenderType.GZip: { Console.WriteLine("view, gzip"); break; } case RenderType.ViewPage: { Console.WriteLine("view"); break; } case RenderType.HomePage | RenderType.DataUri | RenderType.GZip: { Console.WriteLine("home, datauri, gzip"); break; } case RenderType.HomePage | RenderType.GZip: { Console.WriteLine("home, gzip"); break; } case RenderType.HomePage: { Console.WriteLine("home"); break; } } }
/// <summary> /// Configures the player with a dynamic metadata file /// </summary> public void Setup(AvailablePlayerType playerType, RenderType renderType, string metadataPath) { Setup(playerType, renderType); _metaDataSourceType = MetadataSourceType.FilePath; _metaDataFilePath = metadataPath; RefreshMetaData(); }
RenderType GetRenderType() { RenderType renderType = RenderType.Extrusions; if (gcodeViewWidget.RenderMoves) { renderType |= RenderType.Moves; } if (gcodeViewWidget.RenderRetractions) { renderType |= RenderType.Retractions; } if (gcodeViewWidget.RenderSpeeds) { renderType |= RenderType.SpeedColors; } if (gcodeViewWidget.SimulateExtrusion) { renderType |= RenderType.SimulateExtrusion; } if (gcodeViewWidget.HideExtruderOffsets) { renderType |= RenderType.HideExtruderOffsets; } return(renderType); }
public void Serialize(BinaryWriter writer) { writer.Write("3DI".ToBytes()); writer.Write((byte)8); writer.Write(Name.ToBytes(8)); writer.Write(0x0012FCD0); // gap writer.Write(1); writer.Write(LodCount); writer.Write(Lod4Distance); writer.Write(Lod3Distance); writer.Write(Lod2Distance); writer.Write(Lod1Distance); // LOD render functions for (int i = 0; i < 4; i++) { writer.Write(RenderType.ToBytes()); } writer.Write(new byte[40]); // gap writer.WriteFixedPoint(BoundingSphereRadius); writer.WriteFixedPoint(BoundingSphereRadius); writer.Write(new byte[20]); // gap writer.Write(TextureCount); }
void CheckSpecialTag() { if (TagName.Equals(Constants.RenderTypeHelperStr)) { m_specialTag = TemplateSpecialTags.RenderType; if (!TemplateHelperFunctions.StringToRenderType.TryGetValue(TagValue, out m_renderType)) { m_renderType = RenderType.Custom; } } else if (TagName.Equals(Constants.RenderQueueHelperStr)) { m_specialTag = TemplateSpecialTags.Queue; SetTagValue(TagValue); } else if (TagName.Equals(Constants.DisableBatchingHelperStr)) { m_specialTag = TemplateSpecialTags.DisableBatching; if (!TemplateHelperFunctions.StringToDisableBatching.TryGetValue(TagValue, out m_disableBatching)) { m_disableBatching = DisableBatching.False; } } else { m_specialTag = TemplateSpecialTags.None; } }
/// <summary> /// Configures the player with a TextAsset resource /// </summary> public void Setup(AvailablePlayerType playerType, RenderType renderType, TextAsset metadata) { Setup(playerType, renderType); _metaDataSourceType = MetadataSourceType.TextAsset; _metaDataFile = metadata; RefreshMetaData(); }
private async Task AddCombatantsAsync(RenderType type, string title = "Import") { string filter = type == RenderType.Monster ? "Monster Files|*.monster" : "Character Files|*.dnd4e"; OpenFileDialog dialog = new OpenFileDialog() { Filter = filter + "|All files (*.*)|*.*", CheckFileExists = true, CheckPathExists = true, Multiselect = true, Title = title, ValidateNames = true }; var result = dialog.ShowDialog(); if (!result.HasValue || !result.Value || (dialog.FileNames.Length == 0)) { return; } if (type == RenderType.Character) { await this.library.AddCharactersAsync(dialog.FileNames); } else if (type == RenderType.Monster) { await this.library.AddMonstersAsync(dialog.FileNames); } }
private void ProcessPoint(double x, double y, RenderType type) { //37 is a magic number to scale the values to the image bounds //Since i'm not quite sure the variation of values of the lorenz system, I eyeballed it and saw that 37 works well for a 2000*2000 image. int isXY = Convert.ToInt32(type == RenderType.XY); int xPixel = (int)Math.Round(x * 37) + width / 2; //Only scale if rendering XY axes. int yPixel = (int)Math.Round(y * 37) + (height / 2) * isXY; //Bounds check if (xPixel <= 0 || xPixel >= width) { t++; return; } if (yPixel <= 0 || yPixel >= height) { t++; return; } //Storing 2D of data in a 1D array, y * width + x int index = yPixel * width + xPixel; histogram[index]++; int currentHitCount = histogram[index] + 1; if (currentHitCount > biggestHit) { biggestHit = currentHitCount; } }
private async Task AddFilesToStatsListAsync(RenderType type, string title = "Import") { string filter = type == RenderType.Monster ? "Monster Files|*.monster" : "Character Files|*.dnd4e"; OpenFileDialog dialog = new OpenFileDialog() { Filter = filter + "|All files (*.*)|*.*", CheckFileExists = true, CheckPathExists = true, Multiselect = true, Title = title, ValidateNames = true }; DialogResult result = dialog.ShowDialog(); if ((result != DialogResult.OK) || (dialog.FileNames.Length == 0)) { return; } Stopwatch timer = Stopwatch.StartNew(); IEnumerable <Combatant> added = null; if (type == RenderType.Character) { added = await this.Library.ImportCharactersFromFileAsync(dialog.FileNames); } else if (type == RenderType.Monster) { added = await this.Library.ImportMonstersFromFileAsync(dialog.FileNames); } timer.Stop(); Trace.TraceInformation("Loading {0}s took {1}ms", type, timer.ElapsedMilliseconds); this.UpdateCounts(); }
public BaseGraphicsRenderer() { color= new Color(0, 0, 0); lineWidth= 1f; pointSize= 1f; renderingType= RenderType.FILL; }
private RenderType CreateRenderInfo() { RenderType renderType = RenderType.Extrusions; if (RenderMoves) { renderType |= RenderType.Moves; } if (RenderRetractions) { renderType |= RenderType.Retractions; } if (RenderSpeeds) { renderType |= RenderType.SpeedColors; } if (SimulateExtrusion) { renderType |= RenderType.SimulateExtrusion; } if (TransparentExtrusion) { renderType |= RenderType.TransparentExtrusion; } if (HideExtruderOffsets) { renderType |= RenderType.HideExtruderOffsets; } return(renderType); }
public static ViewportCoordinates OffsetFor(this SpritePosition p, RenderType t) { ViewportCoordinates result; OffsetFor(p, t, out result); return(result); }
string GetRenderTypeDescription(RenderType rt) { switch (rt) { case RenderType.Opaque: return("A fully opaque cubic voxel which doesn't allow light to pass through. Supports 3 textures: top, bottom and a third texture for all 6 sides."); case RenderType.OpaqueAnimated: return("A fully opaque cubic voxel which doesn't allow light to pass through. Supports 3 textures with animation."); case RenderType.Opaque6tex: return("A fully opaque cubic voxel which doesn't allow light to pass through. Supports 6 textures: one texture per cube face."); case RenderType.OpaqueNoAO: return("A fully opaque cubic voxel which doesn't allow light to pass through. Does not support ambient occlusion nor global illumination (doesn't get dark)."); case RenderType.Cloud: return("A render type specific for rendering clouds."); case RenderType.Transp6tex: return("A transparent cubic voxel. Supports 6 textures: one texture per cube face. The alpha value of the texture determines the level of transparency."); case RenderType.Water: return("Reserved for water rendering."); case RenderType.Cutout: return("A cutout cubic voxel. Mostly used for tree leaves and voxels with holes."); case RenderType.CutoutCross: return("Reserved for vegetation rendering. Uses two quads to render bushes."); case RenderType.Empty: return("Does not render anything but can generate collider."); case RenderType.Custom: return("Used for custom shapes like objects, half-blocks, stylish trees or vegetation, etc. The material used by the prefab will be used for rendering (check the online documentation about custom voxels for valid materials)."); default: return("Unknown render type!"); } }
public override void OnDraw(Graphics2D graphics2D) { if (loadedGCode != null) { Affine transform = TotalTransform; CreateGrid(transform); double gridLineWidths = 0.2 * layerScale; Stroke stroke = new Stroke(grid, gridLineWidths); if (RenderGrid) { graphics2D.Render(stroke, RGBA_Bytes.DarkGray); } RenderType renderType = RenderType.Extrusions; if (RenderMoves) { renderType |= RenderType.Moves; } if (RenderRetractions) { renderType |= RenderType.Retractions; } GCodeRenderInfo renderInfo = new GCodeRenderInfo(activeLayerIndex, activeLayerIndex, transform, layerScale, renderType, FeatureToStartOnRatio0To1, FeatureToEndOnRatio0To1, null); gCodeRenderer.Render(graphics2D, renderInfo); } base.OnDraw(graphics2D); }
public bool HasRenderInfo( ref RenderType renderType, ref RenderQueue renderQueue ) { if( !m_validData ) return false: bool foundRenderType = false: bool foundRenderQueue = false: int count = m_availableTags.Count: for( int i = 0: i < count: i++ ) { if( m_availableTags[ i ].TagName.Equals( Constants.RenderTypeHelperStr ) ) { if( TemplateHelperFunctions.StringToRenderType.ContainsKey( m_availableTags[ i ].TagValue ) ) { renderType = TemplateHelperFunctions.StringToRenderType[ m_availableTags[ i ].TagValue ]: foundRenderType = true: } } else if( m_availableTags[ i ].TagName.Equals( Constants.RenderQueueHelperStr ) ) { string value = m_availableTags[ i ].TagValue.Split( '+' )[ 0 ].Split( '-' )[ 0 ]: if( TemplateHelperFunctions.StringToRenderQueue.ContainsKey( value ) ) { renderQueue = TemplateHelperFunctions.StringToRenderQueue[ value ]: foundRenderQueue = true: } } } return foundRenderType && foundRenderQueue: }
public string RenderTypeString(RenderType t) { switch (t) { case RenderType.SCRIPTS: return "scripts"; case RenderType.STYLES: return "styles"; } return ""; }
private RenderType Type; //Render Type(Single Frame or Animation) #endregion Fields #region Constructors //Start - Start Frame Animation (Also the frame number for a single frame render) //Curr - Current Frame (Keeps track of the render progress) //End - End Frame of Animation (Not used in sight frame render) public BlendFile(String exe, String file, String dir, RenderType option, int first, int last) { key++; BlenderExe = exe; BlenderFile = file; SaveDir = dir; Type = option; Start = first; End = last; }
public RendererPass ApplyPass(RenderType type, Color clearColor) { CurrentPass = _passes[type]; YND.GraphicsDevice.SetRenderTarget(CurrentPass.RenderTarget); YND.GraphicsDevice.Clear(clearColor); CurrentPass.Lights = Lights; return _passes[type]; }
public void MoveToScreen(RenderType type, bool realFullScreen = false) { YND.GraphicsDevice.SetRenderTarget(null); YND.GraphicsDevice.Clear(Color.Black); using (var sbh = new SpriteBatchHelper()) { sbh.DrawFullScreen(_passes[type].RenderTarget, realFullScreen); } }
public TileMustRestOn(string name, RenderType renderType, Material material, int textureX, int textureY, int x8th, int y8th, int restOnX, int restOnY, Tile[] restOns, bool drop) : base(name, renderType, material, textureX, textureY) { this.x8th = x8th; this.y8th = y8th; this.restOnX = restOnX; this.restOnY = restOnY; this.restOns = restOns; this.drop = drop; }
private double GetExtrusionWidth(RenderType renderType) { double width = .4; if ((renderType & RenderType.SimulateExtrusion) == RenderType.SimulateExtrusion) { double area = extrusionVolumeMm3 / ((end - start).Length); width = area / layerHeight; } return width; }
protected string GetHtmlInclude(string bundleName, RenderType t) { string type = RenderTypeString(t); string path = string.Format("{0}.{1}", bundleName, type); JToken token = GetBundleResultToken(path); if (token != null) { return token.ToString(); } return null; }
public Tile(string name, RenderType renderType, Material material, int textureX, int textureY) { index = getNewIndex(); TileList[index] = this; this.name = name; this.material = material; this.displayName = name; this.displayNamePlural = displayName; this.renderType = renderType; this.textureArea = new Point(textureX, textureY); }
public DXGraphicsRenderer(Game pmGame) { dxg= new DirectXGraphics(); settings= new GraphicsSettings(); game= pmGame; clearColor= new Color("royalblue"); vbuffer= null; ibuffer= null; renderType= RenderType.FILL; layout= null; }
private double GetRadius(RenderType renderType) { double radius = .2; if ((renderType & RenderType.SimulateExtrusion) == RenderType.SimulateExtrusion) { double area = extrusionVolumeMm3 / ((end - start).Length); radius = Math.Sqrt(area / Math.PI); } return radius; }
public static string CreateComponentResult(ComponentResult result,RenderType Type) { if(Type==RenderType.Xml) { return new XMLSerializer().Serializer(result); } else { return new JSONSerializer().Serializer(result); } }
public GCodeRenderInfo(int startLayerIndex, int endLayerIndex, Affine transform, double layerScale, RenderType renderType, double featureToStartOnRatio0To1, double featureToEndOnRatio0To1, Vector2[] extruderOffsets) { this.startLayerIndex = startLayerIndex; this.endLayerIndex = endLayerIndex; this.transform = transform; this.layerScale = layerScale; this.currentRenderType = renderType; this.featureToStartOnRatio0To1 = featureToStartOnRatio0To1; this.featureToEndOnRatio0To1 = featureToEndOnRatio0To1; this.extruderOffsets = extruderOffsets; }
public Texture2D Render(Camera camera, GameTime gameTime, RenderType renderType) { if (renderType == RenderType.ToScreen) Game.GraphicsDevice.SetRenderTarget(null); else Game.GraphicsDevice.SetRenderTarget(Outputs["Output"]); Game.GraphicsDevice.Clear(Color.Black); Process(camera, gameTime); if (renderType == RenderType.ToScreen) return null; else return Outputs["Output"]; }
public void Render(RenderType Type, string ReportPath, string ReportFile, string ReportName, ReportDataSource Data) { _ReportName = ReportName; _ReportPath = ReportPath; _ReportFile = ReportFile; _DS = Data; switch (Type) { case RenderType.MSReportViewer: GenerateMSReport(); break; case RenderType.PDFReportViewer: GeneratePDFReport("Report is being generated<br>please wait..."); break; } }
/// <summary> /// Create and populate the chart with the supplied information /// </summary> /// <param name="width">The width of the chart</param> /// <param name="height">The height of the chart</param> /// <param name="renderType">The RenderType of chart which represents how the chart will be rendered to the UI.</param> /// <returns>The chart object.</returns> private Chart CreateChart(int width, int height, RenderType renderType) { // 1 create the chart object var chart = InitialiseChart(width, height); // 2 Add the Title object, if it's defined. if (this._chartData.Title != null) chart.Titles.Add(CreateTitle()); // 3 Add the Legend Object chart.Legends.Add(CreateLegend()); // 4 Add the data to the object chart.Series.Add(LoadChartData()); // 5 Add Areas to the chart chart.ChartAreas.Add(CreateChartArea()); // 6 Set the chosen renderType chart.RenderType = renderType; return chart; }
private async Task AddCombatantsAsync (RenderType type, string title = "Import") { string filter = type == RenderType.Monster ? "Monster Files|*.monster" : "Character Files|*.dnd4e"; OpenFileDialog dialog = new OpenFileDialog() { Filter = filter + "|All files (*.*)|*.*", CheckFileExists = true, CheckPathExists = true, Multiselect = true, Title = title, ValidateNames = true }; var result = dialog.ShowDialog(); if (!result.HasValue || !result.Value || (dialog.FileNames.Length == 0)) { return; } if (type == RenderType.Character) { await this.library.AddCharactersAsync(dialog.FileNames); } else if (type == RenderType.Monster) { await this.library.AddMonstersAsync(dialog.FileNames); } }
public TileFurniture(string name, RenderType renderType, int textureX, int textureY, int width, int height, bool platform) : base(name, renderType, Material.furniture, textureX, textureY) { size = new Point(width, height); topIsPlatform = platform; }
// Sets the rendering type public virtual void setRenderingType(RenderType type) { renderingType= type; }
/// <summary> /// Load the viewer with an specific render type /// </summary> public string Load(string report, RenderType renderType) { //read the report stream string contents = null; //read the report stream from an embedded resource or an external file System.IO.Stream stream = null; if (EmbeddedReportFiles) stream = Assembly.GetCallingAssembly().GetManifestResourceStream(report); else stream = File.OpenRead(report); using (StreamReader reader = new StreamReader(stream)) contents = reader.ReadToEnd(); //load the parameters into the viewer reportViewer.Parameters = parameters.GetReportStringParameters(); //load the report contents into the report viewer reportViewer.SourceRdl = contents; try { //reload the data objects into the report viewer for (int i = 0; i < datas.GetCount(); i++) reportViewer.Report.DataSets[datas.GetReportViewerData(i).DataName].SetData( datas.GetReportViewerData(i).Data); //refresh the report reportViewer.Rebuild(); //unique identifier for the file name string fileName = Guid.NewGuid().ToString(); //render the document reportViewer.SaveAs(string.Format(@"{0}\{1}.pdf", reportFolder, fileName), renderType.ToString()); //return the saved file return string.Format("{0}.pdf", fileName); } catch (NullReferenceException ex) { throw new Exception(string.Format("Could not load the report !\r\n{0}", ex.Message)); } catch (ArgumentException) { //can not pass the report argument because the report viewer could not reload the data //because there is an error in the report definition, so te report it self will print the error } return null; }
protected virtual HtmlString Render(RenderType key) { _logger.LogVerbose("Render called with option {0}", key.ToString()); var sb = new StringBuilder(); if (_toBeRendered.ContainsKey(key)) { // go through the order of bundles within the config file foreach (var bundle in GetOrderList()) { _logger.LogVerbose(" trying bundle {0}", bundle); if (_toBeRendered[key].Contains(bundle.ToString())) { _logger.LogVerbose(" rendering {0}", bundle); var html = GetHtmlInclude(bundle, key); if (html != null) { sb.AppendLine(html); } } } } else { _logger.LogDebug(" no bundle data contained"); } _logger.LogVerbose("Render outputs: {0}", sb.ToString()); return new HtmlString(sb.ToString()); }
//property.Expanded = EditorGUILayout.Foldout( property.Expanded, property.GetPropertyType().PropertyTypeString() ); public void Draw() { var shaderNameContent = new GUIContent( "Shader Name", "Name for shader. Includes the hierarchy listing, that is, MyShaders/Shader will be in a folder called \"MyShaders\" in the shader selection dropdown. Also used when referring to fallback shaders."); var oldColor = GUI.color; if( string.IsNullOrEmpty(_shaderName ) ) { GUI.color = Color.red; } _shaderName.Value = EditorGUILayout.TextField(shaderNameContent, _shaderName.Value); GUI.color = oldColor; var shaderFallbackContent = new GUIContent( "Shader Fallback", "Fallback shader to use in case this shader can not be used."); _shaderFallback.Value = EditorGUILayout.TextField( shaderFallbackContent, _shaderFallback.Value ); var targetContent = new GUIContent("Shader Model","Requires more recent hardware to use the shader, but allows for more instructions, texture reads, and more input information."); _shaderTarget = (ShaderTarget)EditorGUILayout.EnumPopup( targetContent, _shaderTarget ); var excludePathContent = new GUIContent("Exclude Path","Exclude a renderpath from shader generation"); _excludePath = (ExcludePath)EditorGUILayout.EnumPopup( excludePathContent, _excludePath ); GUILayout.Space(8); _showQueueSettings = EditorGUILayout.Foldout( _showQueueSettings, "Queue Settings" ); if( _showQueueSettings ) { var renderTypeContent = new GUIContent("Render Type","This is the rendertype tag inserted into the shader. Can be used for shader replace"); _renderType = (RenderType)EditorGUILayout.EnumPopup( renderTypeContent, _renderType ); if ( _renderType == RenderType.Custom ) _renderTypeCustom.Value = EditorGUILayout.TextField( "Custom Type" ,_renderTypeCustom.Value ); var queueContent = new GUIContent("Render Queue","The render queue that this material will be put in"); _queue = (Queue)EditorGUILayout.EnumPopup( queueContent, _queue ); var offContent = new GUIContent( "Queue Offset", "Offset for drawing. Used to ensure some things draw before or after others, it specifically is an offset from the given queue- That is to say, you won't have a transparent object draw before an opaque object (or similar) due to this offset."); _queueAdjust = EditorGUILayout.IntSlider(offContent, _queueAdjust.Value, -100, 100); } GUILayout.Space( 8 ); _showCullingAndDepthSettings = EditorGUILayout.Foldout( _showCullingAndDepthSettings, "Culling and Depth Settings" ); if( _showCullingAndDepthSettings ) { var zWriteContent = new GUIContent("Write Depth","Depth is considered when testing other objects. Disable for certain effects, like letting other things draw over yourself, or for speed on most overlays."); _zWrite = (ZWrite)EditorGUILayout.EnumPopup( zWriteContent, _zWrite ); var cullModeContent = new GUIContent("CullMode","Select back / forward to clip backwards facing polygons"); _cullMode = (CullMode)EditorGUILayout.EnumPopup( cullModeContent, _cullMode ); var zTestContent = new GUIContent("ZTest","Select Z-Test Value"); _zTest = (ZTest)EditorGUILayout.EnumPopup( zTestContent, _zTest ); var enableLODContent = new GUIContent("Enable LOD","Enable Shader LOD scaling"); _enableLOD = EditorGUILayout.BeginToggleGroup( enableLODContent, _enableLOD ); _lod = EditorGUILayout.IntSlider( "LOD", _lod, 0, 1000 ); EditorGUILayout.EndToggleGroup(); } GUILayout.Space( 8 ); _showBlending = EditorGUILayout.Foldout( _showBlending, "Blending Settings" ); if( _showBlending ) { var blendingTypeContent = new GUIContent("Blend Type","Use a build in blend mode or a custom blend mode"); _blending = (BlendingType)EditorGUILayout.EnumPopup( blendingTypeContent, _blending ); if( CustomBlendingEnabled() ) { var srcBlendContent = new GUIContent("Src Blend Mode","How the source channel of blending is used"); _srcBlend = (BlendingMode)EditorGUILayout.EnumPopup( srcBlendContent, _srcBlend ); var dstBlendContent = new GUIContent("Dst Blend Mode","How the destination channel of blending is used"); _dstBlend = (BlendingMode)EditorGUILayout.EnumPopup( dstBlendContent, _dstBlend ); } } GUILayout.Space( 8 ); _showColorAndLighting = EditorGUILayout.Foldout( _showColorAndLighting, "Color And Lighting Settings" ); if( _showColorAndLighting ) { GUILayout.BeginHorizontal(); GUILayout.Label( "Color Mask:", GUILayout.ExpandWidth(false) ); _colorMaskR.Value = EditorExtensions.ToggleButton( _colorMaskR.Value, "R","Mask R Channel"); _colorMaskG.Value = EditorExtensions.ToggleButton( _colorMaskG.Value, "G","Mask G Channel"); _colorMaskB.Value = EditorExtensions.ToggleButton( _colorMaskB.Value, "B","Mask B Channel"); _colorMaskA.Value = EditorExtensions.ToggleButton( _colorMaskA.Value, "A","Mask A Channel"); GUILayout.EndHorizontal(); _dualForward = GUILayout.Toggle( _dualForward, new GUIContent( "Forward Dual Lightmaps","Use dual lightmaps in the forward rendering path" )); _fullForwardShadows = GUILayout.Toggle( _fullForwardShadows, new GUIContent( "Forward Full Shadows", "Support all shadow types in Forward rendering path." )); _softVegetation = GUILayout.Toggle( _softVegetation, new GUIContent( "Soft Vegetation", "Makes the surface shader only be rendered when Soft Vegetation is on." )); _noAmbient = GUILayout.Toggle( _noAmbient, new GUIContent( "No Ambient", "Do not apply any ambient lighting or spherical harmonics lights.")); _noLightmap = GUILayout.Toggle( _noLightmap, new GUIContent( "No Lightmaps", "Disables lightmap support in this shader (makes a shader smaller)." )); _addShadow = GUILayout.Toggle( _addShadow, new GUIContent( "Advanced Shadow Pass", "Performs vertex transformations and clipping for the shadow pass, you need to use this if shadows do not display properly." )); _ignoreProjectors = GUILayout.Toggle( _ignoreProjectors, new GUIContent( "Ignore Projectors", "Ignores projector components, should be used if your doing custom vertex transformations or most transparency" )); _approxview = GUILayout.Toggle( _approxview, new GUIContent( "Approximate View", "Computes normalized view direction per-vertex instead of per-pixel, for shaders that need it. This is faster, but view direction is not entirely correct when camera gets close to surface." )); _halfasview = GUILayout.Toggle( _halfasview, new GUIContent( "Half As View", "Pass half-direction vector into the lighting function instead of view-direction. Half-direction will be computed and normalized per vertex. This is faster, but not entirely correct." )); _noForwardAdd = GUILayout.Toggle( _noForwardAdd, new GUIContent( "Disable Forward Add", "Disables Forward rendering additive pass. This makes the shader support one full directional light, with all other lights computed per-vertex/SH. Makes shaders smaller as well." )); } GUILayout.Space( 8 ); _showFogSettings = EditorGUILayout.Foldout( _showFogSettings, "Fog Settings" ); if( _showFogSettings ) { _fogModeOverride = EditorGUILayout.BeginToggleGroup( "Fog Mode Override", _fogModeOverride ); var fogModeContent = new GUIContent("Fog Mode","The type of fog to use"); _fogMode = (FogMode)EditorGUILayout.EnumPopup( fogModeContent, _fogMode ); if( _fogMode == FogMode.Linear ) { _fogNearLinear.Value = EditorGUILayout.FloatField( "Near Linear Range:", _fogNearLinear ); _fogFarLinear.Value = EditorGUILayout.FloatField( "Far Linear Range:", _fogFarLinear ); } EditorGUILayout.EndToggleGroup(); _fogColorOverride = EditorGUILayout.BeginToggleGroup( "Fog Color Override", _fogColorOverride ); _fogColor.Value = EditorGUILayout.ColorField("Fog Color:", _fogColor ); EditorGUILayout.EndToggleGroup(); _fogDensityOverride = EditorGUILayout.BeginToggleGroup( "Fog Density Override", _fogDensityOverride ); _fogDensity.Value = EditorGUILayout.FloatField( "Fog Density:", _fogDensity ); EditorGUILayout.EndToggleGroup(); } }
public static void ResetConfig() { MapFile = ""; Output = ""; Type = RenderType.Isometric; UseRenderLayers = false; RenderInterval = 1; RenderLayers.Clear(); Directory = ""; UseHighQuality = false; UseLowQuality = false; }
public static void LoadConfig(string[] args) { for (int idx = 0; idx < args.Length; idx++) { if (args[idx].StartsWith("-")) { switch (args[idx].ToLower()) { case "-map": if (args.Length < idx + 1 || args[idx + 1].StartsWith("-")) throw new ArgumentException("Please specify a map name to use."); MapFile = args[++idx]; break; case "-out": if (args.Length < idx + 1 || args[idx + 1].StartsWith("-")) throw new ArgumentException("Please specify a file to save to."); Output = args[++idx]; break; case "-lq": UseLowQuality = true; break; case "-hq": UseHighQuality = true; break; case "-type": if (args.Length < idx + 1 || args[idx + 1].StartsWith("-")) throw new ArgumentException("Please specify a render type."); switch (args[++idx].ToLower()) { case "iso": Type = RenderType.Isometric; break; case "overview": Type = RenderType.Overview; break; default: throw new ArgumentException(string.Format("Unknown render type: {0}", args[idx + 1])); } break; case "-layers": if (args.Length < idx + 1 || args[idx+1].StartsWith("-")) throw new ArgumentException("Please specify the layers to render."); UseRenderLayers = true; string[] layers = args[++idx].Split(new [] {','}); for (int ldx = 0; ldx < layers.Length; ldx++) { // Split on dash to get ranges string[] range = layers[ldx].Split(new[] {'-'}); if (range.Length > 1) { // Have a range, try to parse the first number for the start int startRange; if (!int.TryParse(range[0], out startRange)) { // Start range can't be parsed, something's messed up with this arg throw new ArgumentException(string.Format("Unable to parse layer parameter: {0}", range[0])); } // Now check if the end range has a slash (signifying an interval) string[] interval = range[1].Split(new[] {'/'}); if (interval.Length > 1) { // First value should be the end range and the second should be the interval int endRange; if (!int.TryParse(interval[0], out endRange)) { throw new ArgumentException(string.Format("Unable to parse layer parameter: {0}", interval[0])); } int rangeInterval; if (!int.TryParse(interval[1], out rangeInterval)) { throw new ArgumentException(string.Format("Unable to parse layer parameter: /{0}", interval[1])); } for (int i = startRange; i <= endRange; i += rangeInterval) { RenderLayers.Add(i); } } else { int endRange; if (!int.TryParse(range[1], out endRange)) { throw new ArgumentException(string.Format("Unable to parse layer parameter: {0}", range[1])); } for (int i = startRange; i <= endRange; i++) { RenderLayers.Add(i); } } } else { if (layers[ldx].StartsWith("/")) { int interval; if (!int.TryParse(layers[ldx].Substring(1), out interval)) { throw new ArgumentException(string.Format("Unable to parse layer parameter: {0}", layers[idx])); } RenderInterval = interval; } else { int layer; if (!int.TryParse(layers[ldx], out layer)) { throw new ArgumentException(string.Format("Unable to parse layer parameter: {0}", layers[ldx])); } RenderLayers.Add(layer); } } } break; case "-dir": if (args.Length < idx + 1 || args[idx + 1].StartsWith("-")) throw new ArgumentException("Please specify the directory to render to."); Directory = args[++idx]; break; } } } }
public MyPolygon(RenderType type = RenderType.Polyline) { _type = type; }
public TileLever(string name, RenderType renderType, Material material, int textureX, int textureY) : base(name, renderType, material, textureX, textureY) { }
protected virtual void Include(RenderType key, string bundleName) { _logger.LogVerbose("Include called with parameters: {0} {1}", key.ToString(), bundleName); if (!_toBeRendered.ContainsKey(key)) { _logger.LogDebug(" first time adding of type {0}", key.ToString()); var list = new List<string>(); _toBeRendered.Add(key, list); } if (!_toBeRendered[key].Contains(bundleName)) { _toBeRendered[key].Add(bundleName); _logger.LogVerbose("Include added {0} to key {0}", bundleName, key.ToString()); } else { _logger.LogInformation("Include was already added {0} to key {0}", bundleName, key.ToString()); } }