主页 / user-208228

Dmitrii's questions

Martin Hope
Dmitrii
Asked: 2020-04-10 23:14:57 +0000 UTC
  • 0

游戏中有一张图片，atlas，2048 x 2048，RGBA。

在 RGBA Crunched ETC2 中压缩时，其大小仅为 0.6 mb

但是在 RAM 分析的过程中，很明显它需要更多的东西！在编辑器中，它需要 16 兆字节，这可以解释为 ETC2 是 android 的压缩格式，而在 PC 上它被解压缩为常规的 RGBA 32 位。

但问题是，在 Android 设备上，它的内存大小为 4 mb！是的，这比 PC 上的 RAM 少 4 倍，但仍然比声明的 0.6 mb 多得多

可能是什么问题，以及如何获取 android 的纹理以使其大小与编辑器中声明的大小相匹配？

android
Martin Hope
Dmitrii
Asked: 2020-04-08 04:59:35 +0000 UTC
  • 1

有一个代码通过鼠标在单元格上拖动 UI 对象，每个单元格是 25 单位米。

int i = (int)Math.Round(Input.mousePosition.x / 25) * 25;
discreteX = i;
int j = (int)Math.Round(Input.mousePosition.y / 25) * 25;
discreteY = j;
g.transform.GetComponent<RectTransform>().anchoredPosition = 
new Vector3(discreteX, discreteY);

它运行良好，anchoredPosition.x总是经过 0，然后变为 +25、+50、+75 等等。

问题是鼠标的坐标与对象的坐标不匹配g，例如，当鼠标悬停在零时 - 即 在左下角，该对象g位于屏幕的中心，其位置为零anchorPosition

在这种情况下，如果anchoredPositon我们改为使用通常的坐标分配

g.transform.position = new Vector3(discreteX, discreteY);

那么鼠标光标和对象的位置g重合，但它的anchoredPosition 永远不会通过0 - 我总是x看到坐标为-35、-10、15、40 等形式的图片。那些。步长仍然是 25，但不是 25 的倍数！

如何解决这个问题呢？将鼠标与坐标对齐anchoredPosition，或保持正常鼠标位置以 25 为单位增量为 25 的倍数。我该怎么做？

c#
Martin Hope
Dmitrii
Asked: 2020-02-05 22:54:25 +0000 UTC
  • -1

有两个水着色器。两者都有一个字段_ReflectionTex ("Internal Reflection", 2D) = "" {}

当你将这些着色器挂在一个对象上并在这个字段中放置一个纹理时，画面就完全不同了——

第一个着色器 Oney 用此图像填充对象，并在其上拉伸。

第二个着色器 FX/Water 用图像填充屏幕空间——这个功能正是我们第一个着色器所需要的！

两个着色器的图像处理代码大致相同 - 它们在这里和那里都采用TEXTCOORD0，对其执行操作 half4 refl = tex2Dproj( _ReflectionTex, UNITY_PROJ_COORD(uv1) ); ，然后在原始纹理具有透明度的地方分配此纹理的值。一般来说，水中的倒影。但同样，效果完全不同。

我想让 Oney 着色器在保持其所有功能的同时，能够将纹理应用到屏幕空间（而不是一个对象），就像 FX / Water 着色器成功完成的那样

代码如下，为了节省一些空间，它被剪掉了一点。因此，如果缺少几个变量——正因为如此，源代码大约会大一倍半。

Shader "Oney" {  //Всем хорош, но не может в наложение текстур на экран. 
    Properties {
        _Color ("Color", Color) = (0.7016652,0.8427501,0.9264706,1)
        _Color_Waves ("Color_Waves", Color) = (0.1096453,0.3823529,0.2920773,1)
        _Normal_1 ("Normal_1", 2D) = "bump" {}
        _Normal_2 ("Normal_2", 2D) = "bump" {}
        _Waves ("Waves", 2D) = "white" {}
        _CubMap ("CubMap", Cube) = "_Skybox" {}
        _Intensity_Waves ("Intensity_Waves", Range(0, 50)) = 10
        _Speed ("Speed", Range(0, 1)) = 0.1
        _Intensity_Color ("Intensity_Color", Range(0, 10)) = 5
        _Spec ("Spec", Range(0, 2)) = 1
        _Gloss ("Gloss", Range(0, 2)) = 1
        _Reflection ("Reflection", Range(0, 2)) = 0
         _ReflectionTex ("Internal Reflection", 2D) = "" {}
    }
    SubShader {
        Tags {
            "RenderType"="Opaque"
        }
        Pass {
            Name "FORWARD"
            Tags {
                "LightMode"="ForwardBase"
            }


            CGPROGRAM

            uniform sampler2D _Normal_2; uniform float4 _Normal_2_ST;
            uniform float _Intensity_Color;
            uniform float4 _Color_Waves;
            uniform float _Speed;
            uniform samplerCUBE _CubMap;
            uniform float _Reflection;
            struct VertexInput {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float4 tangent : TANGENT;
                float4 texcoord0 : TEXCOORD0;
            };
            struct VertexOutput {
                float4 pos : SV_POSITION;
                float4 uv0 : TEXCOORD0;
                float4 posWorld : TEXCOORD1;
                float3 normalDir : TEXCOORD2;
                float3 tangentDir : TEXCOORD3;
                float3 bitangentDir : TEXCOORD4;
                LIGHTING_COORDS(5,6)
                UNITY_FOG_COORDS(7)
            };
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;
                o.uv0 = v.texcoord0;
                o.normalDir = UnityObjectToWorldNormal(v.normal);
                o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
                o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
                float4 node_9273 = _Time + _TimeEditor;
                float2 node_9735 = (o.uv0+(node_9273.r*_Speed)*float2(0,1));
                float4 _Waves_var = tex2Dlod(_Waves,float4(TRANSFORM_TEX(node_9735, _Waves),0.0,0));
                v.vertex.xyz += (_Waves_var.r*v.normal*_Intensity_Waves);
                o.posWorld = mul(unity_ObjectToWorld, v.vertex);
                float3 lightColor = _LightColor0.rgb;
                o.pos = UnityObjectToClipPos(v.vertex );
                UNITY_TRANSFER_FOG(o,o.pos);
                TRANSFER_VERTEX_TO_FRAGMENT(o)
                return o;
            }
            sampler2D _ReflectionTex;
            float4 frag(VertexOutput i) : COLOR {
                i.normalDir = normalize(i.normalDir);
                float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);
                float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
                float4 node_1446 = _Time + _TimeEditor;
                float2 node_4184 = (i.uv0+node_1446.g*float2(0.0002,0.0001));
                float3 _Normal_1_var = UnpackNormal(tex2D(_Normal_1,TRANSFORM_TEX(node_4184, _Normal_1)));
                float2 node_5576 = (i.uv0+node_1446.g*float2(0.0002,-0.0001));
                float3 _Normal_2_var = UnpackNormal(tex2D(_Normal_2,TRANSFORM_TEX(node_5576, _Normal_2)));



                float3 normalLocal = (_Normal_1_var.rgb+_Normal_2_var.rgb);
                //Expiremental
                float4 uv1 = i.uv0;
                half4 refl = tex2Dproj( _ReflectionTex, UNITY_PROJ_COORD(uv1) );



                float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals
                float3 viewReflectDirection = reflect( -viewDirection, normalDirection );
                float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);
                float3 lightColor = _LightColor0.rgb;
                float3 halfDirection = normalize(viewDirection+lightDirection);

/// Final Color:
                float3 finalColor = diffuse + specular + emissive;
               fixed4 finalRGBA = fixed4(finalColor,1);
           finalRGBA.rgb = lerp( finalColor.rgb, refl.rgb, 1);              finalRGBA.a = refl.a;
                UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
                return finalRGBA;
            }
            ENDCG

第二个着色器，FX/水

Shader "FX/Water" { // Умеет класть текстуру прямо на экран!
Properties {
    _WaveScale ("Wave scale", Range (0.002,0.15)) = 0.063
    _ReflDistort ("Reflection distort", Range (0,15)) = 0.44
    [NoScaleOffset] _Fresnel ("Fresnel (A) ", 2D) = "gray" {}
    [NoScaleOffset] _BumpMap ("Normalmap ", 2D) = "bump" {}
    WaveSpeed ("Wave speed (map1 x,y; map2 x,y)", Vector) = (19,9,-16,-7)
    [NoScaleOffset] _ReflectiveColor ("Reflective color (RGB) fresnel (A) ", 2D) = "" {}
    _HorizonColor ("Simple water horizon color", COLOR)  = ( .172, .463, .435, 1)
     _ReflectionTex ("Internal Reflection", 2D) = "" {}
}


// -----------------------------------------------------------
// Fragment program cards


Subshader {
    Tags { "WaterMode"="Refractive" "RenderType"="Opaque" }
    Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog




#include "UnityCG.cginc"

struct appdata {
    float4 vertex : POSITION;
    float3 normal : NORMAL;
};

struct v2f {
    float4 pos : SV_POSITION;
    #if defined(HAS_REFLECTION) || defined(HAS_REFRACTION)
        float4 ref : TEXCOORD0;
        float2 bumpuv0 : TEXCOORD1;
        float2 bumpuv1 : TEXCOORD2;
        float3 viewDir : TEXCOORD3;
    #else
        float2 bumpuv0 : TEXCOORD0;
        float2 bumpuv1 : TEXCOORD1;
        float3 viewDir : TEXCOORD2;
    #endif
    UNITY_FOG_COORDS(4)
};

v2f vert(appdata v)
{
    v2f o;
    o.pos = UnityObjectToClipPos(v.vertex);


    // scroll bump waves
    float4 temp;
    float4 wpos = mul (unity_ObjectToWorld, v.vertex);
    temp.xyzw = wpos.xzxz * _WaveScale4 + _WaveOffset;
    o.bumpuv0 = temp.xy;
    o.bumpuv1 = temp.wz;

    // object space view direction (will normalize per pixel)
    o.viewDir.xzy = WorldSpaceViewDir(v.vertex);

    #if defined(HAS_REFLECTION) || defined(HAS_REFRACTION)
    o.ref = ComputeNonStereoScreenPos(o.pos);
    #endif

    UNITY_TRANSFER_FOG(o,o.pos);
    return o;
}

sampler2D _ReflectionTex;



half4 frag( v2f i ) : SV_Target
{
    i.viewDir = normalize(i.viewDir);

    // combine two scrolling bumpmaps into one
    half3 bump1 = UnpackNormal(tex2D( _BumpMap, i.bumpuv0 )).rgb;
    half3 bump2 = UnpackNormal(tex2D( _BumpMap, i.bumpuv1 )).rgb;
    half3 bump = (bump1 + bump2) * 0.5;

    // fresnel factor
    half fresnelFac = dot( i.viewDir, bump );

    // perturb reflection/refraction UVs by bumpmap, and lookup colors

    float4 uv1 = i.ref; uv1.xy += bump * _ReflDistort;
    half4 refl = tex2Dproj( _ReflectionTex, UNITY_PROJ_COORD(uv1) );


    // final color is between refracted and reflected based on fresnel
    half4 color;

    half4 water = tex2D( _ReflectiveColor, float2(fresnelFac,fresnelFac) );
    color.rgb = lerp( water.rgb, refl.rgb, water.a );
    color.a = refl.a * water.a;


    UNITY_APPLY_FOG(i.fogCoord, color);
    return color;
}
ENDCG

    }
}

}
unity3d
Martin Hope
Dmitrii
Asked: 2020-10-17 17:38:43 +0000 UTC
  • 1

当您将 BoxCollider 添加到新项目时，它将自动拉伸以适合该项目。当您更改此项目的网格时，碰撞器不会自动缩回。collider 本身的 api 中没有“AlignToSize”之类的方法。简直有

 BoxCollider.size

 Use this to return or set the size of the BoxCollider component of a 
 GameObject. Unity measures the size in the GameObject's local space

但是如果我们写

 collider.size = Vector3.one;

然后最后我们得到一个对撞机，不是根据物体的大小，而是简单的边长为 1x1x1

那么如何拉伸 BoxCollider 以适应对象呢？

c#
Martin Hope
Dmitrii
Asked: 2020-07-25 23:00:06 +0000 UTC
  • 1

（今天我已经问了一个类似的问题，（将文件迁移到 lfs && gc --aggressive --prune=now它们不同后，存储库超过 2gb。请不要删除。我只有 2 台计算机，我正在尝试以不同的方式减小存储库的大小。

有一个 2 gigs 的存储库，bitbucket 说有必要减小大小。

有两个不需要的 800 兆字节的文件夹。将它们从历史中删除

GIT_LFS_SKIP_SMUDGE=1 git filter-branch--tree-filter 'rm -rf Assets/oneBadFolder && rm -rf Assets/second-bad-folder'

之后，存储库的大小增加到了惊人的 5.3 GB！但这是可以理解的——他只是还没有清理垃圾。正在做

git reflog expire --expire-unreachable=now --all
git gc --prune-now

大小变为 2.23 giga。在从历史记录中删除这些文件夹之前，大小为 2.1 GB。

问题是我做错了什么？为什么从历史中删除两个各 800 MB 的文件夹以及随后的垃圾清理操作最终导致存储库的大小增加？以及如何解决？

git
Martin Hope
Dmitrii
Asked: 2020-07-25 22:07:32 +0000 UTC
  • 0

已达到 bitbucket 的 2 GB 限制。弹出有关超出存储大小和只读访问权限的警告。将我的本地存储库迁移到 lfs，如下所示。

#!/bin/sh
#
# Migrating repository to LFS using extensions from root `.gitattributes`.

# Get extensions specified in `.gitattributes`:
lfs_extensions=$(cat ./.gitattributes | grep -o '^[^ ]*' | tr '\n' ',' | sed 
's/,$//g')

# Migrate files with given extensions and rewriting history in all local 
branches:
git lfs migrate import --everything --include="$lfs_extensions" --verbose

之后做了

git gc -aggressive --prune=now

并在这一切之后检查

git count-objects -v -H

它给了我

count: 0
size: 0 bytes
in-pack: 277884
packs: 1
size-pack: 2.24 GiB
prune-packable: 0
garbage: 0
size-garbage: 0 bytes

那些。存储库的大小仍然是 2 GB，甚至变得更大了一些。

.gitattributes 的内容

Assets/Content/** filter=lfs diff=lfs merge=lfs -text
\# filter=lfs diff=lfs merge=lfs -text
*.jpg filter=lfs diff=lfs merge=lfs -text
*.jpeg filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text
*.gif filter=lfs diff=lfs merge=lfs -text
*.psd filter=lfs diff=lfs merge=lfs -text
*.ai filter=lfs diff=lfs merge=lfs -text
*.tif filter=lfs diff=lfs merge=lfs -text
*.tiff filter=lfs diff=lfs merge=lfs -text
*.raw filter=lfs diff=lfs merge=lfs -text
*.mp3 filter=lfs diff=lfs merge=lfs -text
*.wav filter=lfs diff=lfs merge=lfs -text
*.ogg filter=lfs diff=lfs merge=lfs -text
*.flac filter=lfs diff=lfs merge=lfs -text
*.mp4 filter=lfs diff=lfs merge=lfs -text
*.mov filter=lfs diff=lfs merge=lfs -text
*.fbx filter=lfs diff=lfs merge=lfs -text
*.FBX filter=lfs diff=lfs merge=lfs -text
*.blend filter=lfs diff=lfs merge=lfs -text
*.obj filter=lfs diff=lfs merge=lfs -text
*.skp filter=lfs diff=lfs merge=lfs -text
*.max filter=lfs diff=lfs merge=lfs -text
*.a filter=lfs diff=lfs merge=lfs -text
*.exr filter=lfs diff=lfs merge=lfs -text
*.tga filter=lfs diff=lfs merge=lfs -text
*.pdf filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.rar filter=lfs diff=lfs merge=lfs -text
*.7z filter=lfs diff=lfs merge=lfs -text
*.tar.gz filter=lfs diff=lfs merge=lfs -text
*.dll filter=lfs diff=lfs merge=lfs -text
*.unitypackage filter=lfs diff=lfs merge=lfs -text
*.aif filter=lfs diff=lfs merge=lfs -text
*.ttf filter=lfs diff=lfs merge=lfs -text
*.rns filter=lfs diff=lfs merge=lfs -text
*.reason filter=lfs diff=lfs merge=lfs -text
*.lxo filter=lfs diff=lfs merge=lfs -text
# Image

# Audio
# Video
# 3D
# etc
/\# filter=lfs diff=lfs merge=lfs -text

另外，我想看看在 git 的主存储库中什么都一样重，为什么没有把它带到 LFS？

写作

$ git verify-pack -v .git/objects/pack\pack-48da725c12c669fde2fdedccf3f88de0b9d31b75.idx

我得到一个答案

 fatal: Cannot open existing pack file '.git/objects/packpack- 
 48da725c12c669fde2fdedccf3f88de0b9d31b75.idx'
.git/objects/packpack-48da725c12c669fde2fdedccf3f88de0b9d31b75.pack: bad

问题

1) 我怎样才能知道哪些文件占用了我的非 LFS 存储库中的空间？

2）如何删除它们并将存储库恢复到足够的大小？

补充： git lfs ls-files给出应该在 LFS 中的那些文件的正常列表，即 迁移奏效了。 git ls-files给出所有文件的简单列表，包括 LFS 和非 LFS。但它应该是这样的吗？

git
Martin Hope
Dmitrii
Asked: 2020-07-09 22:31:48 +0000 UTC
  • 0

有一个武器脚本。我们发射光线投射，当我们击中它时，我们会查看撞击点。

if (Physics.Raycast(camPos, camForward, out _hit, 10000, aimingMask))
{
  weaponTransform.LookAt(_hit);
}

但是，如果我们没有得到它呢？如何使武器看向同一个方向，例如，好像我们在 100 距离处击中一样？

hit = camForward * 100;
weaponTransform.LookAt(_hit);

此代码使武器看起来偏向某处。但绝对不是光束会在 100 距离处击中的地方。

c#
Martin Hope
Dmitrii
Asked: 2020-07-06 17:59:38 +0000 UTC
  • 1

Unity 编辑器有方便的 Debug.Log 日志。除了他们向控制台打印一条消息之外，当您单击此消息时，您会直接重定向到脚本中的正确位置 - 调用此调试的位置。但是如果你想以某种方式包装这个方法并在那里添加事件时间，例如像这样

public static void LogError(this object obj, string message)
{     
        message += DateTime.Now.ToString();
        Debug.LogError(message);
}

然后在控制台中点击这样的调试将我们重定向到这个方法，我们的“包装器”。如何使补充 Debug.Log 方法成为可能，同时保留重定向到所需脚本行的功能？

c#
Martin Hope
Dmitrii
Asked: 2020-06-18 17:30:29 +0000 UTC
  • 1

我们找出类中的字段数及其值如下

     object bobik = new dog();
     foreach(FieldInfo field in bobik.GetType().GetFields())
     {
      Console.WriteLine("{0} {1} {2}", field.FieldType, field.Name, 
      field.GetValue(bobik));
     }

但是如果我们在课堂上遇到，比如list，那么控制台就会显示我们

System.Collections.Generic.List`1[ClassName] fieldName

在这个过程中如何扩展工作表呢？可以做

if(field.GetType().IsArray)
{
SomeAction
}

但是做不到

IsList

你怎么能最终拉出并扩展这张表呢？

c#
Martin Hope
Dmitrii
Asked: 2020-06-15 23:33:06 +0000 UTC
  • 3

调试需要读取类的所有字段的名称及其值。好吧，例如，有一个类 dog 的实例

class dog
{
public int age = 3;
public string name = "barboss";
public bool isHungry = false;
}

在不立即知道字段名称的情况下，我怎么能在输出中得到类似的东西

dog:{int age 3, string name "barboss,bool isHungry false};
c#
Martin Hope
Dmitrii
Asked: 2020-06-14 23:49:45 +0000 UTC
  • 0

有一个克隆的远程存储库 X

我想创建此存储库的精确副本，而不是将其克隆到计算机上，而是远程存储在 bitbucket 上。

做了什么

git clone
git remote set-url origin <Адрес второго пустого репозитория>
git push

一切似乎都被淹没了，但新存储库的大小比旧存储库小 20% 左右。

我做错什么了吗？有没有更简单方便的方法来复制远程存储库？

git
Martin Hope
Dmitrii
Asked: 2020-04-05 14:52:38 +0000 UTC
  • 1

我想以 PNG 格式获得地形的准确图像，包括所有的树木和草。

Application.CaptureScreenshot

它不起作用，因为您首先需要将相机对准，对齐以获得方形图像，查看所有角落以使其不会出现在任何地方......通常，当您不止一次这样做时，我想自动化它。

我怎样才能做到这一点？例如，仅拍摄整个地形或平面。

c#
Martin Hope
Dmitrii
Asked: 2020-04-03 16:09:00 +0000 UTC
  • 2

该单元中的探查器有一个很棒的功能 - 深度剖析。由于资源成本较高，它允许您跟踪脚本中函数的负载。不幸的是，当我在 Android 设备上运行该项目时，即使按下了 Deep Profile 按钮，分析器也会生成常规配置文件的结果，而不是深度配置文件，而无需指定确切的脚本，更不用说函数了。我知道这对智能手机来说是一个很大的负担，但也许有一种方法不仅可以在编辑器中启用 Deep 配置文件？

android
Martin Hope
Dmitrii
Asked: 2020-04-01 15:51:50 +0000 UTC
  • 0

在 WinForms 中，当创建一个元素时，我们可以简单地点击它——工作室为这个元素创建了一个事件处理程序，例如

private void Button1_Click(object sender, RoutedEventArgs e)
{

}

进入就够了

Button1.Text = "Поменяли текст кнопки"

一切都会奏效。但是在 UWP 应用程序中，当您单击同一个按钮时，工作室会创建相同的处理程序，但已经调用它

private void Button_Click(object sender, RoutedEventArgs e)
{

}

现在也不可能以任何方式处理界面的元素。是否可以在 Xaml 本身中写一个名称（默认情况下不存在）并已经引用它

<Button Content="Button" **Name="btn1"** HorizontalAlignment="Left" Margin="177,85,0,0" VerticalAlignment="Top" Height="123" Width="264" Click="Button_Click"/>

此外，按钮本身没有文本属性。甚至还有

btn1.FontSize

而且没有文字。一般来说，请向那些正在从 WinForms 过渡的人解释一下 - 为什么要删除这些东西，以及它们用什么代替？

c#
Martin Hope
Dmitrii
Asked: 2020-12-28 15:04:34 +0000 UTC
  • 1

Unity 上有一个向服务器发送 POST 请求的应用程序。

public IEnumerator POST()
{
    WWWForm form = new WWWForm();
    form.AddField("variable1", "222");
    var www = new WWW("http://127.0.0.1:8080/server.js", form);
    yield return www;
    Debug.Log(www.text);
    www.Dispose();
    yield break;
}

node.js 上有一个服务器接受它并发回有关接收和日期的信息。

 function accept(req, res) 
{
   console.log(req);
// через 1.5 секунды ответить сообщением
   setTimeout(function() {
    res.end('Отправляем обратно! ' + new Date() + req.url);
   }, 1500);
}

消息在我们使用的客户端中发送到服务器并返回

WWW.text

从服务器接收响应字符串。以及在服务器上使用什么？如何解密来自 Unity 的 POST 请求？现在我只是使用

console.log(req)

最后，一切都失败了。此外，预期

("variable1", "222");

不在这之中。这就是即将发生的事情。

IncomingMessage {   _readableState:    ReadableState {
     objectMode: false,
     highWaterMark: 16384,
     buffer: BufferList { head: null, tail: null, length: 0 },
     length: 0,
     pipes: null,
     pipesCount: 0,
     flowing: null,
     ended: false,
     endEmitted: false,
     reading: false,
     sync: true,
     needReadable: false,
     emittedReadable: false,
     readableListening: false,
     resumeScheduled: false,
     destroyed: false,
     defaultEncoding: 'utf8',
     awaitDrain: 0,
     readingMore: true,
     decoder: null,
     encoding: null },   readable: true,   domain: null,   _events: {},   _eventsCount: 0,   _maxListeners: undefined,   socket:    Socket {
     connecting: false,
     _hadError: false,
     _handle:
      TCP {
        reading: true,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0,
        _consumed: true },
     _parent: null,
     _host: null,
     _readableState:
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [BufferList],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: true,
        sync: false,
        needReadable: true,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: false,
        destroyed: false,
        defaultEncoding: 'utf8',
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: true,
     domain: null,
     _events:
      { end: [Array],
        finish: [Function: onSocketFinish],
        _socketEnd: [Function: onSocketEnd],
        drain: [Array],
        timeout: [Function: socketOnTimeout],
        data: [Function: bound socketOnData],
        error: [Function: socketOnError],
        close: [Array],
        resume: [Function: onSocketResume],
        pause: [Function: onSocketPause] },
     _eventsCount: 10,
     _maxListeners: undefined,
     _writableState:
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        finalCalled: false,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        destroyed: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',
        length: 0,
        writing: false,
        corked: 0,
        sync: true,
        bufferProcessing: false,
        onwrite: [Function: bound onwrite],
        writecb: null,
        writelen: 0,
        bufferedRequest: null,
        lastBufferedRequest: null,
        pendingcb: 0,
        prefinished: false,
        errorEmitted: false,
        bufferedRequestCount: 0,
        corkedRequestsFree: [Object] },
     writable: true,
     allowHalfOpen: true,
     _bytesDispatched: 0,
     _sockname: null,
     _pendingData: null,
     _pendingEncoding: '',
     server:
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 1,
        _handle: [TCP],
        _usingWorkers: false,
        _workers: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        keepAliveTimeout: 5000,
        _pendingResponseData: 0,
        maxHeadersCount: null,
        _connectionKey: '6::::8080',
        [Symbol(asyncId)]: 6 },
     _server:
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 1,
        _handle: [TCP],
        _usingWorkers: false,
        _workers: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        keepAliveTimeout: 5000,
        _pendingResponseData: 0,
        maxHeadersCount: null,
        _connectionKey: '6::::8080',
        [Symbol(asyncId)]: 6 },
     _idleTimeout: 120000,
     _idleNext:
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Circular],
        _unrefed: true,
        msecs: 120000,
        nextTick: false,
        _timer: [Timer] },
     _idlePrev:
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Circular],
        _unrefed: true,
        msecs: 120000,
        nextTick: false,
        _timer: [Timer] },
     _idleStart: 25381,
     _destroyed: false,
     parser:
      HTTPParser {
        '0': [Function: parserOnHeaders],
        '1': [Function: parserOnHeadersComplete],
        '2': [Function: parserOnBody],
        '3': [Function: parserOnMessageComplete],
        '4': [Function: bound onParserExecute],
        _headers: [],
        _url: '',
        _consumed: true,
        socket: [Circular],
        incoming: [Circular],
        outgoing: null,
        maxHeaderPairs: 2000,
        onIncoming: [Function: bound parserOnIncoming] },
     on: [Function: socketOnWrap],
     _paused: false,
     read: [Function],
     _consuming: true,
     _httpMessage:
      ServerResponse {
        domain: null,
        _events: [Object],
        _eventsCount: 1,
        _maxListeners: undefined,
        output: [],
        outputEncodings: [],
        outputCallbacks: [],
        outputSize: 0,
        writable: true,
        _last: false,
        upgrading: false,
        chunkedEncoding: false,
        shouldKeepAlive: true,
        useChunkedEncodingByDefault: true,
        sendDate: true,
        _removedConnection: false,
        _removedContLen: false,
        _removedTE: false,
        _contentLength: null,
        _hasBody: true,
        _trailer: '',
        finished: false,
        _headerSent: false,
        socket: [Circular],
        connection: [Circular],
        _header: null,
        _onPendingData: [Function: bound updateOutgoingData],
        _sent100: false,
        _expect_continue: false,
        [Symbol(outHeadersKey)]: null },
     [Symbol(asyncId)]: 9,
     [Symbol(bytesRead)]: 0,
     [Symbol(asyncId)]: 11,
     [Symbol(triggerAsyncId)]: 6 },   connection:    Socket {
     connecting: false,
     _hadError: false,
     _handle:
      TCP {
        reading: true,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0,
        _consumed: true },
     _parent: null,
     _host: null,
     _readableState:
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [BufferList],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: true,
        sync: false,
        needReadable: true,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: false,
        destroyed: false,
        defaultEncoding: 'utf8',
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: true,
     domain: null,
     _events:
      { end: [Array],
        finish: [Function: onSocketFinish],
        _socketEnd: [Function: onSocketEnd],
        drain: [Array],
        timeout: [Function: socketOnTimeout],
        data: [Function: bound socketOnData],
        error: [Function: socketOnError],
        close: [Array],
        resume: [Function: onSocketResume],
        pause: [Function: onSocketPause] },
     _eventsCount: 10,
     _maxListeners: undefined,
     _writableState:
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        finalCalled: false,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        destroyed: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',
        length: 0,
        writing: false,
        corked: 0,
        sync: true,
        bufferProcessing: false,
        onwrite: [Function: bound onwrite],
        writecb: null,
        writelen: 0,
        bufferedRequest: null,
        lastBufferedRequest: null,
        pendingcb: 0,
        prefinished: false,
        errorEmitted: false,
        bufferedRequestCount: 0,
        corkedRequestsFree: [Object] },
     writable: true,
     allowHalfOpen: true,
     _bytesDispatched: 0,
     _sockname: null,
     _pendingData: null,
     _pendingEncoding: '',
     server:
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 1,
        _handle: [TCP],
        _usingWorkers: false,
        _workers: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        keepAliveTimeout: 5000,
        _pendingResponseData: 0,
        maxHeadersCount: null,
        _connectionKey: '6::::8080',
        [Symbol(asyncId)]: 6 },
     _server:
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 1,
        _handle: [TCP],
        _usingWorkers: false,
        _workers: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        keepAliveTimeout: 5000,
        _pendingResponseData: 0,
        maxHeadersCount: null,
        _connectionKey: '6::::8080',
        [Symbol(asyncId)]: 6 },
     _idleTimeout: 120000,
     _idleNext:
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Circular],
        _unrefed: true,
        msecs: 120000,
        nextTick: false,
        _timer: [Timer] },
     _idlePrev:
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Circular],
        _unrefed: true,
        msecs: 120000,
        nextTick: false,
        _timer: [Timer] },
     _idleStart: 25381,
     _destroyed: false,
     parser:
      HTTPParser {
        '0': [Function: parserOnHeaders],
        '1': [Function: parserOnHeadersComplete],
        '2': [Function: parserOnBody],
        '3': [Function: parserOnMessageComplete],
        '4': [Function: bound onParserExecute],
        _headers: [],
        _url: '',
        _consumed: true,
        socket: [Circular],
        incoming: [Circular],
        outgoing: null,
        maxHeaderPairs: 2000,
        onIncoming: [Function: bound parserOnIncoming] },
     on: [Function: socketOnWrap],
     _paused: false,
     read: [Function],
     _consuming: true,
     _httpMessage:
      ServerResponse {
        domain: null,
        _events: [Object],
        _eventsCount: 1,
        _maxListeners: undefined,
        output: [],
        outputEncodings: [],
        outputCallbacks: [],
        outputSize: 0,
        writable: true,
        _last: false,
        upgrading: false,
        chunkedEncoding: false,
        shouldKeepAlive: true,
        useChunkedEncodingByDefault: true,
        sendDate: true,
        _removedConnection: false,
        _removedContLen: false,
        _removedTE: false,
        _contentLength: null,
        _hasBody: true,
        _trailer: '',
        finished: false,
        _headerSent: false,
        socket: [Circular],
        connection: [Circular],
        _header: null,
        _onPendingData: [Function: bound updateOutgoingData],
        _sent100: false,
        _expect_continue: false,
        [Symbol(outHeadersKey)]: null },
     [Symbol(asyncId)]: 9,
     [Symbol(bytesRead)]: 0,
     [Symbol(asyncId)]: 11,
     [Symbol(triggerAsyncId)]: 6 },   httpVersionMajor: 1,   httpVersionMinor: 1,   httpVersion: '1.1',   complete: false,   headers:    { host: '127.0.0.1:8080',
     'user-agent': 'UnityPlayer/2017.1.1f1 (UnityWebRequest/1.0, libcurl/7.51.0-DEV)',
     accept: '*/*',
     'accept-encoding': 'identity',
     'content-type': 'application/x-www-form-urlencoded',
     'x-unity-version': '2017.1.1f1',
     'content-length': '152' },   rawHeaders:    [ 'Host',
     '127.0.0.1:8080',
     'User-Agent',
     'UnityPlayer/2017.1.1f1 (UnityWebRequest/1.0, libcurl/7.51.0-DEV)',
     'Accept',
     '*/*',
     'Accept-Encoding',
     'identity',
     'Content-Type',
     'application/x-www-form-urlencoded',
     'X-Unity-Version',
     '2017.1.1f1',
     'Content-Length',
     '152' ],   trailers: {},   rawTrailers: [],   upgrade: false,   url: '/server.js',   method: 'POST',   statusCode: null,   statusMessage: null,   client:    Socket {
     connecting: false,
     _hadError: false,
     _handle:
      TCP {
        reading: true,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0,
        _consumed: true },
     _parent: null,
     _host: null,
     _readableState:
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [BufferList],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: true,
        sync: false,
        needReadable: true,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: false,
        destroyed: false,
        defaultEncoding: 'utf8',
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: true,
     domain: null,
     _events:
      { end: [Array],
        finish: [Function: onSocketFinish],
        _socketEnd: [Function: onSocketEnd],
        drain: [Array],
        timeout: [Function: socketOnTimeout],
        data: [Function: bound socketOnData],
        error: [Function: socketOnError],
        close: [Array],
        resume: [Function: onSocketResume],
        pause: [Function: onSocketPause] },
     _eventsCount: 10,
     _maxListeners: undefined,
     _writableState:
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        finalCalled: false,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        destroyed: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',
        length: 0,
        writing: false,
        corked: 0,
        sync: true,
        bufferProcessing: false,
        onwrite: [Function: bound onwrite],
        writecb: null,
        writelen: 0,
        bufferedRequest: null,
        lastBufferedRequest: null,
        pendingcb: 0,
        prefinished: false,
        errorEmitted: false,
        bufferedRequestCount: 0,
        corkedRequestsFree: [Object] },
     writable: true,
     allowHalfOpen: true,
     _bytesDispatched: 0,
     _sockname: null,
     _pendingData: null,
     _pendingEncoding: '',
     server:
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 1,
        _handle: [TCP],
        _usingWorkers: false,
        _workers: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        keepAliveTimeout: 5000,
        _pendingResponseData: 0,
        maxHeadersCount: null,
        _connectionKey: '6::::8080',
        [Symbol(asyncId)]: 6 },
     _server:
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 1,
        _handle: [TCP],
        _usingWorkers: false,
        _workers: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        keepAliveTimeout: 5000,
        _pendingResponseData: 0,
        maxHeadersCount: null,
        _connectionKey: '6::::8080',
        [Symbol(asyncId)]: 6 },
     _idleTimeout: 120000,
     _idleNext:
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Circular],
        _unrefed: true,
        msecs: 120000,
        nextTick: false,
        _timer: [Timer] },
     _idlePrev:
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Circular],
        _unrefed: true,
        msecs: 120000,
        nextTick: false,
        _timer: [Timer] },
     _idleStart: 25381,
     _destroyed: false,
     parser:
      HTTPParser {
        '0': [Function: parserOnHeaders],
        '1': [Function: parserOnHeadersComplete],
        '2': [Function: parserOnBody],
        '3': [Function: parserOnMessageComplete],
        '4': [Function: bound onParserExecute],
        _headers: [],
        _url: '',
        _consumed: true,
        socket: [Circular],
        incoming: [Circular],
        outgoing: null,
        maxHeaderPairs: 2000,
        onIncoming: [Function: bound parserOnIncoming] },
     on: [Function: socketOnWrap],
     _paused: false,
     read: [Function],
     _consuming: true,
     _httpMessage:
      ServerResponse {
        domain: null,
        _events: [Object],
        _eventsCount: 1,
        _maxListeners: undefined,
        output: [],
        outputEncodings: [],
        outputCallbacks: [],
        outputSize: 0,
        writable: true,
        _last: false,
        upgrading: false,
        chunkedEncoding: false,
        shouldKeepAlive: true,
        useChunkedEncodingByDefault: true,
        sendDate: true,
        _removedConnection: false,
        _removedContLen: false,
        _removedTE: false,
        _contentLength: null,
        _hasBody: true,
        _trailer: '',
        finished: false,
        _headerSent: false,
        socket: [Circular],
        connection: [Circular],
        _header: null,
        _onPendingData: [Function: bound updateOutgoingData],
        _sent100: false,
        _expect_continue: false,
        [Symbol(outHeadersKey)]: null },
     [Symbol(asyncId)]: 9,
     [Symbol(bytesRead)]: 0,
     [Symbol(asyncId)]: 11,
     [Symbol(triggerAsyncId)]: 6 },   _consuming: false,   _dumped: false }
javascript
Martin Hope
Dmitrii
Asked: 2020-07-04 14:09:31 +0000 UTC
  • 1

有一个方法

public static Object Instantiate(Object original,  
   Vector3 position, Quaternion rotation, Transform parent);

如果我需要创建一个空对象（如在 Create Empty 编辑器中），我是否需要创建一个预制件，提供指向它的链接，或者我是否可以以某种方式获取并创建一个空对象？

c#
Martin Hope
Dmitrii
Asked: 2020-06-26 14:28:41 +0000 UTC
  • 0

将 Unity 更新到 5.6.1f 版本后，WebGL 构建出现问题。

使用

SceneManager.LoadScene

或者

SceneManagerLoadSceneAcynh

场景打开，但它只包含上一个场景中的 DontDestroyOnLoad 对象。

那些。舞台空荡荡的，连个摄像头都没有，一片漆黑。没有错误，即使使用 Develop 和 DebugSumbols。

我在英文部分看到了类似的东西，但是他们没有回答问题 https://forum.unity3d.com/threads/black-screen-when-changing-scene-in-webgl-using-unity-5-6.473367 /

unity3d