void CreateSphere(Cubemap _texture, Vector3 pos)
{
GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
GameObject temp = new GameObject(_texture.ToString());
spheres.Add(go.transform);
go.transform.SetParent(temp.transform);
Transform t = temp.GetComponent <Transform> ();
t.localScale = Vector3.one * scale;
MeshRenderer mr = go.GetComponent <MeshRenderer> ();
Material mat = new Material(_shader);
Cubemap tex = null;
tex = new Cubemap(_texture.width, TextureFormat.ARGB32, false);
Color[][] pixels = new Color[6][];
if (!getPixel)
{
for (int i = 0; i < 6; i++)
{
pixels [i] = new Color[_texture.width * _texture.width];
pixels [i] = _texture.GetPixels(cubemapFaces [i]);
tex.SetPixels(pixels [i], cubemapFaces [i]);
}
}
else
{
for (int ii = 0; ii < 6; ii++)
{
pixels [ii] = new Color[_texture.width * _texture.width];
int i = 0;
for (int y = 0; y < _texture.width; y++)
{
for (int x = 0; x < _texture.width; x++)
{
pixels [ii] [i] = _texture.GetPixel(cubemapFaces [ii], x, y);
i++;
}
}
tex.SetPixels(pixels [ii], cubemapFaces [ii]);
}
}
//tex.SetPixels (pixels);
tex.Apply();
LabelMaker.MakeLabel(_texture.name.ToString().Remove(0, 5), Color.white, t);
tex.filterMode = FilterMode.Point;
mat.mainTexture = tex;
mat.name = _texture.name;
go.name = _texture.name;
mr.material = mat;
tex.wrapMode = TextureWrapMode.Clamp;
tex.Apply();
t.SetParent(transform);
t.position = pos;
}
static int Apply(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 1)
{
Cubemap obj = LuaScriptMgr.GetNetObject <Cubemap>(L, 1);
obj.Apply();
return(0);
}
else if (count == 2)
{
Cubemap obj = LuaScriptMgr.GetNetObject <Cubemap>(L, 1);
bool arg0 = LuaScriptMgr.GetBoolean(L, 2);
obj.Apply(arg0);
return(0);
}
else if (count == 3)
{
Cubemap obj = LuaScriptMgr.GetNetObject <Cubemap>(L, 1);
bool arg0 = LuaScriptMgr.GetBoolean(L, 2);
bool arg1 = LuaScriptMgr.GetBoolean(L, 3);
obj.Apply(arg0, arg1);
return(0);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: Cubemap.Apply");
}
return(0);
}
/*!
* Add a reflection line with the specified Rotation on the specified face.
*
* \param cubemap The Cubemap to add to.
* \param rotation Rotation of the reflection line
* \param faces The Cubemap faces to add the line to.
*/
public static void addReflectionlineToCubemap(Cubemap cubemap, float rotation, int lineWidth, params CubemapFace[] faces)
{
UnityDebug.assert(cubemap.width == cubemap.height, "Cubemap is not square!");
foreach (CubemapFace face in faces)
{
var colors = cubemap.GetPixels(face);
int middle = (cubemap.width / 2) - 1;
var center = new int[] { middle, middle };
var origStart = new int[] { middle, 0 };
var newStart = rotatePointAroundPoint2D(origStart, center, rotation);
var origEnd = new int[] { middle, cubemap.height - 2 };
var newEnd = rotatePointAroundPoint2D(origEnd, center, rotation);
LineDrawer.plotThickLineAA(newStart[0], newStart[1], newEnd[0], newEnd[1], lineWidth, delegate(int x, int y, float i) {
colors[y * cubemap.width + (cubemap.width - 1 - x)] = new Color(i, i, i);
});
cubemap.SetPixels(colors, face);
}
if (faces.Length > 0)
{
cubemap.Apply();
}
}
public void OnResetCubemap()
{
if (Index > 0)
{
return;
}
if (mCubemap == null)
{
mCubemap = new Cubemap(2, TextureFormat.RGB24, false);
}
Color[] xzPixels = new Color[4] {
mEnvirment_MidColor, mEnvirment_MidColor, mEnvirment_MidColor, mEnvirment_MidColor
};
Color[] yPositivePixels = new Color[4] {
mEnvirment_Skycolor, mEnvirment_Skycolor, mEnvirment_Skycolor, mEnvirment_Skycolor
};
Color[] yNavigatePixels = new Color[4] {
mEnvirment_GroundColor, mEnvirment_GroundColor, mEnvirment_GroundColor, mEnvirment_GroundColor
};
mCubemap.SetPixels(xzPixels, CubemapFace.NegativeX, 0);
mCubemap.SetPixels(xzPixels, CubemapFace.PositiveX, 0);
mCubemap.SetPixels(xzPixels, CubemapFace.NegativeZ, 0);
mCubemap.SetPixels(xzPixels, CubemapFace.PositiveZ, 0);
mCubemap.SetPixels(yPositivePixels, CubemapFace.PositiveY, 0);
mCubemap.SetPixels(yNavigatePixels, CubemapFace.NegativeY, 0);
mCubemap.Apply();
}
IEnumerator Capture(Cubemap cubemap, CubemapFace face, Camera cam)
{
var width = Screen.width;
var height = Screen.height;
Texture2D tex = new Texture2D(height, height, texFor, mipmap);
int cubeSize = cubemap.height;
cam.transform.localRotation = RotationOf(face);
yield return(new WaitForEndOfFrame());
tex.ReadPixels(new Rect((width - height) / 2, 0, height, height), 0, 0);
tex.Apply();
tex = Scale(tex, cubeSize, cubeSize);
Color cubeCol;
for (int y = 0; y < cubeSize; y++)
{
for (int x = 0; x < cubeSize; x++)
{
cubeCol = tex.GetPixel(cubeSize + x, (cubeSize - 1) - y);
if (Linear)
{
cubeCol = cubeCol.linear;
}
cubemap.SetPixel(face, x, y, cubeCol);
}
}
cubemap.Apply();
DestroyImmediate(tex);
}
void ComputeEncodeSkyBox()
{
ComputeShader cs = Resources.Load <ComputeShader>("EncodeSkyBox");
if (cs == null)
{
return;
}
int kanel = cs.FindKernel("CS_EncodeSkyBox");
CubemapFace[] faces = new CubemapFace[]
{
CubemapFace.PositiveX,
CubemapFace.NegativeX,
CubemapFace.PositiveY,
CubemapFace.NegativeY,
CubemapFace.PositiveZ,
CubemapFace.NegativeZ,
};
Cubemap clone = new Cubemap(mCubeSize, TextureFormat.RGBA32, false);
for (int i = 0; i < faces.Length; ++i)
{
Color[] cols;
CreateFace(cs, kanel, i, out cols);
clone.SetPixels(cols, faces[i]);
}
clone.Apply(false, !mOutputTextureReadable);
SaveTexture <Cubemap>(clone, GetPath());
}
void TestGenerateSpecCubemap()
{
float dv = 1.0f / m_Cubemap.height;
float du = 1.0f / m_Cubemap.width;
float uoffs = 0.5f / m_Cubemap.width;
float voffs = 0.5f / m_Cubemap.height;
m_DbgLightDir0.Normalize();
m_DbgLightDir1.Normalize();
foreach (CubemapFace face in CubemapFace.GetValues(typeof(CubemapFace)))
{
for (int y = 0; y < m_Cubemap.height; y++)
{
float v = y * dv + voffs;
for (int x = 0; x < m_Cubemap.width; x++)
{
float u = x * du + uoffs;
Vector3 dir = UVToDir(u, v, face);
dir.Normalize();
m_Cubemap.SetPixel(face, x, y, EvalSpecLighting(dir));
}
}
}
m_Cubemap.Apply();
}
IEnumerator CaptureImportanceSample(Cubemap cubemap, CubemapFace face, Camera cam, int mip)
{
var width = Screen.width;
var height = Screen.height;
Texture2D tex = new Texture2D(height, height, TextureFormat.ARGB32, false);
cam.transform.localRotation = Rotation(face);
yield return(new WaitForEndOfFrame());
tex.ReadPixels(new Rect((width - height) / 2, 0, height, height), 0, 0);
tex.Apply();
int cubeSize = Mathf.Max(1, cubemap.width >> mip);
tex = Resize(tex, cubeSize, cubeSize, true);
Color[] tempCol = tex.GetPixels();
cubemap.SetPixels(tempCol, face, mip);
cubemap.Apply(false);
DestroyImmediate(tex);
}
IEnumerator CreateCubemap(CubePoint point)
{
GameObject camObject = new GameObject("CubemapCamera");
camObject.transform.parent = point.transform;
camObject.transform.localPosition = Vector3.zero;
Camera cam = (Camera)camObject.AddComponent(typeof(Camera));
cam.fieldOfView = 90;
cam.depth = 10;
cam.nearClipPlane = 0.001f;
cam.farClipPlane = 1000.0f;
Cubemap cubemap = new Cubemap(this.size, this.textureFormat, this.mipmap);
//yield return new WaitForEndOfFrame();
yield return(StartCoroutine(Snapshot(cubemap, CubemapFace.PositiveZ, cam)));
yield return(StartCoroutine(Snapshot(cubemap, CubemapFace.PositiveX, cam)));
yield return(StartCoroutine(Snapshot(cubemap, CubemapFace.NegativeX, cam)));
yield return(StartCoroutine(Snapshot(cubemap, CubemapFace.NegativeZ, cam)));
yield return(StartCoroutine(Snapshot(cubemap, CubemapFace.PositiveY, cam)));
yield return(StartCoroutine(Snapshot(cubemap, CubemapFace.NegativeY, cam)));
cubemap.Apply(mipmap);
AssetDatabase.CreateAsset(cubemap, "Assets/AssetStore/" + path + "/" + point.cubePointName + ".cubemap");
AssetDatabase.SaveAssets();
Destroy(camObject);
}
public void capture(ref Cubemap targetCube, Transform at, bool HDR)
{
if (targetCube == null)
{
return;
}
GameObject go = new GameObject("_temp_probe");
go.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideAndDontSave;
go.SetActive(true);
Camera cam = go.AddComponent <Camera>();
if (at != null)
{
go.transform.position = at.position;
}
if (HDR)
{
Shader.EnableKeyword("MARMO_RGBM");
Shader.DisableKeyword("MARMO_RGBA");
Shader.SetGlobalFloat("_GlowStrength", 0f);
Shader.SetGlobalFloat("_EmissionLM", 0f);
cam.SetReplacementShader(Shader.Find("Hidden/Marmoset/RGBM Replacement"), "RenderType");
}
cam.RenderToCubemap(targetCube);
targetCube.Apply(false);
if (HDR)
{
cam.ResetReplacementShader();
Shader.DisableKeyword("MARMO_RGBM");
Shader.EnableKeyword("MARMO_RGBA");
}
GameObject.DestroyImmediate(go);
}
private Cubemap mapToCubemap(float[,,] map, int size)
{
Color[][] colors = new Color[6][];
for (int m = 0; m < 6; m++)
{
colors[m] = new Color[size * size];
for (int y = 0; y < size; y++)
{
for (int x = 0; x < size; x++)
{
colors[m][x + y * size] = Color.Lerp(Color.black, Color.white, (map[m, x, y] + 1.0f) / 2.0f);
}
}
}
Cubemap cubemap = new Cubemap(size, TextureFormat.RGB24, true);
cubemap.SetPixels(colors[0], CubemapFace.PositiveX);
cubemap.SetPixels(colors[1], CubemapFace.NegativeX);
cubemap.SetPixels(colors[2], CubemapFace.PositiveY);
cubemap.SetPixels(colors[3], CubemapFace.NegativeY);
cubemap.SetPixels(colors[4], CubemapFace.PositiveZ);
cubemap.SetPixels(colors[5], CubemapFace.NegativeZ);
cubemap.Apply();
cubemap.name = "Perlin Noise Cubemap";
cubemap.wrapMode = TextureWrapMode.Clamp;
cubemap.filterMode = FilterMode.Point;
return(cubemap);
}
void Awake()
{
cam = gameObject.GetComponent <Camera>();
cam.depthTextureMode |= DepthTextureMode.Depth | DepthTextureMode.MotionVectors;
ssrtMaterial = new Material(Shader.Find("Hidden/SSRT"));
mesh = new Mesh();
mesh.vertices = new Vector3[]
{
new Vector3(-1, -1, 1),
new Vector3(-1, 1, 1),
new Vector3(1, 1, 1),
new Vector3(1, -1, 1)
};
mesh.uv = new Vector2[]
{
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 0),
new Vector2(1, 1)
};
mesh.SetIndices(new int[] { 0, 1, 2, 3 }, MeshTopology.Quads, 0);
if (fallbackMethod == FallbackMethod.DynamicCubemap)
{
cubemapFallback = new Cubemap(32, TextureFormat.RGB24, true);
cubemapFallback.Apply(true);
}
}
void AddToCubemap(StreetView.Face face, Texture2D tex)
{
if (cubemap == null)
cubemap = new Cubemap(downloader.options.resolution, TextureFormat.ARGB32, false);
CubemapFace cubemapFace = CubemapFace.PositiveX;
switch (face) {
case StreetView.Face.Up:
cubemapFace = CubemapFace.NegativeY;
break;
case StreetView.Face.Down:
cubemapFace = CubemapFace.PositiveY;
break;
case StreetView.Face.Front:
cubemapFace = CubemapFace.PositiveZ;
break;
case StreetView.Face.Back:
cubemapFace = CubemapFace.NegativeZ;
break;
case StreetView.Face.Left:
cubemapFace = CubemapFace.NegativeX;
break;
case StreetView.Face.Right:
cubemapFace = CubemapFace.PositiveX;
break;
}
cubemap.SetPixels(tex.GetPixels(), cubemapFace);
cubemap.Apply();
material.SetTexture("_Cubemap", cubemap);
targetRenderer.material = material;
}
void SetCookie()
{
float y = 0.0F;
while (y < noise.height)
{
float x = 0.0F;
while (x < noise.width)
{
//Perlin Noise
float xCoord = x_org + x / noise.width * scale;
float yCoord = y_org + y / noise.height * scale;
float sample = Mathf.PerlinNoise(xCoord, yCoord);
sample += brightness;
pix[(int)y * noise.width + (int)x] = new Color(sample, sample, sample, sample);
x++;
}
y++;
}
x_org += speed;
y_org += speed;
noise.SetPixels(pix, CubemapFace.NegativeX);
// noise.SetPixels(pix, CubemapFace.NegativeY);
noise.SetPixels(pix, CubemapFace.NegativeZ);
noise.SetPixels(pix, CubemapFace.PositiveX);
noise.SetPixels(pix, CubemapFace.PositiveY);
noise.SetPixels(pix, CubemapFace.PositiveZ);
noise.Apply();
}
//--------------------------------------------------------------------------------------
// Builds a normalizer cubemap, with the texels solid angle stored in the fourth component
void BuildNormalizerSolidAngleCubemap(int a_Size, Cubemap a_Surface)
{
//a_Size = a_Surface.width;
int iCubeFace, u, v;
Vector3 a_XYZ = new Vector3(0,0,0);
Color[] i_CubeMapColors = new Color[a_Size*a_Size];
//
float weight = 0.0f;
//iterate over cube faces
for(iCubeFace=0; iCubeFace<6; iCubeFace++)
{
for(v=0; v< a_Size; v++)
{
for(u=0; u < a_Size; u++)
{
// calc TexelToVect in a_XYZ
a_XYZ = TexelToVect(iCubeFace, (float)u, (float)v, a_Size);
// calc weight
weight = TexelCoordSolidAngle(iCubeFace, (float)u, (float)v, a_Size);
// Compress a_XYZ to fit into Color
i_CubeMapColors[v * a_Size + u] = new Color ((a_XYZ[0]+1.0f)/2.0f, (a_XYZ[1]+1.0f)/2.0f, (a_XYZ[2]+1.0f)/2.0f, weight);
}
}
// set CubemapFace
a_Surface.SetPixels(i_CubeMapColors, (CubemapFace)iCubeFace);
}
// set cubeMap
a_Surface.Apply(true);
// Debug.Log ("BuildNormalizerSolidAngleCubemap finished");
}
private Cubemap InterpolateTexture(Cubemap tex0, Cubemap tex1, Cubemap tex2, Vector3 weight)
{
Cubemap result = new Cubemap(256, TextureFormat.Alpha8, true);
foreach (CubemapFace face in System.Enum.GetValues(typeof(CubemapFace)))
{
if (face == CubemapFace.Unknown)
{
continue;
}
for (int y = 0; y < 256; ++y)
{
for (int x = 0; x < 256; ++x)
{
Color c0 = tex0.GetPixel(face, x, y);
Color c1 = tex1.GetPixel(face, x, y);
Color c2 = tex2.GetPixel(face, x, y);
Color color = weight.x * c0 + weight.y * c1 + weight.z * c2;
result.SetPixel(face, x, y, color);
}
}
}
result.Apply();
return(result);
}
public static void DirectionalCubemap()
{
int faceSize = 8;
Cubemap cube = new Cubemap(faceSize, TextureFormat.RGB24, false);
// For each side
foreach (CubemapFace face in System.Enum.GetValues(typeof(CubemapFace)))
{
Color[] pixels = new Color[faceSize * faceSize];
for (int x = 0; x < faceSize; ++x)
{
for (int y = 0; y < faceSize; ++y)
{
int index = x + y * faceSize;
Vector3 dir = Utils.Cubemap.CubemapDirection(face,
(x + 0.5f) / (float)faceSize - 0.5f,
(y + 0.5f) / (float)faceSize - 0.5f);
pixels[index] = new Color(dir.x, dir.y, dir.z);
}
}
cube.SetPixels(pixels, face);
cube.Apply();
}
AssetDatabase.CreateAsset(cube, "Assets/BiasedPhysics/DirectionalCubemap.cubemap");
Debug.Log("Generated /BiasedPhysics/DirectionalCubemap.cubemap");
}
public static void clearCheckerCube(ref Cubemap cube)
{
Color gray0 = new Color(0.25f, 0.25f, 0.25f, 0.25f);
Color gray1 = new Color(0.50f, 0.50f, 0.50f, 0.25f);
Color[] c = cube.GetPixels(CubemapFace.NegativeX);
int w = cube.width;
int sqw = Mathf.Max(1, w / 4); //width of square
for (int face = 0; face < 6; ++face)
{
for (int x = 0; x < w; ++x)
{
for (int y = 0; y < w; ++y)
{
if (((x / sqw) % 2) == ((y / sqw) % 2))
{
c[y * w + x] = gray0;
}
else
{
c[y * w + x] = gray1;
}
}
}
cube.SetPixels(c, (CubemapFace)face);
}
cube.Apply(true);
}
//Convert a RenderTexture to a Cubemap
public static Cubemap RenderTextureToCubemap(RenderTexture input)
{
if (input.dimension != UnityEngine.Rendering.TextureDimension.Cube)
{
Debug.LogWarning("Input render texture dimension must be cube");
return(null);
}
if (input.width != input.height)
{
Debug.LogWarning("Input render texture must be square");
return(null);
}
Cubemap output = new Cubemap(input.width, ConvertFormat(input.format), false);
Texture2D tmp_face = new Texture2D(input.width, input.height, output.format, false);
RenderTexture active = RenderTexture.active;
for (int face = 0; face < 6; ++face)
{
Graphics.SetRenderTarget(input, 0, (CubemapFace)face);
tmp_face.ReadPixels(new Rect(0, 0, input.width, input.height), 0, 0);
output.SetPixels(tmp_face.GetPixels(), (CubemapFace)face);
}
output.Apply();
RenderTexture.active = active;
Object.DestroyImmediate(tmp_face);
return(output);
}
public void CopyToFace()
{
if (cubemapResolution != sourceTextureResolution.x || cubemapResolution != sourceTextureResolution.y)
{
throw new Exception("Panoramic texture to cubemap texture generator error: cubemap resolution is different from source texture width or height.");
}
for (int x = 0; x < cubemapResolution; x++)
{
for (int y = 0; y < cubemapResolution; y++)
{
targetCubemap.SetPixel(targetFace, x, y, sourceTexture.GetPixel(x, y));
}
}
targetCubemap.Apply();
}
// Use this for initialization
void Start()
{
cam = GameObject.Find("Camera");
//gameObject.transform.eulerAngles = new Vector3(0,0,0);
Mesh mesh = gameObject.GetComponent <MeshFilter>().mesh;
child0 = new GameObject("child0");
child0.AddComponent <MeshFilter>();
child0.AddComponent <MeshRenderer>();
child0.transform.position = gameObject.transform.position;
child0.transform.parent = gameObject.transform;
child0.GetComponent <MeshFilter>().mesh = mesh;
child0.GetComponent <MeshRenderer>().material = gameObject.GetComponent <MeshRenderer>().material;
//child0.transform.localScale = new Vector3(1,1,1);
child0.transform.eulerAngles = new Vector3(0, 90, 0);
child1 = new GameObject("child1");
child1.AddComponent <MeshFilter>();
child1.AddComponent <MeshRenderer>();
child1.transform.position = gameObject.transform.position;
child1.transform.parent = gameObject.transform;
child1.GetComponent <MeshFilter>().mesh = mesh;
child1.GetComponent <MeshRenderer>().material = gameObject.GetComponent <MeshRenderer>().material;
//child0.transform.localScale = new Vector3(1,1,1);
child1.transform.eulerAngles = new Vector3(0, 180, 0);
child2 = new GameObject("child2");
child2.AddComponent <MeshFilter>();
child2.AddComponent <MeshRenderer>();
child2.transform.position = gameObject.transform.position;
child2.transform.parent = gameObject.transform;
child2.GetComponent <MeshFilter>().mesh = mesh;
child2.GetComponent <MeshRenderer>().material = gameObject.GetComponent <MeshRenderer>().material;
//child0.transform.localScale = new Vector3(1,1,1);
child2.transform.eulerAngles = new Vector3(0, 270, 0);
gameObject.transform.up = cam.transform.position - gameObject.transform.position;
int width = 256;
heightMap = new Cubemap(width, TextureFormat.ARGB32, false);
for (int i = 0; i < width; i++)
{
for (int j = 0; j < width; j++)
{
heightMap.SetPixel(CubemapFace.NegativeX, i, j, new Color(1, 0, 0, 1));
heightMap.SetPixel(CubemapFace.NegativeY, i, j, new Color(1, 1, 0, 1));
heightMap.SetPixel(CubemapFace.NegativeZ, i, j, new Color(1, 0, 1, 1));
heightMap.SetPixel(CubemapFace.PositiveX, i, j, new Color(1, 1, 0.5f, 1));
heightMap.SetPixel(CubemapFace.PositiveY, i, j, new Color(1, 1, 0.75f, 1));
heightMap.SetPixel(CubemapFace.PositiveZ, i, j, new Color(1, 1, 1, 1));
}
}
heightMap.Apply();
}
void OnWizardCreate()
{
if (camera == null)
{
camera = Camera.main;
}
// render into cubemap
camera.RenderToCubemap(cubemap);
cubemap.Apply();
ConvertToPng();
}
private static void ClearBakedTexture(Texture cubemap)
{
Cubemap p = cubemap as Cubemap;
FillCubemapFace(p, CubemapFace.PositiveX, Color.black);
FillCubemapFace(p, CubemapFace.PositiveY, Color.black);
FillCubemapFace(p, CubemapFace.PositiveZ, Color.black);
FillCubemapFace(p, CubemapFace.NegativeX, Color.black);
FillCubemapFace(p, CubemapFace.NegativeY, Color.black);
FillCubemapFace(p, CubemapFace.NegativeZ, Color.black);
p.Apply();
}
public override void OnInspectorGUI()
{
if (this.m_Images == null)
{
this.InitTexturesFromCubemap();
}
EditorGUIUtility.labelWidth = 50f;
Cubemap cubemap = this.target as Cubemap;
if (cubemap == null)
{
return;
}
GUILayout.BeginVertical(new GUILayoutOption[0]);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
this.ShowFace("Right\n(+X)", CubemapFace.PositiveX);
this.ShowFace("Left\n(-X)", CubemapFace.NegativeX);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
this.ShowFace("Top\n(+Y)", CubemapFace.PositiveY);
this.ShowFace("Bottom\n(-Y)", CubemapFace.NegativeY);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
this.ShowFace("Front\n(+Z)", CubemapFace.PositiveZ);
this.ShowFace("Back\n(-Z)", CubemapFace.NegativeZ);
GUILayout.EndHorizontal();
GUILayout.EndVertical();
EditorGUIUtility.labelWidth = 0f;
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
EditorGUILayout.HelpBox("Lowering face size is a destructive operation, you might need to re-assign the textures later to fix resolution issues. It's preferable to use Cubemap texture import type instead of Legacy Cubemap assets.", MessageType.Warning);
int num = TextureUtil.GetGLWidth(cubemap);
num = EditorGUILayout.IntPopup("Face size", num, CubemapInspector.kSizes, CubemapInspector.kSizesValues, new GUILayoutOption[0]);
int num2 = TextureUtil.CountMipmaps(cubemap);
bool useMipmap = EditorGUILayout.Toggle("MipMaps", num2 > 1, new GUILayoutOption[0]);
bool flag = TextureUtil.GetLinearSampled(cubemap);
flag = EditorGUILayout.Toggle("Linear", flag, new GUILayoutOption[0]);
bool flag2 = TextureUtil.IsCubemapReadable(cubemap);
flag2 = EditorGUILayout.Toggle("Readable", flag2, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
if (TextureUtil.ReformatCubemap(ref cubemap, num, num, cubemap.format, useMipmap, flag))
{
this.InitTexturesFromCubemap();
}
TextureUtil.MarkCubemapReadable(cubemap, flag2);
cubemap.Apply();
}
}
public IEnumerator LoadAndSaveCubemapMaterials(string path, bool isRightEye)
{
List <Texture2D> textures = new List <Texture2D>();
if (Directory.Exists(GetCacheDirectory(path)))
{
StatusText.SetText("Loading textures from cache");
yield return(StartCoroutine(GetTexturesFromCache(path, textures)));
}
else
{
StatusText.SetText("Loading textures from tif");
yield return(StartCoroutine(GetTexturesFromTif(path, textures)));
}
int texSize = textures[0].width;
TextureFormat format = textures[0].format;
StatusText.SetText("Creating cubemap");
yield return(null);
Cubemap cubemap = new Cubemap(texSize, format, false);
yield return(StartCoroutine(CreateCubemapFromTextures(textures, cubemap)));
cubemap.Apply();
Material eyeMat = new Material(Shader.Find("Skybox/Cubemap"));
eyeMat.SetTexture(Shader.PropertyToID("_Tex"), cubemap);
if (isRightEye)
{
rightEye = eyeMat;
}
else
{
leftEye = eyeMat;
}
loaded = true;
for (int i = 0; i < textures.Count; ++i)
{
Destroy(textures[i]);
}
textures.Clear();
textures = null;
}
private static Cubemap GenerateHeightmap(Config cfg)
{
Random.State savedState = Random.state;
int size = cfg.heightCubemapSize;
Cubemap heightMap = new Cubemap(size, TextureFormat.RGB24, false);
// Pixels are laid out right to left, top to bottom
Color[] pixels = new Color[size * size];
Color pixel = new Color();
var generator = new LibNoise.Generator.Perlin();
generator.Frequency = cfg.noiseScale;
generator.OctaveCount = cfg.octaves;
generator.Seed = cfg.seed;
foreach (CubemapFace face in System.Enum.GetValues(typeof(CubemapFace)))
{
if (face == CubemapFace.Unknown)
{
continue;
}
for (int y = 0; y < size; ++y)
{
for (int x = 0; x < size; ++x)
{
Vector2 uv = new Vector2((float)x / (size - 1), (float)y / (size - 1));
Vector3 radiusVec = CubemapProjections.GetRadiusVectorFromFace(face, uv);
/*pixel.r = (radius.x + 1) * 0.5f;
* pixel.g = (radius.y + 1) * 0.5f;
* pixel.b = (radius.z + 1) * 0.5f;*/
float height = (float)generator.GetValue(radiusVec * cfg.radius);
height = (height + 1) * 0.5f;
pixel.r = pixel.g = pixel.b = height;
pixels[x + y * size] = pixel;
}
}
heightMap.SetPixels(pixels, face);
heightMap.Apply();
}
Random.state = savedState;
return(heightMap);
}
//Reads the pixels in from the side, and assigns it to the proper face of the cubemap
private void AssignCubemapFace(Texture2D side, CubemapFace cubemapFace)
{
for (int i = 0; i < _size; i++)
{
for (int j = 0; j < _size; j++)
{
Color pixel = side.GetPixel(i, j);
_tempCubeMap.SetPixel(cubemapFace, i, j, pixel);
}
}
_tempCubeMap.Apply();
}
private static Cubemap GetDefaultBlackCube()
{
var cm = new Cubemap(1, TextureFormat.RGB24, true);
cm.SetPixels(new Color[] { Color.black }, CubemapFace.NegativeX, 0);
cm.SetPixels(new Color[] { Color.black }, CubemapFace.PositiveX, 0);
cm.SetPixels(new Color[] { Color.black }, CubemapFace.NegativeY, 0);
cm.SetPixels(new Color[] { Color.black }, CubemapFace.PositiveY, 0);
cm.SetPixels(new Color[] { Color.black }, CubemapFace.NegativeZ, 0);
cm.SetPixels(new Color[] { Color.black }, CubemapFace.PositiveZ, 0);
cm.Apply();
return(cm);
}
public void toCube(ref Cubemap cube, int mip, ColorMode cubeColorMode, bool useGamma)
{
int faceLength = faceSize * faceSize;
Color[] facePixels = new Color[faceLength];
for (int face = 0; face < 6; ++face)
{
pixelCopy(ref facePixels, 0, pixels, face * faceLength, faceLength);
encode(ref facePixels, facePixels, cubeColorMode, useGamma);
cube.SetPixels(facePixels, (CubemapFace)face, mip);
}
cube.Apply(false);
}
void Start()
{
Camera mainCam = GetComponent <Camera>();
if (GenerateNewMap)
{
cubemap = new Cubemap(512, TextureFormat.ARGB32, false);
}
mainCam.RenderToCubemap(cubemap);
cubemap.Apply();
}
