// System.Collections.Generic.SortedDictionary<int,Vector2>
public void RebuildTextureCache()
{
texturecache.Clear();
passindex.Clear();
for (int i = 0; i < this.shader.DefaultEffect.Description.GlobalVariableCount; i++)
{
EffectVariable var = this.shader.DefaultEffect.GetVariableByIndex(i);
if (var.GetVariableType().Description.TypeName == "Texture2D")
{
EffectResourceVariable rv = var.AsResource();
texturecache.Add(rv);
}
if (var.GetVariableType().Description.TypeName == "float" ||
var.GetVariableType().Description.TypeName == "int")
{
if (var.Description.Semantic == "PASSINDEX")
{
passindex.Add(var.AsScalar());
}
if (var.Description.Semantic == "PASSITERATIONINDEX")
{
passiterindex.Add(var.AsScalar());
}
}
}
}
public override FunctionBase GetExecuterInstance(int index, string value, RenderContext context, ScriptRuntime runtime,
MMEEffectManager manager, MMEEffectTechnique technique, MMEEffectPass pass)
{
LoopByCountFunction func = new LoopByCountFunction();
func.runtime = runtime;
if (string.IsNullOrWhiteSpace(value))
{
throw new InvalidMMEEffectShaderException("LoopByCount=;は指定できません。int,float,boolいずれかの変数名を伴う必要があります。");
}
EffectVariable rawVariable = manager.EffectFile.GetVariableByName(value);
string typeName = rawVariable.GetVariableType().Description.TypeName.ToLower();
int loopCount = 0;
switch (typeName)
{
case "bool":
case "int":
loopCount = rawVariable.AsScalar().GetInt();
break;
case "float":
loopCount = (int)rawVariable.AsScalar().GetFloat();
break;
default:
throw new InvalidMMEEffectShaderException("LoopByCountに指定できる変数の型はfloat,int,boolのいずれかです。");
}
func.loopCount = loopCount;
return(func);
}
/// <summary>
/// 自身のインスタンスを作成して返す。
/// </summary>
/// <param name="index">連番。ファンクション名の末尾に付与される１桁の数値（0～9）。省略時は 0 。</param>
/// <param name="value">値。ファンクション名と '=' を挟んだ右辺に記された文字列。</param>
/// <param name="runtime"></param>
/// <param name="effect">ファンクションが属しているエフェクト。</param>
/// <param name="technique">ファンクションが属しているテクニック。パスに属している場合には null を指定。</param>
/// <param name="pass">ファンクションが属しているパス。テクニックに属している場合には null を指定。</param>
/// <returns></returns>
public override 関数 ファンクションインスタンスを作成する(int index, string value, ScriptRuntime runtime, エフェクト effect, テクニック technique, パス pass)
{
var func = new LoopByCount関数();
func._runtime = runtime;
if (string.IsNullOrWhiteSpace(value))
{
throw new InvalidMMEEffectShader例外("LoopByCount=;（空文字列）は指定できません。int,float,boolいずれかの変数名を伴う必要があります。");
}
EffectVariable d3dVariable = effect.D3DEffect.GetVariableByName(value);
string typeName = d3dVariable.TypeInfo.Description.TypeName.ToLower();
int loopCount = 0;
switch (typeName)
{
case "bool":
case "int":
loopCount = d3dVariable.AsScalar().GetInt();
break;
case "float":
loopCount = (int)d3dVariable.AsScalar().GetFloat();
break;
default:
throw new InvalidMMEEffectShader例外("LoopByCountに指定できる変数の型はfloat,int,boolのいずれかです。");
}
func._ループ回数 = loopCount;
return(func);
}
public void SetParameter(string varName, object varValue)
{
EffectVariable ev = DXEffect.GetVariableByName(varName);
if (ev.IsValid)
{
if (varValue is bool)
{
ev.AsScalar().Set((bool)varValue);
}
else if (varValue is int)
{
ev.AsScalar().Set((int)varValue);
}
else if (varValue is uint)
{
ev.AsScalar().Set((uint)varValue);
}
else if (varValue is float)
{
ev.AsScalar().Set((float)varValue);
}
else if (varValue is double)
{
ev.AsScalar().Set((float)(double)varValue);
}
else if (varValue is Vector2)
{
ev.AsVector().Set((Vector2)varValue);
}
else if (varValue is Vector3)
{
ev.AsVector().Set((Vector3)varValue);
}
else if (varValue is Vector4[])
{
ev.AsVector().Set((Vector4[])varValue);
}
else if (varValue is Vector4)
{
ev.AsVector().Set((Vector4)varValue);
}
else if (varValue is Matrix)
{
ev.AsMatrix().SetMatrix((Matrix)varValue);
}
//else if (varValue is DXTexture2DClass) ev.AsShaderResource().SetResource((varValue as DXTexture2DClass).TextureResourceView);
else if (varValue is ShaderResourceView)
{
ev.AsShaderResource().SetResource(varValue as ShaderResourceView);
}
else if (varValue == null)
{
ev.AsShaderResource().SetResource(null);
}
else /* ... */ } {
}
}
protected override void Subscribe(EffectVariable variable, IMotionManager motion, RenderContext context)
{
if (this.SyncInEditMode)
{
variable.AsScalar().Set(motion.ElapsedTime);
}
else
{
variable.AsScalar().Set(motion.ElapsedTime);
}
}
protected override void Subscribe(EffectVariable variable, IMotionManager motion, RenderContext context)
{
if (SyncInEditMode)
{
variable.AsScalar().Set(motion.CurrentFrame);
}
else
{
variable.AsScalar().Set(MotionTimer.stopWatch.ElapsedMilliseconds / 1000f);
}
}
protected override void 数を更新する(EffectVariable 数, モーション管理 モーション)
{
if (SyncInEditMode)
{
数.AsScalar().Set(モーション.前回のフレームからの経過時間sec);
}
else
{
数.AsScalar().Set(モーション.前回のフレームからの経過時間sec);
}
}
protected override void 数を更新する(EffectVariable 数, モーション管理 モーション)
{
if (SyncInEditMode)
{
数.AsScalar().Set(モーション.現在再生中のモーションのフレーム位置sec);
}
else
{
数.AsScalar().Set(モーションタイマ.stopWatch.ElapsedMilliseconds / 1000f);
}
}
public override void Execute(ISubset ipmxSubset, Action <ISubset> drawAction)
{
int count = runtime.LoopCounts.Pop();
targetVariable.AsScalar().Set(count);
runtime.LoopCounts.Push(count);
}
public void OnPreRender(Device device, float diffTime)
{
EffectVariable ev = effect.GetVariableByName("diffTime");
EffectScalarVariable esv = ev.AsScalar();
esv.Set(diffTime);
}
public override SubscriberBase GetSubscriberInstance(EffectVariable variable, RenderContext context, MMEEffectManager effectManager, int semanticIndex)
{
EffectVariable annotation = variable.GetAnnotationByName("SyncInEditMode");
bool syncMode = false;
if (annotation != null)
{
syncMode = annotation.AsScalar().GetInt() == 1;
}
return(GetSubscriberInstance(syncMode));
}
public static bool GetBoolFromFloatVVVV(this EffectVariable var, bool defaultValue)
{
if (var.IsValid)
{
return(var.AsScalar().GetFloat() > 0.5f);
}
else
{
return(defaultValue);
}
}
public ImageShaderPass(EffectPass pd)
{
this.Mips = false;
this.CustomFormat = false;
this.Scale = 1.0f;
this.DoScale = false;
this.Reference = eImageScaleReference.Previous;
this.ComputeData = new ImageComputeData(pd);
EffectVariable var = pd.GetAnnotationByName("format");
if (var.IsValid)
{
string fmt = var.AsString().GetString();
this.CustomFormat = true;
this.Format = (SlimDX.DXGI.Format)Enum.Parse(typeof(SlimDX.DXGI.Format), fmt, true);
}
var = pd.GetAnnotationByName("mips");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.Mips = b;
}
var = pd.GetAnnotationByName("scale");
if (var.IsValid)
{
this.Scale = var.AsScalar().GetFloat();
this.DoScale = true;
}
var = pd.GetAnnotationByName("initial");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.Reference = b ? eImageScaleReference.Initial : eImageScaleReference.Previous;
}
}
public override 数管理 数登録インスタンスを生成して返す(EffectVariable variable, エフェクト effect, int semanticIndex)
{
EffectVariable annotation = variable.GetAnnotationByName("SyncInEditMode");
bool syncMode = false;
if (annotation != null)
{
syncMode = (annotation.AsScalar().GetInt() == 1);
}
return(時間変数登録インスタンスを生成して返す(syncMode));
}
public static int GetIntAnnotation(this EffectPass ext, string name, int defaultvalue)
{
EffectVariable var = ext.GetAnnotationByName(name);
if (var.IsValid)
{
return(var.AsScalar().GetInt());
}
else
{
return(defaultvalue);
}
}
/// <summary>
/// Returns a Bool annotation techniques specified in
/// </summary>
/// <param name="technique">Techniques</param>
/// <param name="attrName">Annotation name</param>
/// <returns>Value</returns>
public static ExtendedBoolean getAnnotationBoolean(EffectTechnique technique, string attrName)
{
EffectVariable annotationVariable = getAnnotation(technique, attrName, "bool");
if (annotationVariable == null)
{
return(ExtendedBoolean.Ignore);
}
int annotation = annotationVariable.AsScalar().GetInt();
if (annotation == 1)
{
return(ExtendedBoolean.Enable);
}
return(ExtendedBoolean.Disable);
}
/// <summary>
/// 指定したテクニックの指定したアノテーションをBool値で取得します
/// </summary>
/// <param name="technique">テクニック</param>
/// <param name="attrName">アノテーション名</param>
/// <returns>値</returns>
public 状態Boolean getAnnotationBoolean(EffectTechnique technique, string attrName)
{
EffectVariable annotationVariable = EffectParseHelper.アノテーションを取得する(technique, attrName);
if (annotationVariable == null)
{
return(状態Boolean.無視);
}
int annotation = annotationVariable.AsScalar().GetInt();
if (annotation == 1)
{
return(状態Boolean.効);
}
return(状態Boolean.無効);
}
public override void Apply(DX11ShaderInstance shaderinstance, DX11RenderSettings settings)
{
if (settings.BackBuffer != null)
{
EffectVariable counter = this.variable.GetAnnotationByName("counter");
if (counter != null)
{
float cnt = counter.AsScalar().GetFloat();
shaderinstance.SetByName(this.Name, settings.BackBuffer.UAV, (int)cnt);
}
else
{
if (settings.ResetCounter)
{
shaderinstance.SetByName(this.Name, settings.BackBuffer.UAV, settings.CounterValue);
}
else
{
shaderinstance.SetByName(this.Name, settings.BackBuffer.UAV);
}
}
}
}
protected override void SetDefault(InputAttribute attr, EffectVariable var)
{
attr.DefaultValue = var.AsScalar().GetFloat();
}
public static void Set(this EffectVariable var, float[] value)
{
var.AsScalar().Set(value);
}
public ImageShaderPass(EffectPass pd)
{
this.Mips = false;
this.CustomFormat = false;
this.ScaleVector = new Vector2(1, 1);
this.DoScale = false;
this.Reference = eImageScaleReference.Previous;
this.BlendPreset = "";
this.DepthPreset = "";
this.UseDepth = false;
this.HasState = false;
this.KeepTarget = false;
this.Absolute = false;
this.IterationCount = 1;
this.ComputeData = new ImageComputeData(pd);
EffectVariable var = pd.GetAnnotationByName("format");
if (var.IsValid)
{
string fmt = var.AsString().GetString();
this.CustomFormat = true;
this.Format = (SlimDX.DXGI.Format)Enum.Parse(typeof(SlimDX.DXGI.Format), fmt, true);
}
var = pd.GetAnnotationByName("mips");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.Mips = b;
}
var = pd.GetAnnotationByName("scale");
if (var.IsValid)
{
if (var.GetVariableType().Description.Class == ShaderVariableClass.Scalar)
{
float s = var.AsScalar().GetFloat();
this.ScaleVector = new Vector2(s, s);
this.DoScale = true;
}
if (var.GetVariableType().Description.Class == ShaderVariableClass.Vector)
{
Vector4 s = var.AsVector().GetVector();
this.ScaleVector = new Vector2(s.X, s.Y);
this.DoScale = true;
}
var = pd.GetAnnotationByName("absolute");
if (var.IsValid && var.GetVariableType().Description.Class == ShaderVariableClass.Scalar)
{
this.Absolute = var.AsScalar().GetFloat() > 0.5f;
}
}
var = pd.GetAnnotationByName("initial");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.Reference = b ? eImageScaleReference.Initial : eImageScaleReference.Previous;
}
var = pd.GetAnnotationByName("iterations");
if (var.IsValid)
{
try
{
int i = var.AsScalar().GetInt();
this.IterationCount = Math.Max(1, i);
}
catch
{
}
}
var = pd.GetAnnotationByName("clear");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.Clear = b;
}
var = pd.GetAnnotationByName("usedepth");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.UseDepth = b;
}
var = pd.GetAnnotationByName("keeptarget");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.KeepTarget = b;
}
var = pd.GetAnnotationByName("hasstate");
if (var.IsValid)
{
bool b = var.AsScalar().GetFloat() > 0.5f;
this.HasState = b;
}
var = pd.GetAnnotationByName("blendpreset");
if (var.IsValid)
{
string blend = var.AsString().GetString();
this.BlendPreset = blend;
}
var = pd.GetAnnotationByName("depthpreset");
if (var.IsValid)
{
string depth = var.AsString().GetString();
this.DepthPreset = depth;
}
}
public override void 数を更新する(EffectVariable 数, 数更新時引数 引数)
{
var currentModel = RenderContext.Instance.描画ターゲットコンテキスト.ワールド空間.Drawableを取得する(_name);
if (currentModel == null)
{
return;
}
IDrawable targetDrawable = (_isSelf) ? 引数.モデル : currentModel;
if (_target == TargetObject.UnUsed)
{
switch (_variableType)
{
case 数型.Float4x4:
数.AsMatrix().SetMatrix(RenderContext.Instance.行列管理.ワールド行列管理.モデルのワールド変換行列を作成して返す(targetDrawable));
break;
case 数型.Float3:
数.AsVector().Set(targetDrawable.モデル状態.位置);
break;
case 数型.Float4:
数.AsVector().Set(new Vector4(targetDrawable.モデル状態.位置, 1f));
break;
case 数型.Float:
数.AsScalar().Set(targetDrawable.モデル状態.率.Length());
break;
case 数型.Bool:
数.AsScalar().Set(targetDrawable.表示中);
break;
default:
break;
}
}
else if (_target == TargetObject.BoneName)
{
IEnumerable <PMXボーン> targetBone = (from bone in ((PMXModel)targetDrawable).スキニング.ボーン配列 where bone.ボーン名 == _itemName select bone);
foreach (var bone in targetBone)
{
Matrix mat = bone.モデルポーズ行列 * RenderContext.Instance.行列管理.ワールド行列管理.モデルのワールド変換行列を作成して返す(targetDrawable);
switch (_variableType)
{
case 数型.Float4x4:
数.AsMatrix().SetMatrix(mat);
break;
case 数型.Float3:
数.AsVector().Set(Vector3.TransformCoordinate(bone.ローカル位置, mat));
break;
case 数型.Float4:
数.AsVector().Set(new Vector4(Vector3.TransformCoordinate(bone.ローカル位置, mat), 1f));
break;
default:
break;
}
break;
}
}
else if (_target == TargetObject.FaceName)
{
モーフ管理 morphManager = ((PMXModel)targetDrawable).モーフ管理;
数.AsScalar().Set(morphManager.モーフの進捗率を返す(_name));
}
else
{
switch (_target)
{
case TargetObject.X:
数.AsScalar().Set(targetDrawable.モデル状態.位置.X);
break;
case TargetObject.Y:
数.AsScalar().Set(targetDrawable.モデル状態.位置.Y);
break;
case TargetObject.Z:
数.AsScalar().Set(targetDrawable.モデル状態.位置.Z);
break;
case TargetObject.XYZ:
数.AsVector().Set(targetDrawable.モデル状態.位置);
break;
case TargetObject.Rx:
case TargetObject.Ry:
case TargetObject.Rz:
case TargetObject.Rxyz:
float xRotation, yRotation, zRotation; //X,Y,Z軸回転量に変換する。
//int type = 0; //分解パターン
if (!CGHelper.クォータニオンをXYZ回転に分解する(targetDrawable.モデル状態.回転, out xRotation, out yRotation, out zRotation))
{
if (!CGHelper.クォータニオンをYZX回転に分解する(targetDrawable.モデル状態.回転, out yRotation, out zRotation, out xRotation))
{
CGHelper.クォータニオンをZXY回転に分解する(targetDrawable.モデル状態.回転, out zRotation, out xRotation, out yRotation);
// type = 2;
}
else
{
// type = 1;
}
}
else
{
// type = 0;
}
if (_target == TargetObject.Rx)
{
数.AsScalar().Set(xRotation);
}
else if (_target == TargetObject.Ry)
{
数.AsScalar().Set(yRotation);
}
else if (_target == TargetObject.Rz)
{
数.AsScalar().Set(zRotation);
}
else
{
数.AsVector().Set(new Vector3(xRotation, yRotation, zRotation));
}
break;
case TargetObject.Si:
数.AsScalar().Set(targetDrawable.モデル状態.率.Length());
break;
case TargetObject.Tr:
// TODO: Trへの対応
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public override void 数を更新する(EffectVariable 数, 数更新時引数 引数)
{
// ターゲットオブジェクトに依存しない
数.AsScalar().Set(引数.材質.エッジ幅); // エッジ幅は材質モーフ適用後の値。
}
public override void 数を更新する(EffectVariable 数, 数更新時引数 引数)
{
数.AsScalar().Set(引数.材質.テッセレーション係数);
}
protected override void SetDefault(InputAttribute attr, EffectVariable var)
{
attr.DefaultValue = var.AsScalar().GetFloat();
attr.IsBang = var.IsBang();
this.isbang = attr.IsBang;
}
public override void 数を更新する(EffectVariable 数, 数更新時引数 引数)
{
数.AsScalar().Set(引数.材質.スフィアモード == スフィアモード.加算);
}
public override void Subscribe(EffectVariable subscribeTo, SubscribeArgument argument)
{
subscribeTo.AsScalar().Set(argument.Material.IsToonUsed);
}
/// <summary>
/// テクスチャのアノテーション解釈に一般的に必要な項目を取得するメソッド
/// </summary>
/// <param name="variable">エフェクト変数</param>
/// <param name="context">レンダーコンテキスト</param>
/// <param name="defaultFormat"></param>
/// <param name="defaultViewPortRatio"></param>
/// <param name="width">テクスチャの幅</param>
/// <param name="height">テクスチャの高さ</param>
/// <param name="depth">テクスチャの深さ(ない場合は-1)</param>
/// <param name="mip">mipレベル</param>
/// <param name="textureFormat">指定されているフォーマット</param>
public static void GetBasicTextureAnnotations(EffectVariable variable, RenderContext context, Format defaultFormat, Vector2 defaultViewPortRatio, bool isTextureSubscriber, out int width, out int height, out int depth,
out int mip, out Format textureFormat)
{
width = -1;
height = -1;
depth = -1;
mip = 0;
textureFormat = defaultFormat;
EffectVariable rawWidthVal = EffectParseHelper.getAnnotation(variable, "width", "int");
EffectVariable rawHeightVal = EffectParseHelper.getAnnotation(variable, "height", "int");
EffectVariable rawDepthVal = EffectParseHelper.getAnnotation(variable, "depth", "int");
if (rawWidthVal != null)
{
width = rawWidthVal.AsScalar().GetInt();
}
if (rawHeightVal != null)
{
height = rawHeightVal.AsScalar().GetInt();
}
if (rawDepthVal != null)
{
depth = rawDepthVal.AsScalar().GetInt();
}
EffectVariable rawViewportRatio = EffectParseHelper.getAnnotation(variable, "viewportratio", "float2");
if (rawViewportRatio != null)
{
if (width != -1 || height != -1 || depth != -1)
{
throw new InvalidMMEEffectShaderException(
string.Format("変数「{0} {1}」のサイズ指定が不正です。Width,Height,Depth/ViewportRatio/Dimensionsはそれぞれ同時に使用できません。",
variable.GetVariableType().Description.TypeName.ToLower(), variable.Description.Name));
}
else
{
Vector4 rawRatio = rawViewportRatio.AsVector().GetVector();
Viewport vp = context.DeviceManager.Context.Rasterizer.GetViewports()[0];
width = (int)(vp.Width * rawRatio.X);
height = (int)(vp.Height * rawRatio.Y);
}
}
EffectVariable rawDimensions = EffectParseHelper.getAnnotation(variable, "dimension", "uint2/uint3");
if (rawDimensions != null)
{
if (width != -1 || height != -1 || depth != -1)
{
throw new InvalidMMEEffectShaderException(
string.Format(
"変数「{0} {1}」のサイズ指定が不正です。Width,Height,Depth/ViewportRatio/Dimensionsはそれぞれ同時に使用できません。",
variable.GetVariableType().Description.TypeName.ToLower(), variable.Description.Name));
}
else
{
string typeName = rawDimensions.GetVariableType().Description.TypeName.ToLower();
if (typeName == "int2")
{
int[] rawDimension = rawDimensions.AsVector().GetIntVectorArray(2);
width = rawDimension[0];
height = rawDimension[1];
}
else
{
int[] rawDimension = rawDimensions.AsVector().GetIntVectorArray(3);
width = rawDimension[0];
height = rawDimension[1];
depth = rawDimension[2];
}
}
}
if (width == -1 || height == -1)
{
if (defaultViewPortRatio != Vector2.Zero)
{
Viewport port = context.DeviceManager.Context.Rasterizer.GetViewports()[0];
width = (int)(port.Width * defaultViewPortRatio.X);
height = (int)(port.Height * defaultViewPortRatio.Y);
}
else
{
if (!isTextureSubscriber)
{
throw new InvalidMMEEffectShaderException(string.Format("width,heightのどちらかの指定は必須です。"));
}
}
}
EffectVariable rawMipLevel = EffectParseHelper.getAnnotation(variable, "MipLevels", "int");
EffectVariable rawLevel = EffectParseHelper.getAnnotation(variable, "levels", "int");
if (rawMipLevel != null && rawLevel != null)
{
throw new InvalidMMEEffectShaderException(
string.Format("変数「{0} {1}」のミップマップレベルが重複して指定されています。「int Miplevels」、「int Levels」は片方しか指定できません。",
variable.GetVariableType().Description.TypeName.ToLower(), variable.Description.Name));
}
else if (rawMipLevel != null || rawLevel != null)
{
EffectVariable mipVal = rawMipLevel ?? rawLevel;
mip = mipVal.AsScalar().GetInt();
}
EffectVariable rawFormat = EffectParseHelper.getAnnotation(variable, "format", "string");
if (rawFormat != null)
{
string formatString = rawFormat.AsString().GetString();
textureFormat = TextureFormat(formatString);
}
}
public override void 数を更新する(EffectVariable 数, 数更新時引数 引数)
{
数.AsScalar().Set(引数.材質.トゥーンを使用する);
}
public override void Subscribe(EffectVariable subscribeTo, SubscribeArgument variable)
{
subscribeTo.AsScalar().Set(variable.Material.EdgeSize);
}
