The Walking Dead VR

Michaelm9945 · Mar 11, 2015

I've attached a photo of my Walking Dead game I made for the Oculus Rift. I recreated the Prison

I have a problem with building the player. I keep getting errors in the scripts. I've managed to fix about 10 different errors, but more keep coming (It's really frustrating)

I can't build my player, because there's compiling errors stopping me from doing that.

Can somebody help me, so I can upload this game on the internet. Its better if I talk to somebody through E-mail, so we can keep in constant contact until this problem is fixed. I will also, send you the game through E-mail.

LaneFox · Mar 11, 2015

You need to post some errors before anyone can attempt to suggest how you are to fix them.

Schneider21 · Mar 11, 2015

Michaelm9945 said: ↑

Its better if I talk to somebody through E-mail, so we can keep in constant contact until this problem is fixed.
Click to expand...

Good lord, that sounds horrible! The boards are the perfect place to resolve your issue. No need to acquire a dedicated support person.

As LaneFox said, you'll have to let people know what the actual errors are before anyone can help you. If the errors point to a line in one of your scripts, it's a good idea to post those scripts as well so people can see what might be going on. Otherwise, all they'll be able to do is tell you what the error already is: here's what's failing and here's the place it's happening.

Michaelm9945 · Mar 11, 2015

These are all the errors that I am receiving

HDR RenderTexture format is not supported on this platform. This
camera will render without HDR buffers.

Assets/Lux/Lux Scripts/Lux Cubemapper/Scripts/LuxCubeProcessor.cs(1040,8):
error CS8025: Parsing error

Assets/OVR/Scripts/Util/OVRMainMenu.cs(98,33): warning CS0414:
The private field `OVRMainMenu.VRVarsSX' is assigned but its value is never used

Assets/OVR/Scripts/Util/OVRMainMenu.cs(99,33): warning CS0414:
The private field `OVRMainMenu.VRVarsSY' is assigned but its value is never used

Assets/OVR/Scripts/Util/OVRMainMenu.cs(100,33): warning CS0414:
The private field `OVRMainMenu.VRVarsWidthX' is assigned but its value is never used

Assets/OVR/Scripts/Util/OVRMainMenu.cs(101,33): warning CS0414:
The private field `OVRMainMenu.VRVarsWidthY' is assigned but its value is never used

Assets/OVR/Scripts/Util/OVRMainMenu.cs(145,24): warning CS0414:
The private field `OVRMainMenu.AlphaFadeValue' is assigned but its value is never used

Assets/OVR/Scripts/Util/OVRUGUI.cs(94,24): warning CS0414:
The private field `OVRUGUI.numOfGUI' is assigned but its value is never used

Assets/Lux/Lux Scripts/Editor/LuxMaterialInspector.cs(55,33):
warning CS0618: `UnityEditor.MaterialEditor.TextureProperty(string, string,
UnityEditor.ShaderUtil.ShaderPropertyTexDim)' is obsolete: `Use TextureProperty
with MaterialProperty instead.'

Assets/Lux/Lux Scripts/Lux Cubemapper/Editor/LuxEnvProbeEditor.cs(208,21):
warning CS0219: The variable `spec' is assigned but its value is never used

Assets/Lux/Lux Scripts/Lux Cubemapper/Editor/LuxEnvProbeEditor.cs(207,21):
warning CS0219: The variable `diff' is assigned but its value is never used

Assets/RoadTool/Editor/RoadTool.cs(240,22): warning CS0618:
`UnityEditor.Undo.RegisterUndo(UnityEngine.Object[], string)'
is obsolete: `Use Undo.RecordObjects instead'

Assets/RoadTool/Editor/RoadTool.cs(253,22): warning CS0618:
`UnityEditor.Undo.RegisterUndo(UnityEngine.Object[], string)'
is obsolete: `Use Undo.RecordObjects instead'

Assets/EasyRoads3D Free/Editor/RoadObjectEditorScript.js(730,74):
BCW0028: WARNING: Implicit downcast from 'System.Object' to 'int'.

Assets/EasyRoads3D Free/Editor/RoadObjectEditorScript.js(813,17):
BCW0023: WARNING: This method could return default value implicitly.

This is the script for Luxcubeprocessor.cs

Code (CSharp):

// ////////////////////

// Lux LuxCubeProcessor

// http://seblagarde.wordpress.com/2012/06/10/amd-cubemapgen-for-physically-based-rendering/

using UnityEngine;

#if UNITY_EDITOR

using UnityEditor;

#endif

public enum ConvoModes

{

Diffuse = 0,

Specular = 1

}

//public class LuxCubeProcessor : ScriptableWizard {

public class LuxCubeProcessor {

public Cubemap cubeMap;

public bool TakeNewProbe;

public GameObject probe;

public ConvoModes ConvolutionMode;

public bool HighestMipIsReflection = true;

public bool PullHDR;

private Color[] CubeMapColors;

public float SpecularPower = 2048; // Matches Lux SpecPower

#if UNITY_EDITOR

//--------------------------------------------------------------------------------------

// parameter, vars and arrays needed by the script

private float[] solidAngles;

private static float CP_PI = 3.14159265358979323846f;

// matrices that map cube map indexing vectors in 3d (after face selection and divide through by the _ABSOLUTE VALUE_ of the max coord) into NVC space

// Note this currently assumes the D3D cube face ordering and orientation

private Vector3[ , ] sgFace2DMapping = new Vector3[ , ] {

//XPOS face 0

{ new Vector3( 0, 0, -1), //u towards negative Z

new Vector3( 0, -1, 0), //v towards negative Y

new Vector3( 1, 0, 0)}, //pos X axis

//XNEG face 1

{ new Vector3( 0, 0, 1), //u towards positive Z

new Vector3( 0, -1, 0), //v towards negative Y

new Vector3( -1, 0, 0)}, //neg X axis

//YPOS face 2

{ new Vector3(1, 0, 0), //u towards positive X

new Vector3(0, 0, 1), //v towards positive Z

new Vector3(0, 1 , 0)}, //pos Y axis

//YNEG face 3

{ new Vector3(1, 0, 0), //u towards positive X

new Vector3(0, 0 , -1), //v towards negative Z

new Vector3(0, -1 , 0)}, //neg Y axis

//ZPOS face 4

{ new Vector3(1, 0, 0), //u towards positive X

new Vector3(0, -1, 0), //v towards negative Y

new Vector3(0, 0, 1)}, //pos Z axis

//ZNEG face 5

{ new Vector3(-1, 0, 0), //u towards negative X

new Vector3(0, -1, 0), //v towards negative Y

new Vector3(0, 0, -1)} //neg Z axis

};

//The 12 edges of the cubemap

// this table is used to average over the edges.

private int[ , ] sg_CubeEdgeList = new int[ , ] {

// face1, face2

{0,2}, // X_POS Y_POS

{0,3}, // X_POS Y_NEG

{0,4}, // X_POS Z_POS

{0,5}, // X_POS Z_NEG

{1,2}, // X_NEG Y_POS

{1,3}, // X_NEG Y_NEG

{1,4}, // X_NEG Z_POS

{1,5}, // X_NEG Z_NEG

{2,4}, // Y_POS Z_POS

{2,5}, // Y_POS Z_NEG

{3,4}, // Y_NEG Z_POS

{3,5} // Y_NEG Z_NEG

};

private int[ , ] sg_CubeCornerList = new int[ , ] {

// face1, face2, face3

{0,2,4}, // X_POS Y_POS Z_POS

{0,2,5}, // X_POS Y_POS Z_NEG

{0,3,4}, // X_POS Y_NEG Z_POS

{0,3,5}, // X_POS Y_NEG Z_NEG

{1,2,4}, // X_NEG Y_POS Z_POS

{1,2,5}, // X_NEG Y_POS Z_NEG

{1,3,4}, // X_NEG Y_NEG Z_POS

{1,3,5}, // X_NEG Y_NEG Z_NEG

};

//--------------------------------------------------------------------------------------

// Helper for Cubemapper Probe

public void ProcessCubemap(Cubemap cube, bool diff, bool hdr)

{

if (diff)

{

ConvolveIrradianceEnvironmentMap(cube);

if (hdr) FakeHDR(cube, false);

Debug.Log("Diff Cube Processed");

}

else

{

ConvolveRadianceEnvironmentMap(cube);

FixupCubeEdges(cube);

if (hdr) FakeHDR(cube, true);

cube.filterMode = FilterMode.Trilinear;

cube.mipMapBias = 0.5f;

Debug.Log("Spec Cube Processed");

}

}

//[MenuItem ("Lux Cubemapper/Cubemapper")]

//static void CreateWizard () {

// ScriptableWizard.DisplayWizard<LuxCubeMapper>("Convolve cubemap", "Go");

//}

//void OnWizardCreate () {

// if (TakeNewProbe) RenderToCubeMap(cubeMap,probe);

// // diffuse

// if (ConvolutionMode == ConvoModes.Diffuse) {

// ConvolveIrradianceEnvironmentMap (cubeMap);

// if (PullHDR) FakeHDR(cubeMap, false);

// }

// if (ConvolutionMode == ConvoModes.Specular) {

// ConvolveRadianceEnvironmentMap (cubeMap);

// FixupCubeEdges(cubeMap);

// if (PullHDR) FakeHDR(cubeMap, true);

// cubeMap.filterMode = FilterMode.Trilinear;

// cubeMap.mipMapBias = 0.5f;

// }

//}

//void OnWizardUpdate () {

//}

//void RenderToCubeMap(Cubemap dest, GameObject probe) {

// var cubeCamera = new GameObject( "CubemapCamera", typeof(Camera) ) as GameObject;

//// cubeCamera.hideFlags = HideFlags.HideInHierarchy;

// var cubeCam = cubeCamera.GetComponent("Camera") as Camera;

// cubeCam.nearClipPlane = 0.001f;

// cubeCam.farClipPlane = 1000.0f;

// cubeCam.aspect = 1.0f;

//// cubeCam.hdr = true;

// cubeCam.cullingMask = 1 << 0;

// cubeCamera.transform.position = probe.transform.position;

// cubeCam.RenderToCubemap(dest);

// GameObject.DestroyImmediate(cubeCamera);

//}

//--------------------------------------------------------------------------------------

// ConvolveRadianceEnvironmentMap

void ConvolveRadianceEnvironmentMap (Cubemap RadianceCube) {

int a_Size = RadianceCube.width;

int n_Size = a_Size;

int startMipLevel = 0;

float specularPower;

float[] specPowr = new float [] {

SpecularPower, SpecularPower/2.0f, SpecularPower/4.0f, SpecularPower/8.0f, SpecularPower/16.0f, SpecularPower/32.0f, SpecularPower/64.0f, SpecularPower/128.0f, SpecularPower/256.0f, SpecularPower/512.0f

};

// Calculate maxmiplevels

int maxMipLevels = (int)Mathf.Log(a_Size, 2) + 1;

//

float mytime = Time.realtimeSinceStartup;

// if HighestMipIsReflection == true then skip processing of the highest mip level

if (HighestMipIsReflection) {

startMipLevel = 1;

n_Size = n_Size >> 1;

}

for (int mipLevel = startMipLevel; mipLevel < maxMipLevels; mipLevel++)

{

Vector4[] m_NormCubeMapArray = new Vector4[n_Size*n_Size*6];

BuildNormalizerSolidAngleArray(n_Size, ref m_NormCubeMapArray);

specularPower = specPowr[mipLevel];

float Angle;

// If we use SpecularPower, automatically calculate the a_BaseFilterAngle required, this will speed the process

Angle = GetBaseFilterAngle(specularPower);

// Go for it:

FilterCubefaces(RadianceCube, m_NormCubeMapArray, mipLevel, Angle, specularPower);

// FilterCubefacesBF(RadianceCube, mipLevel, Angle, specularPower);

n_Size = n_Size >> 1;

}

//

Debug.Log(Time.realtimeSinceStartup - mytime);

RadianceCube.Apply(false);

}

void FilterCubefaces (Cubemap RadianceCubeMap, Vector4[] m_NormCubeMapArray, int mipLevel, float a_FilterConeAngle, float a_SpecularPower)

{

// Read the first CubeFace

Color[] InputCubeFacePixels = RadianceCubeMap.GetPixels(CubemapFace.PositiveX, mipLevel);

// Get its dimensions

int faceLength = InputCubeFacePixels.Length;

int a_Size = (int)Mathf.Sqrt(faceLength);

// Create new array for all Faces

Color[] PixelsOfAllFaces = new Color[faceLength * 6];

// Copy first face

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, 0);

// Copy all other Faces

for (int readFace = 1; readFace < 6; readFace++ ) {

InputCubeFacePixels = RadianceCubeMap.GetPixels((CubemapFace)readFace, mipLevel);

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, faceLength * readFace);

}

InputCubeFacePixels = null;

// Declare jagged output array and init its child arrays

Color[][] OutputCubeFacePixels = new Color[6][];

OutputCubeFacePixels[0] = new Color[faceLength];

OutputCubeFacePixels[1] = new Color[faceLength];

OutputCubeFacePixels[2] = new Color[faceLength];

OutputCubeFacePixels[3] = new Color[faceLength];

OutputCubeFacePixels[4] = new Color[faceLength];

OutputCubeFacePixels[5] = new Color[faceLength];

// FilterCubeSurfaces

float srcTexelAngle;

float dotProdThresh;

int filterSize;

// Angle about center tap to define filter cone

float filterAngle;

// Min angle a src texel can cover (in degrees)

srcTexelAngle = (180.0f / CP_PI) * Mathf.Atan2(1.0f, (float)a_Size);

// Filter angle is 1/2 the cone angle

filterAngle = a_FilterConeAngle / 2.0f;

// Ensure filter angle is larger than a texel

if(filterAngle < srcTexelAngle)

{

filterAngle = srcTexelAngle;

}

// Ensure filter cone is always smaller than the hemisphere

if(filterAngle > 90.0f)

{

filterAngle = 90.0f;

}

// The maximum number of texels in 1D the filter cone angle will cover

// Used to determine bounding box size for filter extents

filterSize = (int)Mathf.Ceil(filterAngle / srcTexelAngle);

// Ensure conservative region always covers at least one texel

if(filterSize < 1)

{

filterSize = 1;

}

// dotProdThresh threshold based on cone angle to determine whether or not taps

// Reside within the cone angle

dotProdThresh = Mathf.Cos( (CP_PI / 180.0f) * filterAngle );

// Process required faces

for (int a_FaceIdx = 0; a_FaceIdx < 6; a_FaceIdx++)

{

// Iterate over dst cube map face texel

for (int a_V = 0; a_V < a_Size; a_V++)

{

for (int a_U = 0; a_U < a_Size; a_U++)

{

Vector4 Sample = new Vector4();

Color tempCol = new Color();

// Get center tap direction

Vector3 centerTapDir = TexelToVect(a_FaceIdx, (float)a_U, (float)a_V, a_Size);

//--------------------------------------------------------------------------------------

// ProcessFilterExtents

float weightAccum = 0.0f;

int startFacePtr = 0;

// Iterate over cubefaces

for(int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++ )

{

// Pointer to the start of the given face

startFacePtr = a_Size*a_Size*iFaceIdx;

for(int v = 0; v < a_Size; v++)

{

for(int u = 0; u < a_Size; u++)

{

// CP_FILTER_TYPE_COSINE_POWER

// Read normalCube single "pixel"

Vector4 m_NormCubeMap_pixel = m_NormCubeMapArray[startFacePtr + a_Size*v + u];

// Pointer to direction in cube map associated with texel

// Vector3 texelVect = TexelToVect(iFaceIdx, (float)u, (float)v, a_Size);

Vector3 texelVect;

// Optimized version

texelVect.x = m_NormCubeMap_pixel[0];// * 2.0f - 1.0f;

texelVect.y = m_NormCubeMap_pixel[1];// * 2.0f - 1.0f;

texelVect.z = m_NormCubeMap_pixel[2];// * 2.0f - 1.0f;

// Check dot product to see if texel is within cone

float tapDotProd = Vector3.Dot(texelVect, centerTapDir);

float weight = 0.0f;

if( tapDotProd >= dotProdThresh && tapDotProd > 0.0f )

{

// Weight should be proportional to the solid angle of the tap

// weight = TexelCoordSolidAngle(iFaceIdx, (float)u, (float)v, a_Size);

weight = m_NormCubeMap_pixel[3];

// Here we decide if we use a Phong/Blinn or a Phong/Blinn BRDF.

// Phong/Blinn BRDF is just the Phong/Blinn model multiply by the cosine of the lambert law

// so just adding one to specularpower do the trick.

// weight *= pow(tapDotProd, (a_SpecularPower + (float32)IsPhongBRDF));

// CP_FILTER_TYPE_COSINE_POWER

weight *= Mathf.Pow(tapDotProd, a_SpecularPower);

// CP_FILTER_TYPE_COSINE

//weight *= tapDotProd;

}

// Accumulate weight

weightAccum += weight;

// Get pixel from the input cubeMap array

tempCol = PixelsOfAllFaces[a_Size*a_Size*iFaceIdx + a_Size*v + u];

Sample += new Vector4(tempCol.r * weight, tempCol.g * weight, tempCol.b * weight, 1.0f);

}

}

}

// one pixel processed

// Lux needs alpha!

OutputCubeFacePixels[a_FaceIdx][a_V*a_Size + a_U] = new Color(Sample.x/ weightAccum, Sample.y/ weightAccum, Sample.z/ weightAccum, 1.0f);

// end inner loops

}

}

}

// Write Pixel from the jagged array back to the cubemap faces

for (int writeFace = 0; writeFace < 6; writeFace++ ) {

Color[] tempColors = OutputCubeFacePixels[writeFace];

RadianceCubeMap.SetPixels(tempColors, (CubemapFace)writeFace, mipLevel);

}

}

// brute force: no look up table used

void FilterCubefacesBF (Cubemap RadianceCubeMap, int mipLevel, float a_FilterConeAngle, float a_SpecularPower)

{

// Read the first CubeFace

Color[] InputCubeFacePixels = RadianceCubeMap.GetPixels(CubemapFace.PositiveX, mipLevel);

// Get its dimensions

int faceLength = InputCubeFacePixels.Length;

int a_Size = (int)Mathf.Sqrt(faceLength);

// Create new array for all Faces

Color[] PixelsOfAllFaces = new Color[faceLength * 6];

// Copy first face

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, 0);

// Copy all other Faces

for (int readFace = 1; readFace < 6; readFace++ ) {

InputCubeFacePixels = RadianceCubeMap.GetPixels((CubemapFace)readFace, mipLevel);

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, faceLength * readFace);

}

InputCubeFacePixels = null;

// declare jagged output array and init its child arrays

Color[][] OutputCubeFacePixels = new Color[6][];

OutputCubeFacePixels[0] = new Color[faceLength];

OutputCubeFacePixels[1] = new Color[faceLength];

OutputCubeFacePixels[2] = new Color[faceLength];

OutputCubeFacePixels[3] = new Color[faceLength];

OutputCubeFacePixels[4] = new Color[faceLength];

OutputCubeFacePixels[5] = new Color[faceLength];

// FilterCubeSurfaces

float srcTexelAngle;

float dotProdThresh;

int filterSize;

//angle about center tap to define filter cone

float filterAngle;

//min angle a src texel can cover (in degrees)

srcTexelAngle = (180.0f / CP_PI) * Mathf.Atan2(1.0f, (float)a_Size);

//filter angle is 1/2 the cone angle

filterAngle = a_FilterConeAngle / 2.0f;

//ensure filter angle is larger than a texel

if(filterAngle < srcTexelAngle)

{

filterAngle = srcTexelAngle;

}

//ensure filter cone is always smaller than the hemisphere

if(filterAngle > 90.0f)

{

filterAngle = 90.0f;

}

// The maximum number of texels in 1D the filter cone angle will cover

// Used to determine bounding box size for filter extents

filterSize = (int)Mathf.Ceil(filterAngle / srcTexelAngle);

// Ensure conservative region always covers at least one texel

if(filterSize < 1)

{

filterSize = 1;

}

// dotProdThresh threshold based on cone angle to determine whether or not taps

// Reside within the cone angle

dotProdThresh = Mathf.Cos( (CP_PI / 180.0f) * filterAngle );

// Process required faces

for (int a_FaceIdx = 0; a_FaceIdx < 6; a_FaceIdx++)

{

// Iterate over dst cube map face texel

for (int a_V = 0; a_V < a_Size; a_V++)

{

for (int a_U = 0; a_U < a_Size; a_U++)

{

Vector4 Sample = new Vector4();

Color tempCol = new Color();

// get center tap direction

Vector3 centerTapDir = TexelToVect(a_FaceIdx, (float)a_U, (float)a_V, a_Size);

//--------------------------------------------------------------------------------------

// ProcessFilterExtents

float weightAccum = 0.0f;

// Iterate over cubefaces

for(int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++ )

{

for(int v = 0; v < a_Size; v++)

{

for(int u = 0; u < a_Size; u++)

{

// CP_FILTER_TYPE_COSINE_POWER

// Pointer to direction in cube map associated with texel

Vector3 texelVect = TexelToVect(iFaceIdx, (float)u, (float)v, a_Size);

// Check dot product to see if texel is within cone

float tapDotProd = Vector3.Dot(texelVect, centerTapDir);

float weight = 0.0f;

if( tapDotProd >= dotProdThresh && tapDotProd > 0.0f )

{

// Weight should be proportional to the solid angle of the tap

weight = TexelCoordSolidAngle(iFaceIdx, (float)u, (float)v, a_Size);

// Here we decide if we use a Phong/Blinn or a Phong/Blinn BRDF.

// Phong/Blinn BRDF is just the Phong/Blinn model multiply by the cosine of the lambert law

// so just adding one to specularpower do the trick.

// weight *= pow(tapDotProd, (a_SpecularPower + (float32)IsPhongBRDF));

// CP_FILTER_TYPE_COSINE_POWER

weight *= Mathf.Pow(tapDotProd, a_SpecularPower);

// CP_FILTER_TYPE_COSINE

//weight *= tapDotProd;

}

// Accumulate weight

weightAccum += weight;

// Get pixel from the input cubeMap array

tempCol = PixelsOfAllFaces[a_Size*a_Size*iFaceIdx + a_Size*v + u];

Sample += new Vector4(tempCol.r * weight, tempCol.g * weight, tempCol.b * weight, 1.0f);

}

}

}

// one pixel processed

// Lux needs alpha!

OutputCubeFacePixels[a_FaceIdx][a_V*a_Size + a_U] = new Color(Sample.x/ weightAccum, Sample.y/ weightAccum, Sample.z/ weightAccum, 1.0f);

// end inner loops

}

}

}

// Write Pixel from the jagged array back to the cubemap faces

for (int writeFace = 0; writeFace < 6; writeFace++ ) {

Color[] tempColors = OutputCubeFacePixels[writeFace];

RadianceCubeMap.SetPixels(tempColors, (CubemapFace)writeFace, mipLevel);

}

}

//--------------------------------------------------------------------------------------

// Irridiance Convolution based on SH

void ConvolveIrradianceEnvironmentMap(Cubemap irrCubeMap)

{

int a_Size = irrCubeMap.width;

Vector4[] m_NormCubeMapArray = new Vector4[a_Size*a_Size*6];

BuildNormalizerSolidAngleArray(a_Size, ref m_NormCubeMapArray);

//This is a custom implementation of D3DXSHProjectCubeMap to avoid to deal with LPDIRECT3DSURFACE9 pointer

//Use Sh order 2 for a total of 9 coefficient as describe in http://www.cs.berkeley.edu/~ravir/papers/envmap/

//accumulators are 64-bit floats in order to have the precision needed

//over a summation of a large number of pixels

double[] SHr = new double[25]; // NUM_SH_COEFFICIENT

double[] SHg = new double[25];

double[] SHb = new double[25];

double[] SHdir = new double[25];

double weightAccum = 0.0;

double weight = 0.0;

int startFacePtr = 0;

for (int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++) {

// read pixels of m_NormCubeMap

//var m_NormCubeMap_pixels = new Color[m_NormCubeMap.width*m_NormCubeMap.height];

//m_NormCubeMap_pixels = m_NormCubeMap.GetPixels((CubemapFace)iFaceIdx);

// Pointer to the start of the given face in m_NormCubeMapArray

startFacePtr = a_Size*a_Size*iFaceIdx;

// read all pixels of irrCubeMap

var cubeMap_pixels = new Color[irrCubeMap.width * irrCubeMap.height];

cubeMap_pixels = irrCubeMap.GetPixels((CubemapFace)iFaceIdx);

for (int y = 0; y < a_Size; y++) {

for (int x = 0; x < a_Size; x++) {

// read normalCube single pixel

Vector4 m_NormCubeMap_pixel = m_NormCubeMapArray[startFacePtr + y*a_Size + x];

// read originalCube single pixel

Color cubeMap_pixel = cubeMap_pixels[y*a_Size + x];

// solid angle stored in 4th channel of normalizer/solid angle cube map

weight = m_NormCubeMap_pixel[3];

//weight = TexelCoordSolidAngle(iFaceIdx, (float)x, (float)y, a_Size);

// pointer to direction and solid angle in cube map associated with texel

Vector3 texelVect;

texelVect.x = m_NormCubeMap_pixel[0];

texelVect.y = m_NormCubeMap_pixel[1];

texelVect.z = m_NormCubeMap_pixel[2];

//texelVect = TexelToVect(iFaceIdx, (float)x, (float)y, a_Size);

EvalSHBasis(texelVect, ref SHdir);

// read original colors and convert to float64

double R = cubeMap_pixel[0];

double G = cubeMap_pixel[1];

double B = cubeMap_pixel[2];

for (int i = 0; i < 25; i++)

{

SHr[i] += R * SHdir[i] * weight;

SHg[i] += G * SHdir[i] * weight;

SHb[i] += B * SHdir[i] * weight;

}

weightAccum += weight;

}

}

}

// Normalization - The sum of solid angle should be equal to the solid angle of the sphere (4 PI), so

// Normalize in order our weightAccum exactly match 4 PI.

for (int i = 0; i < 25; ++i)

{

SHr[i] *= 4.0 * CP_PI / weightAccum;

SHg[i] *= 4.0 * CP_PI / weightAccum;

SHb[i] *= 4.0 * CP_PI / weightAccum;

}

// Second step - Generate cubemap from SH coefficient

// Normalized vectors per cubeface and per-texel solid angle

// Why do we do it a 2nd time????

BuildNormalizerSolidAngleArray(a_Size, ref m_NormCubeMapArray);

for (int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++) {

// Pointer to the start of the given face in m_NormCubeMapArray

startFacePtr = a_Size*a_Size*iFaceIdx;

for (int y = 0; y < a_Size; y++) {

for (int x = 0; x < a_Size; x++) {

// read normalCube pixel

Vector4 m_NormCubeMap_pixel = m_NormCubeMapArray[startFacePtr + y*a_Size + x];

// read normalvector and pass it to EvalSHBasis to get SHdir

Vector3 texelVect;

texelVect.x = m_NormCubeMap_pixel[0];

texelVect.y = m_NormCubeMap_pixel[1];

texelVect.z = m_NormCubeMap_pixel[2];

//texelVect = TexelToVect(iFaceIdx, (float)x, (float)y, a_Size);

EvalSHBasis( texelVect, ref SHdir);

// set color values

double R = 0.0;

double G = 0.0;

double B = 0.0;

for (int i = 0; i < 25; ++i)

{

R += (SHr[i] * SHdir[i] * SHBandFactor[i]);

G += (SHg[i] * SHdir[i] * SHBandFactor[i]);

B += (SHb[i] * SHdir[i] * SHBandFactor[i]);

}

// Lux needs alpha!

irrCubeMap.SetPixel((CubemapFace)iFaceIdx, x, y, new Color((float)R,(float)G,(float)B, 1.0f ));

}

}

}

irrCubeMap.Apply();

}

//--------------------------------------------------------------------------------------

// This function return the BaseFilterAngle require by cubemapgen to its FilterExtends

// It allow to optimize the texel to access base on the specular power.

static float GetBaseFilterAngle(float cosinePower)

{

// We want to find the alpha such that:

// cos(alpha)^cosinePower = epsilon

// That's: acos(epsilon^(1/cosinePower))

const float threshold = 0.000001f; // Empirical threshold (Work perfectly, didn't check for a more big number, may get some performance and still god approximation)

float Angle = 180.0f;

if (Angle != 0.0f)

{

Angle = Mathf.Acos(Mathf.Pow(threshold, 1.0f / cosinePower));

Angle *= 180.0f / CP_PI; // Convert to degree

Angle *= 2.0f; // * 2.0f because cubemapgen divide by 2 later

}

return Angle;

}

//--------------------------------------------------------------------------------------

// Convert cubemap face texel coordinates and face idx to 3D vector

Vector3 TexelToVect(int a_FaceIdx, float a_U, float a_V, int a_Size) {

float nvcU, nvcV;

nvcU = (2.0f * ((float)a_U + 0.5f) / (float)a_Size ) - 1.0f;

nvcV = (2.0f * ((float)a_V + 0.5f) / (float)a_Size ) - 1.0f;

// U contribution

Vector3 Dir = sgFace2DMapping[a_FaceIdx, 0] * nvcU;

// V contribution

Vector3 tempVec = sgFace2DMapping[a_FaceIdx, 1] * nvcV;

Dir += tempVec;

// Add face axis

Dir += sgFace2DMapping[a_FaceIdx, 2];

// Normalize vector

Dir = Vector3.Normalize(Dir);

return(Dir);

}

//--------------------------------------------------------------------------------------

// Convert 3D vector to cubemap face texel coordinates and face idx

private Vector3 VectToTexelCoord(Vector3 a_XYZ, int a_Size) {

float nvcU, nvcV;

float maxCoord;

Vector3 onFaceXYZ;

int faceIdx;

float u, v;

// Get Absolute value

Vector3 absXYZ = new Vector3(Mathf.Abs(a_XYZ.x), Mathf.Abs(a_XYZ.y), Mathf.Abs(a_XYZ.z));

if( (absXYZ[0] >= absXYZ[1]) && (absXYZ[0] >= absXYZ[2]) )

{

maxCoord = absXYZ[0];

if(a_XYZ[0] >= 0) faceIdx = 0; // face = XPOS -> FACE_X_POS

else faceIdx = 1; // FACE_X_NEG;

}

else if ( (absXYZ[1] >= absXYZ[0]) && (absXYZ[1] >= absXYZ[2]) )

{

maxCoord = absXYZ[1];

if(a_XYZ[1] >= 0) faceIdx = 2; // face = XPOS -> FACE_Y_POS

else faceIdx = 3; // FACE_Y_NEG;

}

else

{

maxCoord = absXYZ[2];

if(a_XYZ[2] >= 0) faceIdx = 4; // face = XPOS -> FACE_Z_POS

else faceIdx = 5; // FACE_Z_NEG;

}

// Divide through by max coord so face vector lies on cube face

onFaceXYZ = a_XYZ * 1.0f/maxCoord;

nvcU = Vector3.Dot(sgFace2DMapping[faceIdx, 0] , onFaceXYZ ); // U-Direction

nvcV = Vector3.Dot(sgFace2DMapping[faceIdx, 1] , onFaceXYZ ); // V-Direction

// Modify original AMD code to return value from 0 to Size - 1

// As we will sample multiple pixels we skip (int)Mathf.Floor here

u = (a_Size - 1) * 0.5f * (nvcU + 1.0f);

v = (a_Size - 1) * 0.5f * (nvcV + 1.0f);

a_XYZ.x = faceIdx;

a_XYZ.y = u;

a_XYZ.z = v;

return a_XYZ;

}

//--------------------------------------------------------------------------------------

// Compute solid angle of given texel in cubemap face for weighting taps in the

// kernel by the area they project to on the unit sphere.

// Original code from Ignacio Castaño

float TexelCoordSolidAngle(int a_FaceIdx, float a_U, float a_V, int faceSize)

{

// Scale up to [-1, 1] range (inclusive), offset by 0.5 to point to texel center.

float U = (2.0f * ((float)a_U + 0.5f) / (float)faceSize ) - 1.0f;

float V = (2.0f * ((float)a_V + 0.5f) / (float)faceSize ) - 1.0f;

float InvResolution = 1.0f / faceSize;

// U and V are the -1..1 texture coordinate on the current face.

// Get projected area for this texel

float x0 = U - InvResolution;

float y0 = V - InvResolution;

float x1 = U + InvResolution;

float y1 = V + InvResolution;

float SolidAngle = AreaElement(x0, y0) - AreaElement(x0, y1) - AreaElement(x1, y0) + AreaElement(x1, y1);

// Returns values between 0.001 and 0.009

// So lets multiply it by 100.0f

return SolidAngle * 100.0f;

}

static float AreaElement( float x, float y )

{

return Mathf.Atan2(x * y, Mathf.Sqrt(x * x + y * y + 1));

}

//--------------------------------------------------------------------------------------

// Fixup cube edges

void FixupCubeEdges (Cubemap CubeMap)

{

int maxMipLevels = (int)(Mathf.Log((float)CubeMap.width, 2.0f)) + 1;

int base_Size = CubeMap.width;

// Do not perform any edge fixed for mip level 0

for (int mipLevel = 1; mipLevel < maxMipLevels; mipLevel++)

{

// declare jagged array for all faces and init its child arrays

Color[][] PixelsOfAllFaces = new Color[6][];

PixelsOfAllFaces[0] = CubeMap.GetPixels(CubemapFace.PositiveX, mipLevel);

PixelsOfAllFaces[1] = CubeMap.GetPixels(CubemapFace.NegativeX, mipLevel);

PixelsOfAllFaces[2] = CubeMap.GetPixels(CubemapFace.PositiveY, mipLevel);

PixelsOfAllFaces[3] = CubeMap.GetPixels(CubemapFace.NegativeY, mipLevel);

PixelsOfAllFaces[4] = CubeMap.GetPixels(CubemapFace.PositiveZ, mipLevel);

PixelsOfAllFaces[5] = CubeMap.GetPixels(CubemapFace.NegativeZ, mipLevel);

int a_Size = base_Size >> mipLevel;

// As we use a_Size as pointer in our arrays we have to lower it by 1

a_Size -= 1;

int a_FixupWidth = 3;

int fixupDist = (int)Mathf.Min( a_FixupWidth, a_Size / 2);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[0,0]], PixelsOfAllFaces[sg_CubeCornerList[0,1]], PixelsOfAllFaces[sg_CubeCornerList[0,2]], 0, 0, a_Size, a_Size, a_Size, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[1,0]], PixelsOfAllFaces[sg_CubeCornerList[1,1]], PixelsOfAllFaces[sg_CubeCornerList[1,2]], a_Size, 0, a_Size, 0, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[2,0]], PixelsOfAllFaces[sg_CubeCornerList[2,1]], PixelsOfAllFaces[sg_CubeCornerList[2,2]], 0, a_Size, a_Size, 0, a_Size, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[3,0]], PixelsOfAllFaces[sg_CubeCornerList[3,1]], PixelsOfAllFaces[sg_CubeCornerList[3,2]], a_Size, a_Size, a_Size, a_Size, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[4,0]], PixelsOfAllFaces[sg_CubeCornerList[4,1]], PixelsOfAllFaces[sg_CubeCornerList[4,2]], a_Size, 0, 0, a_Size, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[5,0]], PixelsOfAllFaces[sg_CubeCornerList[5,1]], PixelsOfAllFaces[sg_CubeCornerList[5,2]], 0, 0, 0, 0, a_Size, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[6,0]], PixelsOfAllFaces[sg_CubeCornerList[6,1]], PixelsOfAllFaces[sg_CubeCornerList[6,2]], a_Size, a_Size, 0, 0, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[7,0]], PixelsOfAllFaces[sg_CubeCornerList[7,1]], PixelsOfAllFaces[sg_CubeCornerList[7,2]], 0, a_Size, 0, a_Size, a_Size, a_Size);

// Perform 2nd iteration in reverse order

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[7,0]], PixelsOfAllFaces[sg_CubeCornerList[7,1]], PixelsOfAllFaces[sg_CubeCornerList[7,2]], 0, a_Size, 0, a_Size, a_Size, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[6,0]], PixelsOfAllFaces[sg_CubeCornerList[6,1]], PixelsOfAllFaces[sg_CubeCornerList[6,2]], a_Size, a_Size, 0, 0, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[5,0]], PixelsOfAllFaces[sg_CubeCornerList[5,1]], PixelsOfAllFaces[sg_CubeCornerList[5,2]], 0, 0, 0, 0, a_Size, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[4,0]], PixelsOfAllFaces[sg_CubeCornerList[4,1]], PixelsOfAllFaces[sg_CubeCornerList[4,2]], a_Size, 0, 0, a_Size, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[3,0]], PixelsOfAllFaces[sg_CubeCornerList[3,1]], PixelsOfAllFaces[sg_CubeCornerList[3,2]], a_Size, a_Size, a_Size, a_Size, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[2,0]], PixelsOfAllFaces[sg_CubeCornerList[2,1]], PixelsOfAllFaces[sg_CubeCornerList[2,2]], 0, a_Size, a_Size, 0, a_Size, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[1,0]], PixelsOfAllFaces[sg_CubeCornerList[1,1]], PixelsOfAllFaces[sg_CubeCornerList[1,2]], a_Size, 0, a_Size, 0, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[0,0]], PixelsOfAllFaces[sg_CubeCornerList[0,1]], PixelsOfAllFaces[sg_CubeCornerList[0,2]], 0, 0, a_Size, a_Size, a_Size, 0);

// Average Edges

// Note that this loop does not process the corner texels, since they have already been averaged

for (int i = 1; i < (a_Size - 1); i++)

{

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[0,0]], PixelsOfAllFaces[sg_CubeEdgeList[0,1]], i, 0, a_Size, a_Size - i, fixupDist, new Vector4(0, 1, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[1,0]], PixelsOfAllFaces[sg_CubeEdgeList[1,1]], i, a_Size, a_Size, i, fixupDist, new Vector4(0, -1, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[2,0]], PixelsOfAllFaces[sg_CubeEdgeList[2,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[3,0]], PixelsOfAllFaces[sg_CubeEdgeList[3,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[4,0]], PixelsOfAllFaces[sg_CubeEdgeList[4,1]], i, 0, 0, i, fixupDist, new Vector4(0, 1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[5,0]], PixelsOfAllFaces[sg_CubeEdgeList[5,1]], i, a_Size, 0, a_Size - i, fixupDist, new Vector4(0, -1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[6,0]], PixelsOfAllFaces[sg_CubeEdgeList[6,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[7,0]], PixelsOfAllFaces[sg_CubeEdgeList[7,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[8,0]], PixelsOfAllFaces[sg_CubeEdgeList[8,1]], i, a_Size, i, 0, fixupDist, new Vector4(0, -1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[9,0]], PixelsOfAllFaces[sg_CubeEdgeList[9,1]], i, 0, a_Size - i, 0, fixupDist, new Vector4(0, 1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[10,0]], PixelsOfAllFaces[sg_CubeEdgeList[10,1]], i, 0, i, a_Size, fixupDist, new Vector4(0, 1, 0, -1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[11,0]], PixelsOfAllFaces[sg_CubeEdgeList[11,1]], i, a_Size, a_Size - i, a_Size, fixupDist, new Vector4(0, -1, 0, -1) );

}

// Perform 2nd iteration in reverse order

/* for (int i = 0; i < (a_Size); i++)

{

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[11,0]], PixelsOfAllFaces[sg_CubeEdgeList[11,1]], i, a_Size, a_Size - i, a_Size, fixupDist, new Vector4(0, -1, 0, -1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[10,0]], PixelsOfAllFaces[sg_CubeEdgeList[10,1]], i, 0, i, a_Size, fixupDist, new Vector4(0, 1, 0, -1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[9,0]], PixelsOfAllFaces[sg_CubeEdgeList[9,1]], i, 0, a_Size - i, 0, fixupDist, new Vector4(0, 1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[8,0]], PixelsOfAllFaces[sg_CubeEdgeList[8,1]], i, a_Size, i, 0, fixupDist, new Vector4(0, -1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[7,0]], PixelsOfAllFaces[sg_CubeEdgeList[7,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[6,0]], PixelsOfAllFaces[sg_CubeEdgeList[6,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[5,0]], PixelsOfAllFaces[sg_CubeEdgeList[5,1]], i, a_Size, 0, a_Size - i, fixupDist, new Vector4(0, -1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[4,0]], PixelsOfAllFaces[sg_CubeEdgeList[4,1]], i, 0, 0, i, fixupDist, new Vector4(0, 1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[3,0]], PixelsOfAllFaces[sg_CubeEdgeList[3,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[2,0]], PixelsOfAllFaces[sg_CubeEdgeList[2,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[1,0]], PixelsOfAllFaces[sg_CubeEdgeList[1,1]], i, a_Size, a_Size, i, fixupDist, new Vector4(0, -1, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[0,0]], PixelsOfAllFaces[sg_CubeEdgeList[0,1]], i, 0, a_Size, a_Size - i, fixupDist, new Vector4(0, 1, -1, 0) );

} */

// Write Pixel from the jagged array back to the cubemap faces

for (int writeFace = 0; writeFace < 6; writeFace++ ) {

Color[] tempColors = PixelsOfAllFaces[writeFace];

CubeMap.SetPixels(tempColors, (CubemapFace)writeFace, mipLevel);

}

}

CubeMap.Apply(false);

}

private void AverageEdge(int a_Size, Color[] face_A, Color[] face_B, int x_A, int y_A, int x_B, int y_B, int fixupDist, Vector4 dir)

{

// As a_Size is used as factor we have to increase it by 1

a_Size += 1;

Color AverageEdgeColor = face_A[a_Size * y_A + x_A] * 0.5f + face_B[+ a_Size * y_B + x_B] * 0.5f;

face_A[a_Size * y_A + x_A] = AverageEdgeColor;

face_B[a_Size * y_B + x_B] = AverageEdgeColor;

/* for (int iFixup = 0; iFixup < fixupDist; iFixup++)

{

float fixupFrac = (float)(fixupDist - iFixup) / (float)fixupDist;

Color AverageEdgeColor_A = face_A[a_Size * y_A + a_Size * (int)dir.y * iFixup + x_A + (int)dir.x * iFixup];

Color AverageEdgeColor_B = face_B[a_Size * y_B + a_Size * (int)dir.w * iFixup + x_B + (int)dir.z * iFixup];

// CP_FIXUP_PULL_HERMITE

float fixupWeight = ((-2.0f * fixupFrac + 3.0f) * fixupFrac * fixupFrac);

// face_A[a_Size* y_A + a_Size * (int)dir.y * iFixup + x_A + (int)dir.x * iFixup ] = Color.red * (fixupWeight);

// face_B[a_Size * y_B + a_Size * (int)dir.w * iFixup + x_B + (int)dir.z * iFixup ] = Color.blue * (fixupWeight);

face_A[a_Size* y_A + a_Size * (int)dir.y * iFixup + x_A + (int)dir.x * iFixup ] = AverageEdgeColor * fixupWeight + AverageEdgeColor_A * (1.0f-fixupWeight) ;

face_B[a_Size * y_B + a_Size * (int)dir.w * iFixup + x_B + (int)dir.z * iFixup ] = AverageEdgeColor * fixupWeight + AverageEdgeColor_B * (1.0f-fixupWeight) ;

} */

}

private void AverageCorner (int a_Size, Color[] face_A , Color[] face_B, Color [] face_C, int x_A, int y_A, int x_B, int y_B, int x_C, int y_C)

{

// As a_Size is used as factor we have to increase it by 1

a_Size += 1;

Color AverageCornerColor = face_A[a_Size * y_A + x_A]/3.0f + face_B[a_Size * y_B + x_B]/3.0f + face_C[a_Size * y_C + x_C]/3.0f;

face_A[ a_Size * y_A + x_A] = AverageCornerColor;

face_B[a_Size * y_B + x_B] = AverageCornerColor;

face_C[a_Size * y_C + x_C] = AverageCornerColor;

}

//--------------------------------------------------------------------------------------

// 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");

}

//--------------------------------------------------------------------------------------

// Builds a normalizer array, with the texels solid angle stored in the fourth component

void BuildNormalizerSolidAngleArray (int a_Size, ref Vector4[] normSolid)

{

int iCubeFace, u, v;

Vector3 a_XYZ = new Vector3(0,0,0);

//

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);

//

normSolid[iCubeFace * a_Size* a_Size + v * a_Size + u] = new Vector4(a_XYZ[0], a_XYZ[1], a_XYZ[2], weight);

}

}

}

// Debug.Log ("BuildNormalizerSolidAngleArray finished");

}

///////////////////////////////////////////////

// SH order use for approximation of irradiance cubemap is 5, mean 5*5 equals 25 coefficients

// #define MAX_SH_ORDER 5

// #define NUM_SH_COEFFICIENT (MAX_SH_ORDER * MAX_SH_ORDER)

void EvalSHBasis(Vector3 dir, ref double[] res )

{

double SqrtPi = (double)Mathf.Sqrt(CP_PI);

double xx = dir[0];

double yy = dir[1];

double zz = dir[2];

// x[i] == pow(x, i), etc.

// float64 x[MAX_SH_ORDER+1], y[MAX_SH_ORDER+1], z[MAX_SH_ORDER+1];

double[] x = new double[26];

double[] y = new double[26];

double[] z = new double[26];

x[0] = 1.0;

y[0] = 1.0;

z[0] = 1.0;

for (int i = 1; i < 25+1; ++i)

{

x[i] = xx * x[i-1];

y[i] = yy * y[i-1];

z[i] = zz * z[i-1];

}

res[0] = (1/(2.0*SqrtPi));

res[1] = -(Mathf.Sqrt(3/CP_PI)*yy)/2.0;

res[2] = (Mathf.Sqrt(3/CP_PI)*zz)/2.0;

res[3] = -(Mathf.Sqrt(3/CP_PI)*xx)/2.0;

res[4] = (Mathf.Sqrt(15/CP_PI)*xx*yy)/2.0;

res[5] = -(Mathf.Sqrt(15/CP_PI)*yy*zz)/2.0;

res[6] = (Mathf.Sqrt(5/CP_PI)*(-1 + 3*z[2]))/4.0;

res[7] = -(Mathf.Sqrt(15/CP_PI)*xx*zz)/2.0;

res[8] = Mathf.Sqrt(15/CP_PI)*(x[2] - y[2])/4.0;

res[9] = (Mathf.Sqrt(35/(2.0f*CP_PI))*(-3*x[2]*yy + y[3]))/4.0;

res[10] = (Mathf.Sqrt(105/CP_PI)*xx*yy*zz)/2.0;

res[11] = -(Mathf.Sqrt(21/(2.0f*CP_PI))*yy*(-1 + 5*z[2]))/4.0;

res[12] = (Mathf.Sqrt(7/CP_PI)*zz*(-3 + 5*z[2]))/4.0;

res[13] = -(Mathf.Sqrt(21/(2.0f*CP_PI))*xx*(-1 + 5*z[2]))/4.0;

res[14] = (Mathf.Sqrt(105/CP_PI)*(x[2] - y[2])*zz)/4.0;

res[15] = -(Mathf.Sqrt(35/(2.0f*CP_PI))*(x[3] - 3*xx*y[2]))/4.0;

res[16] = (3*Mathf.Sqrt(35/CP_PI)*xx*yy*(x[2] - y[2]))/4.0;

res[17] = (-3*Mathf.Sqrt(35/(2.0f*CP_PI))*(3*x[2]*yy - y[3])*zz)/4.0;

res[18] = (3*Mathf.Sqrt(5/CP_PI)*xx*yy*(-1 + 7*z[2]))/4.0f;

res[19] = (-3*Mathf.Sqrt(5/(2.0f*CP_PI))*yy*zz*(-3 + 7*z[2]))/4.0;

res[20] = (3*(3 - 30*z[2] + 35*z[4]))/(16.0*SqrtPi);

res[21] = (-3*Mathf.Sqrt(5/(2.0f*CP_PI))*xx*zz*(-3+ 7*z[2]))/4.0;

res[22] = (3*Mathf.Sqrt(5/CP_PI)*(x[2] - y[2])*(-1 + 7*z[2]))/8.0;

res[23] = (-3*Mathf.Sqrt(35/(2.0f*CP_PI))*(x[3] - 3*xx*y[2])*zz)/4.0;

res[24] = (3*Mathf.Sqrt(35/CP_PI)*(x[4] - 6*x[2]*y[2] + y[4]))/16.0;

}

// See Peter-Pike Sloan paper for these coefficients

static double[] SHBandFactor = {

1.0,

2.0 / 3.0, 2.0 / 3.0, 2.0 / 3.0,

1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0,

0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, // The 4 band will be zeroed

- 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0

};

void FakeHDR (Cubemap CubeMap, bool hasmipLevels) {

int maxMipLevels = 1;

if (hasmipLevels) {

maxMipLevels = (int)(Mathf.Log((float)CubeMap.width, 2.0f)) + 1;

}

int base_Size = CubeMap.width;

Vector4 rgbmColor = new Vector4();

for (int mipLevel = 0; mipLevel < maxMipLevels; mipLevel++)

{

int a_Size = base_Size >> mipLevel;

// As we use a_Size as pointer in our arrays we have to lower it by 1

//a_Size -= 1;

for (int a_FaceIdx = 0; a_FaceIdx < 6; a_FaceIdx++)

{

// Get all pixels of the given face

Color[] FaceColors = CubeMap.GetPixels((CubemapFace)a_FaceIdx, mipLevel);

// Iterate over dst cube map face texel

for (int a_V = 0; a_V < a_Size; a_V++)

{

for (int a_U = 0; a_U < a_Size; a_U++)

{

rgbmColor.x = FaceColors[a_V * a_Size + a_U].r;

rgbmColor.y = FaceColors[a_V * a_Size + a_U].g;

rgbmColor.z = FaceColors[a_V * a_Size + a_U].b;

rgbmColor *= 1.0f/6.0f;

rgbmColor.w = Mathf.Clamp01(Mathf.Max(Mathf.Max(rgbmColor.x, rgbmColor.y), rgbmColor.z));

rgbmColor.w = Mathf.Ceil(rgbmColor.w*255.0f) / 255.0f;

rgbmColor.x = rgbmColor.x / rgbmColor.w;

rgbmColor.y = rgbmColor.y / rgbmColor.w;

rgbmColor.z = rgbmColor.z / rgbmColor.w;

FaceColors[a_V * a_Size + a_U] = rgbmColor;

}

}

CubeMap.SetPixels(FaceColors,(CubemapFace)a_FaceIdx, mipLevel);

}

}

CubeMap.Apply(false);

}

}

#endif

This is the script for OVRMainMenu.cs

Code (CSharp):

/************************************************************************************

Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.

Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License");

you may not use the Oculus VR Rift SDK except in compliance with the License,

which is provided at the time of installation or download, or which

otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at

http://www.oculusvr.com/licenses/LICENSE-3.2

Unless required by applicable law or agreed to in writing, the Oculus VR SDK

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

************************************************************************************/

// #define SHOW_DK2_VARIABLES

// Use the Unity new GUI with Unity 4.6 or above.

#if UNITY_4_6 || UNITY_5_0

#define USE_NEW_GUI

#endif

using System;

using System.Collections;

using UnityEngine;

#if USE_NEW_GUI

using UnityEngine.UI;

# endif

//-------------------------------------------------------------------------------------

// ***** OVRMainMenu

//

/// <summary>

/// OVRMainMenu is used to control the loading of different scenes. It also renders out

/// a menu that allows a user to modify various Rift settings, and allow for storing

/// these settings for recall later.

///

/// A user of this component can add as many scenes that they would like to be able to

/// have access to.

///

/// OVRMainMenu is currently attached to the OVRPlayerController prefab for convenience,

/// but can safely removed from it and added to another GameObject that is used for general

/// Unity logic.

///

/// </summary>

public class OVRMainMenu : MonoBehaviour

{

/// <summary>

/// The amount of time in seconds that it takes for the menu to fade in.

/// </summary>

public float FadeInTime = 2.0f;

/// <summary>

/// An optional texture that appears before the menu fades in.

/// </summary>

public UnityEngine.Texture FadeInTexture = null;

/// <summary>

/// An optional font that replaces Unity's default Arial.

/// </summary>

public Font FontReplace = null;

/// <summary>

/// The key that toggles the menu.

/// </summary>

public KeyCode MenuKey = KeyCode.Space;

/// <summary>

/// The key that quits the application.

/// </summary>

public KeyCode QuitKey = KeyCode.Escape;

/// <summary>

/// Scene names to show on-screen for each of the scenes in Scenes.

/// </summary>

public string [] SceneNames;

/// <summary>

/// The set of scenes that the user can jump to.

/// </summary>

public string [] Scenes;

private bool ScenesVisible = false;

// Spacing for scenes menu

private int StartX = 490;

private int StartY = 250;

private int WidthX = 300;

private int WidthY = 23;

// Spacing for variables that users can change

private int VRVarsSX = 553;

private int VRVarsSY = 250;

private int VRVarsWidthX = 175;

private int VRVarsWidthY = 23;

private int StepY = 25;

// Handle to OVRCameraRig

private OVRCameraRig CameraController = null;

// Handle to OVRPlayerController

private OVRPlayerController PlayerController = null;

// Controller buttons

private bool PrevStartDown;

private bool PrevHatDown;

private bool PrevHatUp;

private bool ShowVRVars;

private bool OldSpaceHit;

// FPS

private float UpdateInterval = 0.5f;

private float Accum = 0;

private int Frames = 0;

private float TimeLeft = 0;

private string strFPS = "FPS: 0";

private string strIPD = "IPD: 0.000";

/// <summary>

/// Prediction (in ms)

/// </summary>

public float PredictionIncrement = 0.001f; // 1 ms

private string strPrediction = "Pred: OFF";

private string strFOV = "FOV: 0.0f";

private string strHeight = "Height: 0.0f";

/// <summary>

/// Controls how quickly the player's speed and rotation change based on input.

/// </summary>

public float SpeedRotationIncrement = 0.05f;

private string strSpeedRotationMultipler = "Spd. X: 0.0f Rot. X: 0.0f";

private bool LoadingLevel = false;

private float AlphaFadeValue = 1.0f;

private int CurrentLevel = 0;

// Rift detection

private bool HMDPresent = false;

private float RiftPresentTimeout = 0.0f;

private string strRiftPresent = "";

// Replace the GUI with our own texture and 3D plane that

// is attached to the rendder camera for true 3D placement

private OVRGUI GuiHelper = new OVRGUI();

private GameObject GUIRenderObject = null;

private RenderTexture GUIRenderTexture = null;

// We want to use new Unity GUI built in 4.6 for OVRMainMenu GUI

// Enable the UsingNewGUI option in the editor,

// if you want to use new GUI and Unity version is higher than 4.6

#if USE_NEW_GUI

private GameObject NewGUIObject = null;

private GameObject RiftPresentGUIObject = null;

#endif

/// <summary>

/// We can set the layer to be anything we want to, this allows

/// a specific camera to render it.

/// </summary>

public string LayerName = "Default";

/// <summary>

/// Crosshair rendered onto 3D plane.

/// </summary>

public UnityEngine.Texture CrosshairImage = null;

private OVRCrosshair Crosshair = new OVRCrosshair();

// Resolution Eye Texture

private string strResolutionEyeTexture = "Resolution: 0 x 0";

// Latency values

private string strLatencies = "Ren: 0.0f TWrp: 0.0f PostPresent: 0.0f";

// Vision mode on/off

private bool VisionMode = true;

#if SHOW_DK2_VARIABLES

private string strVisionMode = "Vision Enabled: ON";

#endif

// We want to hold onto GridCube, for potential sharing

// of the menu RenderTarget

OVRGridCube GridCube = null;

// We want to hold onto the VisionGuide so we can share

// the menu RenderTarget

OVRVisionGuide VisionGuide = null;

#region MonoBehaviour Message Handlers

/// <summary>

/// Awake this instance.

/// </summary>

void Awake()

{

// Find camera controller

OVRCameraRig[] CameraControllers;

CameraControllers = gameObject.GetComponentsInChildren<OVRCameraRig>();

if(CameraControllers.Length == 0)

Debug.LogWarning("OVRMainMenu: No OVRCameraRig attached.");

else if (CameraControllers.Length > 1)

Debug.LogWarning("OVRMainMenu: More then 1 OVRCameraRig attached.");

else{

CameraController = CameraControllers[0];

#if USE_NEW_GUI

OVRUGUI.CameraController = CameraController;

#endif

}

// Find player controller

OVRPlayerController[] PlayerControllers;

PlayerControllers = gameObject.GetComponentsInChildren<OVRPlayerController>();

if(PlayerControllers.Length == 0)

Debug.LogWarning("OVRMainMenu: No OVRPlayerController attached.");

else if (PlayerControllers.Length > 1)

Debug.LogWarning("OVRMainMenu: More then 1 OVRPlayerController attached.");

else{

PlayerController = PlayerControllers[0];

#if USE_NEW_GUI

OVRUGUI.PlayerController = PlayerController;

#endif

}

#if USE_NEW_GUI

// Create canvas for using new GUI

NewGUIObject = new GameObject();

NewGUIObject.name = "OVRGUIMain";

NewGUIObject.transform.parent = GameObject.Find("LeftEyeAnchor").transform;

RectTransform r = NewGUIObject.AddComponent<RectTransform>();

r.sizeDelta = new Vector2(100f, 100f);

r.localScale = new Vector3(0.001f, 0.001f, 0.001f);

r.localPosition = new Vector3(0.01f, 0.17f, 0.53f);

r.localEulerAngles = Vector3.zero;

Canvas c = NewGUIObject.AddComponent<Canvas>();

#if (UNITY_5_0)

// TODO: Unity 5.0b11 has an older version of the new GUI being developed in Unity 4.6.

// Remove this once Unity 5 has a more recent merge of Unity 4.6.

c.renderMode = RenderMode.World;

#else

c.renderMode = RenderMode.WorldSpace;

#endif

c.pixelPerfect = false;

#endif

}

/// <summary>

/// Start this instance.

/// </summary>

void Start()

{

AlphaFadeValue = 1.0f;

CurrentLevel = 0;

PrevStartDown = false;

PrevHatDown = false;

PrevHatUp = false;

ShowVRVars = false;

OldSpaceHit = false;

strFPS = "FPS: 0";

LoadingLevel = false;

ScenesVisible = false;

// Set the GUI target

GUIRenderObject = GameObject.Instantiate(Resources.Load("OVRGUIObjectMain")) as GameObject;

if(GUIRenderObject != null)

{

// Chnge the layer

GUIRenderObject.layer = LayerMask.NameToLayer(LayerName);

if(GUIRenderTexture == null)

{

int w = Screen.width;

int h = Screen.height;

// We don't need a depth buffer on this texture

GUIRenderTexture = new RenderTexture(w, h, 0);

GuiHelper.SetPixelResolution(w, h);

// NOTE: All GUI elements are being written with pixel values based

// from DK1 (1280x800). These should change to normalized locations so

// that we can scale more cleanly with varying resolutions

GuiHelper.SetDisplayResolution(1280.0f, 800.0f);

}

}

// Attach GUI texture to GUI object and GUI object to Camera

if(GUIRenderTexture != null && GUIRenderObject != null)

{

GUIRenderObject.GetComponent<Renderer>().material.mainTexture = GUIRenderTexture;

if(CameraController != null)

{

// Grab transform of GUI object

Vector3 ls = GUIRenderObject.transform.localScale;

Vector3 lp = GUIRenderObject.transform.localPosition;

Quaternion lr = GUIRenderObject.transform.localRotation;

// Attach the GUI object to the camera

GUIRenderObject.transform.parent = CameraController.centerEyeAnchor;

// Reset the transform values (we will be maintaining state of the GUI object

// in local state)

GUIRenderObject.transform.localScale = ls;

GUIRenderObject.transform.localPosition = lp;

GUIRenderObject.transform.localRotation = lr;

// Deactivate object until we have completed the fade-in

// Also, we may want to deactive the render object if there is nothing being rendered

// into the UI

GUIRenderObject.SetActive(false);

}

}

// Make sure to hide cursor

if(Application.isEditor == false)

{

#if UNITY_5_0

Cursor.visible = false;

Cursor.lockState = CursorLockMode.Locked;

#else

Screen.showCursor = false;

Screen.lockCursor = true;

#endif

}

// CameraController updates

if(CameraController != null)

{

// Add a GridCube component to this object

GridCube = gameObject.AddComponent<OVRGridCube>();

GridCube.SetOVRCameraController(ref CameraController);

// Add a VisionGuide component to this object

VisionGuide = gameObject.AddComponent<OVRVisionGuide>();

VisionGuide.SetOVRCameraController(ref CameraController);

VisionGuide.SetFadeTexture(ref FadeInTexture);

VisionGuide.SetVisionGuideLayer(ref LayerName);

}

// Crosshair functionality

Crosshair.Init();

Crosshair.SetCrosshairTexture(ref CrosshairImage);

Crosshair.SetOVRCameraController (ref CameraController);

Crosshair.SetOVRPlayerController(ref PlayerController);

// Check for HMD and sensor

CheckIfRiftPresent();

#if USE_NEW_GUI

if (!string.IsNullOrEmpty(strRiftPresent)){

ShowRiftPresentGUI();

}

#endif

}

/// <summary>

/// Update this instance.

/// </summary>

void Update()

{

if(LoadingLevel == true)

return;

// Main update

UpdateFPS();

// CameraController updates

if(CameraController != null)

{

UpdateIPD();

UpdateRecenterPose();

UpdateVisionMode();

UpdateFOV();

UpdateEyeHeightOffset();

UpdateResolutionEyeTexture();

UpdateLatencyValues();

}

// PlayerController updates

if(PlayerController != null)

{

UpdateSpeedAndRotationScaleMultiplier();

UpdatePlayerControllerMovement();

}

// MainMenu updates

UpdateSelectCurrentLevel();

// Device updates

UpdateDeviceDetection();

// Crosshair functionality

Crosshair.UpdateCrosshair();

#if USE_NEW_GUI

if (ShowVRVars && RiftPresentTimeout <= 0.0f)

{

NewGUIObject.SetActive(true);

UpdateNewGUIVars();

OVRUGUI.UpdateGUI();

}

else

{

NewGUIObject.SetActive(false);

}

#endif

// Toggle Fullscreen

if(Input.GetKeyDown(KeyCode.F11))

Screen.fullScreen = !Screen.fullScreen;

if (Input.GetKeyDown(KeyCode.M))

OVRManager.display.mirrorMode = !OVRManager.display.mirrorMode;

// Escape Application

if (Input.GetKeyDown(QuitKey))

Application.Quit();

}

/// <summary>

/// Updates Variables for new GUI.

/// </summary>

#if USE_NEW_GUI

void UpdateNewGUIVars()

{

#if SHOW_DK2_VARIABLES

// Print out Vision Mode

OVRUGUI.strVisionMode = strVisionMode;

#endif

// Print out FPS

OVRUGUI.strFPS = strFPS;

// Don't draw these vars if CameraController is not present

if (CameraController != null)

{

OVRUGUI.strPrediction = strPrediction;

OVRUGUI.strIPD = strIPD;

OVRUGUI.strFOV = strFOV;

OVRUGUI.strResolutionEyeTexture = strResolutionEyeTexture;

OVRUGUI.strLatencies = strLatencies;

}

// Don't draw these vars if PlayerController is not present

if (PlayerController != null)

{

OVRUGUI.strHeight = strHeight;

OVRUGUI.strSpeedRotationMultipler = strSpeedRotationMultipler;

}

OVRUGUI.strRiftPresent = strRiftPresent;

}

#endif

void OnGUI()

{

// Important to keep from skipping render events

if (Event.current.type != EventType.Repaint)

return;

#if !USE_NEW_GUI

// Fade in screen

if(AlphaFadeValue > 0.0f)

{

AlphaFadeValue -= Mathf.Clamp01(Time.deltaTime / FadeInTime);

if(AlphaFadeValue < 0.0f)

{

AlphaFadeValue = 0.0f;

}

else

{

GUI.color = new Color(0, 0, 0, AlphaFadeValue);

GUI.DrawTexture( new Rect(0, 0, Screen.width, Screen.height ), FadeInTexture );

return;

}

}

#endif

// We can turn on the render object so we can render the on-screen menu

if(GUIRenderObject != null)

{

if (ScenesVisible ||

ShowVRVars ||

Crosshair.IsCrosshairVisible() ||

RiftPresentTimeout > 0.0f ||

VisionGuide.GetFadeAlphaValue() > 0.0f)

{

GUIRenderObject.SetActive(true);

}

else

{

GUIRenderObject.SetActive(false);

}

}

//***

// Set the GUI matrix to deal with portrait mode

Vector3 scale = Vector3.one;

Matrix4x4 svMat = GUI.matrix; // save current matrix

// substitute matrix - only scale is altered from standard

GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, scale);

// Cache current active render texture

RenderTexture previousActive = RenderTexture.active;

// if set, we will render to this texture

if(GUIRenderTexture != null && GUIRenderObject.activeSelf)

{

RenderTexture.active = GUIRenderTexture;

GL.Clear (false, true, new Color (0.0f, 0.0f, 0.0f, 0.0f));

}

// Update OVRGUI functions (will be deprecated eventually when 2D renderingc

// is removed from GUI)

GuiHelper.SetFontReplace(FontReplace);

// If true, we are displaying information about the Rift not being detected

// So do not show anything else

if(GUIShowRiftDetected() != true)

{

GUIShowLevels();

GUIShowVRVariables();

}

// The cross-hair may need to go away at some point, unless someone finds it

// useful

Crosshair.OnGUICrosshair();

// Since we want to draw into the main GUI that is shared within the MainMenu,

// we call the OVRVisionGuide GUI function here

VisionGuide.OnGUIVisionGuide();

// Restore active render texture

if (GUIRenderObject.activeSelf)

{

RenderTexture.active = previousActive;

}

// ***

// Restore previous GUI matrix

GUI.matrix = svMat;

}

#endregion

#region Internal State Management Functions

/// <summary>

/// Updates the FPS.

/// </summary>

void UpdateFPS()

{

TimeLeft -= Time.deltaTime;

Accum += Time.timeScale/Time.deltaTime;

++Frames;

// Interval ended - update GUI text and start new interval

if( TimeLeft <= 0.0 )

{

// display two fractional digits (f2 format)

float fps = Accum / Frames;

if(ShowVRVars == true)// limit gc

strFPS = System.String.Format("FPS: {0:F2}",fps);

TimeLeft += UpdateInterval;

Accum = 0.0f;

Frames = 0;

}

}

/// <summary>

/// Updates the IPD.

/// </summary>

void UpdateIPD()

{

if(ShowVRVars == true) // limit gc

{

strIPD = System.String.Format("IPD (mm): {0:F4}", OVRManager.profile.ipd * 1000.0f);

}

}

void UpdateRecenterPose()

{

if(Input.GetKeyDown(KeyCode.R))

{

OVRManager.display.RecenterPose();

}

}

/// <summary>

/// Updates the vision mode.

/// </summary>

void UpdateVisionMode()

{

if (Input.GetKeyDown(KeyCode.F2))

{

VisionMode = !VisionMode;

OVRManager.tracker.isEnabled = VisionMode;

#if SHOW_DK2_VARIABLES

strVisionMode = VisionMode ? "Vision Enabled: ON" : "Vision Enabled: OFF";

#endif

}

}

/// <summary>

/// Updates the FOV.

/// </summary>

void UpdateFOV()

{

if(ShowVRVars == true)// limit gc

{

OVRDisplay.EyeRenderDesc eyeDesc = OVRManager.display.GetEyeRenderDesc(OVREye.Left);

strFOV = System.String.Format ("FOV (deg): {0:F3}", eyeDesc.fov.y);

}

}

/// <summary>

/// Updates resolution of eye texture

/// </summary>

void UpdateResolutionEyeTexture()

{

if (ShowVRVars == true) // limit gc

{

OVRDisplay.EyeRenderDesc leftEyeDesc = OVRManager.display.GetEyeRenderDesc(OVREye.Left);

OVRDisplay.EyeRenderDesc rightEyeDesc = OVRManager.display.GetEyeRenderDesc(OVREye.Right);

float scale = OVRManager.instance.nativeTextureScale * OVRManager.instance.virtualTextureScale;

float w = (int)(scale * (float)(leftEyeDesc.resolution.x + rightEyeDesc.resolution.x));

float h = (int)(scale * (float)Mathf.Max(leftEyeDesc.resolution.y, rightEyeDesc.resolution.y));

strResolutionEyeTexture = System.String.Format("Resolution : {0} x {1}", w, h);

}

}

/// <summary>

/// Updates latency values

/// </summary>

void UpdateLatencyValues()

{

#if !UNITY_ANDROID || UNITY_EDITOR

if (ShowVRVars == true) // limit gc

{

OVRDisplay.LatencyData latency = OVRManager.display.latency;

if (latency.render < 0.000001f && latency.timeWarp < 0.000001f && latency.postPresent < 0.000001f)

strLatencies = System.String.Format("Ren : N/A TWrp: N/A PostPresent: N/A");

else

strLatencies = System.String.Format("Ren : {0:F3} TWrp: {1:F3} PostPresent: {2:F3}",

latency.render,

latency.timeWarp,

latency.postPresent);

}

#endif

}

/// <summary>

/// Updates the eye height offset.

/// </summary>

void UpdateEyeHeightOffset()

{

if(ShowVRVars == true)// limit gc

{

float eyeHeight = OVRManager.profile.eyeHeight;

strHeight = System.String.Format ("Eye Height (m): {0:F3}", eyeHeight);

}

}

/// <summary>

/// Updates the speed and rotation scale multiplier.

/// </summary>

void UpdateSpeedAndRotationScaleMultiplier()

{

float moveScaleMultiplier = 0.0f;

PlayerController.GetMoveScaleMultiplier(ref moveScaleMultiplier);

if(Input.GetKeyDown(KeyCode.Alpha7))

moveScaleMultiplier -= SpeedRotationIncrement;

else if (Input.GetKeyDown(KeyCode.Alpha8))

moveScaleMultiplier += SpeedRotationIncrement;

PlayerController.SetMoveScaleMultiplier(moveScaleMultiplier);

float rotationScaleMultiplier = 0.0f;

PlayerController.GetRotationScaleMultiplier(ref rotationScaleMultiplier);

if(Input.GetKeyDown(KeyCode.Alpha9))

rotationScaleMultiplier -= SpeedRotationIncrement;

else if (Input.GetKeyDown(KeyCode.Alpha0))

rotationScaleMultiplier += SpeedRotationIncrement;

PlayerController.SetRotationScaleMultiplier(rotationScaleMultiplier);

if(ShowVRVars == true)// limit gc

strSpeedRotationMultipler = System.String.Format ("Spd.X: {0:F2} Rot.X: {1:F2}",

moveScaleMultiplier,

rotationScaleMultiplier);

}

/// <summary>

/// Updates the player controller movement.

/// </summary>

void UpdatePlayerControllerMovement()

{

if(PlayerController != null)

PlayerController.SetHaltUpdateMovement(ScenesVisible);

}

/// <summary>

/// Updates the select current level.

/// </summary>

void UpdateSelectCurrentLevel()

{

ShowLevels();

if (!ScenesVisible)

return;

CurrentLevel = GetCurrentLevel();

if (Scenes.Length != 0

&& (OVRGamepadController.GPC_GetButton(OVRGamepadController.Button.A)

|| Input.GetKeyDown(KeyCode.Return)))

{

LoadingLevel = true;

Application.LoadLevelAsync(Scenes[CurrentLevel]);

}

}

/// <summary>

/// Shows the levels.

/// </summary>

/// <returns><c>true</c>, if levels was shown, <c>false</c> otherwise.</returns>

bool ShowLevels()

{

if (Scenes.Length == 0)

{

ScenesVisible = false;

return ScenesVisible;

}

bool curStartDown = OVRGamepadController.GPC_GetButton(OVRGamepadController.Button.Start);

bool startPressed = (curStartDown && !PrevStartDown) || Input.GetKeyDown(KeyCode.RightShift);

PrevStartDown = curStartDown;

if (startPressed)

{

ScenesVisible = !ScenesVisible;

}

return ScenesVisible;

}

/// <summary>

/// Gets the current level.

/// </summary>

/// <returns>The current level.</returns>

int GetCurrentLevel()

{

bool curHatDown = false;

if(OVRGamepadController.GPC_GetButton(OVRGamepadController.Button.Down) == true)

curHatDown = true;

bool curHatUp = false;

if(OVRGamepadController.GPC_GetButton(OVRGamepadController.Button.Down) == true)

curHatUp = true;

if((PrevHatDown == false) && (curHatDown == true) ||

Input.GetKeyDown(KeyCode.DownArrow))

{

CurrentLevel = (CurrentLevel + 1) % SceneNames.Length;

}

else if((PrevHatUp == false) && (curHatUp == true) ||

Input.GetKeyDown(KeyCode.UpArrow))

{

CurrentLevel--;

if(CurrentLevel < 0)

CurrentLevel = SceneNames.Length - 1;

}

PrevHatDown = curHatDown;

PrevHatUp = curHatUp;

return CurrentLevel;

}

#endregion

#region Internal GUI Functions

/// <summary>

/// Show the GUI levels.

/// </summary>

void GUIShowLevels()

{

if(ScenesVisible == true)

{

// Darken the background by rendering fade texture

GUI.color = new Color(0, 0, 0, 0.5f);

GUI.DrawTexture( new Rect(0, 0, Screen.width, Screen.height ), FadeInTexture );

GUI.color = Color.white;

if(LoadingLevel == true)

{

string loading = "LOADING...";

GuiHelper.StereoBox (StartX, StartY, WidthX, WidthY, ref loading, Color.yellow);

return;

}

for (int i = 0; i < SceneNames.Length; i++)

{

Color c;

if(i == CurrentLevel)

c = Color.yellow;

else

c = Color.black;

int y = StartY + (i * StepY);

GuiHelper.StereoBox (StartX, y, WidthX, WidthY, ref SceneNames[i], c);

}

}

}

/// <summary>

/// Show the VR variables.

/// </summary>

void GUIShowVRVariables()

{

bool SpaceHit = Input.GetKey(MenuKey);

if ((OldSpaceHit == false) && (SpaceHit == true))

{

if (ShowVRVars == true)

{

ShowVRVars = false;

}

else

{

ShowVRVars = true;

#if USE_NEW_GUI

OVRUGUI.InitUIComponent = ShowVRVars;

#endif

}

}

OldSpaceHit = SpaceHit;

// Do not render if we are not showing

if (ShowVRVars == false)

return;

#if !USE_NEW_GUI

int y = VRVarsSY;

#if SHOW_DK2_VARIABLES

// Print out Vision Mode

GuiHelper.StereoBox (VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strVisionMode, Color.green);

#endif

// Draw FPS

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strFPS, Color.green);

// Don't draw these vars if CameraController is not present

if (CameraController != null)

{

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strPrediction, Color.white);

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strIPD, Color.yellow);

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strFOV, Color.white);

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strResolutionEyeTexture, Color.white);

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strLatencies, Color.white);

}

// Don't draw these vars if PlayerController is not present

if (PlayerController != null)

{

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strHeight, Color.yellow);

GuiHelper.StereoBox(VRVarsSX, y += StepY, VRVarsWidthX, VRVarsWidthY,

ref strSpeedRotationMultipler, Color.white);

}

#endif

}

// RIFT DETECTION

/// <summary>

/// Checks to see if HMD and / or sensor is available, and displays a

/// message if it is not.

/// </summary>

void CheckIfRiftPresent()

{

HMDPresent = OVRManager.display.isPresent;

if (!HMDPresent)

{

RiftPresentTimeout = 15.0f;

if (!HMDPresent)

strRiftPresent = "NO HMD DETECTED";

#if USE_NEW_GUI

OVRUGUI.strRiftPresent = strRiftPresent;

#endif

}

}

/// <summary>

/// Show if Rift is detected.

/// </summary>

/// <returns><c>true</c>, if show rift detected was GUIed, <c>false</c> otherwise.</returns>

bool GUIShowRiftDetected()

{

#if !USE_NEW_GUI

if(RiftPresentTimeout > 0.0f)

{

GuiHelper.StereoBox (StartX, StartY, WidthX, WidthY,

ref strRiftPresent, Color.white);

return true;

}

#else

if(RiftPresentTimeout < 0.0f)

DestroyImmediate(RiftPresentGUIObject);

#endif

return false;

}

/// <summary>

/// Updates the device detection.

/// </summary>

void UpdateDeviceDetection()

{

if(RiftPresentTimeout > 0.0f)

RiftPresentTimeout -= Time.deltaTime;

}

/// <summary>

/// Show rift present GUI with new GUI

/// </summary>

void ShowRiftPresentGUI()

{

#if USE_NEW_GUI

RiftPresentGUIObject = new GameObject();

RiftPresentGUIObject.name = "RiftPresentGUIMain";

RiftPresentGUIObject.transform.parent = GameObject.Find("LeftEyeAnchor").transform;

RectTransform r = RiftPresentGUIObject.AddComponent<RectTransform>();

r.sizeDelta = new Vector2(100f, 100f);

r.localPosition = new Vector3(0.01f, 0.17f, 0.53f);

r.localEulerAngles = Vector3.zero;

r.localScale = new Vector3(0.001f, 0.001f, 0.001f);

Canvas c = RiftPresentGUIObject.AddComponent<Canvas>();

#if UNITY_5_0

// TODO: Unity 5.0b11 has an older version of the new GUI being developed in Unity 4.6.

// Remove this once Unity 5 has a more recent merge of Unity 4.6.

c.renderMode = RenderMode.World;

#else

c.renderMode = RenderMode.WorldSpace;

#endif

c.pixelPerfect = false;

OVRUGUI.RiftPresentGUI(RiftPresentGUIObject);

#endif

}

#endregion

}

This is the script for OVRUGUI.cs

/************************************************************************************

Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.

Licensed under the Oculus VR Rift SDK License Version

3.2 (the "License");
you may not use the Oculus VR Rift SDK except in compliance with the License,
which is provided at the time of installation or download, or which
otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at

http://www.oculusvr.com/licenses/LICENSE-3.2

Unless required by applicable law or agreed to in writing, the Oculus VR SDK
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

************************************************************************************/

// Use the Unity new GUI with Unity 4.6 or above.
#if UNITY_4_6 || UNITY_5_0
#define USE_NEW_GUI
#endif

using UnityEngine;
#if USE_NEW_GUI
using UnityEngine.UI;
#endif
using System.Collections;

//-------------------------------------------------------------------------------------
/// <summary>
/// Class for Unity new GUI built in 4.6
/// </summary>
public class OVRUGUI
{
#if USE_NEW_GUI

#region UIGameObject
private static GameObject NewGUIManager;
private static GameObject RiftPresent;
private static GameObject LowPersistence;
private static GameObject VisionMode;
private static GameObject FPS;
private static GameObject Prediction;
private static GameObject IPD;
private static GameObject FOV;
private static GameObject Height;
private static GameObject SpeedRotationMutipler;
private static GameObject DeviceDetection;
private static GameObject ResolutionEyeTexture;
private static GameObject Latencies;
#endregion

#region VRVariables
[HideInInspector]
public static string strRiftPresent = null;
[HideInInspector]
public static string strLPM = null; //"LowPersistenceMode: ON";
[HideInInspector]
public static string strVisionMode = null;//"Vision Enabled: ON";
[HideInInspector]
public static string strFPS = null;//"FPS: 0";
[HideInInspector]
public static string strIPD = null;//"IPD: 0.000";
[HideInInspector]
public static string strPrediction = null;//"Pred: OFF";
[HideInInspector]
public static string strFOV = null;//"FOV: 0.0f";
[HideInInspector]
public static string strHeight = null;//"Height: 0.0f";
[HideInInspector]
public static string strSpeedRotationMultipler = null;//"Spd. X: 0.0f Rot. X: 0.0f";
[HideInInspector]
public static OVRPlayerController PlayerController = null;
[HideInInspector]
public static OVRCameraRig CameraController = null;
//[HideInInspector]
//public static string strDeviceDetection = null;// Device attach / detach
[HideInInspector]
public static string strResolutionEyeTexture = null;// "Resolution : {0} x {1}"
[HideInInspector]
public static string strLatencies = null;// Device attach / detach
#endregion

[HideInInspector]
public static bool InitUIComponent = false;
private static float offsetY = 55.0f;
private static bool isInited = false;
private static int numOfGUI = 0;
private static GameObject text;

/// <summary>
/// It's for rift present GUI
/// </summary>
public static void RiftPresentGUI(GameObject GUIMainOBj)
{
RiftPresent = ComponentComposition(RiftPresent);
RiftPresent.transform.parent = GUIMainOBj.transform;
RiftPresent.name = "RiftPresent";
RectTransform r = RiftPresent.GetComponent<RectTransform>();
r.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
r.localScale = new Vector3(1.0f, 1.0f, 1.0f);
r.localEulerAngles = Vector3.zero;

Text t = RiftPresent.GetComponentInChildren<Text>();
t.text = strRiftPresent;
t.fontSize = 20;
}

/// <summary>
/// It's for rift present GUI
/// </summary>
public static void UpdateGUI()
{
if (InitUIComponent && !isInited)
{
InitUIComponents();
}

UpdateVariable();
}

/// <summary>
/// Update VR Variables
/// </summary>
static void UpdateVariable()
{
NewGUIManager.transform.localPosition = new Vector3(0.0f, 100.0f, 0.0f);

if (!string.IsNullOrEmpty(strLPM))
LowPersistence.GetComponentInChildren<Text>().text = strLPM;
if (!string.IsNullOrEmpty(strVisionMode))
VisionMode.GetComponentInChildren<Text>().text = strVisionMode;
if (!string.IsNullOrEmpty(strFPS))
FPS.GetComponentInChildren<Text>().text = strFPS;
if (!string.IsNullOrEmpty(strPrediction))
Prediction.GetComponentInChildren<Text>().text = strPrediction;
if (!string.IsNullOrEmpty(strIPD))
IPD.GetComponentInChildren<Text>().text = strIPD;
if (!string.IsNullOrEmpty(strFOV))
FOV.GetComponentInChildren<Text>().text = strFOV;
if (!string.IsNullOrEmpty(strResolutionEyeTexture))
ResolutionEyeTexture.GetComponentInChildren<Text>().text = strResolutionEyeTexture;
if (!string.IsNullOrEmpty(strLatencies))
Latencies.GetComponentInChildren<Text>().text = strLatencies;

if (PlayerController != null)
{
if (!string.IsNullOrEmpty(strHeight))
Height.GetComponentInChildren<Text>().text = strHeight;
if (!string.IsNullOrEmpty(strSpeedRotationMultipler))
SpeedRotationMutipler.GetComponentInChildren<Text>().text = strSpeedRotationMultipler;
}
}

/// <summary>
/// Initialize UI GameObjects
/// </summary>
static void InitUIComponents()
{
float posY = 0.0f;
int fontSize = 20;

NewGUIManager = new GameObject();
NewGUIManager.name = "GUIManager";
NewGUIManager.transform.parent = GameObject.Find("OVRGUIMain").transform;
NewGUIManager.transform.localPosition = Vector3.zero;
NewGUIManager.transform.localEulerAngles = Vector3.zero;
NewGUIManager.transform.localScale = new Vector3(1.0f, 1.0f, 1.0f);

// Print out for Low Persistence Mode
if (!string.IsNullOrEmpty(strLPM))
{
LowPersistence = UIObjectManager(LowPersistence, "LowPersistence", posY -= offsetY, strLPM, fontSize);
}

// Print out for VisionMode
if (!string.IsNullOrEmpty(strVisionMode))
{
VisionMode = UIObjectManager(VisionMode, "VisionMode", posY -= offsetY, strVisionMode, fontSize);
}

// Print out for FPS
if (!string.IsNullOrEmpty(strFPS))
{
FPS = UIObjectManager(FPS, "FPS", posY -= offsetY, strFPS, fontSize);
}

// Print out for Prediction
if (!string.IsNullOrEmpty(strPrediction))
{
Prediction = UIObjectManager(Prediction, "Prediction", posY -= offsetY, strPrediction, fontSize);
}

// Print out for IPD
if (!string.IsNullOrEmpty(strIPD))
{
IPD = UIObjectManager(IPD, "IPD", posY -= offsetY, strIPD, fontSize);
}

// Print out for FOV
if (!string.IsNullOrEmpty(strFOV))
{
FOV = UIObjectManager(FOV, "FOV", posY -= offsetY, strFOV, fontSize);
}

if (PlayerController != null)
{
// Print out for Height
if (!string.IsNullOrEmpty(strHeight))
{
Height = UIObjectManager(Height, "Height", posY -= offsetY, strHeight, fontSize);
}

// Print out for Speed Rotation Multiplier
if (!string.IsNullOrEmpty(strSpeedRotationMultipler))
{
SpeedRotationMutipler = UIObjectManager(SpeedRotationMutipler, "SpeedRotationMutipler", posY -= offsetY, strSpeedRotationMultipler, fontSize);
}
}

// Print out for Resoulution of Eye Texture
if (!string.IsNullOrEmpty(strResolutionEyeTexture))
{
ResolutionEyeTexture = UIObjectManager(ResolutionEyeTexture, "Resolution", posY -= offsetY, strResolutionEyeTexture, fontSize);
}

// Print out for Latency
if (!string.IsNullOrEmpty(strLatencies))
{
Latencies = UIObjectManager(Latencies, "Latency", posY -= offsetY, strLatencies, 17);
posY = 0.0f;
}

InitUIComponent = false;
isInited = true;

}

static GameObject UIObjectManager(GameObject gameObject, string name, float posY, string text, int fontSize)
{
gameObject = ComponentComposition(gameObject);
gameObject.name = name;
gameObject.transform.parent = NewGUIManager.transform;

RectTransform r = gameObject.GetComponent<RectTransform>();
r.localPosition = new Vector3(0.0f, posY -= offsetY, 0.0f);

Text t = gameObject.GetComponentInChildren<Text>();
t.text = text;
t.fontSize = fontSize;
gameObject.transform.localEulerAngles = Vector3.zero;

r.localScale = new Vector3(1.0f, 1.0f, 1.0f);

return gameObject;

}

/// <summary>
/// Component composition
/// </summary>
/// <returns> Composed game object. </returns>
static GameObject ComponentComposition(GameObject GO)
{
GO = new GameObject ();
GO.AddComponent<RectTransform> ();
GO.AddComponent<CanvasRenderer> ();
GO.AddComponent<Image> ();
GO.GetComponent<RectTransform> ().sizeDelta = new Vector2 (350f, 50f);
GO.GetComponent<Image> ().color = new Color (7f / 255f, 45f / 255f, 71f / 255f, 200f / 255f);

text = new GameObject ();
text.AddComponent<RectTransform> ();
text.AddComponent<CanvasRenderer> ();
text.AddComponent<Text> ();
text.GetComponent<RectTransform> ().sizeDelta = new Vector2 (350f, 50f);
text.GetComponent<Text> ().font = (Font)Resources.Load ("DINPro-Bold");
text.transform.parent = GO.transform;
text.name = "TextBox";

return GO;
}

#endif
}

This is the script for LuxMaterialInspector.cs

Code (CSharp):

using System.Collections.Generic;

using UnityEngine;

using UnityEditor;

using System.Linq;

public class LuxMaterialInspector : MaterialEditor {

public bool diffuseOnly;

public override void OnInspectorGUI ()

{

// render the default inspector

base.OnInspectorGUI ();

// if we are not visible... return

if (!isVisible)

return;

// get the current keywords from the material

Material targetMat = target as Material;

string[] keyWords = targetMat.shaderKeywords;

//if (targetMat.shader.name.Contains("Diffuse") || targetMat.shader.name.Contains("diffuse")) {

// diffuseOnly = true;

//}

// IBL settings

bool diffCube = keyWords.Contains ("DIFFCUBE_OFF");

bool specCube = keyWords.Contains ("SPECCUBE_OFF");

bool ambientOcclusion = keyWords.Contains ("LUX_AO_ON");

GUILayout.BeginVertical("box");

GUILayout.Label("Customize Material");

EditorGUI.BeginChangeCheck();

EditorGUILayout.BeginHorizontal();

// DiffCube

diffCube = EditorGUILayout.Toggle ("", diffCube, GUILayout.Width(14));

EditorGUILayout.LabelField("Disable diffuse Cube IBL");

EditorGUILayout.EndHorizontal();

// SpecCube

if (targetMat.HasProperty("_SpecCubeIBL")) {

EditorGUILayout.BeginHorizontal();

specCube = EditorGUILayout.Toggle ("", specCube, GUILayout.Width(14));

EditorGUILayout.LabelField("Disable specular Cube IBL");

EditorGUILayout.EndHorizontal();

}

// AO

if (targetMat.HasProperty("_AO") ) {

EditorGUILayout.BeginHorizontal();

ambientOcclusion = EditorGUILayout.Toggle ("", ambientOcclusion, GUILayout.Width(14));

EditorGUILayout.LabelField("Enable Ambient Occlusion");

EditorGUILayout.EndHorizontal();

if (ambientOcclusion) {

TextureProperty("_AO", "Ambient Occlusion (Alpha)", ShaderUtil.ShaderPropertyTexDim.TexDim2D );

}

}

if (EditorGUI.EndChangeCheck())

{

// if the checkbox is changed, reset the shader keywords

var keywords = new List<string> { diffCube ? "DIFFCUBE_OFF" : "DIFFCUBE_ON"};

if (specCube) {

keywords.Add("SPECCUBE_OFF");

}

else if (!diffuseOnly) {

keywords.Add("SPECCUBE_ON");

}

if (ambientOcclusion) {

keywords.Add("LUX_AO_ON");

}

else {

keywords.Add("LUX_AO_OFF");

}

//keywords.Add("_BumpMap");

//keywords.Add({ specCube ? "SPECCUBE_OFF" : "SPECCUBE_ON"});

targetMat.shaderKeywords = keywords.ToArray ();

EditorUtility.SetDirty (targetMat);

}

GUILayout.EndVertical();

}

}

This is the script for LuxEnvProbeEditor.cs

Code (CSharp):

#if UNITY_EDITOR

using UnityEngine;

using UnityEditor;

using System.Collections;

using System.Collections.Generic;

using System.IO;

//using System.

[CustomEditor(typeof(LuxEnvProbe))]

public class LuxEnvProbeEditor : Editor

{

private SerializedObject LuxProbe;

LuxEnvProbe Target;

LuxCubeProcessor ConvolutedCubemap = new LuxCubeProcessor();

private SerializedProperty Culling;

private SerializedProperty DiffSize;

private SerializedProperty SpecSize;

private SerializedProperty UseHDR;

private SerializedProperty Smooth;

private SerializedProperty SmoothWidth;

private SerializedProperty linear;

private SerializedProperty UseRTC;

private SerializedProperty Mode;

private SerializedProperty BoxSize;

private SerializedProperty AssignedMeshes;

private GameObject newAssignedMesh;

//private SerializedProperty init;

private Object diffcubeObj;

private Object speccubeObj;

//if you want to show debug msg box

//just change the value

//bool ShowDebugMsg = true;

void OnEnable()

{

Target = (LuxEnvProbe)target;

LuxProbe = new SerializedObject(target);

DiffSize = LuxProbe.FindProperty("DiffSize");

SpecSize = LuxProbe.FindProperty("SpecSize");

Culling = LuxProbe.FindProperty("CullingMask");

UseHDR = LuxProbe.FindProperty("HDR");

Smooth = LuxProbe.FindProperty("SmoothEdges");

SmoothWidth = LuxProbe.FindProperty("SmoothEdgePixel");

linear = LuxProbe.FindProperty("Linear");

UseRTC = LuxProbe.FindProperty("UseRTC");

// BoxProjection

Mode = LuxProbe.FindProperty("Mode");

BoxSize = LuxProbe.FindProperty("BoxSize");

// AssignedMeshes = LuxProbe.FindProperty("AssignedMeshes");

//init = LuxProbe.FindProperty("init");

}

public override void OnInspectorGUI()

{

// Debug

// DrawDefaultInspector();

// Update assigned Materials in BoxProjection Mode

if (Mode.enumValueIndex == 1) {

Target.SyncAssignedGameobjects();

}

/* Debugging only better leave it as it is

EditorGUILayout.BeginVertical();

GUILayout.Label("Cubemaps will be saved as"+Target.cubeName.ToString());

EditorGUILayout.EndVertical();

*/

//DrawDefaultInspector();

// Let's give it some styles \m/

GUIStyle buttonStyle = new GUIStyle(GUI.skin.button);

buttonStyle.margin = new RectOffset(4,4,10,10);

buttonStyle.padding = new RectOffset(10, 10, 10, 10);

GUIStyle smallbuttonStyle = new GUIStyle(GUI.skin.button);

smallbuttonStyle.margin = new RectOffset(4,4,0,0);

EditorGUILayout.BeginVertical("Box");

GUILayout.Space(5);

//Cubemap Settings

GUILayout.Label("Probe Settings", "BoldLabel");

//FaceSizes

EditorGUILayout.BeginHorizontal();

EditorGUILayout.BeginVertical();

EditorGUILayout.PropertyField(DiffSize, new GUIContent("Diffuse Size"));

EditorGUILayout.PropertyField(SpecSize, new GUIContent("Specular Size"));

EditorGUILayout.EndVertical();

EditorGUILayout.EndHorizontal();

// Baking Options

GUILayout.Space(5);

EditorGUILayout.BeginHorizontal();

EditorGUILayout.BeginHorizontal(GUILayout.MinWidth(114));

EditorGUILayout.PropertyField(UseHDR, new GUIContent(""), GUILayout.Width(14));

GUILayout.Label("Pull to HDR", GUILayout.MinWidth(96));

EditorGUILayout.EndHorizontal();

EditorGUILayout.BeginHorizontal();

EditorGUILayout.PropertyField(linear, new GUIContent(""), GUILayout.Width(14));

GUILayout.Label("Set to Linear Space");

EditorGUILayout.EndHorizontal();

EditorGUILayout.EndHorizontal();

EditorGUILayout.BeginHorizontal();

EditorGUILayout.BeginHorizontal(GUILayout.MinWidth(114));

EditorGUILayout.PropertyField(Smooth, new GUIContent(""), GUILayout.Width(14));

GUILayout.Label("Smooth Edges", GUILayout.MinWidth(96));

EditorGUILayout.EndHorizontal();

EditorGUILayout.BeginHorizontal();

if (Smooth.boolValue) {

EditorGUILayout.PropertyField(SmoothWidth, new GUIContent(""), GUILayout.Width(14));

GUILayout.Label("Edge Width");

}

EditorGUILayout.EndHorizontal();

EditorGUILayout.EndHorizontal();

EditorGUILayout.BeginVertical("Box");

GUILayout.Space(4);

EditorGUILayout.PropertyField(Mode, new GUIContent("Cube Mode"));

if (Mode.enumValueIndex == 1) {

GUILayout.Space(4);

Target.ShowAssignedMeshes = EditorGUILayout.Foldout(Target.ShowAssignedMeshes,"Manage associated GameObjects");

if (Target.ShowAssignedMeshes) {

GUILayout.Space(4);

for (int i = 0; i < Target.AssignedMeshes.Count; i++)

{

EditorGUILayout.BeginHorizontal();

GUILayout.Space(4);

// TODO: Make it work with SerializedProperty

Target.AssignedMeshes[i] = (GameObject)EditorGUILayout.ObjectField("", Target.AssignedMeshes[i], typeof(GameObject), true);

if (GUILayout.Button("Remove", EditorStyles.miniButton, GUILayout.Width(50)) ) {

Target.AssignedMeshes.RemoveAt(i);

}

EditorGUILayout.EndHorizontal();

GUILayout.Space(2);

}

GUILayout.Space(5);

EditorGUILayout.BeginHorizontal();

GUILayout.Space(4);

newAssignedMesh = (GameObject)EditorGUILayout.ObjectField("", newAssignedMesh, typeof(GameObject), true);

if (GUILayout.Button("Add", EditorStyles.miniButton, GUILayout.Width(50)) ) {

if (newAssignedMesh) {

Target.AssignedMeshes.Add(newAssignedMesh);

newAssignedMesh = null;

}

}

EditorGUILayout.EndHorizontal();

}

GUILayout.Space(5);

}

EditorGUILayout.EndVertical();

//Camera Settings

GUILayout.Space(5);

GUILayout.Label("Probe Camera Settings", "BoldLabel");

EditorGUILayout.EnumPopup("Clear Flags", Target.ClearFlags);

EditorGUILayout.ColorField("Clear Color", Target.ClearColor);

EditorGUILayout.PropertyField(Culling, new GUIContent("Culling Mask"));

EditorGUILayout.FloatField("Near Clip Plane", Target.Near);

EditorGUILayout.FloatField("Far Clip Plane", Target.Far);

EditorGUILayout.PropertyField(UseRTC, new GUIContent("RenderToCubemap"));

if (GUILayout.Button("Bake Probe", buttonStyle))

{

if(UseRTC.boolValue) {

Target.RenderToCubeMap();

}

else {

Target.PreSetup();

Target.InitRenderCube();

}

}

EditorGUILayout.EndVertical();

EditorGUILayout.BeginVertical("Box");

GUILayout.Space(5);

GUILayout.Label("Process Cubemaps", "BoldLabel");

EditorGUILayout.BeginHorizontal();

EditorGUILayout.BeginVertical();

GUILayout.Label("Diffuse Cubemap");

// use object in order to enable manual assignment

diffcubeObj = EditorGUILayout.ObjectField(Target.DIFFCube, typeof(Cubemap), false, GUILayout.MinHeight(64), GUILayout.MinWidth(64), GUILayout.MaxWidth(64));

Target.DIFFCube = (Cubemap)diffcubeObj;

EditorGUILayout.EndVertical();

EditorGUILayout.BeginVertical();

GUILayout.Label("Specular Cubemap");

// use object in order to enable manual assignment

speccubeObj = EditorGUILayout.ObjectField(Target.SPECCube, typeof(Cubemap), false, GUILayout.MinHeight(64), GUILayout.MinWidth(64), GUILayout.MaxWidth(64));

Target.SPECCube = (Cubemap)speccubeObj;

EditorGUILayout.EndVertical();

EditorGUILayout.EndHorizontal();

if (GUILayout.Button("Get Generated Cubemaps", buttonStyle))

{

Target.init = false;

Target.CleanUp();

Target.RetriveCubemap();

Cubemap diff = Target.DIFFCube;

Cubemap spec = Target.SPECCube;

}

if (GUILayout.Button("Convolve Cubemaps", buttonStyle))

{

Target.init = false;

Target.CleanUp();

Cubemap diff = null;

Cubemap spec = null;

if (!EditorApplication.isPlaying && Target.DIFFCube != null && Target.SPECCube != null)

{

diff = Target.DIFFCube;

spec = Target.SPECCube;

}

bool hdr = Target.HDR;

if (diff == null || spec == null)

{

if (UnityEditor.EditorUtility.DisplayDialog("No Cubemaps found", "Please generate or assign cubemaps to the probe.", "OK"))

{

return;

}

}

if (UnityEditor.EditorUtility.DisplayDialog("Convolve Cubemaps", "Proceed to cubemap convolution?\nThis could take a while.", "Proceed", "Cancel"))

{

ConvolutedCubemap.ProcessCubemap(diff, true, hdr);

ConvolutedCubemap.ProcessCubemap(spec, false, hdr);

}

}

EditorGUILayout.EndVertical();

if(GUI.changed){

// EditorUtility.SetDirty(Target);

//EditorUtility.SetDirty(myTrackData);

}

LuxProbe.ApplyModifiedProperties();

//Debugging only better leave it as it is

/*

if (ShowDebugMsg)

{

EditorGUILayout.BeginVertical("Box");

EditorGUILayout.ToggleLeft("Init",Target.init);

GUILayout.Label("Cubemaps will be saved as:");

if (Target.DiffPath != null && Target.SpecPath != null)

{

GUILayout.Label(Target.DiffPath.ToString(), EditorStyles.wordWrappedLabel);

GUILayout.Label(Target.SpecPath.ToString(), EditorStyles.wordWrappedLabel);

}

EditorGUILayout.EndVertical();

}*/

}

// Draw BoxSize Handles

void OnSceneGUI () {

if (Mode.enumValueIndex == 1) {

BoxSize.vector3Value = Handles.ScaleHandle (BoxSize.vector3Value, Target.transform.position, Target.transform.rotation, 3.5f);

}

}

}

#endif

This is the script for RoadTool.cs

Code (CSharp):

// @khenkel

// parabox llc

using UnityEngine;

using UnityEditor;

using System.Collections;

using System.Collections.Generic;

using System.Text;

[CustomEditor(typeof(Road))]

public class RoadTool : Editor

{

#region Private

Road road;

#endregion

#region Constant

const float MIN_ROAD_WIDTH = .3f;

const float MAX_ROAD_WIDTH = 50f;

const float MIN_GROUND_OFFSET = .001f;

const float MAX_GROUND_OFFSET = 1f;

#endregion

#region Shortcut

// big list of things that cause onscenegui to loop endlessly if mixed with our code.

public bool earlyOut

{

get

{

return (

Event.current.alt ||

Tools.current == Tool.View ||

GUIUtility.hotControl > 0 ||

(Event.current.isMouse ? Event.current.button > 1 : false) ||

Tools.viewTool == ViewTool.FPS ||

Tools.viewTool == ViewTool.Orbit);

}

}

#endregion

#region Initalization / Destruction

[MenuItem("GameObject/Create Other/Road %#r")]

public static void init()

{

GameObject go = new GameObject();

Road r = go.AddComponent<Road>();

r.acceptInput = true;

r.mat = (Material)Resources.LoadAssetAtPath("Assets/RoadTool/Example/Texture/Materials/Road.mat", typeof(Material));

go.name = "Road " + go.GetInstanceID();

go.AddComponent<MeshRenderer>();

Selection.activeObject = go;

}

public void OnEnable()

{

road = (Road)target;

}

#endregion

#region Window Lifecycle

bool showUVOptions = false;

public override void OnInspectorGUI()

{

GUI.changed = false;

road.roadWidth = EditorGUILayout.Slider("Road Width", road.roadWidth, MIN_ROAD_WIDTH, MAX_ROAD_WIDTH);

road.groundOffset = EditorGUILayout.Slider("Ground Offset", road.groundOffset, MIN_GROUND_OFFSET, MAX_GROUND_OFFSET);

EditorGUILayout.HelpBox("A negative value inserts new points at the end of the line.", MessageType.Info);

road.insertPoint = EditorGUILayout.IntField("Insert At Point", road.insertPoint);

road.connectEnds = EditorGUILayout.Toggle("Connect Ends", road.connectEnds);

showUVOptions = EditorGUILayout.Foldout(showUVOptions, "UV Options");

if(showUVOptions)

{

road.swapUV = EditorGUILayout.Toggle("Swap UV", road.swapUV);

road.flipU = EditorGUILayout.Toggle("Flip U", road.flipU);

road.flipV = EditorGUILayout.Toggle("Flip V", road.flipV);

road.uvScale = EditorGUILayout.Vector2Field("Scale", road.uvScale);

road.uvOffset = EditorGUILayout.Vector2Field("Offset", road.uvOffset);

}

road.mat = (Material)EditorGUILayout.ObjectField("Material", road.mat, typeof(Material), true);

if(road.acceptInput)

{

GUI.backgroundColor = Color.red;

if(GUILayout.Button("Lock"))

{

road.acceptInput = false;

SceneView.RepaintAll();

}

}

else

{

GUI.backgroundColor = Color.green;

if(GUILayout.Button("Modify"))

{

road.acceptInput = true;

SceneView.RepaintAll();

}

}

GUI.backgroundColor = Color.white;

if(GUI.changed)

{

EditorUtility.SetDirty(road);

road.Refresh();

SceneView.RepaintAll();

}

}

#endregion

#region Scene

Vector3 groundPoint = Vector3.zero;

Vector3 tp;

public void OnSceneGUI()

{

if(road.acceptInput == false)

return;

Event e = Event.current;

if(e.type == EventType.ValidateCommand)

{

road.Refresh();

SceneView.RepaintAll();

}

if(e.isKey && (e.keyCode == KeyCode.Escape || e.keyCode == KeyCode.Return))

{

road.acceptInput = false;

SceneView.RepaintAll();

}

// Existing point handles

DrawHandleGUI(road.points);

// TODO -- figure out why Handles.PositionHandle is sooo slow when panning

if(!e.alt)

for(int i = 0; i < road.points.Count; i++)

{

tp = road.points[i];

road.points[i] = Handles.PositionHandle(road.points[i], Quaternion.identity);

if(tp != road.points[i])

{

Vector3 p = road.points[i];

p.y = road.GroundHeight(road.points[i]);

road.points[i] = p;

road.Refresh();

}

}

if(earlyOut)

return;

// New point placement from here down

int controlID = GUIUtility.GetControlID(FocusType.Passive);

HandleUtility.AddDefaultControl(controlID);

if(e.modifiers != 0 || Tools.current != Tool.Move)

{

if(e.type == EventType.mouseUp && e.button == 0 && Tools.current != Tool.Move && e.modifiers == 0)

{

FindSceneView().ShowNotification(new GUIContent("Tool must be set to 'Move' to place points!", ""));

SceneView.RepaintAll();

}

return;

}

if( (e.type == EventType.mouseDown || e.type == EventType.mouseDrag) && e.button == 0)

{

Ray ray = HandleUtility.GUIPointToWorldRay(e.mousePosition);

RaycastHit ground = new RaycastHit();

if( Physics.Raycast(ray.origin, ray.direction, out ground) )

groundPoint = ground.point;

}

// Listen for mouse input

if(e.type == EventType.mouseUp && e.button == 0)

{

Ray ray = HandleUtility.GUIPointToWorldRay(e.mousePosition);

RaycastHit ground = new RaycastHit();

if( Physics.Raycast(ray.origin, ray.direction, out ground) )

{

groundPoint = ground.point;

AddPoint(groundPoint);

}

}

}

public static SceneView FindSceneView()

{

return SceneView.lastActiveSceneView == null ? EditorWindow.GetWindow<SceneView>() : SceneView.lastActiveSceneView;

}

#endregion

#region Handles

public void DrawHandleGUI(List<Vector3> points)

{

if(points == null || points.Count < 1)

return;

Handles.BeginGUI();

GUI.backgroundColor = Color.red;

for(int i = 0; i < points.Count; i++)

{

Vector2 p = HandleUtility.WorldToGUIPoint(points[i]);

if(GUI.Button(new Rect(p.x+10, p.y-50, 25, 25), "x"))

DeletePoint(i);

GUI.Label(new Rect(p.x+45, p.y-50, 200, 25), "Point: " + i.ToString());

}

GUI.backgroundColor = Color.white;

Handles.EndGUI();

}

#endregion

#region Point Management

public void AddPoint(Vector3 v)

{

Undo.RegisterUndo(new Object[1]{target as Object}, "Set Point");

if(road.insertPoint < 0 || road.insertPoint > road.points.Count)

road.points.Add(v);

else

road.points.Insert(road.insertPoint, v);

road.Refresh();

SceneView.RepaintAll();

}

public void DeletePoint(int index)

{

Undo.RegisterUndo(new Object[]{target}, "Delete Point");

road.points.RemoveAt(index);

road.Refresh();

SceneView.RepaintAll();

}

#endregion

}

And this is the script for RoadObjectEditorScript.js

import System.Collections.Generic;
import System.IO;
import EasyRoads3D;
import EasyRoads3DEditor;
@CustomEditor(RoadObjectScript)
class RoadObjectEditorScript extends Editor
{
var counter : int;
var pe : float;
var tv : boolean;
var tvDone : boolean;
var debugDone : boolean;
var res : boolean;
var col : Collider;

function OnEnable(){

target.backupLocation = EditorPrefs.GetInt("ER3DbckLocation", 0);

if(target.OQCODQCQOC == null){
ODCDDDDDDQ();
target.OCOOCQODQD(null, null, null);
}

target.ODODQOQO = target.OQCODQCQOC.ODDDCOQDCC();
target.ODODQOQOInt = target.OQCODQCQOC.OCDDCDCCQD();
if(target.splatmapLayer >= target.ODODQOQO.Length)target.splatmapLayer = 4;
if(target.customMesh != null){
if(target.customMesh.GetComponent(typeof(Collider))){
col = target.customMesh.GetComponent(typeof(Collider));
}else if(OQCDOODQQQ.terrain != null){
col = OQCDOODQQQ.terrain.GetComponent(typeof(TerrainCollider));
}
}else if(OQCDOODQQQ.terrain != null){
col = OQCDOODQQQ.terrain.GetComponent(typeof(TerrainCollider));
}

if(ODCDDDDDDQ()){
OQCDOODQQQ.OQOOCOCDDQ();
}
target.ODQDODOODQs = new GameObject[0];

}
function OnInspectorGUI(){

EasyRoadsGUIMenu(true, true, target);
}
function OnSceneGUI() {
if(target.OQCODQCQOC == null){
ODCDDDDDDQ();
target.OCOOCQODQD(null, null, null);
if(target.OCDQCCOCOC != EditorApplication.currentScene && target.OQCODQCQOC == null){
OCQCDCCDOC.terrainList.Clear();
target.OCDQCCOCOC = EditorApplication.currentScene;
}

}

OnScene();

}
function EasyRoadsGUIMenu(flag : boolean, senderIsMain : boolean, nRoadScript : RoadObjectScript) : int {

if(target.OQDDCQCCDQ == null || target.OODQCQCDQO == null || target.ODOOCQDQCD == null || target.OQDDCQCCDQ.Length == 0 ){
target.OQDDCQCCDQ = new boolean[5];
target.OODQCQCDQO = new boolean[5];
target.ODOOCQDQCD = nRoadScript;

target.ODODQCCDOC = target.OQCODQCQOC.OQQCCOQDQO();
target.ODODQOQO = target.OQCODQCQOC.ODDDCOQDCC();
target.ODODQOQOInt = target.OQCODQCQOC.OCDDCDCCQD();
}
origAnchor = GUI.skin.box.alignment;
if(target.OODCOCOOCC == null){
target.OODCOCOOCC = Resources.Load("ER3DSkin", GUISkin);
target.OQQOCCQOOC = Resources.Load("ER3DLogo", Texture2D);
}
if(!flag) target.OODODDQDOQ();
if(target.ODDDQCOOQD == -1) target.ODQDODOODQ = null;
var origSkin : GUISkin = GUI.skin;
GUI.skin = target.OODCOCOOCC;
EditorGUILayout.Space();

EditorGUILayout.BeginHorizontal ();
GUILayout.FlexibleSpace();
target.OQDDCQCCDQ[0] = GUILayout.Toggle(target.OQDDCQCCDQ[0] ,new GUIContent("", " Add road markers. "),"AddMarkers",GUILayout.Width(40), GUILayout.Height(22));
if(target.OQDDCQCCDQ[0] == true && target.OODQCQCDQO[0] == false) {
target.OODODDQDOQ();
target.OQDDCQCCDQ[0] = true; target.OODQCQCDQO[0] = true;
}
target.OQDDCQCCDQ[1] = GUILayout.Toggle(target.OQDDCQCCDQ[1] ,new GUIContent("", " Insert road markers. "),"insertMarkers",GUILayout.Width(40),GUILayout.Height(22));
if(target.OQDDCQCCDQ[1] == true && target.OODQCQCDQO[1] == false) {
target.OODODDQDOQ();
target.OQDDCQCCDQ[1] = true; target.OODQCQCDQO[1] = true;
}
target.OQDDCQCCDQ[2] = GUILayout.Toggle(target.OQDDCQCCDQ[2] ,new GUIContent("", " Process the terrain and create road geometry. "),"terrain",GUILayout.Width(40),GUILayout.Height(22));

if(target.OQDDCQCCDQ[2] == true && (target.OODQCQCDQO[2] == false || target.doTerrain)) {

if(target.markers <= 2){
EditorUtility.DisplayDialog("Alert", "A minimum of 2 road markers is required before the terrain can be leveled!", "Close");
target.OQDDCQCCDQ[2] = false;
}else{
if(target.disableFreeAlerts)EditorUtility.DisplayDialog("Alert", "Switching back to 'Edit Mode' is not supported in the free version.\n\nClick Close to generate the road mesh and deform the terrain. This process can take some time depending on the terrains heightmap resolution and the optional vegetation removal, please be patient!\n\nYou can always restore the terrain using the EasyRoads3D terrain restore option in the main menu.\n\nNote: you can disable displaying this message in General Settings.", "Close");
if(!flag){
EditorUtility.DisplayDialog("Alert", "The Unity Terrain Object does not accept height values < 0. The river floor will be equal or higher then the water level. Position all markers higher above the terrain!", "Close");
target.OQDDCQCCDQ[2] = false;
}else{
tvDone = false;
target.OODODDQDOQ();
target.OQDDCQCCDQ[2] = true; target.OODQCQCDQO[2] = true;
target.OOCQCCQOQQ = true;
target.doTerrain = false;
target.markerDisplayStr = "Show Markers";
if(target.objectType < 2){

#if UNITY_4_6
#elif UNITY_4_5
#elif UNITY_4_3
#else
Undo.RegisterUndo(OQCDOODQQQ.terrain.terrainData, "EasyRoads3D Terrain leveling");
#endif

if(!target.displayRoad){
target.displayRoad = true;
target.OQCODQCQOC.OQOCOCCQOC(true, target.OCCQOQDDDO);
}
OCQCDCCDOC.ODQODCODOD = false;

OOQCOOQQDO(target);
if(target.OOQDOOQQ)target.OQCCOODCDO();

}else{

target.OQCODQCQOC.OCCODDODOO(target.transform, false);
}
}
if(target.disableFreeAlerts)EditorUtility.DisplayDialog("Finished!", "The terrain data has been updated.\n\nIf you want to keep these changes and add more road objects it is recommended to update the terrain backup data using the EasyRoads3D terrain backup options in the main menu. By doing this you will not loose the current terrain changes if later in the development process you want to restore the terrain back to the current status.\n\nYou can also duplicate the terrain object in the project panel and keep that as the terrain backup.\n\nNote: you can disable displaying this message in General Settings.", "Close");
}
}

target.OQDDCQCCDQ[3] = GUILayout.Toggle(target.OQDDCQCCDQ[3] ,new GUIContent("", " General settings. "),"settings",GUILayout.Width(40),GUILayout.Height(22));
if(target.OQDDCQCCDQ[3] == true && target.OODQCQCDQO[3] == false) {
target.OODODDQDOQ();
target.OQDDCQCCDQ[3] = true; target.OODQCQCDQO[3] = true;
}
target.OQDDCQCCDQ[4] = GUILayout.Toggle(target.OQDDCQCCDQ[4] ,new GUIContent("", "Version and Purchase Info"),"info",GUILayout.Width(40),GUILayout.Height(22));
if(target.OQDDCQCCDQ[4] == true && target.OODQCQCDQO[4] == false) {
target.OODODDQDOQ();
target.OQDDCQCCDQ[4] = true; target.OODQCQCDQO[4] = true;
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
GUI.skin = null;
GUI.skin = origSkin;
target.ODDDQCOOQD = -1;
for(var i : int = 0; i < 5; i++){
if(target.OQDDCQCCDQ){
target.ODDDQCOOQD = i;
target.OODQCOQQQQ = i;
}
}
if(target.ODDDQCOOQD == -1) target.OODODDQDOQ();
var markerMenuDisplay : int = 1;
if(target.ODDDQCOOQD == 0 || target.ODDDQCOOQD == 1) markerMenuDisplay = 0;
else if(target.ODDDQCOOQD == 2 || target.ODDDQCOOQD == 3 || target.ODDDQCOOQD == 4) markerMenuDisplay = 0;

if(target.OOCQCCQOQQ && !target.OQDDCQCCDQ[2] && Application.isPlaying){
EditorPrefs.SetBool("ERv2isPlaying", true);

}

if(target.OOCQCCQOQQ && !target.OQDDCQCCDQ[2]){
target.OQDDCQCCDQ[2] = true;
target.OODQCQCDQO[2] = true;
if(target.disableFreeAlerts)EditorUtility.DisplayDialog("Alert", "Switching back to 'Edit Mode' to add markers or change other settings is not supported in the free version.\n\nDrag the road mesh to the root of the hierarchy and delete the EasyRoads3D editor object once the road is ready!\n\nYou can use Undo to restore the terrain.", "Close");
}
GUI.skin.box.alignment = TextAnchor.UpperLeft;
if(target.ODDDQCOOQD >= 0 && target.ODDDQCOOQD != 4){
if(target.ODODQCCDOC == null || target.ODODQCCDOC.Length == 0){

target.ODODQCCDOC = target.OQCODQCQOC.OQQCCOQDQO();
target.ODODQOQO = target.OQCODQCQOC.ODDDCOQDCC();
target.ODODQOQOInt = target.OQCODQCQOC.OCDDCDCCQD();
}
EditorGUILayout.BeginHorizontal();
GUILayout.Box(target.ODODQCCDOC[target.ODDDQCOOQD], GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(50));
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
}
if(target.ODDDQCOOQD == -1 && target.ODQDODOODQ != null) Selection.activeGameObject = target.ODQDODOODQ.gameObject;
GUI.skin.box.alignment = origAnchor;

if(target.erInit == "" || (OCQCDCCDOC.debugFlag && !debugDone)){
debugDone = true;

target.erInit = OCDQQCOQOD.OQOCQOQCOO(target.version);
target.OQCODQCQOC.erInit = target.erInit;

this.Repaint();

}
if(target.erInit != "" && res){

target.OQDODQOODQ(target.geoResolution, false, false);
res = false;
}
if(target.erInit.Length == 0){
}else if(target.ODDDQCOOQD == 0 || target.ODDDQCOOQD == 1){
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Refresh Surfaces", GUILayout.Width(200))){
target.ODDCCCQCOC();
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}else if(target.ODDDQCOOQD == 3){

GUI.skin.box.alignment = TextAnchor.MiddleLeft;
GUILayout.Box(" General Settings", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
if(target.objectType != 2){
GUILayout.Space(10);
var oldDisplay : boolean = target.displayRoad;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Display object", "This will activate/deactivate the road object transforms"), GUILayout.Width(125) );
target.displayRoad = EditorGUILayout.Toggle (target.displayRoad);
EditorGUILayout.EndHorizontal();
if(oldDisplay != target.displayRoad){
target.OQCODQCQOC.OQOCOCCQOC(target.displayRoad, target.OCCQOQDDDO);
}
}
if(target.materialStrings == null){target.materialStrings = new String[2]; target.materialStrings[0] = "Diffuse Shader"; target.materialStrings[1] = "Transparent Shader"; }
if(target.materialStrings.Length == 0){target.materialStrings = new String[2]; target.materialStrings[0] = "Diffuse Shader"; target.materialStrings[1] = "Transparent Shader"; }
var cm : int = target.materialType;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Surface Material", "The material type used for the road surfaces."), GUILayout.Width(125) );
target.materialType = EditorGUILayout.Popup (target.materialType, target.materialStrings, GUILayout.Width(115));
EditorGUILayout.EndHorizontal();
if(cm != target.materialType) target.OQCODQCQOC.ODODDDCCOQ(target.materialType);
if(target.materialType == 1){
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Surface Opacity", "This controls the transparacy level of the surface objects."), GUILayout.Width(125) );
var so : float = target.surfaceOpacity;
target.surfaceOpacity = EditorGUILayout.Slider(target.surfaceOpacity, 0, 1, GUILayout.Width(150));
EditorGUILayout.EndHorizontal();
if(so != target.surfaceOpacity) target.OQCODQCQOC.OOCQQCCCDO(target.surfaceOpacity);
}
EditorGUILayout.Space();
if(target.objectType < 2){
var od: boolean = target.multipleTerrains;
}
GUI.enabled = true;
GUI.enabled = false;
var cl = target.backupLocation;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Backup Location", "Use outside Assets folder unless you are using the asset server."), GUILayout.Width(125) );
target.backupLocation = EditorGUILayout.Popup (target.backupLocation, target.backupStrings, GUILayout.Width(115));
EditorGUILayout.EndHorizontal();
if(target.backupLocation != cl){
if(target.backupLocation == 1){
if(EditorUtility.DisplayDialog("Backup Location", "Changing the backup location to inside the assets folder is only recommended when you want to synchronize EasyRoads3D backup files with the assetserver.\n\nWould you like to continue?", "Yes", "No")){
EditorPrefs.SetInt("ER3DbckLocation", target.backupLocation);
OOQDDDCQDD.SwapFiles(target.backupLocation);
EditorUtility.DisplayDialog("Confirmation", "The backup location has been updated, all backup folders and files have been copied to the new location.\n\nUse CTRL+R to update the assets folder!", "Close");
}else target.backupLocation = 0;
}else{
if(EditorUtility.DisplayDialog("Backup Location", "The backup location will be changed to outside the assets folder.\n\nWould you like to continue?", "Yes", "No")){
EditorPrefs.SetInt("ER3DbckLocation", target.backupLocation);
OOQDDDCQDD.SwapFiles(target.backupLocation);
EditorUtility.DisplayDialog("Confirmation", "The backup location has been updated, all backup folders and files have been copied to the new location.\n\nUse CTRL+R to update the assets folder!", "Close");
}else target.backupLocation = 1;
}
}
GUI.enabled = true;
od = OCQCDCCDOC.debugFlag;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Enable Debugging", "This will enable debugging."), GUILayout.Width(125) );;
OCQCDCCDOC.debugFlag = EditorGUILayout.Toggle (OCQCDCCDOC.debugFlag);
EditorGUILayout.EndHorizontal();
if(od != OCQCDCCDOC.debugFlag && OCQCDCCDOC.debugFlag) debugDone = false;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Free version alerts", "Uncheck to disable free version alerts."), GUILayout.Width(125) );;
target.disableFreeAlerts = EditorGUILayout.Toggle (target.disableFreeAlerts);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.Box(" Object Settings", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
EditorGUILayout.BeginHorizontal();
var wd : float = target.roadWidth;
if(target.objectType == 0)GUILayout.Label(new GUIContent(" Road width", "The width of the road") , GUILayout.Width(125));
else GUILayout.Label(new GUIContent(" River Width", "The width of the river") , GUILayout.Width(125));
target.roadWidth = EditorGUILayout.FloatField(target.roadWidth, GUILayout.Width(40) );
EditorGUILayout.EndHorizontal();
if(wd != target.roadWidth) target.OQDODQOODQ(target.geoResolution, false, false);
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Default Indent", "The distance from the left and right side of the road to the part of the terrain levelled at the same height as the road"), GUILayout.Width(125));
target.indent = EditorGUILayout.FloatField(target.indent, GUILayout.Width(40));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Raise Markers", "This will raise the position of the markers (m)."), GUILayout.Width(125) );;
target.raiseMarkers = EditorGUILayout.FloatField (target.raiseMarkers, GUILayout.Width(40));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Force Y Position", "When toggled on, ne road markers will inherit the y position of the previous marker."), GUILayout.Width(125) );;
target.forceY = EditorGUILayout.Toggle (target.forceY);
EditorGUILayout.EndHorizontal();
if(target.forceY){
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Y Change", "The marker will be raised / lowered according this amount for every 100 meters."), GUILayout.Width(125) );;
target.yChange = EditorGUILayout.FloatField (target.yChange, GUILayout.Width(40));
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Surrounding", "This represents the distance over which the terrain will be gradually leveled to the original terrain height"), GUILayout.Width(125));
target.surrounding = EditorGUILayout.FloatField(target.surrounding, GUILayout.Width(40));
EditorGUILayout.EndHorizontal();
var OldClosedTrack : boolean = target.OOQDOOQQ;
EditorGUILayout.BeginHorizontal();
if(target.objectType == 0)GUILayout.Label(new GUIContent(" Closed Track", "This will connect the 'start' and 'end' of the road"), GUILayout.Width(125) );
else if(target.objectType == 1)GUILayout.Label(new GUIContent(" Closed River", "This will connect the 'start' and 'end' of the river"), GUILayout.Width(125) );
else GUILayout.Label(new GUIContent(" Closed Object", "This will connect the 'start' and 'end' of the object"), GUILayout.Width(125) );
target.OOQDOOQQ = EditorGUILayout.Toggle (target.OOQDOOQQ);
EditorGUILayout.EndHorizontal();
if(OldClosedTrack != target.OOQDOOQQ){
target.ODDCCCQCOC();
}
EditorGUILayout.BeginHorizontal();
GUI.enabled = false;
GUILayout.Label(new GUIContent(" iOS Platform", "This will prepare the road mesh for the iOS Platform"), GUILayout.Width(125) );
target.iOS = EditorGUILayout.Toggle (target.iOS);
EditorGUILayout.EndHorizontal();
if(OldClosedTrack != target.iOS){
}
GUI.enabled = true;

EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Geometry Resolution", "The polycount of the generated surfaces. It is recommended to use a low resolution while creating the road. Use the maximum resolution when processing the final terrain."), GUILayout.Width(125) );
var gr : float = target.geoResolution;
target.geoResolution = EditorGUILayout.Slider(target.geoResolution, 0.5, 5, GUILayout.Width(150));
EditorGUILayout.EndHorizontal();
if(gr != target.geoResolution) target.OQDODQOODQ(target.geoResolution, false, false);
EditorGUILayout.BeginHorizontal();
OldClosedTrack = target.iOS;
GUI.enabled = false;
GUILayout.Label(new GUIContent(" Tangents", "This will automatically calculate mesh tangents data required for bump mapping. Note that this will take a little bit more preocessing time."), GUILayout.Width(125) );
target.applyTangents = EditorGUILayout.Toggle (target.applyTangents);
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
EditorGUILayout.Space();
GUILayout.Box(" Render Settings", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
GUI.enabled = false;
if(OQCDOODQQQ.selectedTerrain == null)OQCDOODQQQ.OQOOCOCDDQ();
var st : int = OQCDOODQQQ.selectedTerrain;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Active Terrain", "The terrain that will be updated"), GUILayout.Width(125) );
OQCDOODQQQ.selectedTerrain = EditorGUILayout.Popup (OQCDOODQQQ.selectedTerrain, OQCDOODQQQ.terrainStrings, GUILayout.Width(115));
EditorGUILayout.EndHorizontal();
if(st != OQCDOODQQQ.selectedTerrain)OQCDOODQQQ.OOODOQCOOQ();
GUI.enabled = true;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Update Vegetation", "When toggled on tree and detail objects near the road will be removed when rendering the terrain."), GUILayout.Width(125) );;
target.handleVegetation = EditorGUILayout.Toggle (target.handleVegetation);
EditorGUILayout.EndHorizontal();
if(target.handleVegetation){
GUI.enabled = false;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Tree Distance (m)", "The distance from the left and the right of the road up to which terrain trees should be removed."), GUILayout.Width(125) );
var tr : float = target.OCOCODCCDD;
target.OCOCODCCDD = EditorGUILayout.Slider(target.OCOCODCCDD, 0, 25, GUILayout.Width(150));
EditorGUILayout.EndHorizontal();
if(tr != target.OCOCODCCDD) target.OQCODQCQOC.OCOCODCCDD = target.OCOCODCCDD;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Detail Distance (m)", "The distance from the left and the right of the road up to which terrain detail opbjects should be removed."), GUILayout.Width(125) );
tr = target.ODDQODQCOO;
target.ODDQODQCOO = EditorGUILayout.Slider(target.ODDQODQCOO, 0, 25, GUILayout.Width(150));
EditorGUILayout.EndHorizontal();
if(tr != target.ODDQODQCOO) target.OQCODQCQOC.ODDQODQCOO = target.ODDQODQCOO;
GUI.enabled = true;
}
EditorGUILayout.Space();

}else if(target.ODDDQCOOQD == 2){

EditorGUILayout.Space();
if(target.objectType == 0)GUILayout.Box(" Road Settings:", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
else GUILayout.Box(" River Settings:", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
GUILayout.Space(10);
var oldRoad : boolean = target.renderRoad;
var oldRoadResolution : float = target.roadResolution;
var oldRoadUV : float = target.tuw;
var oldRaise : float = target.raise;
var oldSegments : int = target.OdQODQOD;
var oldOOQQQDOD : float = target.OOQQQDOD;
var oldOOQQQDODOffset : float = target.OOQQQDODOffset;
var oldOOQQQDODLength : float = target.OOQQQDODLength;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Render"," When active, terrain matching road geometry will be created."), GUILayout.Width(105) );
target.renderRoad = EditorGUILayout.Toggle (target.renderRoad);
EditorGUILayout.EndHorizontal();
if(target.renderRoad){
if(target.objectType == 0){
if(target.roadTexture == null){
mat = Resources.Load("roadMaterial", typeof(Material));
target.roadTexture = mat.mainTexture;
}
GUI.enabled = false;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Material"," The road texture."), GUILayout.Width(105) );
if(GUILayout.Button (target.roadTexture, GUILayout.Width(75), GUILayout.Height(75))){
}
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
}
EditorGUILayout.BeginHorizontal();
GUI.enabled = false;
GUILayout.Label(new GUIContent(" Road Segments"," The number of segments over the width of the road."), GUILayout.Width(105) );
target.OdQODQOD = EditorGUILayout.IntSlider(target.OdQODQOD, 1, 10, GUILayout.Width(175));
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
if(target.OdQODQOD > 1){
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Bumpyness"," The bumypness of the surface of the road."), GUILayout.Width(95) );
target.OOQQQDOD = EditorGUILayout.Slider(target.OOQQQDOD, 0, 1, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Bumpyness Offset"," The bumypness variation of the road."), GUILayout.Width(95) );
target.OOQQQDODOffset = EditorGUILayout.Slider(target.OOQQQDODOffset, 0, 1, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Bumpyness Density"," The bumypness density on the road."), GUILayout.Width(95) );
target.OOQQQDODLength = EditorGUILayout.Slider(target.OOQQQDODLength, 0.01, 1, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
}
GUI.enabled = false;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Resolution"," The resolution level of the road geometry."), GUILayout.Width(95) );
target.roadResolution = EditorGUILayout.IntSlider(target.roadResolution, 1, 10, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
if(target.objectType == 0){
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" UV Mapping"," Use the slider to control texture uv mapping of the road geometry."), GUILayout.Width(95) );
target.tuw = EditorGUILayout.Slider(target.tuw, 1, 30, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Raise (cm)","Optionally increase this setting when parts of the terrain stick through the road geometry. It is recommended to adjust these areas using the terrain tools!"), GUILayout.Width(95) );
target.raise = EditorGUILayout.Slider(target.raise, 0, 100, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
}else{
}
GUILayout.Space(5);
GUI.enabled = false;
if(target.applyTangents)GUI.enabled = false;
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Calculate Tangents", GUILayout.Width(175))){
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
GUI.enabled = true;
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Save Geometry", GUILayout.Width(175))){
target.ODCDDDOCDO();
Debug.Log("Road object geometry saved");
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Finalize Object", GUILayout.Width(175))){
var bflag = false;
for(i=0;i<target.ODODQQOD.Length;i++){
if(target.ODODQQOD){
bflag = true;
break;
}
}
if(target.autoODODDQQO || target.sosBuild == true)bflag = false;
if(EditorUtility.DisplayDialog("Important!", "This will unlink the road from the EasyRoads3D editor object and the EasyRoads3D object will be destroyed!\n\nWould you like to continue?", "Yes", "No")){
if(bflag){
if(EditorUtility.DisplayDialog("Important!", "This object includes activated side objects that have not yet been build!\n\nAre you sure you would you like to continue?", "Yes", "No")){
bflag = false;
}
}
if(!bflag){
target.OQCODQCQOC.FinalizeObject(target.gameObject);
DestroyImmediate(target.gameObject);
}
}
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
}
EditorGUILayout.Space();
if(oldRoad != target.renderRoad || oldRoadResolution != target.roadResolution || oldRoadUV != target.tuw || oldRaise != target.raise || oldSegments != target.OdQODQOD || target.OOQQQDOD != oldOOQQQDOD || target.OOQQQDODOffset != oldOOQQQDODOffset || target.OOQQQDODLength != oldOOQQQDODLength){

target.OQQOCOQQOC();

}
GUILayout.Box(" Terrain Settings:", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
GUILayout.Space(5);
var oldApplySplatmap : boolean = target.applySplatmap;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Apply Splatmap"," When active, the road will be added to the terrain splatmap. The quality highly depends on the terrain Control Texture Resolution size."), GUILayout.Width(125) );
target.applySplatmap = EditorGUILayout.Toggle (target.applySplatmap);
EditorGUILayout.EndHorizontal();
if(target.applySplatmap){
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Terrain texture", "This represents the terrain texture which will be used for the road spatmap."), GUILayout.Width(125) );
target.splatmapLayer = EditorGUILayout.IntPopup (target.splatmapLayer, target.ODODQOQO, target.ODODQOQOInt, GUILayout.Width(120));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Expand"," Use this setting to increase the size of the splatmap."), GUILayout.Width(125) );
target.expand = EditorGUILayout.IntSlider(target.expand,0, 3, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Smooth Level"," Use this setting to blur the road splatmap for smoother results."), GUILayout.Width(125) );
target.splatmapSmoothLevel = EditorGUILayout.IntSlider (target.splatmapSmoothLevel, 0, 3, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Offset x"," Moves the road splatmap in the x direction."), GUILayout.Width(125) );
target.offsetX = EditorGUILayout.IntField (target.offsetX, GUILayout.Width(50));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Offset y"," Moves the road splatmap in the y direction."), GUILayout.Width(125) );
target.offsetY= EditorGUILayout.IntField (target.offsetY, GUILayout.Width(50));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Opacity","Use this setting to blend the road splatmap with the terrain splatmap."), GUILayout.Width(125) );
target.opacity = EditorGUILayout.Slider (target.opacity, 0, 1, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
GUILayout.Space(5);
GUI.enabled = target.OCDCOQDCDQ;
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Apply Changes", GUILayout.Width(175))){
target.OQCCOODCDO();

if(target.OOQDOOQQ)target.OQCCOODCDO();
target.OCDCOQDCDQ = false;
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
GUILayout.Space(5);
if(oldApplySplatmap != target.applySplatmap){
target.OQCCOODCDO();

if(target.OOQDOOQQ)target.OQCCOODCDO();
}
GUI.enabled = true;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Terrain Smoothing:", "This will smoothen the terrain near the surface edges according the below distance."), GUILayout.Width(175) );
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Edges (m)","This represents the smoothen distance."), GUILayout.Width(125) );
target.smoothDistance = EditorGUILayout.Slider (target.smoothDistance, 0, 5, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Update Edges", GUILayout.Width(175))){

#if UNITY_4_6
#elif UNITY_4_5
#elif UNITY_4_3
#else
Undo.RegisterUndo(OQCDOODQQQ.terrain.terrainData, "EasyRoads3D Terrain smooth");
#endif
target.OQCODQCQOC.OQQDCDQQDC(target.smoothDistance, 0);
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Surrounding (m)","This represents the smoothen distance."), GUILayout.Width(125) );
target.smoothSurDistance = EditorGUILayout.Slider (target.smoothSurDistance, 0, 15, GUILayout.Width(175));
EditorGUILayout.EndHorizontal();
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Update Surrounding", GUILayout.Width(175))){

#if UNITY_4_6
#elif UNITY_4_5
#elif UNITY_4_3
#else
Undo.RegisterUndo(OQCDOODQQQ.terrain.terrainData, "EasyRoads3D Terrain smooth");
#endif
target.OQCODQCQOC.OQQDCDQQDC(target.smoothSurDistance, 1);
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();

GUILayout.Box(" Cam Fly Over", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));
GUI.enabled = false;
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Position", ""), GUILayout.Width(75) );
var sp : float = target.splinePos;
target.splinePos = EditorGUILayout.Slider(target.splinePos, 0, 0.9999);
EditorGUILayout.EndHorizontal();
if(sp != target.splinePos){
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label(new GUIContent(" Height", ""), GUILayout.Width(75) );
sp = target.camHeight;
target.camHeight = EditorGUILayout.Slider(target.camHeight, 1, 10);
EditorGUILayout.EndHorizontal();
if(sp != target.camHeight){
}
GUI.enabled = true;
EditorGUILayout.Space();
}else if(target.ODDDQCOOQD == 4){
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();

GUILayout.Label(target.OQQOCCQOOC);
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(" EasyRoads3D v"+target.version);
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();

GUILayout.Label(" Version Type: Free Version", GUILayout.Height(22));
if(GUILayout.Button ("i", GUILayout.Width(22))){
Application.OpenURL ("http://www.unityterraintools.com");
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Help", GUILayout.Width(225))){
Application.OpenURL ("http://www.unityterraintools.com/manual.php");
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
GUI.skin = origSkin;
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box("Check out the full version if you had like to take advantage of all the features including the built-in paramatric modeling tool", GUILayout.Width(250));
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Get the Full Version", GUILayout.Width(225))){
// AssetStore.Open("http://u3d.as/content/anda-soft/easy-roads3d-pro/1Ch");
Application.OpenURL ("https://www.assetstore.unity3d.com/#/content/469");
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent(" Newsletter Sign Up:",""), GUILayout.Width(155) );
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent(" Name", ""), GUILayout.Width(75) );
target.uname = GUILayout.TextField(target.uname, GUILayout.Width(150));
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent(" Email", ""), GUILayout.Width(75) );
target.email = GUILayout.TextField(target.email, GUILayout.Width(150));
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if(GUILayout.Button ("Submit", GUILayout.Width(225))){
EditorUtility.DisplayDialog("Newsletter Signup", OCDDOQCCDD0.NewsletterSignUp(target.uname, target.email), "Ok");
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}else{
if(target.markers != target.OCCQOQDDDO.childCount){
target.ODDCCCQCOC();
}
EditorGUILayout.Space();
GUILayout.Box(" General Info", GUILayout.MinWidth(253), GUILayout.MaxWidth(1500), GUILayout.Height(20));

if(RoadObjectScript.objectStrings == null){
RoadObjectScript.objectStrings = new String[3];
RoadObjectScript.objectStrings[0] = "Road Object"; RoadObjectScript.objectStrings[1]="River Object";RoadObjectScript.objectStrings[2]="Procedural Mesh Object";
}
if(target.distance == "-1"){
var ar : String[] = target.OQCODQCQOC.ODQQQDDDCQ(-1);
target.distance = ar[0];
}
EditorGUILayout.Space();
GUILayout.Label(" Object Type: " + RoadObjectScript.objectStrings[target.objectType]);
if(target.objectType == 0) GUILayout.Label(" Total Road Distance: " + target.distance.ToString() + " km");
}
EditorGUILayout.Space();
if (GUI.tooltip != "") GUI.Label(new Rect(Input.mousePosition.x, Screen.height - Input.mousePosition.y, 200, 40), GUI.tooltip);
if (GUI.changed)
{
target.OCDCOQDCDQ = true;
}
return markerMenuDisplay;
}
function OOCDDQQOOD(fwd: Vector3, targetDir: Vector3, up: Vector3) : float {
var perp: Vector3 = Vector3.Cross(fwd, targetDir);
var dir: float = Vector3.Dot(perp, up);
if (dir > 0.0) {
return 1.0;
} else if (dir < 0.0) {
return -1.0;
} else {
return 0.0;
}
}
function OnScene(){
var cEvent : Event = Event.current;
if(target.OODQCOQQQQ != -1 && Event.current.shift) target.OQDDCQCCDQ[target.OODQCOQQQQ] = true;
if(target.OQDDCQCCDQ == null || target.OQDDCQCCDQ.Length == 0){
target.OQDDCQCCDQ = new boolean[5];
target.OODQCQCDQO = new boolean[5];
}
if((cEvent.shift && cEvent.type == EventType.mouseDown) || target.OQDDCQCCDQ[1])
{
var hit : RaycastHit;
var mPos : Vector2 = cEvent.mousePosition;
mPos.y = Screen.height - mPos.y - 40;
var ray : Ray = Camera.current.ScreenPointToRay(mPos);

if (Physics.Raycast (Camera.current.transform.position, ray.direction, hit, 3000))

{
if(target.OQDDCQCCDQ[0]){
go = target.OOOCOOQCOD(hit.point);
}
else if(target.OQDDCQCCDQ[1] && cEvent.type == EventType.mouseDown && cEvent.shift){

target.ODDCCQDCQC(hit.point, true);
}
else if(target.OQDDCQCCDQ[1] && cEvent.shift) target.ODDCCQDCQC(hit.point, false);
else if(target.handleInsertFlag) target.handleInsertFlag = target.OQCODQCQOC.OOOCDCQDOC();
Selection.activeGameObject = target.obj.gameObject;
}
}
if(cEvent.control && cEvent.alt && cEvent.type == EventType.mouseDown){
mPos = cEvent.mousePosition;
mPos.y = Screen.height - mPos.y - 40;
ray = Camera.current.ScreenPointToRay(mPos);
if (Physics.Raycast (Camera.current.transform.position, ray.direction, hit, 3000))
{
if(hit.collider.gameObject.GetComponent(typeof(Terrain)) != null){

var t : Terrain = hit.collider.gameObject.GetComponent(typeof(Terrain));
for(i = 0; i < OQCDOODQQQ.terrains.Length; i++){

if(t == OQCDOODQQQ.terrains){
if(OQCDOODQQQ.terrains.Length > 1)OQCDOODQQQ.selectedTerrain = i + 1;
else OQCDOODQQQ.selectedTerrain = i;
OQCDOODQQQ.OOODOQCOOQ();
EditorUtility.SetDirty (target);
}
}
}
}
}
if(target.OQCQDODCQQ != target.obj || target.obj.name != target.OQQODDQQOO){
target.OQCODQCQOC.OCQOQQOCCO();
target.OQCQDODCQQ = target.obj;
target.OQQODDQQOO = target.obj.name;
}
if(target.ODQDODOODQ != null){
target.OQCODQCQOC.OOOCDCQDOC();

}
if(target.transform.position != Vector3.zero) target.transform.position = Vector3.zero;
}
static function ODCDDDDDDQ() : boolean{

var flag : boolean = false;
var terrains : Terrain[] = MonoBehaviour.FindObjectsOfType(typeof(Terrain));
for(terrain in terrains) {
if(!terrain.gameObject.GetComponent(EasyRoads3DTerrainID)){
var terrainscript : EasyRoads3DTerrainID = terrain.gameObject.AddComponent("EasyRoads3DTerrainID");
var id : String = UnityEngine.Random.Range(100000000,999999999).ToString();
terrainscript.terrainid = id;
flag = true;

path = Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + id;
if( !Directory.Exists(path)){
try{
Directory.CreateDirectory( path);
}
catch(e:System.Exception)
{
Debug.Log("Could not create directory: " + path + " " + e);
}
}
if(Directory.Exists(path)){

}
}
}
}
static function OOQCOOQQDO(target){
EditorUtility.DisplayProgressBar("Build EasyRoads3D Object","Initializing", 0);

scripts = FindObjectsOfType(typeof(RoadObjectScript));
var rObj : List.<Transform> = new List.<Transform>();
for(script in scripts) {
if(script.transform != target.transform) rObj.Add(script.transform);
}
if(target.ODODQOQO == null){
target.ODODQOQO = target.OQCODQCQOC.ODDDCOQDCC();
target.ODODQOQOInt = target.OQCODQCQOC.OCDDCDCCQD();
}
target.OQDODQOODQ(0.5f, true, false);

if(OQCDOODQQQ.selectedTerrain == null || target.OQCODQCQOC.terrain == null)OQCDOODQQQ.OQOOCOCDDQ();
target.OQCODQCQOC.OCDCCOCOQO();

OQCDOODQQQ.OOCCDDOCCO(target.OQCODQCQOC.terrain, Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder + "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OQQODDQQOO+"_splatMap");

OOQDDDCQDD.ODQODDOOCC(target.OQCODQCQOC.terrain, Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OQQODDQQOO+"_heightmap.backup");
var hitOCOCCDOQQD : List.<tPoint> = target.OQCODQCQOC.OQCCCOQCOO(Vector3.zero, target.raise, target.obj, target.OOQDOOQQ, rObj, target.handleVegetation);
var changeArr : List.<Vector3> = new List.<Vector3>();
var stepsf : float = Mathf.Floor(hitOCOCCDOQQD.Count / 10);
var steps : int = Mathf.RoundToInt(stepsf);

for(i = 0; i < 10;i++){
changeArr = target.OQCODQCQOC.OOCDDDQQQD(hitOCOCCDOQQD, i * steps, steps, changeArr);
EditorUtility.DisplayProgressBar("Build EasyRoads3D Object","Updating Terrain", i * 10);
}

changeArr = target.OQCODQCQOC.OOCDDDQQQD(hitOCOCCDOQQD, 10 * steps, hitOCOCCDOQQD.Count - (10 * steps), changeArr);
target.OQCODQCQOC.OQCQCCCOOQ(changeArr, rObj);
if(target.OQCODQCQOC.handleVegetation){
target.OQCODQCQOC.OCCDDQCOCO();

path = Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OCDCQCDDDO.OQQODDQQOO;
OOCDCOQDQC.OQDDODQOOQ(Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder);
OOCDCOQDQC.OQDDODQOOQ(Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain));
OOQDDDCQDD.ODCDDCDCQD(target.OQCODQCQOC.OQQDCCOCCO.ToArray(), target.OQCODQCQOC.ODQDDQQOQQ, path);
}

target.OQCCOODCDO();

target.OQCODQCQOC.ODODDCCCQC(target.transform, true);
target.OQCODQCQOC.OOCCQQODQO();
EditorUtility.ClearProgressBar();

}
function OCOCCCDDDO(target){
EditorUtility.DisplayProgressBar("Restore EasyRoads3D Object","Restoring terrain data", 0f);
target.OQDODQOODQ(target.geoResolution, false, false);

if(target.OQCODQCQOC.OQQQOODDCC != null && target.OQCODQCQOC != null){
if(target.OQCODQCQOC.editRestore && File.Exists(Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OQQODDQQOO+"_heightmap.backup")){
OOQDDDCQDD.OCDDQCDODO(target.OQCODQCQOC.terrain, Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OQQODDQQOO+"_heightmap.backup");
}else if(target.OQCODQCQOC.editRestore){
Debug.LogWarning("The original terrain heightmap data file was not found. If necessary you may restore the terrain data by using Undo or, if the terrain backup is up to date, through the EasyRoads3D Menu");
}
}

if(target.OQCODQCQOC != null){
target.OQCODQCQOC.OQCODQODOQ();
if(target.OQCODQCQOC.handleVegetation && target.OQCODQCQOC.editRestore){
if(target.OQCODQCQOC.OQQDCCOCCO != null){
if(target.OQCODQCQOC.OQQDCCOCCO.Count == 0){
// get treeData from file
path = Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OQQODDQQOO;
target.OQCODQCQOC.OQQDCCOCCO = OOQDDDCQDD.ODCCCCQQCQ(path);
}
if(target.OQCODQCQOC.OQQDCCOCCO != null) target.OQCODQCQOC.OCCOCQQDOO();

if(target.OQCODQCQOC.ODQDDQQOQQ.Count == 0){
// get detailData from file

path = Directory.GetCurrentDirectory() + OOCDCOQDQC.backupFolder+ "/" + OQCDOODQQQ.OCCQOOCOCQ(target.OQCODQCQOC.terrain) + "/"+target.OQCODQCQOC.OQQODDQQOO;
target.OQCODQCQOC.ODQDDQQOQQ = OOQDDDCQDD.ODQQDOCODQ(path);

}
if(target.OQCODQCQOC.ODQDDQQOQQ != null) target.OQCODQCQOC.OQCDDCCCOD();
}
}
}
target.ODODDDOO = false;

EditorUtility.ClearProgressBar();
}
}

I don't know anything about script. I just want to build my player, so I can publish my game Online for people to play

LaneFox · Mar 11, 2015

There actually aren't any errors there, those are warnings. Have you actually read them?

Please, calm down and form a coherent post. Use code tags when posting code.

If builds fail, post the errors that the build failure returns.

Michaelm9945 · Mar 11, 2015

The build failure returns this warning

Assets/Lux/Lux Scripts/Lux Cubemapper/Scripts/LuxCubeProcessor.cs(1040,8): error CS8025: Parsing error

And this is the script

Code (CSharp):

// ////////////////////

// Lux LuxCubeProcessor

// http://seblagarde.wordpress.com/2012/06/10/amd-cubemapgen-for-physically-based-rendering/

using UnityEngine;

#if UNITY_EDITOR

using UnityEditor;

#endif

public enum ConvoModes

{

Diffuse = 0,

Specular = 1

}

//public class LuxCubeProcessor : ScriptableWizard {

public class LuxCubeProcessor {

public Cubemap cubeMap;

public bool TakeNewProbe;

public GameObject probe;

public ConvoModes ConvolutionMode;

public bool HighestMipIsReflection = true;

public bool PullHDR;

private Color[] CubeMapColors;

public float SpecularPower = 2048; // Matches Lux SpecPower

#if UNITY_EDITOR

//--------------------------------------------------------------------------------------

// parameter, vars and arrays needed by the script

private float[] solidAngles;

private static float CP_PI = 3.14159265358979323846f;

// matrices that map cube map indexing vectors in 3d (after face selection and divide through by the _ABSOLUTE VALUE_ of the max coord) into NVC space

// Note this currently assumes the D3D cube face ordering and orientation

private Vector3[ , ] sgFace2DMapping = new Vector3[ , ] {

//XPOS face 0

{ new Vector3( 0, 0, -1), //u towards negative Z

new Vector3( 0, -1, 0), //v towards negative Y

new Vector3( 1, 0, 0)}, //pos X axis

//XNEG face 1

{ new Vector3( 0, 0, 1), //u towards positive Z

new Vector3( 0, -1, 0), //v towards negative Y

new Vector3( -1, 0, 0)}, //neg X axis

//YPOS face 2

{ new Vector3(1, 0, 0), //u towards positive X

new Vector3(0, 0, 1), //v towards positive Z

new Vector3(0, 1 , 0)}, //pos Y axis

//YNEG face 3

{ new Vector3(1, 0, 0), //u towards positive X

new Vector3(0, 0 , -1), //v towards negative Z

new Vector3(0, -1 , 0)}, //neg Y axis

//ZPOS face 4

{ new Vector3(1, 0, 0), //u towards positive X

new Vector3(0, -1, 0), //v towards negative Y

new Vector3(0, 0, 1)}, //pos Z axis

//ZNEG face 5

{ new Vector3(-1, 0, 0), //u towards negative X

new Vector3(0, -1, 0), //v towards negative Y

new Vector3(0, 0, -1)} //neg Z axis

};

//The 12 edges of the cubemap

// this table is used to average over the edges.

private int[ , ] sg_CubeEdgeList = new int[ , ] {

// face1, face2

{0,2}, // X_POS Y_POS

{0,3}, // X_POS Y_NEG

{0,4}, // X_POS Z_POS

{0,5}, // X_POS Z_NEG

{1,2}, // X_NEG Y_POS

{1,3}, // X_NEG Y_NEG

{1,4}, // X_NEG Z_POS

{1,5}, // X_NEG Z_NEG

{2,4}, // Y_POS Z_POS

{2,5}, // Y_POS Z_NEG

{3,4}, // Y_NEG Z_POS

{3,5} // Y_NEG Z_NEG

};

private int[ , ] sg_CubeCornerList = new int[ , ] {

// face1, face2, face3

{0,2,4}, // X_POS Y_POS Z_POS

{0,2,5}, // X_POS Y_POS Z_NEG

{0,3,4}, // X_POS Y_NEG Z_POS

{0,3,5}, // X_POS Y_NEG Z_NEG

{1,2,4}, // X_NEG Y_POS Z_POS

{1,2,5}, // X_NEG Y_POS Z_NEG

{1,3,4}, // X_NEG Y_NEG Z_POS

{1,3,5}, // X_NEG Y_NEG Z_NEG

};

//--------------------------------------------------------------------------------------

// Helper for Cubemapper Probe

public void ProcessCubemap(Cubemap cube, bool diff, bool hdr)

{

if (diff)

{

ConvolveIrradianceEnvironmentMap(cube);

if (hdr) FakeHDR(cube, false);

Debug.Log("Diff Cube Processed");

}

else

{

ConvolveRadianceEnvironmentMap(cube);

FixupCubeEdges(cube);

if (hdr) FakeHDR(cube, true);

cube.filterMode = FilterMode.Trilinear;

cube.mipMapBias = 0.5f;

Debug.Log("Spec Cube Processed");

}

}

//[MenuItem ("Lux Cubemapper/Cubemapper")]

//static void CreateWizard () {

// ScriptableWizard.DisplayWizard<LuxCubeMapper>("Convolve cubemap", "Go");

//}

//void OnWizardCreate () {

// if (TakeNewProbe) RenderToCubeMap(cubeMap,probe);

// // diffuse

// if (ConvolutionMode == ConvoModes.Diffuse) {

// ConvolveIrradianceEnvironmentMap (cubeMap);

// if (PullHDR) FakeHDR(cubeMap, false);

// }

// if (ConvolutionMode == ConvoModes.Specular) {

// ConvolveRadianceEnvironmentMap (cubeMap);

// FixupCubeEdges(cubeMap);

// if (PullHDR) FakeHDR(cubeMap, true);

// cubeMap.filterMode = FilterMode.Trilinear;

// cubeMap.mipMapBias = 0.5f;

// }

//}

//void OnWizardUpdate () {

//}

//void RenderToCubeMap(Cubemap dest, GameObject probe) {

// var cubeCamera = new GameObject( "CubemapCamera", typeof(Camera) ) as GameObject;

//// cubeCamera.hideFlags = HideFlags.HideInHierarchy;

// var cubeCam = cubeCamera.GetComponent("Camera") as Camera;

// cubeCam.nearClipPlane = 0.001f;

// cubeCam.farClipPlane = 1000.0f;

// cubeCam.aspect = 1.0f;

//// cubeCam.hdr = true;

// cubeCam.cullingMask = 1 << 0;

// cubeCamera.transform.position = probe.transform.position;

// cubeCam.RenderToCubemap(dest);

// GameObject.DestroyImmediate(cubeCamera);

//}

//--------------------------------------------------------------------------------------

// ConvolveRadianceEnvironmentMap

void ConvolveRadianceEnvironmentMap (Cubemap RadianceCube) {

int a_Size = RadianceCube.width;

int n_Size = a_Size;

int startMipLevel = 0;

float specularPower;

float[] specPowr = new float [] {

SpecularPower, SpecularPower/2.0f, SpecularPower/4.0f, SpecularPower/8.0f, SpecularPower/16.0f, SpecularPower/32.0f, SpecularPower/64.0f, SpecularPower/128.0f, SpecularPower/256.0f, SpecularPower/512.0f

};

// Calculate maxmiplevels

int maxMipLevels = (int)Mathf.Log(a_Size, 2) + 1;

//

float mytime = Time.realtimeSinceStartup;

// if HighestMipIsReflection == true then skip processing of the highest mip level

if (HighestMipIsReflection) {

startMipLevel = 1;

n_Size = n_Size >> 1;

}

for (int mipLevel = startMipLevel; mipLevel < maxMipLevels; mipLevel++)

{

Vector4[] m_NormCubeMapArray = new Vector4[n_Size*n_Size*6];

BuildNormalizerSolidAngleArray(n_Size, ref m_NormCubeMapArray);

specularPower = specPowr[mipLevel];

float Angle;

// If we use SpecularPower, automatically calculate the a_BaseFilterAngle required, this will speed the process

Angle = GetBaseFilterAngle(specularPower);

// Go for it:

FilterCubefaces(RadianceCube, m_NormCubeMapArray, mipLevel, Angle, specularPower);

// FilterCubefacesBF(RadianceCube, mipLevel, Angle, specularPower);

n_Size = n_Size >> 1;

}

//

Debug.Log(Time.realtimeSinceStartup - mytime);

RadianceCube.Apply(false);

}

void FilterCubefaces (Cubemap RadianceCubeMap, Vector4[] m_NormCubeMapArray, int mipLevel, float a_FilterConeAngle, float a_SpecularPower)

{

// Read the first CubeFace

Color[] InputCubeFacePixels = RadianceCubeMap.GetPixels(CubemapFace.PositiveX, mipLevel);

// Get its dimensions

int faceLength = InputCubeFacePixels.Length;

int a_Size = (int)Mathf.Sqrt(faceLength);

// Create new array for all Faces

Color[] PixelsOfAllFaces = new Color[faceLength * 6];

// Copy first face

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, 0);

// Copy all other Faces

for (int readFace = 1; readFace < 6; readFace++ ) {

InputCubeFacePixels = RadianceCubeMap.GetPixels((CubemapFace)readFace, mipLevel);

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, faceLength * readFace);

}

InputCubeFacePixels = null;

// Declare jagged output array and init its child arrays

Color[][] OutputCubeFacePixels = new Color[6][];

OutputCubeFacePixels[0] = new Color[faceLength];

OutputCubeFacePixels[1] = new Color[faceLength];

OutputCubeFacePixels[2] = new Color[faceLength];

OutputCubeFacePixels[3] = new Color[faceLength];

OutputCubeFacePixels[4] = new Color[faceLength];

OutputCubeFacePixels[5] = new Color[faceLength];

// FilterCubeSurfaces

float srcTexelAngle;

float dotProdThresh;

int filterSize;

// Angle about center tap to define filter cone

float filterAngle;

// Min angle a src texel can cover (in degrees)

srcTexelAngle = (180.0f / CP_PI) * Mathf.Atan2(1.0f, (float)a_Size);

// Filter angle is 1/2 the cone angle

filterAngle = a_FilterConeAngle / 2.0f;

// Ensure filter angle is larger than a texel

if(filterAngle < srcTexelAngle)

{

filterAngle = srcTexelAngle;

}

// Ensure filter cone is always smaller than the hemisphere

if(filterAngle > 90.0f)

{

filterAngle = 90.0f;

}

// The maximum number of texels in 1D the filter cone angle will cover

// Used to determine bounding box size for filter extents

filterSize = (int)Mathf.Ceil(filterAngle / srcTexelAngle);

// Ensure conservative region always covers at least one texel

if(filterSize < 1)

{

filterSize = 1;

}

// dotProdThresh threshold based on cone angle to determine whether or not taps

// Reside within the cone angle

dotProdThresh = Mathf.Cos( (CP_PI / 180.0f) * filterAngle );

// Process required faces

for (int a_FaceIdx = 0; a_FaceIdx < 6; a_FaceIdx++)

{

// Iterate over dst cube map face texel

for (int a_V = 0; a_V < a_Size; a_V++)

{

for (int a_U = 0; a_U < a_Size; a_U++)

{

Vector4 Sample = new Vector4();

Color tempCol = new Color();

// Get center tap direction

Vector3 centerTapDir = TexelToVect(a_FaceIdx, (float)a_U, (float)a_V, a_Size);

//--------------------------------------------------------------------------------------

// ProcessFilterExtents

float weightAccum = 0.0f;

int startFacePtr = 0;

// Iterate over cubefaces

for(int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++ )

{

// Pointer to the start of the given face

startFacePtr = a_Size*a_Size*iFaceIdx;

for(int v = 0; v < a_Size; v++)

{

for(int u = 0; u < a_Size; u++)

{

// CP_FILTER_TYPE_COSINE_POWER

// Read normalCube single "pixel"

Vector4 m_NormCubeMap_pixel = m_NormCubeMapArray[startFacePtr + a_Size*v + u];

// Pointer to direction in cube map associated with texel

// Vector3 texelVect = TexelToVect(iFaceIdx, (float)u, (float)v, a_Size);

Vector3 texelVect;

// Optimized version

texelVect.x = m_NormCubeMap_pixel[0];// * 2.0f - 1.0f;

texelVect.y = m_NormCubeMap_pixel[1];// * 2.0f - 1.0f;

texelVect.z = m_NormCubeMap_pixel[2];// * 2.0f - 1.0f;

// Check dot product to see if texel is within cone

float tapDotProd = Vector3.Dot(texelVect, centerTapDir);

float weight = 0.0f;

if( tapDotProd >= dotProdThresh && tapDotProd > 0.0f )

{

// Weight should be proportional to the solid angle of the tap

// weight = TexelCoordSolidAngle(iFaceIdx, (float)u, (float)v, a_Size);

weight = m_NormCubeMap_pixel[3];

// Here we decide if we use a Phong/Blinn or a Phong/Blinn BRDF.

// Phong/Blinn BRDF is just the Phong/Blinn model multiply by the cosine of the lambert law

// so just adding one to specularpower do the trick.

// weight *= pow(tapDotProd, (a_SpecularPower + (float32)IsPhongBRDF));

// CP_FILTER_TYPE_COSINE_POWER

weight *= Mathf.Pow(tapDotProd, a_SpecularPower);

// CP_FILTER_TYPE_COSINE

//weight *= tapDotProd;

}

// Accumulate weight

weightAccum += weight;

// Get pixel from the input cubeMap array

tempCol = PixelsOfAllFaces[a_Size*a_Size*iFaceIdx + a_Size*v + u];

Sample += new Vector4(tempCol.r * weight, tempCol.g * weight, tempCol.b * weight, 1.0f);

}

}

}

// one pixel processed

// Lux needs alpha!

OutputCubeFacePixels[a_FaceIdx][a_V*a_Size + a_U] = new Color(Sample.x/ weightAccum, Sample.y/ weightAccum, Sample.z/ weightAccum, 1.0f);

// end inner loops

}

}

}

// Write Pixel from the jagged array back to the cubemap faces

for (int writeFace = 0; writeFace < 6; writeFace++ ) {

Color[] tempColors = OutputCubeFacePixels[writeFace];

RadianceCubeMap.SetPixels(tempColors, (CubemapFace)writeFace, mipLevel);

}

}

// brute force: no look up table used

void FilterCubefacesBF (Cubemap RadianceCubeMap, int mipLevel, float a_FilterConeAngle, float a_SpecularPower)

{

// Read the first CubeFace

Color[] InputCubeFacePixels = RadianceCubeMap.GetPixels(CubemapFace.PositiveX, mipLevel);

// Get its dimensions

int faceLength = InputCubeFacePixels.Length;

int a_Size = (int)Mathf.Sqrt(faceLength);

// Create new array for all Faces

Color[] PixelsOfAllFaces = new Color[faceLength * 6];

// Copy first face

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, 0);

// Copy all other Faces

for (int readFace = 1; readFace < 6; readFace++ ) {

InputCubeFacePixels = RadianceCubeMap.GetPixels((CubemapFace)readFace, mipLevel);

InputCubeFacePixels.CopyTo(PixelsOfAllFaces, faceLength * readFace);

}

InputCubeFacePixels = null;

// declare jagged output array and init its child arrays

Color[][] OutputCubeFacePixels = new Color[6][];

OutputCubeFacePixels[0] = new Color[faceLength];

OutputCubeFacePixels[1] = new Color[faceLength];

OutputCubeFacePixels[2] = new Color[faceLength];

OutputCubeFacePixels[3] = new Color[faceLength];

OutputCubeFacePixels[4] = new Color[faceLength];

OutputCubeFacePixels[5] = new Color[faceLength];

// FilterCubeSurfaces

float srcTexelAngle;

float dotProdThresh;

int filterSize;

//angle about center tap to define filter cone

float filterAngle;

//min angle a src texel can cover (in degrees)

srcTexelAngle = (180.0f / CP_PI) * Mathf.Atan2(1.0f, (float)a_Size);

//filter angle is 1/2 the cone angle

filterAngle = a_FilterConeAngle / 2.0f;

//ensure filter angle is larger than a texel

if(filterAngle < srcTexelAngle)

{

filterAngle = srcTexelAngle;

}

//ensure filter cone is always smaller than the hemisphere

if(filterAngle > 90.0f)

{

filterAngle = 90.0f;

}

// The maximum number of texels in 1D the filter cone angle will cover

// Used to determine bounding box size for filter extents

filterSize = (int)Mathf.Ceil(filterAngle / srcTexelAngle);

// Ensure conservative region always covers at least one texel

if(filterSize < 1)

{

filterSize = 1;

}

// dotProdThresh threshold based on cone angle to determine whether or not taps

// Reside within the cone angle

dotProdThresh = Mathf.Cos( (CP_PI / 180.0f) * filterAngle );

// Process required faces

for (int a_FaceIdx = 0; a_FaceIdx < 6; a_FaceIdx++)

{

// Iterate over dst cube map face texel

for (int a_V = 0; a_V < a_Size; a_V++)

{

for (int a_U = 0; a_U < a_Size; a_U++)

{

Vector4 Sample = new Vector4();

Color tempCol = new Color();

// get center tap direction

Vector3 centerTapDir = TexelToVect(a_FaceIdx, (float)a_U, (float)a_V, a_Size);

//--------------------------------------------------------------------------------------

// ProcessFilterExtents

float weightAccum = 0.0f;

// Iterate over cubefaces

for(int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++ )

{

for(int v = 0; v < a_Size; v++)

{

for(int u = 0; u < a_Size; u++)

{

// CP_FILTER_TYPE_COSINE_POWER

// Pointer to direction in cube map associated with texel

Vector3 texelVect = TexelToVect(iFaceIdx, (float)u, (float)v, a_Size);

// Check dot product to see if texel is within cone

float tapDotProd = Vector3.Dot(texelVect, centerTapDir);

float weight = 0.0f;

if( tapDotProd >= dotProdThresh && tapDotProd > 0.0f )

{

// Weight should be proportional to the solid angle of the tap

weight = TexelCoordSolidAngle(iFaceIdx, (float)u, (float)v, a_Size);

// Here we decide if we use a Phong/Blinn or a Phong/Blinn BRDF.

// Phong/Blinn BRDF is just the Phong/Blinn model multiply by the cosine of the lambert law

// so just adding one to specularpower do the trick.

// weight *= pow(tapDotProd, (a_SpecularPower + (float32)IsPhongBRDF));

// CP_FILTER_TYPE_COSINE_POWER

weight *= Mathf.Pow(tapDotProd, a_SpecularPower);

// CP_FILTER_TYPE_COSINE

//weight *= tapDotProd;

}

// Accumulate weight

weightAccum += weight;

// Get pixel from the input cubeMap array

tempCol = PixelsOfAllFaces[a_Size*a_Size*iFaceIdx + a_Size*v + u];

Sample += new Vector4(tempCol.r * weight, tempCol.g * weight, tempCol.b * weight, 1.0f);

}

}

}

// one pixel processed

// Lux needs alpha!

OutputCubeFacePixels[a_FaceIdx][a_V*a_Size + a_U] = new Color(Sample.x/ weightAccum, Sample.y/ weightAccum, Sample.z/ weightAccum, 1.0f);

// end inner loops

}

}

}

// Write Pixel from the jagged array back to the cubemap faces

for (int writeFace = 0; writeFace < 6; writeFace++ ) {

Color[] tempColors = OutputCubeFacePixels[writeFace];

RadianceCubeMap.SetPixels(tempColors, (CubemapFace)writeFace, mipLevel);

}

}

//--------------------------------------------------------------------------------------

// Irridiance Convolution based on SH

void ConvolveIrradianceEnvironmentMap(Cubemap irrCubeMap)

{

int a_Size = irrCubeMap.width;

Vector4[] m_NormCubeMapArray = new Vector4[a_Size*a_Size*6];

BuildNormalizerSolidAngleArray(a_Size, ref m_NormCubeMapArray);

//This is a custom implementation of D3DXSHProjectCubeMap to avoid to deal with LPDIRECT3DSURFACE9 pointer

//Use Sh order 2 for a total of 9 coefficient as describe in http://www.cs.berkeley.edu/~ravir/papers/envmap/

//accumulators are 64-bit floats in order to have the precision needed

//over a summation of a large number of pixels

double[] SHr = new double[25]; // NUM_SH_COEFFICIENT

double[] SHg = new double[25];

double[] SHb = new double[25];

double[] SHdir = new double[25];

double weightAccum = 0.0;

double weight = 0.0;

int startFacePtr = 0;

for (int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++) {

// read pixels of m_NormCubeMap

//var m_NormCubeMap_pixels = new Color[m_NormCubeMap.width*m_NormCubeMap.height];

//m_NormCubeMap_pixels = m_NormCubeMap.GetPixels((CubemapFace)iFaceIdx);

// Pointer to the start of the given face in m_NormCubeMapArray

startFacePtr = a_Size*a_Size*iFaceIdx;

// read all pixels of irrCubeMap

var cubeMap_pixels = new Color[irrCubeMap.width * irrCubeMap.height];

cubeMap_pixels = irrCubeMap.GetPixels((CubemapFace)iFaceIdx);

for (int y = 0; y < a_Size; y++) {

for (int x = 0; x < a_Size; x++) {

// read normalCube single pixel

Vector4 m_NormCubeMap_pixel = m_NormCubeMapArray[startFacePtr + y*a_Size + x];

// read originalCube single pixel

Color cubeMap_pixel = cubeMap_pixels[y*a_Size + x];

// solid angle stored in 4th channel of normalizer/solid angle cube map

weight = m_NormCubeMap_pixel[3];

//weight = TexelCoordSolidAngle(iFaceIdx, (float)x, (float)y, a_Size);

// pointer to direction and solid angle in cube map associated with texel

Vector3 texelVect;

texelVect.x = m_NormCubeMap_pixel[0];

texelVect.y = m_NormCubeMap_pixel[1];

texelVect.z = m_NormCubeMap_pixel[2];

//texelVect = TexelToVect(iFaceIdx, (float)x, (float)y, a_Size);

EvalSHBasis(texelVect, ref SHdir);

// read original colors and convert to float64

double R = cubeMap_pixel[0];

double G = cubeMap_pixel[1];

double B = cubeMap_pixel[2];

for (int i = 0; i < 25; i++)

{

SHr[i] += R * SHdir[i] * weight;

SHg[i] += G * SHdir[i] * weight;

SHb[i] += B * SHdir[i] * weight;

}

weightAccum += weight;

}

}

}

// Normalization - The sum of solid angle should be equal to the solid angle of the sphere (4 PI), so

// Normalize in order our weightAccum exactly match 4 PI.

for (int i = 0; i < 25; ++i)

{

SHr[i] *= 4.0 * CP_PI / weightAccum;

SHg[i] *= 4.0 * CP_PI / weightAccum;

SHb[i] *= 4.0 * CP_PI / weightAccum;

}

// Second step - Generate cubemap from SH coefficient

// Normalized vectors per cubeface and per-texel solid angle

// Why do we do it a 2nd time????

BuildNormalizerSolidAngleArray(a_Size, ref m_NormCubeMapArray);

for (int iFaceIdx = 0; iFaceIdx < 6; iFaceIdx++) {

// Pointer to the start of the given face in m_NormCubeMapArray

startFacePtr = a_Size*a_Size*iFaceIdx;

for (int y = 0; y < a_Size; y++) {

for (int x = 0; x < a_Size; x++) {

// read normalCube pixel

Vector4 m_NormCubeMap_pixel = m_NormCubeMapArray[startFacePtr + y*a_Size + x];

// read normalvector and pass it to EvalSHBasis to get SHdir

Vector3 texelVect;

texelVect.x = m_NormCubeMap_pixel[0];

texelVect.y = m_NormCubeMap_pixel[1];

texelVect.z = m_NormCubeMap_pixel[2];

//texelVect = TexelToVect(iFaceIdx, (float)x, (float)y, a_Size);

EvalSHBasis( texelVect, ref SHdir);

// set color values

double R = 0.0;

double G = 0.0;

double B = 0.0;

for (int i = 0; i < 25; ++i)

{

R += (SHr[i] * SHdir[i] * SHBandFactor[i]);

G += (SHg[i] * SHdir[i] * SHBandFactor[i]);

B += (SHb[i] * SHdir[i] * SHBandFactor[i]);

}

// Lux needs alpha!

irrCubeMap.SetPixel((CubemapFace)iFaceIdx, x, y, new Color((float)R,(float)G,(float)B, 1.0f ));

}

}

}

irrCubeMap.Apply();

}

//--------------------------------------------------------------------------------------

// This function return the BaseFilterAngle require by cubemapgen to its FilterExtends

// It allow to optimize the texel to access base on the specular power.

static float GetBaseFilterAngle(float cosinePower)

{

// We want to find the alpha such that:

// cos(alpha)^cosinePower = epsilon

// That's: acos(epsilon^(1/cosinePower))

const float threshold = 0.000001f; // Empirical threshold (Work perfectly, didn't check for a more big number, may get some performance and still god approximation)

float Angle = 180.0f;

if (Angle != 0.0f)

{

Angle = Mathf.Acos(Mathf.Pow(threshold, 1.0f / cosinePower));

Angle *= 180.0f / CP_PI; // Convert to degree

Angle *= 2.0f; // * 2.0f because cubemapgen divide by 2 later

}

return Angle;

}

//--------------------------------------------------------------------------------------

// Convert cubemap face texel coordinates and face idx to 3D vector

Vector3 TexelToVect(int a_FaceIdx, float a_U, float a_V, int a_Size) {

float nvcU, nvcV;

nvcU = (2.0f * ((float)a_U + 0.5f) / (float)a_Size ) - 1.0f;

nvcV = (2.0f * ((float)a_V + 0.5f) / (float)a_Size ) - 1.0f;

// U contribution

Vector3 Dir = sgFace2DMapping[a_FaceIdx, 0] * nvcU;

// V contribution

Vector3 tempVec = sgFace2DMapping[a_FaceIdx, 1] * nvcV;

Dir += tempVec;

// Add face axis

Dir += sgFace2DMapping[a_FaceIdx, 2];

// Normalize vector

Dir = Vector3.Normalize(Dir);

return(Dir);

}

//--------------------------------------------------------------------------------------

// Convert 3D vector to cubemap face texel coordinates and face idx

private Vector3 VectToTexelCoord(Vector3 a_XYZ, int a_Size) {

float nvcU, nvcV;

float maxCoord;

Vector3 onFaceXYZ;

int faceIdx;

float u, v;

// Get Absolute value

Vector3 absXYZ = new Vector3(Mathf.Abs(a_XYZ.x), Mathf.Abs(a_XYZ.y), Mathf.Abs(a_XYZ.z));

if( (absXYZ[0] >= absXYZ[1]) && (absXYZ[0] >= absXYZ[2]) )

{

maxCoord = absXYZ[0];

if(a_XYZ[0] >= 0) faceIdx = 0; // face = XPOS -> FACE_X_POS

else faceIdx = 1; // FACE_X_NEG;

}

else if ( (absXYZ[1] >= absXYZ[0]) && (absXYZ[1] >= absXYZ[2]) )

{

maxCoord = absXYZ[1];

if(a_XYZ[1] >= 0) faceIdx = 2; // face = XPOS -> FACE_Y_POS

else faceIdx = 3; // FACE_Y_NEG;

}

else

{

maxCoord = absXYZ[2];

if(a_XYZ[2] >= 0) faceIdx = 4; // face = XPOS -> FACE_Z_POS

else faceIdx = 5; // FACE_Z_NEG;

}

// Divide through by max coord so face vector lies on cube face

onFaceXYZ = a_XYZ * 1.0f/maxCoord;

nvcU = Vector3.Dot(sgFace2DMapping[faceIdx, 0] , onFaceXYZ ); // U-Direction

nvcV = Vector3.Dot(sgFace2DMapping[faceIdx, 1] , onFaceXYZ ); // V-Direction

// Modify original AMD code to return value from 0 to Size - 1

// As we will sample multiple pixels we skip (int)Mathf.Floor here

u = (a_Size - 1) * 0.5f * (nvcU + 1.0f);

v = (a_Size - 1) * 0.5f * (nvcV + 1.0f);

a_XYZ.x = faceIdx;

a_XYZ.y = u;

a_XYZ.z = v;

return a_XYZ;

}

//--------------------------------------------------------------------------------------

// Compute solid angle of given texel in cubemap face for weighting taps in the

// kernel by the area they project to on the unit sphere.

// Original code from Ignacio Castaño

float TexelCoordSolidAngle(int a_FaceIdx, float a_U, float a_V, int faceSize)

{

// Scale up to [-1, 1] range (inclusive), offset by 0.5 to point to texel center.

float U = (2.0f * ((float)a_U + 0.5f) / (float)faceSize ) - 1.0f;

float V = (2.0f * ((float)a_V + 0.5f) / (float)faceSize ) - 1.0f;

float InvResolution = 1.0f / faceSize;

// U and V are the -1..1 texture coordinate on the current face.

// Get projected area for this texel

float x0 = U - InvResolution;

float y0 = V - InvResolution;

float x1 = U + InvResolution;

float y1 = V + InvResolution;

float SolidAngle = AreaElement(x0, y0) - AreaElement(x0, y1) - AreaElement(x1, y0) + AreaElement(x1, y1);

// Returns values between 0.001 and 0.009

// So lets multiply it by 100.0f

return SolidAngle * 100.0f;

}

static float AreaElement( float x, float y )

{

return Mathf.Atan2(x * y, Mathf.Sqrt(x * x + y * y + 1));

}

//--------------------------------------------------------------------------------------

// Fixup cube edges

void FixupCubeEdges (Cubemap CubeMap)

{

int maxMipLevels = (int)(Mathf.Log((float)CubeMap.width, 2.0f)) + 1;

int base_Size = CubeMap.width;

// Do not perform any edge fixed for mip level 0

for (int mipLevel = 1; mipLevel < maxMipLevels; mipLevel++)

{

// declare jagged array for all faces and init its child arrays

Color[][] PixelsOfAllFaces = new Color[6][];

PixelsOfAllFaces[0] = CubeMap.GetPixels(CubemapFace.PositiveX, mipLevel);

PixelsOfAllFaces[1] = CubeMap.GetPixels(CubemapFace.NegativeX, mipLevel);

PixelsOfAllFaces[2] = CubeMap.GetPixels(CubemapFace.PositiveY, mipLevel);

PixelsOfAllFaces[3] = CubeMap.GetPixels(CubemapFace.NegativeY, mipLevel);

PixelsOfAllFaces[4] = CubeMap.GetPixels(CubemapFace.PositiveZ, mipLevel);

PixelsOfAllFaces[5] = CubeMap.GetPixels(CubemapFace.NegativeZ, mipLevel);

int a_Size = base_Size >> mipLevel;

// As we use a_Size as pointer in our arrays we have to lower it by 1

a_Size -= 1;

int a_FixupWidth = 3;

int fixupDist = (int)Mathf.Min( a_FixupWidth, a_Size / 2);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[0,0]], PixelsOfAllFaces[sg_CubeCornerList[0,1]], PixelsOfAllFaces[sg_CubeCornerList[0,2]], 0, 0, a_Size, a_Size, a_Size, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[1,0]], PixelsOfAllFaces[sg_CubeCornerList[1,1]], PixelsOfAllFaces[sg_CubeCornerList[1,2]], a_Size, 0, a_Size, 0, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[2,0]], PixelsOfAllFaces[sg_CubeCornerList[2,1]], PixelsOfAllFaces[sg_CubeCornerList[2,2]], 0, a_Size, a_Size, 0, a_Size, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[3,0]], PixelsOfAllFaces[sg_CubeCornerList[3,1]], PixelsOfAllFaces[sg_CubeCornerList[3,2]], a_Size, a_Size, a_Size, a_Size, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[4,0]], PixelsOfAllFaces[sg_CubeCornerList[4,1]], PixelsOfAllFaces[sg_CubeCornerList[4,2]], a_Size, 0, 0, a_Size, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[5,0]], PixelsOfAllFaces[sg_CubeCornerList[5,1]], PixelsOfAllFaces[sg_CubeCornerList[5,2]], 0, 0, 0, 0, a_Size, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[6,0]], PixelsOfAllFaces[sg_CubeCornerList[6,1]], PixelsOfAllFaces[sg_CubeCornerList[6,2]], a_Size, a_Size, 0, 0, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[7,0]], PixelsOfAllFaces[sg_CubeCornerList[7,1]], PixelsOfAllFaces[sg_CubeCornerList[7,2]], 0, a_Size, 0, a_Size, a_Size, a_Size);

// Perform 2nd iteration in reverse order

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[7,0]], PixelsOfAllFaces[sg_CubeCornerList[7,1]], PixelsOfAllFaces[sg_CubeCornerList[7,2]], 0, a_Size, 0, a_Size, a_Size, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[6,0]], PixelsOfAllFaces[sg_CubeCornerList[6,1]], PixelsOfAllFaces[sg_CubeCornerList[6,2]], a_Size, a_Size, 0, 0, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[5,0]], PixelsOfAllFaces[sg_CubeCornerList[5,1]], PixelsOfAllFaces[sg_CubeCornerList[5,2]], 0, 0, 0, 0, a_Size, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[4,0]], PixelsOfAllFaces[sg_CubeCornerList[4,1]], PixelsOfAllFaces[sg_CubeCornerList[4,2]], a_Size, 0, 0, a_Size, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[3,0]], PixelsOfAllFaces[sg_CubeCornerList[3,1]], PixelsOfAllFaces[sg_CubeCornerList[3,2]], a_Size, a_Size, a_Size, a_Size, 0, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[2,0]], PixelsOfAllFaces[sg_CubeCornerList[2,1]], PixelsOfAllFaces[sg_CubeCornerList[2,2]], 0, a_Size, a_Size, 0, a_Size, a_Size);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[1,0]], PixelsOfAllFaces[sg_CubeCornerList[1,1]], PixelsOfAllFaces[sg_CubeCornerList[1,2]], a_Size, 0, a_Size, 0, 0, 0);

AverageCorner(a_Size, PixelsOfAllFaces[sg_CubeCornerList[0,0]], PixelsOfAllFaces[sg_CubeCornerList[0,1]], PixelsOfAllFaces[sg_CubeCornerList[0,2]], 0, 0, a_Size, a_Size, a_Size, 0);

// Average Edges

// Note that this loop does not process the corner texels, since they have already been averaged

for (int i = 1; i < (a_Size - 1); i++)

{

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[0,0]], PixelsOfAllFaces[sg_CubeEdgeList[0,1]], i, 0, a_Size, a_Size - i, fixupDist, new Vector4(0, 1, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[1,0]], PixelsOfAllFaces[sg_CubeEdgeList[1,1]], i, a_Size, a_Size, i, fixupDist, new Vector4(0, -1, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[2,0]], PixelsOfAllFaces[sg_CubeEdgeList[2,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[3,0]], PixelsOfAllFaces[sg_CubeEdgeList[3,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[4,0]], PixelsOfAllFaces[sg_CubeEdgeList[4,1]], i, 0, 0, i, fixupDist, new Vector4(0, 1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[5,0]], PixelsOfAllFaces[sg_CubeEdgeList[5,1]], i, a_Size, 0, a_Size - i, fixupDist, new Vector4(0, -1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[6,0]], PixelsOfAllFaces[sg_CubeEdgeList[6,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[7,0]], PixelsOfAllFaces[sg_CubeEdgeList[7,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[8,0]], PixelsOfAllFaces[sg_CubeEdgeList[8,1]], i, a_Size, i, 0, fixupDist, new Vector4(0, -1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[9,0]], PixelsOfAllFaces[sg_CubeEdgeList[9,1]], i, 0, a_Size - i, 0, fixupDist, new Vector4(0, 1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[10,0]], PixelsOfAllFaces[sg_CubeEdgeList[10,1]], i, 0, i, a_Size, fixupDist, new Vector4(0, 1, 0, -1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[11,0]], PixelsOfAllFaces[sg_CubeEdgeList[11,1]], i, a_Size, a_Size - i, a_Size, fixupDist, new Vector4(0, -1, 0, -1) );

}

// Perform 2nd iteration in reverse order

/* for (int i = 0; i < (a_Size); i++)

{

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[11,0]], PixelsOfAllFaces[sg_CubeEdgeList[11,1]], i, a_Size, a_Size - i, a_Size, fixupDist, new Vector4(0, -1, 0, -1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[10,0]], PixelsOfAllFaces[sg_CubeEdgeList[10,1]], i, 0, i, a_Size, fixupDist, new Vector4(0, 1, 0, -1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[9,0]], PixelsOfAllFaces[sg_CubeEdgeList[9,1]], i, 0, a_Size - i, 0, fixupDist, new Vector4(0, 1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[8,0]], PixelsOfAllFaces[sg_CubeEdgeList[8,1]], i, a_Size, i, 0, fixupDist, new Vector4(0, -1, 0, 1) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[7,0]], PixelsOfAllFaces[sg_CubeEdgeList[7,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[6,0]], PixelsOfAllFaces[sg_CubeEdgeList[6,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[5,0]], PixelsOfAllFaces[sg_CubeEdgeList[5,1]], i, a_Size, 0, a_Size - i, fixupDist, new Vector4(0, -1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[4,0]], PixelsOfAllFaces[sg_CubeEdgeList[4,1]], i, 0, 0, i, fixupDist, new Vector4(0, 1, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[3,0]], PixelsOfAllFaces[sg_CubeEdgeList[3,1]], a_Size, i, 0, i, fixupDist, new Vector4(-1, 0, 1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[2,0]], PixelsOfAllFaces[sg_CubeEdgeList[2,1]], 0, i, a_Size, i, fixupDist, new Vector4(1, 0, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[1,0]], PixelsOfAllFaces[sg_CubeEdgeList[1,1]], i, a_Size, a_Size, i, fixupDist, new Vector4(0, -1, -1, 0) );

AverageEdge(a_Size, PixelsOfAllFaces[sg_CubeEdgeList[0,0]], PixelsOfAllFaces[sg_CubeEdgeList[0,1]], i, 0, a_Size, a_Size - i, fixupDist, new Vector4(0, 1, -1, 0) );

} */

// Write Pixel from the jagged array back to the cubemap faces

for (int writeFace = 0; writeFace < 6; writeFace++ ) {

Color[] tempColors = PixelsOfAllFaces[writeFace];

CubeMap.SetPixels(tempColors, (CubemapFace)writeFace, mipLevel);

}

}

CubeMap.Apply(false);

}

private void AverageEdge(int a_Size, Color[] face_A, Color[] face_B, int x_A, int y_A, int x_B, int y_B, int fixupDist, Vector4 dir)

{

// As a_Size is used as factor we have to increase it by 1

a_Size += 1;

Color AverageEdgeColor = face_A[a_Size * y_A + x_A] * 0.5f + face_B[+ a_Size * y_B + x_B] * 0.5f;

face_A[a_Size * y_A + x_A] = AverageEdgeColor;

face_B[a_Size * y_B + x_B] = AverageEdgeColor;

/* for (int iFixup = 0; iFixup < fixupDist; iFixup++)

{

float fixupFrac = (float)(fixupDist - iFixup) / (float)fixupDist;

Color AverageEdgeColor_A = face_A[a_Size * y_A + a_Size * (int)dir.y * iFixup + x_A + (int)dir.x * iFixup];

Color AverageEdgeColor_B = face_B[a_Size * y_B + a_Size * (int)dir.w * iFixup + x_B + (int)dir.z * iFixup];

// CP_FIXUP_PULL_HERMITE

float fixupWeight = ((-2.0f * fixupFrac + 3.0f) * fixupFrac * fixupFrac);

// face_A[a_Size* y_A + a_Size * (int)dir.y * iFixup + x_A + (int)dir.x * iFixup ] = Color.red * (fixupWeight);

// face_B[a_Size * y_B + a_Size * (int)dir.w * iFixup + x_B + (int)dir.z * iFixup ] = Color.blue * (fixupWeight);

face_A[a_Size* y_A + a_Size * (int)dir.y * iFixup + x_A + (int)dir.x * iFixup ] = AverageEdgeColor * fixupWeight + AverageEdgeColor_A * (1.0f-fixupWeight) ;

face_B[a_Size * y_B + a_Size * (int)dir.w * iFixup + x_B + (int)dir.z * iFixup ] = AverageEdgeColor * fixupWeight + AverageEdgeColor_B * (1.0f-fixupWeight) ;

} */

}

private void AverageCorner (int a_Size, Color[] face_A , Color[] face_B, Color [] face_C, int x_A, int y_A, int x_B, int y_B, int x_C, int y_C)

{

// As a_Size is used as factor we have to increase it by 1

a_Size += 1;

Color AverageCornerColor = face_A[a_Size * y_A + x_A]/3.0f + face_B[a_Size * y_B + x_B]/3.0f + face_C[a_Size * y_C + x_C]/3.0f;

face_A[ a_Size * y_A + x_A] = AverageCornerColor;

face_B[a_Size * y_B + x_B] = AverageCornerColor;

face_C[a_Size * y_C + x_C] = AverageCornerColor;

}

//--------------------------------------------------------------------------------------

// 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");

}

//--------------------------------------------------------------------------------------

// Builds a normalizer array, with the texels solid angle stored in the fourth component

void BuildNormalizerSolidAngleArray (int a_Size, ref Vector4[] normSolid)

{

int iCubeFace, u, v;

Vector3 a_XYZ = new Vector3(0,0,0);

//

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);

//

normSolid[iCubeFace * a_Size* a_Size + v * a_Size + u] = new Vector4(a_XYZ[0], a_XYZ[1], a_XYZ[2], weight);

}

}

}

// Debug.Log ("BuildNormalizerSolidAngleArray finished");

}

///////////////////////////////////////////////

// SH order use for approximation of irradiance cubemap is 5, mean 5*5 equals 25 coefficients

// #define MAX_SH_ORDER 5

// #define NUM_SH_COEFFICIENT (MAX_SH_ORDER * MAX_SH_ORDER)

void EvalSHBasis(Vector3 dir, ref double[] res )

{

double SqrtPi = (double)Mathf.Sqrt(CP_PI);

double xx = dir[0];

double yy = dir[1];

double zz = dir[2];

// x[i] == pow(x, i), etc.

// float64 x[MAX_SH_ORDER+1], y[MAX_SH_ORDER+1], z[MAX_SH_ORDER+1];

double[] x = new double[26];

double[] y = new double[26];

double[] z = new double[26];

x[0] = 1.0;

y[0] = 1.0;

z[0] = 1.0;

for (int i = 1; i < 25+1; ++i)

{

x[i] = xx * x[i-1];

y[i] = yy * y[i-1];

z[i] = zz * z[i-1];

}

res[0] = (1/(2.0*SqrtPi));

res[1] = -(Mathf.Sqrt(3/CP_PI)*yy)/2.0;

res[2] = (Mathf.Sqrt(3/CP_PI)*zz)/2.0;

res[3] = -(Mathf.Sqrt(3/CP_PI)*xx)/2.0;

res[4] = (Mathf.Sqrt(15/CP_PI)*xx*yy)/2.0;

res[5] = -(Mathf.Sqrt(15/CP_PI)*yy*zz)/2.0;

res[6] = (Mathf.Sqrt(5/CP_PI)*(-1 + 3*z[2]))/4.0;

res[7] = -(Mathf.Sqrt(15/CP_PI)*xx*zz)/2.0;

res[8] = Mathf.Sqrt(15/CP_PI)*(x[2] - y[2])/4.0;

res[9] = (Mathf.Sqrt(35/(2.0f*CP_PI))*(-3*x[2]*yy + y[3]))/4.0;

res[10] = (Mathf.Sqrt(105/CP_PI)*xx*yy*zz)/2.0;

res[11] = -(Mathf.Sqrt(21/(2.0f*CP_PI))*yy*(-1 + 5*z[2]))/4.0;

res[12] = (Mathf.Sqrt(7/CP_PI)*zz*(-3 + 5*z[2]))/4.0;

res[13] = -(Mathf.Sqrt(21/(2.0f*CP_PI))*xx*(-1 + 5*z[2]))/4.0;

res[14] = (Mathf.Sqrt(105/CP_PI)*(x[2] - y[2])*zz)/4.0;

res[15] = -(Mathf.Sqrt(35/(2.0f*CP_PI))*(x[3] - 3*xx*y[2]))/4.0;

res[16] = (3*Mathf.Sqrt(35/CP_PI)*xx*yy*(x[2] - y[2]))/4.0;

res[17] = (-3*Mathf.Sqrt(35/(2.0f*CP_PI))*(3*x[2]*yy - y[3])*zz)/4.0;

res[18] = (3*Mathf.Sqrt(5/CP_PI)*xx*yy*(-1 + 7*z[2]))/4.0f;

res[19] = (-3*Mathf.Sqrt(5/(2.0f*CP_PI))*yy*zz*(-3 + 7*z[2]))/4.0;

res[20] = (3*(3 - 30*z[2] + 35*z[4]))/(16.0*SqrtPi);

res[21] = (-3*Mathf.Sqrt(5/(2.0f*CP_PI))*xx*zz*(-3+ 7*z[2]))/4.0;

res[22] = (3*Mathf.Sqrt(5/CP_PI)*(x[2] - y[2])*(-1 + 7*z[2]))/8.0;

res[23] = (-3*Mathf.Sqrt(35/(2.0f*CP_PI))*(x[3] - 3*xx*y[2])*zz)/4.0;

res[24] = (3*Mathf.Sqrt(35/CP_PI)*(x[4] - 6*x[2]*y[2] + y[4]))/16.0;

}

// See Peter-Pike Sloan paper for these coefficients

static double[] SHBandFactor = {

1.0,

2.0 / 3.0, 2.0 / 3.0, 2.0 / 3.0,

1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0,

0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, // The 4 band will be zeroed

- 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0, - 1.0 / 24.0

};

void FakeHDR (Cubemap CubeMap, bool hasmipLevels) {

int maxMipLevels = 1;

if (hasmipLevels) {

maxMipLevels = (int)(Mathf.Log((float)CubeMap.width, 2.0f)) + 1;

}

int base_Size = CubeMap.width;

Vector4 rgbmColor = new Vector4();

for (int mipLevel = 0; mipLevel < maxMipLevels; mipLevel++)

{

int a_Size = base_Size >> mipLevel;

// As we use a_Size as pointer in our arrays we have to lower it by 1

//a_Size -= 1;

for (int a_FaceIdx = 0; a_FaceIdx < 6; a_FaceIdx++)

{

// Get all pixels of the given face

Color[] FaceColors = CubeMap.GetPixels((CubemapFace)a_FaceIdx, mipLevel);

// Iterate over dst cube map face texel

for (int a_V = 0; a_V < a_Size; a_V++)

{

for (int a_U = 0; a_U < a_Size; a_U++)

{

rgbmColor.x = FaceColors[a_V * a_Size + a_U].r;

rgbmColor.y = FaceColors[a_V * a_Size + a_U].g;

rgbmColor.z = FaceColors[a_V * a_Size + a_U].b;

rgbmColor *= 1.0f/6.0f;

rgbmColor.w = Mathf.Clamp01(Mathf.Max(Mathf.Max(rgbmColor.x, rgbmColor.y), rgbmColor.z));

rgbmColor.w = Mathf.Ceil(rgbmColor.w*255.0f) / 255.0f;

rgbmColor.x = rgbmColor.x / rgbmColor.w;

rgbmColor.y = rgbmColor.y / rgbmColor.w;

rgbmColor.z = rgbmColor.z / rgbmColor.w;

FaceColors[a_V * a_Size + a_U] = rgbmColor;

}

}

CubeMap.SetPixels(FaceColors,(CubemapFace)a_FaceIdx, mipLevel);

}

}

CubeMap.Apply(false);

}

}

#endif

Cherno · Mar 13, 2015

You forgot a "}" somewhere. You have to go through your whole script and check if every "{" has a "}". It's probably easier if you comment out whole functions and do it in parts. That way you can see which parts of your script are clean. If that fails, try looking for a missing ";", although that would give a different kind of error message.

Search Unity

The Walking Dead VR

Michaelm9945

Attached Files:

2015-03-07_141531.png

LaneFox

Schneider21

Michaelm9945

LaneFox

Michaelm9945

Cherno

Search Unity

Unity ID

Useful Searches

The Walking Dead VR

Attached Files: