void ProcessSaw(float[] buffer, int samplesPerBuffer, ProcArgs pargs)
{
const int fix = 0x70;
int bufPos = 0;
do
{
interPos += pargs.InterStep;
if (interPos >= 1)
{
interPos--;
}
int var1 = (int)(interPos * 0x100) - fix;
int var2 = (int)(interPos * 0x10000) << 17;
int var3 = var1 - (var2 >> 27);
pos = var3 + (pos >> 1);
float baseSamp = (float)pos / 0x100;
buffer[bufPos++] += baseSamp * pargs.LeftVol;
buffer[bufPos++] += baseSamp * pargs.RightVol;
pargs.LeftVol += pargs.LeftVolStep;
pargs.RightVol += pargs.RightVolStep;
} while (--samplesPerBuffer > 0);
}
void ProcessTri(float[] buffer, uint samplesPerBuffer, ProcArgs pargs)
{
int bufPos = 0;
do
{
interPos += pargs.InterStep;
if (interPos >= 1)
{
interPos--;
}
float baseSamp;
if (interPos < 0.5f)
{
baseSamp = interPos * 4 - 1;
}
else
{
baseSamp = 3 - (interPos * 4);
}
buffer[bufPos++] += baseSamp * pargs.LeftVol;
buffer[bufPos++] += baseSamp * pargs.RightVol;
pargs.LeftVol += pargs.LeftVolStep;
pargs.RightVol += pargs.RightVolStep;
} while (--samplesPerBuffer > 0);
}
public void Test_Procedure_CanLookup()
{
var descriptor = this.FindPage("LocatorQuery2");
var args = new ProcArgs(typeof(int), typeof(object));
var factory = this.engine.Proc(descriptor, args);
factory.ShouldNotBeNull();
}
public void Page_WithResultObject_CanConvertFromAnyType()
{
PageDescriptor descriptor = this.FindPage("LocatorQuery2");
ProcArgs args1 = new ProcArgs(typeof(object), typeof(int));
ProcArgs args2 = new ProcArgs(typeof(object), typeof(string));
this.engine.Proc(descriptor, args1).ShouldNotBeNull();
this.engine.Proc(descriptor, args2).ShouldNotBeNull();
}
public void Page_IfExists_ReturnsFactory()
{
PageDescriptor descriptor = this.FindPage("LocatorQuery2");
ProcArgs args = new ProcArgs(typeof(int), typeof(object));
ProcFactory factory = this.engine.Proc(descriptor, args);
factory.ShouldNotBeNull();
}
public void Test_Page_ResultVariance()
{
var descriptor = this.FindPage("LocatorQuery2");
var args1 = new ProcArgs(typeof(object), typeof(int));
var args2 = new ProcArgs(typeof(object), typeof(string));
this.engine.Proc(descriptor, args1).ShouldNotBeNull();
this.engine.Proc(descriptor, args2).ShouldNotBeNull();
}
public void Test_Procedure_CannotLookup_NoDomain()
{
var descriptor = this.locator.FindPage("NoDomainQuery", typeof(NoDomainAccessor));
var args = new ProcArgs(typeof(object), typeof(object));
descriptor.ShouldNotBeNull();
descriptor.DomainType.ShouldBeNull();
Should.Throw <ProcExecutionException>(() => this.engine.Proc(descriptor, args));
}
public void Proc_IfNoDomainAssociated_ThrowsExpectedException()
{
PageDescriptor descriptor = this.locator.FindPage("NoDomainQuery", typeof(NoDomainAccessor));
ProcArgs args = new ProcArgs(typeof(object), typeof(object));
descriptor.ShouldNotBeNull();
descriptor.DomainType.ShouldBeNull();
Should.Throw <ProcExecutionException>(() => this.engine.Proc(descriptor, args));
}
public string Sql <TModel, TResult>(Runnable <TModel, TResult> model)
{
IProcLocator locator = this.Context?.Locator ?? new ProcLocator();
IProcEngine engine = this.Context?.Engine ?? new ProcEngine(null);
PageDescriptor descriptor = locator.FindPage("Query", this.GetType());
ProcArgs args = new ProcArgs(typeof(Runnable <TModel, TResult>), typeof(List <TResult>));
ProcFactory factory = engine.Proc(descriptor, args);
return(factory(model).Buffer.ReadToEnd().Text.Trim());
}
public void Page_CanResolveFactory_WithoutDomain()
{
PageDescriptor descriptor = this.locator.FindPage("NoDomainQuery", typeof(NoDomainAccessor));
ProcArgs args = new ProcArgs(typeof(object), typeof(object));
descriptor.ShouldNotBeNull();
descriptor.DomainType.ShouldBeNull();
PageFactory factory = Should.NotThrow(() => this.engine.Page(descriptor.PageType));
factory.ShouldNotBeNull();
}
public void Test_Page_CanLookup_NoDomain()
{
var descriptor = this.locator.FindPage("NoDomainQuery", typeof(NoDomainAccessor));
var args = new ProcArgs(typeof(object), typeof(object));
descriptor.ShouldNotBeNull();
descriptor.DomainType.ShouldBeNull();
var factory = Should.NotThrow(() => this.engine.Page(descriptor.PageType));
factory.ShouldNotBeNull();
}
void ProcessNormal(float[] buffer, int samplesPerBuffer, ProcArgs pargs)
{
float GetSample(int position)
{
position += sample.GetOffset();
return((sample.bUnsigned ? ROM.Instance.Reader.ReadByte(position) - 0x80 : ROM.Instance.Reader.ReadSByte(position)) / (float)0x80);
}
int bufPos = 0;
do
{
float baseSamp = GetSample(pos);
float deltaSamp;
if (pos + 1 >= sample.Length)
{
deltaSamp = sample.bLoop ? GetSample(sample.LoopPoint) - baseSamp : 0;
}
else
{
deltaSamp = GetSample(pos + 1) - baseSamp;
}
float finalSamp = baseSamp + deltaSamp * interPos;
buffer[bufPos++] += finalSamp * pargs.LeftVol;
buffer[bufPos++] += finalSamp * pargs.RightVol;
pargs.LeftVol += pargs.LeftVolStep;
pargs.RightVol += pargs.RightVolStep;
interPos += pargs.InterStep;
int posDelta = (int)interPos;
interPos -= posDelta;
pos += posDelta;
if (pos >= sample.Length)
{
if (sample.bLoop)
{
pos = sample.LoopPoint;
}
else
{
Stop();
break;
}
}
} while (--samplesPerBuffer > 0);
}
public ProcCacheKey(PageDescriptor descriptor, ProcArgs args)
{
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
this.PageType = descriptor.PageType;
this.ModelType = args.ModelType;
this.ResultType = args.ResultType;
}
void ProcessSquare(float[] buffer, int samplesPerBuffer, ProcArgs pargs)
{
float CalcThresh(int val)
{
int iThreshold = (gsPSG.MinimumCycle << 24) + val;
iThreshold = (iThreshold < 0 ? ~iThreshold : iThreshold) >> 8;
iThreshold = iThreshold * gsPSG.CycleAmplitude + (gsPSG.InitialCycle << 24);
return(iThreshold / (float)0x100000000);
}
int curPos = pos += (processStep == 0 ? gsPSG.CycleSpeed << 24 : 0);
int nextPos = curPos + (gsPSG.CycleSpeed << 24);
float curThresh = CalcThresh(curPos), nextThresh = CalcThresh(nextPos);
float deltaThresh = nextThresh - curThresh;
float baseThresh = curThresh + (deltaThresh * (processStep / (float)Config.Instance.InterFrames));
float threshStep = deltaThresh / Config.Instance.InterFrames * SoundMixer.Instance.SamplesReciprocal;
float fThreshold = baseThresh;
int bufPos = 0;
do
{
float baseSamp = interPos < fThreshold ? 0.5f : -0.5f;
baseSamp += 0.5f - fThreshold;
fThreshold += threshStep;
buffer[bufPos++] += baseSamp * pargs.LeftVol;
buffer[bufPos++] += baseSamp * pargs.RightVol;
pargs.LeftVol += pargs.LeftVolStep;
pargs.RightVol += pargs.RightVolStep;
interPos += pargs.InterStep;
if (interPos >= 1)
{
interPos--;
}
} while (--samplesPerBuffer > 0);
}
