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();
    }
Ejemplo n.º 3
0
        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;
            }
        }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
0
 public OverlayMaterialConfig(RenderType type, int color, int opacity, int texture)
 {
     Type    = type;
     Color   = color;
     Opacity = opacity;
     Texture = texture;
 }
Ejemplo n.º 6
0
 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);
     }
 }
Ejemplo n.º 7
0
        /// <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);
        }
Ejemplo n.º 8
0
        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);
        }
Ejemplo n.º 9
0
 public void Set(UIPanel m_panel, UIWidget m_target, RenderType _RenderType)
 {
     this.mPanel      = m_panel;
     this.mTarget     = m_target;
     this.mRenderType = _RenderType;
     AddToPanel();
 }
Ejemplo n.º 10
0
        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);
        }
Ejemplo n.º 11
0
        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());
            }
            }
        }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 13
0
        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));
        }
Ejemplo n.º 14
0
        /// <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);
                }
            }
        }
Ejemplo n.º 15
0
        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;
        }
Ejemplo n.º 16
0
        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);
        }
Ejemplo n.º 17
0
 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));
            }
        }
Ejemplo n.º 19
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();
 }
Ejemplo n.º 21
0
        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);
        }
Ejemplo n.º 22
0
        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);
            }
        }
Ejemplo n.º 26
0
        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();
        }
Ejemplo n.º 28
0
 public BaseGraphicsRenderer()
 {
     color=	new Color(0, 0, 0);
     lineWidth=	1f;
     pointSize=	1f;
     renderingType=	RenderType.FILL;
 }
Ejemplo n.º 29
0
        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);
        }
Ejemplo n.º 30
0
        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!");
            }
        }
Ejemplo n.º 32
0
        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);
        }
Ejemplo n.º 33
0
		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:
		}
Ejemplo n.º 34
0
 public string RenderTypeString(RenderType t)
 {
   switch (t) {
     case RenderType.SCRIPTS: return "scripts";
     case RenderType.STYLES: return "styles";
   }
   return "";
 }
Ejemplo n.º 35
0
        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;
        }
Ejemplo n.º 36
0
        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];
        }
Ejemplo n.º 37
0
        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);
            }
        }
Ejemplo n.º 38
0
 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;
 }
Ejemplo n.º 39
0
        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;
        }
Ejemplo n.º 40
0
    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;
    }
Ejemplo n.º 41
0
 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);
 }
Ejemplo n.º 42
0
 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;
 }
Ejemplo n.º 43
0
		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;
		}
Ejemplo n.º 44
0
 public static string CreateComponentResult(ComponentResult result,RenderType Type)
 {
     if(Type==RenderType.Xml)
     {
         return new XMLSerializer().Serializer(result);
     }
     else
     {
         return new JSONSerializer().Serializer(result);
     }
 }
Ejemplo n.º 45
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;
             }
     }
 }
Ejemplo n.º 46
0
		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"];
        }
Ejemplo n.º 48
0
 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;
     }
 }
Ejemplo n.º 49
0
        /// <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);
            }
        }
Ejemplo n.º 51
0
 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;
 }
Ejemplo n.º 52
0
 // Sets the rendering type
 public virtual void setRenderingType(RenderType type)
 {
     renderingType=	type;
 }
Ejemplo n.º 53
0
        /// <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;
        }
Ejemplo n.º 54
0
    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());
    }
Ejemplo n.º 55
0
        //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();
            }
        }
Ejemplo n.º 56
0
        public static void ResetConfig()
        {
            MapFile = "";
            Output = "";
            Type = RenderType.Isometric;
            UseRenderLayers = false;
            RenderInterval = 1;
            RenderLayers.Clear();
            Directory = "";

            UseHighQuality = false;
            UseLowQuality = false;
        }
Ejemplo n.º 57
0
        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;
                    }
                }
            }
        }
Ejemplo n.º 58
0
 public MyPolygon(RenderType type = RenderType.Polyline)
 {
     _type = type;
 }
Ejemplo n.º 59
0
 public TileLever(string name, RenderType renderType, Material material, int textureX, int textureY)
     : base(name, renderType, material, textureX, textureY)
 {
 }
Ejemplo n.º 60
0
 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());
   }
 }