2013-07-18 10:32:51 wyz365889 阅读数 11896

步骤描述:

1.首先下载LitJson源码

下载地址:http://lbv.github.io/litjson/

2.LitJson在Unity3d中的配置
Unity3d的assets中的plugins目录下新建一个文件夹litjson,然后把litjson的源代码中所有.cs文件放到这里。Unity3D文档描述中plugins目录中的脚本会先运行,这样保证在我们写其他脚本的时候,litjson已经加载并运行好了。

3.在脚本中引用litjson命名空间,using LitJson

例子解析:

using UnityEngine;
using System.Collections;
using LitJson;
public class UseJson : MonoBehaviour {

	// Use this for initialization
	void Start () {
		JsonData jsonData = new JsonData();
		
		jsonData["name"] = "wyz";
		jsonData["age"] = 28;
		jsonData["sex"] = "male";
		string  strJson = jsonData.ToJson(); //转化成json格式字符串
		
		Debug.Log(strJson); //result {"name":"wyz","age":28,"sex":"male"}
				
	
		JsonData jsonData2 = JsonMapper.ToObject(strJson);   //转化成json格式数据
		
		Debug.Log(jsonData2["name"]);	//wyz
		
		
		jsonData["info"] = new JsonData();
		jsonData["info"]["phone"] = 4424323;      
		jsonData["info"]["address"] = "fuzhou";
		strJson = jsonData.ToJson();
		
		Debug.Log(strJson);		//result:{"name":"wyz","age":28,"sex":"male","info":{"phone":4424323,"address":"fuzhou"}}
		
		JsonData jsonData3 = JsonMapper.ToObject(strJson);
		
		Debug.Log(jsonData3["info"]["phone"]);	//4424323
		
		Debug.Log(jsonData3["info"][1]);	//fuzhou
		
		Debug.Log(jsonData3["info"].Count);		//2
		
		JsonData data = new JsonData ();
                data.Add (1);
                data.Add (2);
                data.Add (3);
                data.Add ("Launch!");
	
		jsonData["myArray"] = data;//数组添加
		strJson = jsonData.ToJson();
		
		Debug.Log(strJson);	
		
		
		for(int i=0;i<jsonData.Count;i++)
		{
			print(jsonData[i]);
			if(jsonData[i].IsArray)
			{
				print(jsonData[i][3]);//数组解析
			}
		}
	
		
	}

}

结果如下:


          

2013-10-07 00:53:20 Meuck 阅读数 1163

为了学习unity3d 里面的换装, 将unity3d 里面的例子改了下, 把资源加载功能剔除, 仅仅保留最基本的换装。

原例子名字叫 CharacterCustomization。 

2013-07-03 21:48:42 bigpaolee 阅读数 14594

json:

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

{
    "name":"中国",
    "province":[
        {
            "name":"黑龙江",
            "cities":{
                "city":[
                    "哈尔滨",
                    "大庆"
                ]
            }
        },
        {
            "name":"广东",
            "cities":{
                "city":[
                    "广州",
                    "深圳",
                    "珠海"
                ]
            }
        },
        {
            "name":"台湾",
            "cities":{
                "city":[
                    "台北",
                    "高雄"
                ]
            }
        },
        {
            "name":"新疆",
            "cities":{
                "city":[
                    "乌鲁木齐"
                ]
            }
        }
    ]
}

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

 

public class JsonDeserialize 
{
    protected string url = "http://localhost:8080/AssetBundleData/Web/Singlea/";
}


using UnityEngine;
using System.Collections.Generic;

public class ChinaJsonDeserialize : JsonDeserialize 
{
    private China _china;

    public China china
    {
        get 
        {
            return _china;
        }
    }

    public ChinaJsonDeserialize(string jsonData)
    {
        _china = new China();
        ParseJson(jsonData);
    }

    void ParseJson(string jsonData)
    {
        
        if (string.IsNullOrEmpty(jsonData))
        {
            Debug.LogError("ChinaJson is null or empty");
            return;
        } 

        Dictionary<string, object> jsonObjects = MiniJSON.Json.Deserialize(jsonData) as Dictionary<string, object>;
        _china.chinaName = jsonObjects["name"].ToString();
        _china.province = new List<Province>();

        List<object> provinceList = jsonObjects["province"] as List<object>;

        foreach (var i in provinceList)
        {
            Dictionary<string, object> province = i as Dictionary<string, object>;
            Province provinceObj = new Province();
            provinceObj.provinceName = province["name"].ToString();
            provinceObj.city = new List<City>();

            Dictionary<string, object> citesDic = province["cities"] as Dictionary<string, object>;

            List<object> childCitesList = citesDic["city"] as List<object>;
            foreach (var childCity in childCitesList)
            {
                City city = new City();
                city.cityName = childCity.ToString();

                provinceObj.city.Add(city);
            }

            _china.province.Add(provinceObj);
        }
    }
}

public class China
{
    public string chinaName;
    public List<Province> province;
}

public class Province
{
    public string provinceName;
    public List<City> city;
}

public class City
{
    public string cityName;
}


using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace MiniJSON {
   
    public static class Json {
        /// <summary>
        /// Parses the string json into a value
        /// </summary>
        /// <param name="json">A JSON string.</param>
        /// <returns>An List<object>, a Dictionary<string, object>, a double, an integer,a string, null, true, or false</returns>
        public static object Deserialize(string json) {
            // save the string for debug information
            if (json == null) {
                return null;
            }

            return Parser.Parse(json);
        }

        sealed class Parser : IDisposable {
            const string WHITE_SPACE = " \t\n\r";
            const string WORD_BREAK = " \t\n\r{}[],:\"";

            enum TOKEN {
                NONE,
                CURLY_OPEN,
                CURLY_CLOSE,
                SQUARED_OPEN,
                SQUARED_CLOSE,
                COLON,
                COMMA,
                STRING,
                NUMBER,
                TRUE,
                FALSE,
                NULL
            };

            StringReader json;

            Parser(string jsonString) {
                json = new StringReader(jsonString);
            }

            public static object Parse(string jsonString) {
                using (var instance = new Parser(jsonString)) {
                    return instance.ParseValue();
                }
            }

            public void Dispose() {
                json.Dispose();
                json = null;
            }

            Dictionary<string, object> ParseObject() {
                Dictionary<string, object> table = new Dictionary<string, object>();

                // ditch opening brace
                json.Read();

                // {
                while (true) {
                    switch (NextToken) {
                    case TOKEN.NONE:
                        return null;
                    case TOKEN.COMMA:
                        continue;
                    case TOKEN.CURLY_CLOSE:
                        return table;
                    default:
                        // name
                        string name = ParseString();
                        if (name == null) {
                            return null;
                        }

                        // :
                        if (NextToken != TOKEN.COLON) {
                            return null;
                        }
                        // ditch the colon
                        json.Read();

                        // value
                        table[name] = ParseValue();
                        break;
                    }
                }
            }

            List<object> ParseArray() {
                List<object> array = new List<object>();

                // ditch opening bracket
                json.Read();

                // [
                var parsing = true;
                while (parsing) {
                    TOKEN nextToken = NextToken;

                    switch (nextToken) {
                    case TOKEN.NONE:
                        return null;
                    case TOKEN.COMMA:
                        continue;
                    case TOKEN.SQUARED_CLOSE:
                        parsing = false;
                        break;
                    default:
                        object value = ParseByToken(nextToken);

                        array.Add(value);
                        break;
                    }
                }

                return array;
            }

            object ParseValue() {
                TOKEN nextToken = NextToken;
                return ParseByToken(nextToken);
            }

            object ParseByToken(TOKEN token) {
                switch (token) {
                case TOKEN.STRING:
                    return ParseString();
                case TOKEN.NUMBER:
                    return ParseNumber();
                case TOKEN.CURLY_OPEN:
                    return ParseObject();
                case TOKEN.SQUARED_OPEN:
                    return ParseArray();
                case TOKEN.TRUE:
                    return true;
                case TOKEN.FALSE:
                    return false;
                case TOKEN.NULL:
                    return null;
                default:
                    return null;
                }
            }

            string ParseString() {
                StringBuilder s = new StringBuilder();
                char c;

                // ditch opening quote
                json.Read();

                bool parsing = true;
                while (parsing) {

                    if (json.Peek() == -1) {
                        parsing = false;
                        break;
                    }

                    c = NextChar;
                    switch (c) {
                    case '"':
                        parsing = false;
                        break;
                    case '\\':
                        if (json.Peek() == -1) {
                            parsing = false;
                            break;
                        }

                        c = NextChar;
                        switch (c) {
                        case '"':
                        case '\\':
                        case '/':
                            s.Append(c);
                            break;
                        case 'b':
                            s.Append('\b');
                            break;
                        case 'f':
                            s.Append('\f');
                            break;
                        case 'n':
                            s.Append('\n');
                            break;
                        case 'r':
                            s.Append('\r');
                            break;
                        case 't':
                            s.Append('\t');
                            break;
                        case 'u':
                            var hex = new StringBuilder();

                            for (int i=0; i< 4; i++) {
                                hex.Append(NextChar);
                            }

                            s.Append((char) Convert.ToInt32(hex.ToString(), 16));
                            break;
                        }
                        break;
                    default:
                        s.Append(c);
                        break;
                    }
                }

                return s.ToString();
            }

            object ParseNumber() {
                string number = NextWord;

                if (number.IndexOf('.') == -1) {
                    long parsedInt;
                    Int64.TryParse(number, out parsedInt);
                    return parsedInt;
                }

                double parsedDouble;
                Double.TryParse(number, out parsedDouble);
                return parsedDouble;
            }

            void EatWhitespace() {
                while (WHITE_SPACE.IndexOf(PeekChar) != -1) {
                    json.Read();

                    if (json.Peek() == -1) {
                        break;
                    }
                }
            }

            char PeekChar {
                get {
                    return Convert.ToChar(json.Peek());
                }
            }

            char NextChar {
                get {
                    return Convert.ToChar(json.Read());
                }
            }

            string NextWord {
                get {
                    StringBuilder word = new StringBuilder();

                    while (WORD_BREAK.IndexOf(PeekChar) == -1) {
                        word.Append(NextChar);

                        if (json.Peek() == -1) {
                            break;
                        }
                    }

                    return word.ToString();
                }
            }

            TOKEN NextToken {
                get {
                    EatWhitespace();

                    if (json.Peek() == -1) {
                        return TOKEN.NONE;
                    }

                    char c = PeekChar;
                    switch (c) {
                    case '{':
                        return TOKEN.CURLY_OPEN;
                    case '}':
                        json.Read();
                        return TOKEN.CURLY_CLOSE;
                    case '[':
                        return TOKEN.SQUARED_OPEN;
                    case ']':
                        json.Read();
                        return TOKEN.SQUARED_CLOSE;
                    case ',':
                        json.Read();
                        return TOKEN.COMMA;
                    case '"':
                        return TOKEN.STRING;
                    case ':':
                        return TOKEN.COLON;
                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                    case '-':
                        return TOKEN.NUMBER;
                    }

                    string word = NextWord;

                    switch (word) {
                    case "false":
                        return TOKEN.FALSE;
                    case "true":
                        return TOKEN.TRUE;
                    case "null":
                        return TOKEN.NULL;
                    }

                    return TOKEN.NONE;
                }
            }
        }

        /// <summary>
        /// Converts a IDictionary / IList object or a simple type (string, int, etc.) into a JSON string
        /// </summary>
        /// <param name="json">A Dictionary<string, object> / List<object></param>
        /// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
        public static string Serialize(object obj) {
            return Serializer.Serialize(obj);
        }

        sealed class Serializer {
            StringBuilder builder;

            Serializer() {
                builder = new StringBuilder();
            }

            public static string Serialize(object obj) {
                var instance = new Serializer();

                instance.SerializeValue(obj);

                return instance.builder.ToString();
            }

            void SerializeValue(object value) {
                IList asList;
                IDictionary asDict;
                string asStr;

                if (value == null) {
                    builder.Append("null");
                }
                else if ((asStr = value as string) != null) {
                    SerializeString(asStr);
                }
                else if (value is bool) {
                    builder.Append(value.ToString().ToLower());
                }
                else if ((asList = value as IList) != null) {
                    SerializeArray(asList);
                }
                else if ((asDict = value as IDictionary) != null) {
                    SerializeObject(asDict);
                }
                else if (value is char) {
                    SerializeString(value.ToString());
                }
                else {
                    SerializeOther(value);
                }
            }

            void SerializeObject(IDictionary obj) {
                bool first = true;

                builder.Append('{');

                foreach (object e in obj.Keys) {
                    if (!first) {
                        builder.Append(',');
                    }

                    SerializeString(e.ToString());
                    builder.Append(':');

                    SerializeValue(obj[e]);

                    first = false;
                }

                builder.Append('}');
            }

            void SerializeArray(IList anArray) {
                builder.Append('[');

                bool first = true;

                foreach (object obj in anArray) {
                    if (!first) {
                        builder.Append(',');
                    }

                    SerializeValue(obj);

                    first = false;
                }

                builder.Append(']');
            }

            void SerializeString(string str) {
                builder.Append('\"');

                char[] charArray = str.ToCharArray();
                foreach (var c in charArray) {
                    switch (c) {
                    case '"':
                        builder.Append("\\\"");
                        break;
                    case '\\':
                        builder.Append("\\\\");
                        break;
                    case '\b':
                        builder.Append("\\b");
                        break;
                    case '\f':
                        builder.Append("\\f");
                        break;
                    case '\n':
                        builder.Append("\\n");
                        break;
                    case '\r':
                        builder.Append("\\r");
                        break;
                    case '\t':
                        builder.Append("\\t");
                        break;
                    default:
                        int codepoint = Convert.ToInt32(c);
                        if ((codepoint >= 32) && (codepoint <= 126)) {
                            builder.Append(c);
                        }
                        else {
                            builder.Append("\\u" + Convert.ToString(codepoint, 16).PadLeft(4, '0'));
                        }
                        break;
                    }
                }

                builder.Append('\"');
            }

            void SerializeOther(object value) {
                if (value is float
                    || value is int
                    || value is uint
                    || value is long
                    || value is double
                    || value is sbyte
                    || value is byte
                    || value is short
                    || value is ushort
                    || value is ulong
                    || value is decimal) {
                    builder.Append(value.ToString());
                }
                else {
                    SerializeString(value.ToString());
                }
            }
        }
    }
}



 

 

2013-06-21 20:39:46 UnSkyToo 阅读数 8788

学习Unity3D有一段时间了,突然想起来该把自己学习的写出博客,方便以后复习。


那就从今天开始吧


今天遇到一个问题,在用Unity3D做2D游戏的动画播放器的时候(没有用第三方的插件)发现一个问题。

Unity3D的中1个单位是一米,但我却不知道是多少像素


举个例子,我有一张 400*300的 Texture,我新建了一个分辨率为800*600的工程

并且在工程中创建了一个Plane用来保存Texture


理论上来说,这个图像显示在屏幕上,应该是占用屏幕1/4的位置,长宽都为屏幕的一半才对


但实际上,显示的大小与你的Plane的Tranform.Scale设置有关(默认为1,1,1)


如果设置Scale,让它达到我们想要的效果。400的像素,我该设置Scale的值为多少?



经过网上查找,解决办法如下


设置Camera的Projection为Otrhgraphic

并且设置Size为屏幕的一半(这里为300)


接下来就简单了。

把Plane的各个方向缩放图片大小的十分之一就可以了


这个例子中,图片大小为400*300,那么设置为Scale(40, 1, 40)


好了,问题解决了,虽然不是很完美,但做2D游戏,暂时可以了


附上2D动画播放器的代码(代码啰嗦了一点)


动画播放器的代码如下

using UnityEngine;
using System.Collections;

public class AnimationManager : MonoBehaviour
{
    public Material AnimationMaterial;

    public int RowFrameCount; // 每一行的帧数
    public int ColFrameCount; // 每一列的帧数
    public int TotalFrame; // 总帧数

    public int FrameWidth; // 每一帧的宽度
    public int FrameHeight;  // 每一帧的高度

    public int FPS; // 每秒播放的帧数
    public bool Loop = false; // 是否循环播放

    private int CurrRowFrame; // 当前帧的行
    private int CurrColFrame; // 当前帧的列

    private bool IsEnd; // 是否结束了

    private float elapsedTime; // 记录播放的时间
    private float frameTime; // 每一帧的时间(1 / fps)

	void Start()
    {
        renderer.material = AnimationMaterial;
        
        renderer.material.SetTextureScale("_MainTex", new Vector2(1.0f / RowFrameCount, 1.0f / ColFrameCount));
        renderer.material.SetTextureOffset("_MainTex", new Vector2(0, 0));

        // 设置Camera的视图为正交矩阵,然后设置Size = Screen.Heigh / 2
        // 设置GameObject的Scale为Texture2D的十分之一即可
        transform.localScale = new Vector3(FrameWidth / 10, 1, FrameHeight / 10);

        CurrColFrame = 0;
        CurrRowFrame = 0;

        IsEnd = false;

        frameTime = 1.0f / FPS;
        elapsedTime = frameTime;

        if (TotalFrame == 0)
        {
            TotalFrame = RowFrameCount * ColFrameCount;
        }
	}

	void Update()
    {
        if (IsEnd)
        {
            return;
        }

        elapsedTime += Time.deltaTime;

        if (elapsedTime >= frameTime)
        {
            elapsedTime -= frameTime;

            CurrRowFrame++;

            if (CurrRowFrame + CurrColFrame * RowFrameCount >= TotalFrame)
            {
                // 播放完成,如果循环
                if (Loop)
                {
                    CurrRowFrame = 0;
                    CurrColFrame = 0;
                }
                else
                {
                    IsEnd = true;
                    return;
                }
            }

            // 换行
            if (CurrRowFrame >= RowFrameCount)
            {
                CurrRowFrame = 0;

                CurrColFrame++;

                if (CurrRowFrame + CurrColFrame * RowFrameCount >= TotalFrame)
                {
                    // 播放完成,如果循环
                    if (Loop)
                    {
                        CurrRowFrame = 0;
                        CurrColFrame = 0;
                    }
                    else
                    {
                        IsEnd = true;
                        return;
                    }
                }

                // 换列
                if (CurrColFrame >= ColFrameCount)
                {
                    // 播放完成,如果循环
                    if (Loop)
                    {
                        CurrRowFrame = 0;
                        CurrColFrame = 0;
                    }
                    else
                    {
                        IsEnd = true;
                        return;
                    }
                }
            }

            SetMaterialOffset();
        }
	}

    private void SetMaterialOffset()
    {
        SetMaterialOffset(new Vector2(
            (float)CurrRowFrame * 1.0f / (float)RowFrameCount,
            (float)(ColFrameCount - 1 - CurrColFrame) * 1.0f / (float)ColFrameCount)); // 翻转纹理的坐标
    }

    private void SetMaterialOffset(Vector2 offset)
    {
        renderer.material.SetTextureOffset("_MainTex", offset);
    }
}
2014-04-28 21:50:49 ggtaas 阅读数 3575

今天用了一下最新的Vuforia for unity3d的例子2-813版本,导入我的unity3d之后,发现ARCamera的检视面板下很多熟悉的元素都不见了,根本没法修改标志,如图所示。而且打开的脚本统统没有几行代码,代码不见了。因此也就没法继续进行开发。之前也有网友问过我这个问题。所以在这里就简单说下解决办法:

主要问题出在Unity3d版本上,我用的是4.0,我换成4.3之后,就没有任何问题了。跟平常一样进行开发,看我的这篇教程:

unity3d+Vuforia开发AR应用



AR研发团队招募有梦想的年轻人,有兴趣可以私信我,最好是在深圳。

没有更多推荐了,返回首页