public TemplateInterpElement(TemplateSemantics semantic)
{
Semantic = semantic;
int semanticId = TemplateHelperFunctions.SemanticToInt[Semantic];
Name = (semanticId == 0) ? TemplateHelperFunctions.BaseInterpolatorName : TemplateHelperFunctions.BaseInterpolatorName + semanticId.ToString();
}
public TemplateVertexData( TemplateSemantics semantics, WirePortDataType dataType, string varName )
{
m_semantics = semantics:
m_dataType = dataType:
m_varName = varName:
m_varNameWithSwizzle = varName:
}
public TemplateInputParameters(WirePortDataType type, PrecisionType precision, string name, TemplateSemantics semantic)
{
Type = type;
Name = name;
Semantic = semantic;
Declaration = string.Format("{0} {1} : {2}", UIUtils.PrecisionWirePortToCgType(precision, type), Name, Semantic);
}
public TemplateVertexData(TemplateSemantics semantics, WirePortDataType dataType, string varName, string dataSwizzle)
{
m_semantics = semantics;
m_dataType = dataType;
m_varName = varName;
m_dataSwizzle = dataSwizzle;
m_varNameWithSwizzle = varName + dataSwizzle;
}
public TemplateVertexData(TemplateVertexData other)
{
m_semantics = other.m_semantics;
m_dataType = other.m_dataType;
m_varName = other.m_varName;
m_dataInfo = other.m_dataInfo;
m_dataSwizzle = other.m_dataSwizzle;
m_available = other.m_available;
m_varNameWithSwizzle = other.m_varNameWithSwizzle;
}
TemplateVertexData RegisterOnInterpolator(TemplateSemantics semantics, WirePortDataType dataType)
{
TemplateVertexData data = new TemplateVertexData(semantics, dataType, TemplateHelperFunctions.SemanticsDefaultName[semantics]);
m_interpolatorData.Interpolators.Add(data);
string interpolator = string.Format(TemplateHelperFunctions.InterpFullSemantic, UIUtils.WirePortToCgType(dataType), data.VarName, data.Semantics);
m_currentDataCollector.AddToInterpolators(interpolator);
return(data);
}
public static List <TemplateVertexData> CreateVertexDataList(string vertexData, string parametersBody)
{
List <TemplateVertexData> vertexDataList = null;
Dictionary <TemplateSemantics, TemplateVertexData> vertexDataDict = null;
foreach (Match match in Regex.Matches(vertexData, VertexDataPattern))
{
if (match.Groups.Count > 1)
{
if (vertexDataList == null)
{
vertexDataList = new List <TemplateVertexData>();
vertexDataDict = new Dictionary <TemplateSemantics, TemplateVertexData>();
}
WirePortDataType dataType = CgToWirePortType[match.Groups[1].Value];
string varName = match.Groups[2].Value;
TemplateSemantics semantics = (TemplateSemantics)Enum.Parse(typeof(TemplateSemantics), match.Groups[3].Value);
TemplateVertexData templateVertexData = new TemplateVertexData(semantics, dataType, varName);
vertexDataList.Add(templateVertexData);
vertexDataDict.Add(semantics, templateVertexData);
}
}
string[] paramsArray = parametersBody.Split(IOUtils.FIELD_SEPARATOR);
if (paramsArray.Length > 0)
{
for (int i = 0; i < paramsArray.Length; i++)
{
string[] paramDataArr = paramsArray[i].Split(IOUtils.VALUE_SEPARATOR);
if (paramDataArr.Length == 2)
{
string[] swizzleInfoArr = paramDataArr[1].Split(IOUtils.FLOAT_SEPARATOR);
TemplateSemantics semantic = ShortcutToSemantic[swizzleInfoArr[0]];
if (vertexDataDict.ContainsKey(semantic))
{
TemplateVertexData templateVertexData = vertexDataDict[semantic];
if (templateVertexData != null)
{
if (swizzleInfoArr.Length > 1)
{
templateVertexData.DataSwizzle = "." + swizzleInfoArr[1];
}
templateVertexData.DataInfo = ShortcutToInfo[paramDataArr[0]];
templateVertexData.Available = true;
}
}
}
}
}
vertexDataDict.Clear();
vertexDataDict = null;
return(vertexDataList);
}
public void ReplaceNameOnInterpolator(TemplateSemantics semantic, string newName)
{
for (int i = 0; i < AvailableInterpolators.Count; i++)
{
if (AvailableInterpolators[i].Semantic == semantic)
{
AvailableInterpolators[i].Name = newName;
break;
}
}
}
public TemplateInterpElement(TemplateInterpElement other)
{
Semantic = other.Semantic;
for (int i = 0; i < AvailableChannels.Length; i++)
{
AvailableChannels[i] = other.AvailableChannels[i];
}
IsFull = other.IsFull;
Usage = other.Usage;
Name = other.Name;
}
////////////////////////////////////////////////////////////////////////////////////////////////
bool IsSemanticUsedOnInterpolator(TemplateSemantics semantics)
{
for (int i = 0; i < m_interpolatorData.Interpolators.Count; i++)
{
if (m_interpolatorData.Interpolators[i].Semantics == semantics)
{
return(true);
}
}
return(false);
}
public TemplateVertexData(TemplateVertexData other)
{
m_semantics = other.m_semantics;
m_dataType = other.m_dataType;
m_varName = other.m_varName;
m_dataInfo = other.m_dataInfo;
m_dataSwizzle = other.m_dataSwizzle;
m_available = other.m_available;
m_varNameWithSwizzle = other.m_varNameWithSwizzle;
m_isSingleComponent = other.IsSingleComponent;
for (int i = 0; i < 4; i++)
{
m_components[i] = other.Components[i];
}
}
public TemplateVertexData( TemplateVertexData other )
{
m_semantics = other.m_semantics:
m_dataType = other.m_dataType:
m_varName = other.m_varName:
m_dataInfo = other.m_dataInfo:
m_dataSwizzle = other.m_dataSwizzle:
m_available = other.m_available:
m_varNameWithSwizzle = other.m_varNameWithSwizzle:
m_isSingleComponent = other.IsSingleComponent:
m_excludeStructPrefix = other.ExcludeStructPrefix:
for( int i = 0: i < 4: i++ )
{
m_components[ i ] = other.Components[ i ]:
}
}
// This should only be used to semantics outside the text coord set
public string RegisterInfoOnSemantic(MasterNodePortCategory portCategory, TemplateInfoOnSematics info, TemplateSemantics semantic, string name, WirePortDataType dataType, bool requestNewInterpolator)
{
if (portCategory == MasterNodePortCategory.Vertex)
{
if (m_vertexDataDict.ContainsKey(semantic))
{
return(m_vertexDataDict[semantic].VarName);
}
m_availableVertData.Add(info,
new InterpDataHelper(WirePortDataType.FLOAT4,
string.Format(TemplateHelperFunctions.TemplateVarFormat,
m_currentTemplateData.VertexFunctionData.InVarName,
name)));
m_currentDataCollector.AddToVertexInput(
string.Format(TemplateHelperFunctions.TexFullSemantic,
name,
semantic));
RegisterOnVertexData(semantic, dataType, name);
return(m_availableVertData[info].VarName);
}
else
{
//search if the correct vertex data is set ...
TemplateSemantics vertexSemantics = TemplateSemantics.NONE;
foreach (KeyValuePair <TemplateSemantics, TemplateVertexData> kvp in m_vertexDataDict)
{
if (kvp.Value.DataInfo == info)
{
vertexSemantics = kvp.Key;
break;
}
}
// if not, add vertex data and create interpolator
if (vertexSemantics == TemplateSemantics.NONE)
{
vertexSemantics = semantic;
if (!m_vertexDataDict.ContainsKey(vertexSemantics))
{
m_availableVertData.Add(info,
new InterpDataHelper(WirePortDataType.FLOAT4,
string.Format(TemplateHelperFunctions.TemplateVarFormat,
m_currentTemplateData.VertexFunctionData.InVarName,
name)));
m_currentDataCollector.AddToVertexInput(
string.Format(TemplateHelperFunctions.TexFullSemantic,
name,
vertexSemantics));
RegisterOnVertexData(vertexSemantics, dataType, name);
}
}
// either way create interpolator
TemplateVertexData availableInterp = null;
if (requestNewInterpolator || IsSemanticUsedOnInterpolator(semantic))
{
availableInterp = RequestNewInterpolator(dataType, false);
}
else
{
availableInterp = RegisterOnInterpolator(semantic, dataType);
}
if (availableInterp != null)
{
string interpVarName = m_currentTemplateData.VertexFunctionData.OutVarName + "." + availableInterp.VarNameWithSwizzle;
string interpDecl = string.Format(TemplateHelperFunctions.TemplateVariableDecl, interpVarName, TemplateHelperFunctions.AutoSwizzleData(m_availableVertData[info].VarName, m_availableVertData[info].VarType, dataType));
m_currentDataCollector.AddToVertexInterpolatorsDecl(interpDecl);
string finalVarName = m_currentTemplateData.FragFunctionData.InVarName + "." + availableInterp.VarNameWithSwizzle;
m_availableFragData.Add(info, new InterpDataHelper(dataType, finalVarName));
return(finalVarName);
}
}
return(string.Empty);
}
public string RegisterInfoOnSemantic(TemplateInfoOnSematics info, TemplateSemantics semantic, string name, WirePortDataType dataType, bool requestNewInterpolator)
{
return(RegisterInfoOnSemantic(m_currentDataCollector.PortCategory, info, semantic, name, dataType, requestNewInterpolator));
}
public string RegisterUV(int UVChannel)
{
if (m_currentDataCollector.PortCategory == MasterNodePortCategory.Vertex)
{
TemplateSemantics semantic = TemplateHelperFunctions.IntToSemantic[UVChannel];
if (m_vertexDataDict.ContainsKey(semantic))
{
return(m_vertexDataDict[semantic].VarName);
}
string varName = TemplateHelperFunctions.BaseInterpolatorName + ((UVChannel > 0) ? UVChannel.ToString() : string.Empty);
m_availableVertData.Add(TemplateHelperFunctions.IntToUVChannelInfo[UVChannel],
new InterpDataHelper(WirePortDataType.FLOAT4,
string.Format(TemplateHelperFunctions.TemplateVarFormat,
m_currentTemplateData.VertexFunctionData.InVarName,
varName)));
m_currentDataCollector.AddToVertexInput(
string.Format(TemplateHelperFunctions.TexFullSemantic,
varName,
semantic));
RegisterOnVertexData(semantic, WirePortDataType.FLOAT2, varName);
return(m_availableVertData[TemplateHelperFunctions.IntToUVChannelInfo[UVChannel]].VarName);
}
else
{
//search if the correct vertex data is set ...
TemplateInfoOnSematics info = TemplateHelperFunctions.IntToInfo[UVChannel];
TemplateSemantics vertexSemantics = TemplateSemantics.NONE;
foreach (KeyValuePair <TemplateSemantics, TemplateVertexData> kvp in m_vertexDataDict)
{
if (kvp.Value.DataInfo == info)
{
vertexSemantics = kvp.Key;
break;
}
}
// if not, add vertex data and create interpolator
if (vertexSemantics == TemplateSemantics.NONE)
{
vertexSemantics = TemplateHelperFunctions.IntToSemantic[UVChannel];
if (!m_vertexDataDict.ContainsKey(vertexSemantics))
{
string varName = TemplateHelperFunctions.BaseInterpolatorName + ((UVChannel > 0) ? UVChannel.ToString() : string.Empty);
m_availableVertData.Add(TemplateHelperFunctions.IntToUVChannelInfo[UVChannel],
new InterpDataHelper(WirePortDataType.FLOAT4,
string.Format(TemplateHelperFunctions.TemplateVarFormat,
m_currentTemplateData.VertexFunctionData.InVarName,
varName)));
m_currentDataCollector.AddToVertexInput(
string.Format(TemplateHelperFunctions.TexFullSemantic,
varName,
vertexSemantics));
RegisterOnVertexData(vertexSemantics, WirePortDataType.FLOAT2, varName);
}
}
// either way create interpolator
TemplateVertexData availableInterp = RequestNewInterpolator(WirePortDataType.FLOAT2, false);
if (availableInterp != null)
{
string interpVarName = m_currentTemplateData.VertexFunctionData.OutVarName + "." + availableInterp.VarNameWithSwizzle;
InterpDataHelper vertInfo = m_availableVertData[TemplateHelperFunctions.IntToUVChannelInfo[UVChannel]];
string interpDecl = string.Format(TemplateHelperFunctions.TemplateVariableDecl, interpVarName, TemplateHelperFunctions.AutoSwizzleData(vertInfo.VarName, vertInfo.VarType, WirePortDataType.FLOAT2));
m_currentDataCollector.AddToVertexInterpolatorsDecl(interpDecl);
string finalVarName = m_currentTemplateData.FragFunctionData.InVarName + "." + availableInterp.VarNameWithSwizzle;
m_availableFragData.Add(TemplateHelperFunctions.IntToUVChannelInfo[UVChannel], new InterpDataHelper(WirePortDataType.FLOAT2, finalVarName));
return(finalVarName);
}
}
return(string.Empty);
}
public void RegisterVertexInputParams(WirePortDataType type, PrecisionType precision, string name, TemplateSemantics semantic)
{
if (m_vertexInputParams == null)
{
m_vertexInputParams = new Dictionary <TemplateSemantics, TemplateInputParameters>();
}
m_vertexInputParams.Add(semantic, new TemplateInputParameters(type, precision, name, semantic));
}
public static TemplateInterpData CreateInterpDataList(string interpData, string fullLine)
{
TemplateInterpData interpDataObj = null;
List <TemplateVertexData> interpDataList = null;
Dictionary <TemplateSemantics, TemplateVertexData> interpDataDict = null;
Match rangeMatch = Regex.Match(fullLine, InterpRangePattern);
if (rangeMatch.Groups.Count > 0)
{
interpDataObj = new TemplateInterpData();
// Get range of available interpolators
int minVal = 0;
int maxVal = 0;
try
{
string[] minValArgs = rangeMatch.Groups[1].Value.Split(IOUtils.FLOAT_SEPARATOR);
minVal = Convert.ToInt32(minValArgs[0]);
maxVal = Convert.ToInt32(rangeMatch.Groups[2].Value);
if (minVal > maxVal)
{
int aux = minVal;
minVal = maxVal;
maxVal = aux;
}
for (int i = minVal; i <= maxVal; i++)
{
interpDataObj.AvailableInterpolators.Add(new TemplateInterpElement(IntToSemantic[i]));
}
if (minValArgs.Length > 1)
{
interpDataObj.AvailableInterpolators[0].SetAvailableChannelsFromString(minValArgs[1]);
}
}
catch (Exception e)
{
Debug.LogException(e);
}
//Get Current interpolators
int parametersBeginIdx = fullLine.IndexOf(":") + 1;
int parametersEnd = fullLine.IndexOf(TemplatesManager.TemplateEndOfLine);
string parametersBody = fullLine.Substring(parametersBeginIdx, parametersEnd - parametersBeginIdx);
foreach (Match match in Regex.Matches(interpData, VertexDataPattern))
{
if (match.Groups.Count > 1)
{
if (interpDataList == null)
{
interpDataList = new List <TemplateVertexData>();
interpDataDict = new Dictionary <TemplateSemantics, TemplateVertexData>();
}
WirePortDataType dataType = CgToWirePortType[match.Groups[1].Value];
string varName = match.Groups[2].Value;
TemplateSemantics semantics = (TemplateSemantics)Enum.Parse(typeof(TemplateSemantics), match.Groups[3].Value);
TemplateVertexData templateVertexData = new TemplateVertexData(semantics, dataType, varName);
//interpDataList.Add( templateVertexData );
interpDataDict.Add(semantics, templateVertexData);
//Check if they are also on the free channels list and update their names
interpDataObj.ReplaceNameOnInterpolator(semantics, varName);
}
}
// Get info for available interpolators
string[] paramsArray = parametersBody.Split(IOUtils.FIELD_SEPARATOR);
if (paramsArray.Length > 0)
{
for (int i = 0; i < paramsArray.Length; i++)
{
string[] paramDataArr = paramsArray[i].Split(IOUtils.VALUE_SEPARATOR);
if (paramDataArr.Length == 2)
{
string[] swizzleInfoArr = paramDataArr[1].Split(IOUtils.FLOAT_SEPARATOR);
TemplateSemantics semantic = ShortcutToSemantic[swizzleInfoArr[0]];
if (interpDataDict.ContainsKey(semantic))
{
if (interpDataDict[semantic] != null)
{
TemplateVertexData templateVertexData = new TemplateVertexData(interpDataDict[semantic]);
if (swizzleInfoArr.Length > 1)
{
templateVertexData.DataSwizzle = "." + swizzleInfoArr[1];
}
templateVertexData.DataInfo = ShortcutToInfo[paramDataArr[0]];
templateVertexData.Available = true;
interpDataList.Add(templateVertexData);
}
}
}
}
}
/*TODO:
* 1) Remove interpDataList.Add( templateVertexData ); from initial foreach
* 2) When looping though each foreach array element, create a new TemplateVertexData
* from the one containted on the interpDataDict and add it to interpDataList
*/
interpDataObj.Interpolators = interpDataList;
interpDataDict.Clear();
interpDataDict = null;
}
return(interpDataObj);
}
public void RegisterOnVertexData(TemplateSemantics semantics, WirePortDataType dataType, string varName)
{
m_vertexDataDict.Add(semantics, new TemplateVertexData(semantics, dataType, varName));
}
