private Texture3DEditorError ComputeAndDisplayTexture3DSettings(ref Texture3DSettings res)
{
isTexture3DSettingsDisplayed = EditorGUILayout.Foldout(isTexture3DSettingsDisplayed, GUI_NAME_IS_TEXTURE_3D_SETTINGS_DISPLAYED);
if (isTexture3DSettingsDisplayed)
{
EditorGUILayout.BeginVertical();
++EditorGUI.indentLevel;
res.name = EditorGUILayout.TextField(GUI_NAME_NAME, res.name);
res.resampleMode = (ResampleMode)EditorGUILayout.Popup(GUI_NAME_RESAMPLE_MODE, (int)res.resampleMode, RESAMPLE_MODE_NAMES);
res.textureFormatValid = (TextureFormatValid)EditorGUILayout.Popup(GUI_NAME_TEXTURE_FORMAT_VALID, (int)res.textureFormatValid, TEXTURE_FORMAT_VALID_NAMES);
res.filterModeValid = (FilterModeValid)EditorGUILayout.Popup(GUI_NAME_FILTER_MODE_VALID, (int)res.filterModeValid, FILTER_MODE_VALID_NAMES);
res.textureWrapModeValid = (TextureWrapModeValid)EditorGUILayout.Popup(GUI_NAME_WRAP_MODE_VALID, (int)res.textureWrapModeValid, TEXTURE_WRAP_MODE_VALID_NAMES);
res.isMipmapEnabled = EditorGUILayout.Toggle(GUI_NAME_IS_MIPMAP_ENABLED, res.isMipmapEnabled);
res.anisoLevel = EditorGUILayout.IntSlider(GUI_NAME_ANISO_LEVEL, res.anisoLevel, 1, 9);
res.width = Texture3DEditor.SanitizeResolution(EditorGUILayout.IntField(GUI_NAME_WIDTH, res.width));
res.height = Texture3DEditor.SanitizeResolution(EditorGUILayout.IntField(GUI_NAME_HEIGHT, res.height));
res.depth = Texture3DEditor.SanitizeResolution(EditorGUILayout.IntField(GUI_NAME_DEPTH, res.depth));
--EditorGUI.indentLevel;
EditorGUILayout.EndVertical();
}
return(Texture3DEditorError.None);
}
public static void CreateTextureSettings()
{
var ts = Texture3DSettings.CreateInstance <Texture3DSettings>();
string path = "Assets/Textures/new texture3D.asset";
path = AssetDatabase.GenerateUniqueAssetPath(path);
Debug.Log("Path: " + path);
ProjectWindowUtil.CreateAsset(ts, path);
}
private static Texture3DEditorError SaveAssetFromTexture3D(Texture3DSettings settings, Texture3D texture3D)
{
string filename = (settings.name.Length > 0) ? (settings.name + "." + FILE_EXTENSION) : DEFAULT_FILENAME;
// Returns path relative to project base directory.
// Required for AssetDatabase.CreateAsset() which expects paths relative to project base.
string path = EditorUtility.SaveFilePanelInProject(SAVE_DIALOGUE, filename, FILE_EXTENSION, "");
if (path.Length == 0)
{
return(Texture3DEditorError.NoSavePathSpecified);
}
AssetDatabase.CreateAsset(texture3D, path);
return(Texture3DEditorError.None);
}
public void OnEnable()
{
settings = target as Texture3DSettings;
oldTextureSize = settings.textureSize;
preview = new Texture2D(settings.textureSize, settings.textureSize, TextureFormat.RGBA32, false);
preview.filterMode = FilterMode.Point;
UpdatePreview();
if (f == false)
{
inst = GetHashCode();
}
else
{
return;
}
f = true;
SceneView.onSceneGUIDelegate += OnSceneGUI;
}
private static Texture3DEditorError ResampleTrilinear(ref Color[] data, List <Texture2D> textureSlices, List <Color[]> textureSlicesData, Texture3DSettings settings)
{
float wScale = 1.0f / (float)settings.depth;
float wBias = 0.5f / (float)settings.depth;
// When computing the slice indices that straddle our interpolation interval we need to subtract off 0.5 pixels,
// as interpolation happens between pixel centers, i.e: 0.5 and 1.5 pixels.
float uScale = 1.0f / (float)settings.width;
float uBias = 0.5f / (float)settings.width;
float vScale = 1.0f / (float)settings.height;
float vBias = 0.5f / (float)settings.height;
float ziScale = (float)textureSlices.Count;
float ziBias = -0.5f;
for (int z = 0; z < settings.depth; ++z)
{
float w = (float)z * wScale + wBias;
float wSamplePositonSlices = w * ziScale + ziBias;
float wSampleInterpolation = Frac(wSamplePositonSlices);
int iz0 = Mathf.FloorToInt(wSamplePositonSlices);
int iz1 = iz0 + 1;
switch (settings.textureWrapModeValid)
{
case TextureWrapModeValid.Repeat:
iz0 = PixelWrap(iz0, textureSlices.Count);
iz1 = PixelWrap(iz1, textureSlices.Count);
break;
case TextureWrapModeValid.Clamp:
default:
iz0 = PixelClamp(iz0, textureSlices.Count);
iz1 = PixelClamp(iz1, textureSlices.Count);
break;
}
Texture2D textureSlice0 = textureSlices[iz0];
Texture2D textureSlice1 = textureSlices[iz1];
Color[] textureSliceData0 = textureSlicesData[iz0];
Color[] textureSliceData1 = textureSlicesData[iz1];
for (int y = 0; y < settings.height; ++y)
{
for (int x = 0; x < settings.width; ++x)
{
int i = z * settings.height * settings.width + y * settings.width + x;
float u = (float)x * uScale + uBias;
float v = (float)y * vScale + vBias;
float px0 = u * (float)textureSlice0.width;
float py0 = v * (float)textureSlice0.height;
float px1 = u * (float)textureSlice1.width;
float py1 = v * (float)textureSlice1.height;
int pxFloor0 = Mathf.FloorToInt(px0 - 0.5f);
int pyFloor0 = Mathf.FloorToInt(py0 - 0.5f);
int pxFloor1 = Mathf.FloorToInt(px1 - 0.5f);
int pyFloor1 = Mathf.FloorToInt(py1 - 0.5f);
float ax0 = px0 - ((float)pxFloor0 + 0.5f);
float ay0 = py0 - ((float)pyFloor0 + 0.5f);
float ax1 = px1 - ((float)pxFloor1 + 0.5f);
float ay1 = py1 - ((float)pyFloor1 + 0.5f);
int pxCeil0 = pxFloor0 + 1;
int pyCeil0 = pyFloor0 + 1;
int pxCeil1 = pxFloor1 + 1;
int pyCeil1 = pyFloor1 + 1;
switch (settings.textureWrapModeValid)
{
case TextureWrapModeValid.Repeat:
pxFloor0 = PixelWrap(pxFloor0, textureSlice0.width);
pyFloor0 = PixelWrap(pyFloor0, textureSlice0.height);
pxFloor1 = PixelWrap(pxFloor1, textureSlice1.width);
pyFloor1 = PixelWrap(pyFloor1, textureSlice1.height);
pxCeil0 = PixelWrap(pxCeil0, textureSlice0.width);
pyCeil0 = PixelWrap(pyCeil0, textureSlice0.height);
pxCeil1 = PixelWrap(pxCeil1, textureSlice1.width);
pyCeil1 = PixelWrap(pyCeil1, textureSlice1.height);
break;
case TextureWrapModeValid.Clamp:
pxFloor0 = PixelClamp(pxFloor0, textureSlice0.width);
pyFloor0 = PixelClamp(pyFloor0, textureSlice0.height);
pxFloor1 = PixelClamp(pxFloor1, textureSlice1.width);
pyFloor1 = PixelClamp(pyFloor1, textureSlice1.height);
pxCeil0 = PixelClamp(pxCeil0, textureSlice0.width);
pyCeil0 = PixelClamp(pyCeil0, textureSlice0.height);
pxCeil1 = PixelClamp(pxCeil1, textureSlice1.width);
pyCeil1 = PixelClamp(pyCeil1, textureSlice1.height);
break;
}
int inw0 = pyCeil0 * textureSlice0.width + pxFloor0;
int ine0 = pyCeil0 * textureSlice0.width + pxCeil0;
int isw0 = pyFloor0 * textureSlice0.width + pxFloor0;
int ise0 = pyFloor0 * textureSlice0.width + pxCeil0;
Color cn0 = Color.Lerp(textureSliceData0[inw0], textureSliceData0[ine0], ax0);
Color cs0 = Color.Lerp(textureSliceData0[isw0], textureSliceData0[ise0], ax0);
Color c0 = Color.Lerp(cs0, cn0, ay0);
int inw1 = pyCeil1 * textureSlice1.width + pxFloor1;
int ine1 = pyCeil1 * textureSlice1.width + pxCeil1;
int isw1 = pyFloor1 * textureSlice1.width + pxFloor1;
int ise1 = pyFloor1 * textureSlice1.width + pxCeil1;
Color cn1 = Color.Lerp(textureSliceData1[inw1], textureSliceData1[ine1], ax1);
Color cs1 = Color.Lerp(textureSliceData1[isw1], textureSliceData1[ise1], ax1);
Color c1 = Color.Lerp(cs1, cn1, ay1);
data[i] = Color.Lerp(c0, c1, wSampleInterpolation);
}
}
}
return(Texture3DEditorError.None);
}
private static Texture3DEditorError ComputeTexture3DFromTextureSlices(ref Texture3D res, List <Texture2D> textureSlices, List <Color[]> textureSlicesData, Texture3DSettings settings)
{
if (textureSlices.Count == 0)
{
return(Texture3DEditorError.NoSlicesSpecified);
}
for (int i = 0, iLen = textureSlices.Count; i < iLen; ++i)
{
if (textureSlices[i] == null)
{
return(Texture3DEditorError.NoTextureAssigned);
}
}
Color[] data = new Color[settings.width * settings.height * settings.depth];
res = new Texture3D(
settings.width,
settings.height,
settings.depth,
Texture3DEditor.GetTextureFormat(settings.textureFormatValid),
settings.isMipmapEnabled
);
res.wrapMode = Texture3DEditor.GetTextureWrapMode(settings.textureWrapModeValid);
res.filterMode = Texture3DEditor.GetTextureFilterMode(settings.filterModeValid);
res.anisoLevel = settings.anisoLevel;
Debug.Assert((int)settings.resampleMode >= 0 && settings.resampleMode < ResampleMode.Count);
Texture3DEditorError error = Texture3DEditorError.None;
switch (settings.resampleMode)
{
case ResampleMode.Nearest:
error = ResampleNearest(ref data, textureSlices, textureSlicesData, settings);
break;
case ResampleMode.Trilinear:
error = ResampleTrilinear(ref data, textureSlices, textureSlicesData, settings);
break;
default:
break;
}
if (error != Texture3DEditorError.None)
{
return(error);
}
res.SetPixels(data, 0);
res.Apply(settings.isMipmapEnabled);
return(Texture3DEditorError.None);
}
