There are some instances when you may need to lock the mouse cursor to the screen. For example rotating the camera where you would press down on the right mouse button then drag the mouse to rotate the camera. If you wish to hide the mouse cursor and lock it to the screen while dragging you can use Screen.lockCursor.

using UnityEngine;

public class lockCursorExample : MonoBehaviour
{
    void DidLockCursor()
    {
        Debug.Log("Locking cursor");
    }

    void DidUnlockCursor()
    {
        Debug.Log("Unlocking cursor");
    }

    private bool wasLocked;

    void Update()
    {
        if (!Screen.lockCursor && this.wasLocked)
        {
            this.wasLocked = false;
            this.DidUnlockCursor();
        }
        else if (Screen.lockCursor && !this.wasLocked)
        {
            this.wasLocked = true;
            this.DidLockCursor();
        }

        if (Input.GetMouseButtonDown(1))
        {
            Screen.lockCursor = true;
        }

        if (Input.GetMouseButtonUp(1))
        {
            Screen.lockCursor = false;
        }
    }
}

Ever wish you could have a tool tip appear when hovering your mouse over a control in the inspector? Well look no further then Unity’s ToolTip attribute that you can apply to your MonoBehaviour’s fields!

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    [Tooltip("Health value between 0 and 100.")]
    public int health = 0;
}

Sometimes it is handy to keep a game object alive for as long as your game is running. In order to prevent your object from being destroyed when loading a new scene use GameObject.DontDestroyOnLoad and your game object will persist between scene changes.


If you need to retrieve the default Arial font via code at runtime you can do so using the Resources.GetBuiltInResource method.

var font = Resources.GetBuiltinResource(typeof(Font), "Arial.ttf") as Font;

If you need to stylize your gui you can use the GUISettings class to change, the cursor color, flash speed, the selection color for text fields, as well as double click behavior.

    public class GuiSettingsExample : MonoBehaviour
    {
        public Color cursorColor;     
        public float flashSpeed;      
        public bool doubleClickSelectWord;       
        public Color selectionColor;             
        public bool tripleCLickLine;             
        private string text = "test string";     
        private Vector2 scroll;                  
        public GUISkin skin;                     

        public void OnGUI()
        {
            GUI.skin = this.skin;
            var settings = GUI.skin.settings;
            settings.cursorColor = this.cursorColor;
            settings.cursorFlashSpeed = this.flashSpeed;
            settings.doubleClickSelectsWord = this.doubleClickSelectWord;
            settings.selectionColor = this.selectionColor;
            settings.tripleClickSelectsLine = this.tripleCLickLine;


            this.scroll = GUILayout.BeginScrollView(this.scroll, false, false, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
            this.text = GUILayout.TextArea(this.text);
            GUILayout.EndScrollView();
        }
    }

// <copyright>
//   Copyright (c) 2012 Codefarts
//   All rights reserved.
//   contact@codefarts.com
//   http://www.codefarts.com
// </copyright>

namespace Codefarts.ObjectPooling
{
    using System;

    /// <summary>
    /// Provides a generic object pooling manager.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ObjectPoolManager<T> where T : class
    {
        /// <summary>
        /// Holds a reference to a singleton instance.
        /// </summary>
        private static ObjectPoolManager<T> instance;

        /// <summary>
        /// Used to track the number of items that have been pushed to the pool.
        /// </summary>
        private int count;

        /// <summary>
        /// Holds the pooled item references.
        /// </summary>
        private T[] cachedItems = new T[10000];


        /// <summary>
        /// Gets or sets the creation callback.
        /// </summary>
        public Func<T> CreationCallback { get; set; }

        /// <summary>
        /// Gets the number of items in the pool.
        /// </summary>
        public int Count
        {
            get
            {
                return this.count;
            }
        }

        /// <summary>
        /// Pops a item from the pool.
        /// </summary>
        /// <returns>A pooled object reference.</returns>
        /// <exception cref="System.NullReferenceException">'CreationCallback' property must be set if you try to pop a item and there are no items available.</exception>
        public T Pop()
        {
            // lock here to prevent treading conflicts with array manipulation
            lock (this.cachedItems)
            {
                // check if there are any pooled objects
                if (this.count < 1)
                {
                    // check if creation callback is null
                    if (this.CreationCallback == null)
                    {
                        throw new NullReferenceException("'CreationCallback' property must be set if you try to pop a item and there are no items available.");
                    }

                    // there are no available objects so create a new one.
                    return this.CreationCallback();
                }

                // reduce the count
                this.count--;

                // retrieve the item and return it
                return this.cachedItems[this.count];
            }
        }

        /// <summary>
        /// Pushes the specified value.
        /// </summary>
        /// <param name="value">The value to push into the pool.</param>
        public void Push(T value)
        {
            // lock here to prevent treading conflicts with array manipulation
            lock (this.cachedItems)
            {
                // update the count
                this.count++;

                // if we need more room for storage increase the size of the cache array
                if (this.count > this.cachedItems.Length)
                {
                    Array.Resize(ref this.cachedItems, this.cachedItems.Length * 2);
                }

                // store the value 
                this.cachedItems[this.count - 1] = value;
            }
        }

        /// <summary>
        /// Gets the singleton instance of the class.
        /// </summary>
        public static ObjectPoolManager<T> Instance
        {
            get
            {
                return instance ?? (instance = new ObjectPoolManager<T>());
            }
        }
    }
}

And some unit tests to go along with it.

// <copyright>
//   Copyright (c) 2012 Codefarts
//   All rights reserved.
//   contact@codefarts.com
//   http://www.codefarts.com
// </copyright>

namespace Codefarts.Tests.ObjectPooling
{
    using System;

    using Codefarts.ObjectPooling;

    using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;

    [TestClass]
    public class ObjectPoolingManagerTests
    {
        ObjectPoolManager<TestObject> manager;

        [TestInitialize]
        public void Setup()
        {
            this.manager = new ObjectPoolManager<TestObject>();
        }

        [TestCleanup]
        public void Cleanup()
        {
            this.manager = null;
        }

        public class TestObject
        {
            public string stringValue;
            public int intValue;
        }

        [TestMethod]
        public void Pop_With_Empty_Pool_NoCallback()
        {
            try
            {
                var item = this.manager.Pop();
                Assert.IsNotNull(item);
            }
            catch (Exception ex)
            {
                Assert.IsTrue(ex is NullReferenceException);
            }
        }

        [TestMethod]
        public void Pop_With_Empty_Pool_WithCallback()
        {
            try
            {
                this.manager.CreationCallback = this.Callback;
                var item = this.manager.Pop();
                Assert.IsNotNull(item);
                Assert.AreEqual(0, item.intValue);
                Assert.AreEqual(null, item.stringValue);
            }
            catch (Exception ex)
            {
                Assert.IsTrue(ex is NullReferenceException);
            }
        }

        private TestObject Callback()
        {
            return new TestObject();
        }

        [TestMethod]
        public void Push_Object()
        {
            try
            {
                Assert.AreEqual(0, this.manager.Count);
                this.manager.Push(new TestObject());
                Assert.AreEqual(1, this.manager.Count);
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.ToString());
            }
        }

        [TestMethod]
        public void Push_Pop_Objects()
        {
            try
            {
                Assert.AreEqual(0, this.manager.Count);
                for (var i = 0; i < 3; i++)
                {
                    this.manager.Push(new TestObject() { stringValue = "Item" + i, intValue = i });
                }

                Assert.AreEqual(3, this.manager.Count);

                for (var i = 3 - 1; i >= 0; i--)
                {
                    var item = this.manager.Pop();
                    Assert.AreEqual(i, item.intValue);
                    Assert.AreEqual("Item" + i, item.stringValue);
                }

                Assert.AreEqual(0, this.manager.Count);
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.ToString());
            }
        }
    }
}

Did you know that the GUI class has a matrix property that you can use to rotate and scale your gui elements.

The sample behavior that is provided below will scale and rotate a gui label in the center of the screen.

public class GuiMatrixDemo : MonoBehaviour
{
    private float rotation;

    /// <summary>
    /// OnGUI is called for rendering and handling GUI events.
    /// </summary>
    public void OnGUI()
    {
        var matrix = GUI.matrix;

        GUI.Label(new Rect(5, 5, 100, 20), "before matrix");

        this.rotation += 15f * Time.deltaTime;
        var scale = Mathf.Clamp((float)Math.Sin(Time.time) + 1 * 2, 1, 3);
        GUI.matrix = Matrix4x4.TRS(new Vector3(Screen.width / 2, Screen.height / 2, 0), Quaternion.Euler(0, 0, this.rotation), Vector3.one * scale);
        var size = GUI.skin.label.CalcSize(new GUIContent("test string"));
        var rect = new Rect((-size.x / 2f), (-size.y / 2f), size.x, size.y);
        GUI.Label(rect, "test string");
        GUI.matrix = matrix;
        GUI.Label(new Rect(5, 25, 100, 20), "after matrix");
    }
}

CMS theory for websites part 1

Published 12/18/2013 by createdbyx in News | Programming
Tags:

NOTE: Originally written in March 2013 I’m only getting around to posting this now. :(

A long sorted history of technological bloat warez …

I have been kicking the following ideas around for a while now and may soon start to implement them. I have become frustrated with the whole slew of content management systems from Wordpress to BlogEngine. They all have a tendency to lock you into there system and there way of doing things not to mention that there is no guarantee that these platforms will exist or still be popular 5, 10, 20+ years from now as technology is constantly changing. The only thing that has remains relatively consistent over the last 20 years has been html markup. in other words the raw data.

I have maintained the content on this personal website of mine for over a decade even before I registered the domain createdbyx.com. And the one thing that has remained consistent is the manual labor involved every time I decided to port the content of this site over to a new platform from straight html pages, to DotNetNuke, to BlogEngine, to a partial port over to asp.net mvc etc. Porting the content over from one platform to the next, and having to adapt and convert the content from one database to another, one theme/skin system to another simply is not going to cut it any longer. As time goes on and as the volume of content continues to grow porting that content over to yet another platform becomes more and more tedious.

I am a long term thinker when it comes to this type of stuff because I fully intend to maintain and update this site for the next 50+ years and beyond. I care about preserving the content & data on my various web sites in a human readable platform independent format.

I began playing around with some ideas on my test server boobietaunt.com using asp.net mvc. My intension was to develop a single page website that had a similar Live Tiles system as the windows 8 start screen. The whole thing would in fact be rendered via jQuery GET requests and dynamically replace content on the page so there would actually be no page loading. But as I discovered search engines like Google frown on this because it’s too difficult for there systems to crawl & index the website content. And it would ultimately obliterate my SEO search rakings. So that approach was not going to work, not to mention the issues with managing history via JavaScript and browser incompatibility issues etc. *sigh* just kill me nao :(

Although I never fully abandon any of my coding work I did stop working on the asp.net mvc implementation of my prototype createdbyx.com website in favor of a even simpler solution. Or so I thought. With Asp.net mvc again I found myself needing to learn new ways of doing things IE: the mvc way of doing things, and not only that I was using the Razor view engine. As much as I applaud the effort of the asp.net mvc team for helping to make asp.net development more easier and cleaner, I decided to stop using it before I devoted too much time going down that rabbit hole.

With asp.net mvc I was locking my self into a system of Razor syntax and Controllers that was again pushing me further and further away and putting more technological layers in between what I was trying to do which was to simply serve up html content. At this point for reasons unknown I got it in my head that I could write a better system then the asp.net mvc team, and in some ways that’s just what I did. And I did it in around 1000 lines of code. I essentially created a simplified MVC clone with Controllers and Views that could be extended upon. A feat I am actually personally proud of considering it has many of the same core features as mvc but does it in just under 1000 lines of code. I wrote it back when mvc 1 was still in beta and just being introduced and then I abandoned it to go work on my various other projects.

The custom built mvc clone I created is (as of this writing) powering my codefarts.com website. After having dusted it off and used it to power my codefarts website I have again come to the conclusion that it is far too complicated a system to use even though it’s hardly any code at all and the compiled assemblies for handling localization, security, settings, blogging, Views, Controllers, and extensions only amount to a combined 175k worth of (debug) dll files.

CodeFartsbinaryfiles

The future going forward …

Trying to think up a ridiculously simple solution for publishing html content is deceptively complex with so many CMS choices out there, but there have been some new ways of doing things as of late that could change all that.

What if you could power a personal website without databases & without using a traditional content management system? What if you could create and update the content on your local machine, have it automatically backed up to the cloud, automatically synchronized across multiple computers, and have it support versioning & branching like a CVS all without even having to log in. You could search for content you have previously written, you could even create or edit content even if you were using someone else's computer, and it could support multiple contributors to your site.

Now what if you could do all of that using just html files and some popular free software. The answer is pretty much YES!

Here is a potential publishing scenario …

  1. Open up notepad or your favorite html editor and write some content
  2. Save to a specific folder on your computer
  3. The system automatically syncs the file to the cloud and all other computers of your choosing (Google Drive, SkyDrive, DropBox, AeroFS etc) providing automatic off site backups.
  4. Automatic syncing your local working copy of your site file to the webserver involves a program like SyncBack that runs at scheduled times via window scheduler to sync files to the web server.
  5. A program always running in the background could detect the changes and commit the changes to a local git repository. As well as the option to publish the files to a git server to provide yet another secondary off site back up.

These are just some of the scenarios that you could set up to automatically publish your website content to the web server.

The end goal?

The elimination of any and all unnecessary server side code. If I could think of a way to go back to managing a website using pure html pages I would, but there are some key pieces of server side code that still need to be present like site templates, a blogging and page caching system.

From a security standpoint the most secure code you can write is no code at all. The more code you write the more vulnerable you make yourself. So focusing on your absolute core needs is essential.

--------------------------------------

Since I originally wrote this post back in march 2013 I have since written a entirely new (and more simplified) web server back end and have ported the local copy of my codefarts.com website over to it. I’ll be making future posts regarding this new system and the reasons why it is even better then the custom built MVC clone I described earlier in this post.


The funny thing about brain disorders is that they affect the one part of your body that you are unable to perceive as being afflicted with something. Kind of like how crazy people don’t know there crazy.

When trying to come up with a name for this disorder I asked stack exchange and got a number of helpful responses. Everything from Analysis paralysis to having a Rube Goldberg mentality.

No matter what I do, I can't help but overcomplicate almost every piece of code/application I write. My mind automatically jumps to thoughts of 'OK, I'll need to write this, this, this, and this, and I'll need to make sure to use a repository and MVVM patterns, utilize this and that library' etc. An hour of coding later and it's already spiraling out of control with features & settings that don't need to be there.

This last week I have recently been spending some time on my old WowTracks.com website, in particular the data acquisition utilities needed to capture and store the World of Warcraft armory data. I started by thinking about what kind of app I needed and where it was going to be run. I considered writing it in Unity3D first so that I could port the application to multiple platforms, but unity’s GUI system is too much of a hassle when it comes to presenting large amounts of complex data. I also considered a win forms app, Windows store/Metro, WPF, Silverlight, or even a console application.

I ended up starting to write it as a console application thinking that I did not need to do anything fancy just create a app that schedules downloads of armory url’s at specified intervals. Didn’t take long for me to realize that a console app was not going to cut it.

I then started to write it as a win forms app only to discover that the data binding was severely lacking compared to WPF and I would have to do a lot of manual coding. After scrapping the win forms app in favor of a WPF app things were going fine until I ran into a little issue with my PC randomly freezing up for one second at a time then unfreezing for one second and repeating until I restarted my computer. At first it was confusing because even after managing to get visual studio to quit my system seemed fine but when I mouse over a link in a web browser (IE, Firefox, Chrome) would cause the system to start locking up for one second intervals again.

Initially it seemed like a virus or hacker got into my system as it was only affecting browser applications but from doing some internet searches it seems there is a huge bug with .net 4.0 and WPF. Something to do with UI automation and large complicated visual element trees causing WPF to cause a system to lockup and slow down. This did not bode well for writing the application in WPF.

*sigh* back to writing the app in win forms again. /rollseyes

After a week of back and fourth and nothing to really show for it, most of the time I spent and code I wrote got me further and further away from the end goal. Which leads me the title of this post. I have self diagnosed Anal-para-complica-tard-isis syndrome.  In other words I suffer from analysis paralysis complicatardation with acute over engineering retarex.

Definitions:
Complicatardation (n.) "someone who is retardedly over-complicated"
Retarex (adj.) "something that is complex to a retarded degree."
Portmanteau “a combination of two (or more) words or morphemes, and their definitions, into one new word.”

PS: You see what I did thar? :P


Code search woes

Published 11/27/2013 by createdbyx in News
Tags:

As a programmer I am getting a bit frustrated when it comes to repeating my self. 

I have started a few hundred .net projects over the last 10+ years and too often I find myself needing to write a piece of code that I am sure I've written before. As soon as I get a sense of dejavu I stop and think OK where and in what project could that piece of code be located. 

Performing windows explorer searches are useless in this case as you never know what the method name was or if it was a piece of code within a method. Simple text based file contents searches are just not up to the task. And they are painfully slow and can return hundreds of files.

There are similar solutions like Krugle, or Ack etc but many of these are on-line search tools. 

What I am looking for is something for windows that can run on my local machine and parse/understand C# .cs and VB.net .vb code files. 

A visual studio extension would be ideal, but the ones I've found only search the open solution not a entire folder hierarchy containing multiple projects etc.

For example I have written a piece of code that you give a directory path and it will return a list of files from that directory structure even files that are in sub folders. But here is what I know...

  1. It uses GetDirectory or GetFiles but does not use GetDirectories
  2. It's a method that takes at least 1 string parameter
  3. It returns a List<> string[] or some type that implements a IEnumerable interface
  4. It's less then 100 lines of code give or take
  5. It may or may not recursively call it self

Given these points of data search every folder and sub folder for methods within code files that contain the closest match.

If I can't find a utility to do this I'm going to say screw it and write my own. Even though I don't really want to have to.


Created by: X

Just another personal website in this crazy online world

Name of author Dean Lunz (aka Created by: X)
Computer programming nerd, and tech geek.
About Me -- Resume