Tab Mapper

Tab or chord file URL

The tab mapper is a handy little tool that will render a guitar tab file with graphic chord diagrams displayed alongside. This comes in handy for people who just don't have every single chord shape memorized. Just plug in the web site address of a valid .tab or .crd file and hit "Go". In general, the tab mapper does a better job with printer friendly URLs. If there is more than one way to play a chord, the tab mapper will choose the most common shape. To see other fingerings, click on the chord diagram and you will be taken to the chord calculator.

Original file located @ http://zedia.net.

Shader "Unlit/Transparent Colored Blurred"
{
  Properties
  {
    _MainTex ("Base (RGB), Alpha (A)", 2D) = "white" {}
    _Distance ("Distance", Float) = 0.015
  }
 
  SubShader
  {
    LOD 100
 
    Tags
    {
      "Queue" = "Transparent"
      "IgnoreProjector" = "True"
      "RenderType" = "Transparent"
    }
 
    Cull Off
    Lighting Off
    ZWrite Off
    Fog { Mode Off }
    Offset -1, -1
    Blend SrcAlpha OneMinusSrcAlpha
 
    Pass
    {
      CGPROGRAM
      #pragma vertex vertexProgram
      #pragma fragment fragmentProgram
 
      #include "UnityCG.cginc"
 
      struct appdata_t
      {
        float4 vertex : POSITION;
        float2 textureCoordinate : TEXCOORD0;
        fixed4 color : COLOR;
      };
 
      struct vertexToFragment
      {
        float4 vertex : SV_POSITION;
        half2 textureCoordinate : TEXCOORD0;
        fixed4 color : COLOR;
      };
 
      sampler2D _MainTex;
      float4 _MainTex_ST;
      float _Distance;
 
      vertexToFragment vertexProgram (appdata_t vertexData)
      {
        vertexToFragment output;
        output.vertex = mul(UNITY_MATRIX_MVP, vertexData.vertex);
        output.textureCoordinate = TRANSFORM_TEX(vertexData.textureCoordinate, _MainTex);
        output.color = vertexData.color;
        return output;
      }
 
      fixed4 fragmentProgram (vertexToFragment input) : COLOR
      {
        float distance = _Distance;
        fixed4 computedColor = tex2D(_MainTex, input.textureCoordinate) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x + distance , input.textureCoordinate.y + distance )) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x + distance , input.textureCoordinate.y)) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x , input.textureCoordinate.y + distance )) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x - distance , input.textureCoordinate.y - distance )) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x + distance , input.textureCoordinate.y - distance )) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x - distance , input.textureCoordinate.y + distance )) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x - distance , input.textureCoordinate.y)) * input.color;
        computedColor += tex2D(_MainTex, half2(input.textureCoordinate.x , input.textureCoordinate.y - distance )) * input.color;
        computedColor = computedColor / 9;
 
        return computedColor;
      }
      ENDCG
    }
  }
}

Shader "Unlit/Transparent Colored Masked"
{
	Properties
	{
		_MainTex ("Base (RGB), Alpha (A)", 2D) = "white" {}
		_AlphaTex ("MaskTexture", 2D) = "white" {}
	}
 
	SubShader
	{
		LOD 100
 
		Tags
		{
			"Queue" = "Transparent"
			"IgnoreProjector" = "True"
			"RenderType" = "Transparent"
		}
 
		Cull Off
		Lighting Off
		ZWrite Off
		Fog { Mode Off }
		Offset -1, -1
		Blend SrcAlpha OneMinusSrcAlpha
 
		Pass
		{
			CGPROGRAM
				#pragma vertex vertexProgram
				#pragma fragment fragmentProgram
 
				#include "UnityCG.cginc"
 
				struct appdata_t
				{
					float4 vertex : POSITION;
					float2 textureCoordinate : TEXCOORD0;
					fixed4 color : COLOR;
				};
 
				struct vertexToFragment
				{
					float4 vertex : SV_POSITION;
					half2 textureCoordinate : TEXCOORD0;
					fixed4 color : COLOR;
				};
 
				sampler2D _MainTex;
				float4 _MainTex_ST;
				sampler2D _AlphaTex;
 
				vertexToFragment vertexProgram (appdata_t vertexData)
				{
					vertexToFragment output;
					output.vertex = mul(UNITY_MATRIX_MVP, vertexData.vertex);
					output.textureCoordinate = TRANSFORM_TEX(vertexData.textureCoordinate, _MainTex);
					output.color = vertexData.color;
					return output;
				}
 
				fixed4 fragmentProgram (vertexToFragment input) : COLOR
				{
					fixed4 computedColor = tex2D(_MainTex, input.textureCoordinate) * input.color;
					fixed4 alphaGuide = tex2D(_AlphaTex, input.textureCoordinate);
 
					if (alphaGuide.a < computedColor.a) computedColor.a = alphaGuide.a;
 
					return computedColor;
				}
			ENDCG
		}
	}
}

Shader "Unlit/Transparent Colored with mask" {
  Properties {
    _MainTex ("Base (RGB), Alpha (A)", 2D) = "white" {}
    _AlphaTex ("Yeahyeah", 2D) = "white" {}
  }
 
  SubShader{
    LOD 100
 
    Tags{
      "Queue" = "Transparent"
      "IgnoreProjector" = "True"
      "RenderType" = "Transparent"
    }
 
    Pass {
      Cull Off
      Lighting Off
      ZWrite Off
      Fog { Mode Off }
      Offset -1, -1
      ColorMask RGB
      AlphaTest Greater .01
      Blend SrcAlpha OneMinusSrcAlpha
      ColorMaterial AmbientAndDiffuse
 
      SetTexture [_MainTex] {
        Combine Texture * Primary
      }
 
      SetTexture [_AlphaTex] {
        Combine previous, texture
      }
    }
  }
}

_newTexture = NGUITools.AddWidget<UITexture>(gameObject);
_newTexture.pivot = UIWidget.Pivot.TopLeft;
_newTexture.material = new Material(Shader.Find("Unlit/Transparent Colored with mask"));
_newTexture.mainTexture = myTexture2D;
_newTexture.MakePixelPerfect();
 
//now we give the shader the textures
 
_newTexture.material.SetTexture(<wbr />"_MainTex", testRed);
_newTexture.material.SetTexture(<wbr />"_AlphaTex", testAlpha);

public class CreateGameObject : EditorWindow{
	[MenuItem("zedia/Utility/GameObject Creator")]
	public static void ShowWindow() {
		EditorWindow.GetWindow<CreateGameObject>("GameObject Creator");
	}
 
	void OnGUI (){
		GUILayout.Label("GameObject Creator4", EditorStyles.boldLabel);
		GUILayout.Label("Creates a new GameObject under the selected GameObject in the Hierarchy,", EditorStyles.label);
		GUILayout.Label("with local position (0,0,0) and local scale (1,1,1)", EditorStyles.label);
		EditorGUILayout.Separator();
		GUILayout.BeginHorizontal();
 
		var retainValue = GUILayout.Button("Add GameObject To:");
		GameObject sel = EditorGUILayout.ObjectField(Selection.activeGameObject, typeof(GameObject), true, GUILayout.Width(140f)) as GameObject;
		if (retainValue){
			CreateTheEmptyGameObject();
		}
	}
 
	public static void CreateTheEmptyGameObject(){
		GameObject newGameObject = new GameObject();
		newGameObject.transform.parent = Selection.activeGameObject.transform;
		newGameObject.transform.localScale = new Vector3(1,1,1);
		newGameObject.transform.localPosition = new Vector3(0,0,0);
		Selection.activeObject = newGameObject;
	}
 
	void OnSelectionChange () { Repaint(); }
}

using UnityEngine;
using System.Collections;
using UnityEditor;
 
public class CreateGameObjectCommand : MonoBehaviour {
	[MenuItem("zedia/Utility/GameObject Creator Command #%m")]
	static void CreateGameObject () {
		GameObject newGameObject = new GameObject();
		newGameObject.transform.parent = Selection.activeGameObject.transform;
		newGameObject.transform.localScale = new Vector3(1,1,1);
		newGameObject.transform.localPosition = new Vector3(0,0,0);
		Selection.activeObject = newGameObject;
	}
}

gameObject.x = 30;

gameObject.tranform.localPosition = new Vector3d (30,  gameObject.tranform.localPosition.y, gameObject.tranform.localPosition.z);