justyx's questions

冒着捡帽子的风险，我还是问了这个问题。

需要为Unity3d编写一个着色器，它看起来是最简单的，呈放射状出现的图像（如下面的 gif 中所示），但具有模糊和渐变透明效果。也就是说，填充图像的一段（例如 30 度）- 不清晰可见，但透明度平滑过渡（下图中的示例）。

同时，零透明度的图像有最大的模糊（虽然它在透明图像上不可见，并且在这个例子中不是很清楚，但是因为当使用着色器时它会应用于照片之间的过渡，一切将在那里清晰可见）并且随着单个像素的透明度降低，它们的模糊程度也会降低。因此，如果透明度为 100（不透明），则模糊 = 0。

看了好几篇文章，脑子里还是想不通。我读了高斯模糊是如何实现的（平均每列/行的精灵上最近像素的 rgb 值），我知道有必要为此附加透明度并根据另一个改变一个，但是，例如，如何做到这一切，直接在代码中，这里还附上了动画，我完全不明白（虽然我明白有一个属性，_TransVal有一个#pragma alpha负责透明度的参数）。

因为 我以前不必编写着色器，老实说，我在 Internet 上找到的那些文章并没有带来太多清晰度 - 特别是在实现问题上。非常了解着色器是什么、它们是什么以及为什么 - 我有它。

如果有人承诺使用我的任务示例逐步描述实施过程并进行解释，我将不胜感激：他们说我们为此需要这个，为此，这就是我们将如何改变模糊，这就是透明度，这就是我们添加动画的方式。

更新 我能够实现的目标：通过调整我在 delirium 中收集的误解的 sigma 和 cutoff 值（由于我缺乏编写着色器的经验），我需要的一切都会发生，除了一个 BUT，精灵在这一切的背后，它从何而来，如何摆脱它，我仍然无法理解。

http://g.recordit.co/rUaGYdynQ3.gif（大图）。

此材质（带着色器）应用于图像。图像和画布，它们被放置在由单独的相机渲染的transparentfx层上（该层在主相机上被禁用）。仍然需要了解如何在后面禁用（或从渲染中删除）这个精灵，并以最小的形式解决任务（填充边缘的透明度不再重要，至少要处理模糊）。

更新 2如果您将它设置在Image类型本身上filled并转动旋钮，任务就解决了fill amount。但是如何人为地关闭图像的渲染，只留下真实的渲染，仍然是不可理解的。

着色器输出：

更新 12 月 29 日 意识到我不太擅长像人一样写作，我尝试使用 Shader Forge，它似乎达到了预期的效果（必要的效果之一）。但结果很奇怪，在某种意义上，在单元的检查器窗口中显示了应有的效果，而在游戏场景中，可以说它表现得“简化”了。请参阅下面的 gif 以更好地理解。GIF1，检查器窗口。 GIF2，游戏窗口

在 Unity 中出现与 instagram API 交互的任务，决定不重新发明轮子并使用现成的解决方案。找了2个库，一个 https://github.com/vespassassina/.NET-Instagram-API-Wrapper https://github.com/InstaSharp/InstaSharp 第二个因为需要支持.net版本被砍掉了高于 2.0（在 Unity 中，不幸的是到目前为止只有它，在 11 月的发布中似乎承诺支持 4.6）。我选择了第一个库，遗憾的是我不明白如何将它正确导入到Unity项目中。

我尝试这样做：我下载了存储库并将其统一放在资产文件夹中，然后在 visual studio 中我将这个库的 2 个现有项目添加到当前解决方案（这会创建统一），并通过添加来自主项目的链接右键单击项目 => 添加链接 => 并指示该库的 2 个项目，在 visual studio 中一切看起来都很好，它们使用 apibase 和 instagram.api 进行连接； 但与此同时，当切换到 Unity 时，错误挂起

实际上问题是如何将库添加到项目中？

更新 关闭和打开 visual studio 时，似乎指向 2 个添加项目的链接消失了，就好像 Unity 以某种方式修改了解决方案一样。

或者我做错了。

我将数据传递给函数进行处理，以便随后将处理结果写入文本文件。从日志触发的顺序来看，我明白问题是值没有时间返回，但我不知道如何处理。我真的需要建议。实际功能本身：

function convertMe(polygonArray){
var toWrite = '';
var dataToReturn = '';

var polygon = JSON.parse(polygonArray);
var isFirst = true;
var printFeature = function (name, poly) {
  var out = {
    "type": "Feature",
    "properties": {
      'name': name,
    },
    "geometry": {
      "type": "Polygon",
      "coordinates": poly
    }
  };
  out = JSON.stringify(out);
  if(!isFirst) {
    out = ',' + out
  }
  isFirst = false;

  toWrite = toWrite + out;
}
toWrite = toWrite + '{"type": "FeatureCollection","features": [';
async.mapSeries([polygon], function (poly, cb) {

  var options = {
    coords: poly,
    precision: 6,
    rowMode: true,
    hashMode: 'extent',
    threshold: 0.2
  };
  printFeature('shape', poly);
  var rowStream = hasher.stream(options),
    a = 0;

  rowStream
    .on('end', cb)
    .pipe(through2.obj(function (arr, enc, callback) {
      for(var i = 0; i < arr.length; i++) {
        var bb = ngeohash.decode_bbox(arr[i]);
        printFeature(arr[i], [
              [
                [bb[1], bb[2]],
                [bb[3], bb[2]],
                [bb[3], bb[0]],
                [bb[1], bb[0]],
                [bb[1], bb[2]]
              ]]);
      }
      callback();
    }));
}, function () {
  toWrite = toWrite + ']}';
  console.log('Внутри вызова '+toWrite);
  return toWrite;
});

};

通话地点：

worldData.features.forEach(function(feature){
q.defer(function(done){
  var dataToConvert = JSON.stringify(feature.geometry.coordinates);
  console.log('Место вызова '+convertMe(dataToConvert));
  //fs.writeFileSync(currDir+'/'+outputDir+'/'+'cell_'+i+'.s2', convertMe(dataToConvert));

  i++;
  done()
   });
});

控制台输出：

Место вызова undefined
Внутри вызова {"type": "FeatureCollection","features": [{"type":"Feature","properties":{"name":"shape"},"geometry":{"type":"Polygon","coordinates":[[[[-56.0828202,46.8785071],[-56.0832065,46.8780553],[-56.0840219,46.877938],[-56.0843308,46.8776271],[-56.0848973,46.8777385],[-56.0852407,46.8776564],[-56.0858329,46.8777385],[-56.0865109,46.8773278],[-56.0874293,46.8769875],[-56.0878327,46.877146],[-56.0880559,46.8770697],[-56.0886396,46.8767118],[-56.0895236,46.8764771],[-56.0898154,46.8763011],[-56.0900643,46.8759197],[-56.0904506,46.8756733],[-56.0915664,46.8757554],[-56.0923045,46.8757437],[-56.0929568,46.8755618],[-56.0933002,46.8758024],[-56.0939696,46.8763656],[-56.0944245,46.8769054],[-56.0951026,46.8773689],[-56.0945619,46.8778089],[-56.0939868,46.8784015],[-56.0929483,46.8789295],[-56.0917295,46.8794399],[-56.0907767,46.8796981],[-56.0896781,46.8799797],[-56.0895408,46.8801029],[-56.0891803,46.8802613],[-56.0892404,46.8804549],[-56.0888112,46.88076],[-56.0883048,46.880801],[-56.0880044,46.8810533],[-56.0866397,46.8813232],[-56.0853265,46.8811354],[-56.0846227,46.8810357],[-56.0850347,46.8808069],[-56.084163,46.8808322],[-56.083258,46.8804314],[-56.0830348,46.8801791],[-56.0830434,46.8797333],[-56.0830863,46.8794399],[-56.0837043,46.8792757],[-56.0834468,46.8791994],[-56.0835841,46.8790586],[-56.0833266,46.8789706],[-56.0832665,46.8788239],[-56.0835498,46.8784308],[-56.0830348,46.8786948],[-56.0828202,46.8785071]]]]}},{"type":"Feature","properties":{"name":"fb24ew"},"geometry":{"type":"Polygon","coordinates":[[[-56.09619140625,46.8841552734375],[-56.085205078125,46.8841552734375],[-56.085205078125,46.878662109375],[-56.09619140625,46.878662109375],[-56.09619140625,46.8841552734375]]]}},{"type":"Feature","properties":{"name":"fb24ey"},"geometry":{"type":"Polygon","coordinates":[[[-56.085205078125,46.8841552734375],[-56.07421875,46.8841552734375],[-56.07421875,46.878662109375],[-56.085205078125,46.878662109375],[-56.085205078125,46.8841552734375]]]}},{"type":"Feature","properties":{"name":"fb24et"},"geometry":{"type":"Polygon","coordinates":[[[-56.09619140625,46.878662109375],[-56.085205078125,46.878662109375],[-56.085205078125,46.8731689453125],[-56.09619140625,46.8731689453125],[-56.09619140625,46.878662109375]]]}},{"type":"Feature","properties":{"name":"fb24ev"},"geometry":{"type":"Polygon","coordinates":[[[-56.085205078125,46.878662109375],[-56.07421875,46.878662109375],[-56.07421875,46.8731689453125],[-56.085205078125,46.8731689453125],[-56.085205078125,46.878662109375]]]}}]}

也就是说，首先我从调用的地方得到 Undefined，然后才在这个地方得到工作的结果（顺便说一句，正确的和我需要的）

任务：我从服务器（不是我的）收集地理数据。为此，我形成了对特定坐标区间的请求，并在 for 循环中向服务器发送请求。我将答案写入文件，这样服务器就不会禁止我通过 tor-control 更改 ip 地址。等待响应是使用 promise 实现的。这是理想的。事实上（根据控制台中的日志判断），数据是随机发送的。告诉我哪里走错了。

for (var i = xMin; i <= xMax; i++) {
    for (var k = yMin; k <= yMax; k++) {
        var swp = swPoint(k, i);
        var nep = nePoint(k, i);
        var llsw = pointToLatLong(swp[0], swp[1]);
        var llne = pointToLatLong(nep[0], nep[1]);
        var datatosend = 'fromlat=' + llsw[0].toString() + 'tolat=' + llne[0].toString() + 'fromlng=' + llsw[1].toString() + 'tolng' + llne[1].toString();

        currX = k;
        currY = i;

        filename = "json/" + currX.toString() + "_" + currY.toString() + "_" + zoom.toString() + ".json";

        options.body = datatosend;

        console.log(filename);

        GetData(options)
        .then(body =>{
            return WriteToFile(body, filename);
        })
        .then(() =>{
            return GetNewCircuit();
        })
        .then(() =>{
            console.log('Step finished');
        })
    }
}

从日志来看，原来是在没有等到前面的操作完成的情况下，冲了4次循环。

控制台日志文本：

json/0_0_1.json
json/1_0_1.json
json/0_1_1.json
json/1_1_1.json
Get response
json/1_1_1.json
Circuit changed
Step finished
Get response
json/1_1_1.json
Circuit changed
Step finished
Get response
json/1_1_1.json
Circuit changed
Step finished
Get response
json/1_1_1.json
Circuit changed
Step finished

调用方法：

function GetNewCircuit(){
    return new promise(function(resolve, reject){
        new_identity('127.0.0.1', 9051, cookie, function(err){
            if(!err){
               console.log('Circuit changed');
               resolve()
            } else{
                console.log(err);
                reject(err);
            }
        });
    });
}

function GetData(reqOptions){
    return new promise(function(resolve, reject){
        request(reqOptions, function(error,response,body){
            if(!error && response.statusCode == 200){
                console.log('Get response');
                resolve(body);
            }
            else{
                reject(error);
            }
        });
    });
}

function WriteToFile(dataToWrite, fileToWrite){
    return new promise(function(resolve, reject) {
        fs.writeFile(fileToWrite, dataToWrite, function(err) {
           if(!err){
               console.log(fileToWrite);
               resolve();
           }
           else{
               reject(err);
           }
        }); 
    });
}

我刚刚开始熟悉js，所以如果除了答案之外，您还建议在哪里以及如何最好地结识，我只会很高兴。

来这里问问题之前，老老实实google了一个小时，没找到答案，虽然有些链接有类似的。问题如下 -在以下结构中，零在JS中意味着什么：

var n = (0, window.unescape)("somestring");

如果您能提供答案或提供您可以阅读的链接，我将不胜感激。

有一个存储点的 json，稍后构建某些 3d 对象，实际上是顶点的坐标。特点是它们位于不均匀的深度。

如您所见，在第 31 个“点集”中，它们紧跟在“坐标”节点之后，在第 32 个点之后，它们又分为 2 个组，组内是所需的点集。任务是通过节点到构成点集合的元素（绿色元素是实际xy的坐标），将属于同一个集合的点收集到一个列表中，送去处理，然后沿着 json 移动。难点在于，在分组的地方（第32个），每组元素都要单独发送，就好像是完整的一样（像第31个的情况，我们在sent里面经历了0,1,2个收集点让我们go further），也就是去32-geometry->coordinates->0 collect里面的东西然后发送到32-geometry->coordinate->1 collect send，然后才进一步。假设 where type: MultiLineString 您可以简单地通过元素添加另一个循环是合乎逻辑的，但是有些事情告诉我我错了。如何在json文件解析实践上正确解决这个问题？

抱歉描述混乱，我尽量详细。

以这种方式更新我试图获取我需要的数据，但是第 32 组的数据合并到一个列表中，我仍然没有弄清楚我应该如何正确地获取它们。现在我明白了，从评论和答案来看，我是从一个根本错误的方面来处理这个问题的。

private void CreateRoads(JSONObject mapData)
    {
        int count = 0;
        foreach (var geo in mapData["features"].list)
        {
            count++;
            var l = new List<Vector3>();


            for (int i = 0; i < geo["geometry"]["coordinates"].list.Count; i++)
            {
                if (!geo["geometry"]["coordinates"][i][0].IsNumber)
                {

                    for (int j = 0; j < geo["geometry"]["coordinates"][i].list.Count; j++)
                    {
                        var c = geo["geometry"]["coordinates"][i][j];
                        var bm = GM.LatLonToMeters(c[1].f, c[0].f);
                        var pm = new Vector2(bm.x - Rect.center.x, bm.y - Rect.center.y);
                        l.Add(pm.ToVector3xz());
                    }
                }
                else
                {
                    var c = geo["geometry"]["coordinates"][i];
                    var bm = GM.LatLonToMeters(c[1].f, c[0].f);
                    var pm = new Vector2(bm.x - Rect.center.x, bm.y - Rect.center.y);
                    l.Add(pm.ToVector3xz());
                }
            }

            var m = new GameObject("road_" + count.ToString()).AddComponent<RoadPolygon>();
            m.transform.localPosition = new Vector3(m.transform.localPosition.x, m.transform.localPosition.y + 1f, m.transform.localPosition.z);
            m.transform.parent = this.transform;
            try
            {
                m.Initialize(geo["properties"]["id"].str, this, l, geo["properties"]["kind"].str);
            }
            catch (Exception ex)
            {
                Debug.Log(ex);
            }
        }
    }

感谢@sp7，我处理了反序列化，但我仍然不明白如何解决块的不同深度级别。什么是通用的，而不是硬编码。有关于深入到最后一个节点（不同之处在于它显然有子节点）的主题的想法，从它到级别，我们收集所需的数据（带坐标的列表），发送它，退出级别，看如果在同一级别还有更多列表，如果我们到达坐标块就不再向上，然后我们转到下一个数字 (33,34,35) 等等......唯一的问题是我不知道不知道如何深入进行这样的传球。谷歌搜索没有多大帮助 =/

        var root = JsonConvert.DeserializeObject<Rootobject>(www.text);
        var features = root.roads.features;
        List<object[][]> coordinates = new List<object[][]>();
        for (int i = 0; i < features.Length; i++)
        {
            coordinates.Add(features[i].geometry.coordinates);
        }
        ConstructRoad(coordinates);