private static bool UsesFun(Axiom axiom, Function fun)
{
var visitor = new FunctionIsReferencedVisitor(fun);
visitor.VisitAxiom(axiom);
return(visitor.Found);
}
public void AddAxiom(Axiom axiom)
{
string axiomName = QKeyValue.FindStringAttribute(axiom.Attributes, "name");
if (axiomName == null)
{
return;
}
var previous = (Axiom)axioms[axiomName];
if (previous == null)
{
axioms.Add(axiomName, axiom);
}
else
{
var r = (Axiom)SelectNonExtern(axiom, previous);
if (r == null)
{
Error(axiom, "more than one declaration of axiom name: {0}", axiomName);
}
else
{
axioms[axiomName] = r;
}
}
}
public void TestAddCardAddsTheCardToThePalette()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Orange, Number.Three, axiom),
new Card(Colour.Blue, Number.Seven, axiom),
new Card(Colour.Red, Number.One, axiom)
};
ICard card = new Card(Colour.Violet, Number.Four, axiom);
IPalette palette = new Palette(cards);
// ACT
palette.AddCard(card);
// ASSERT
Assert.AreEqual(expected: cards.Count + 1, actual: palette.Cards.Count);
bool found = palette.Cards
.Where(c => c.Colour == card.Colour)
.Any(c => c.Number == card.Number);
Assert.IsTrue(found, "Card exists");
}
public override void AddAxiom(Axiom ax, string attributes)
{
//Contract.Requires(ax != null);
base.AddAxiom(ax, attributes);
axiomConjuncts.Add(translator.Translate(ax.Expr));
}
public void AssertParseMethod042()
{
// Arrange
const string text = @"Awaiting authorization permits with work Description ""Some description"".";
var sentences = SentenceParser.Parse(new Parser(text));
// Act
var actual = EvisionLanguageProcessor.Processor.Parse(sentences.First());
// Assert
var expected = new QueryDefinition
{
Target = "permit",
Properties = new List <AttributeDefinition>
{
new AttributeDefinition(Create(TokenKind.None, "state", -1), new MultipartToken
{
CreateToken(TokenKind.None, "Awaiting", 0),
CreateToken(TokenKind.None, "authorization", 1),
}),
new AttributeDefinition(new MultipartToken
{
CreateToken(TokenKind.None, "work", 4),
CreateToken(TokenKind.None, "Description", 5),
}, Create(TokenKind.None, "\"Some description\"", 6)),
},
};
Axiom.AssertAreEqual(expected, actual);
}
public void AssertParseMethod018()
{
// Arrange
const string text = @"permits of type Cold worK .";
var sentences = SentenceParser.Parse(new Parser(text));
// Act
var actual = EvisionLanguageProcessor.Processor.Parse(sentences.First());
// Assert
var expected = new QueryDefinition
{
Target = "permit",
Properties = new List <AttributeDefinition>
{
new AttributeDefinition(Create(TokenKind.None, "type", 2), new MultipartToken
{
CreateToken(TokenKind.None, "Cold", 3),
CreateToken(TokenKind.None, "worK", 4),
}),
},
};
Axiom.AssertAreEqual(expected, actual);
}
public void AssertParseMethod034()
{
// Arrange
const string text = @"awaiting authorization Permits signEd last week.";
var sentences = SentenceParser.Parse(new Parser(text));
// Act
var actual = EvisionLanguageProcessor.Processor.Parse(sentences.First());
// Assert
var expected = new QueryDefinition
{
Target = "permit",
Properties = new List <AttributeDefinition>
{
new AttributeDefinition(Create(TokenKind.None, "state", -1), new MultipartToken
{
CreateToken(TokenKind.None, "awaiting", 0),
CreateToken(TokenKind.None, "authorization", 1),
}),
new AttributeDefinition(Create(TokenKind.None, "signEd", 3), new MultipartToken
{
CreateToken(TokenKind.None, "last", 4),
CreateToken(TokenKind.None, "week", 5),
}),
},
};
Axiom.AssertAreEqual(expected, actual);
}
public void AssertParseMethod041()
{
// Arrange
const string text = @"awaiting authorization Isolations signEd one year ago titled a.";
var sentences = SentenceParser.Parse(new Parser(text));
// Act
var actual = EvisionLanguageProcessor.Processor.Parse(sentences.First());
// Assert
var expected = new QueryDefinition
{
Target = "isolation",
Properties = new List <AttributeDefinition>
{
new AttributeDefinition(Create(TokenKind.None, "state", -1), new MultipartToken
{
CreateToken(TokenKind.None, "awaiting", 0),
CreateToken(TokenKind.None, "authorization", 1),
}),
new AttributeDefinition(Create(TokenKind.None, "signEd", 3), new MultipartToken
{
CreateToken(TokenKind.None, "one", 4),
CreateToken(TokenKind.None, "year", 5),
CreateToken(TokenKind.None, "ago", 6),
}),
new AttributeDefinition(Create(TokenKind.None, "titled", 7), Create(TokenKind.None, "a", 8)),
},
};
Axiom.AssertAreEqual(expected, actual);
}
public void TestAddNullCardThrowsArgumentNullException()
{
// ARRANGE
IAxiom axiom = new Axiom();
ICanvas canvas = new Canvas(axiom);
// ACT
ArgumentNullException argumentNullException = null;
try
{
canvas.AddCard(null);
}
catch (ArgumentNullException ex)
{
argumentNullException = ex;
}
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
// ASSERT
Assert.IsNotNull(argumentNullException);
}
private static void GenAxioms(Formula target, HashSet <Formula> formulas, Axiom a, Inference inference, HashSet <Formula> newF)
{
foreach (var f1 in formulas)
{
foreach (var f2 in formulas)
{
foreach (var f3 in formulas)
{
var f = SubstituteInFormula(a, f1, f2, f3);
if (f.Equals(target) == false)
{
var ok = true;
lock (inference)
{
ok = inference.Push(f);
}
if (ok)
{
ParseFormula(f, newF);
}
}
}
}
}
}
public void TestScoringCards()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Blue, Number.Five, axiom),
new Card(Colour.Red, Number.Seven, axiom),
new Card(Colour.Green, Number.Seven, axiom),
new Card(Colour.Blue, Number.Two, axiom),
};
IRule redRule = new RedRule();
IPalette palette = new Palette(cards);
// ACT
IList <ICard> scoringCards = redRule.ScoringCards(palette);
// ASSERT
Assert.IsNotNull(scoringCards);
Assert.AreEqual(expected: 1, scoringCards.Count);
ICard card = scoringCards.Single();
Assert.AreEqual(Colour.Red, card.Colour);
Assert.AreEqual(Number.Seven, card.Number);
}
public void AssertParseMethod033()
{
// Arrange
const string text = @"coLd woRk Permits signEd five days ago.";
var sentences = SentenceParser.Parse(new Parser(text));
// Act
var actual = EvisionLanguageProcessor.Processor.Parse(sentences.First());
// Assert
var expected = new QueryDefinition
{
Target = "permit",
Properties = new List <AttributeDefinition>
{
new AttributeDefinition(Create(TokenKind.None, "type", -1), new MultipartToken
{
CreateToken(TokenKind.None, "coLd", 0),
CreateToken(TokenKind.None, "woRk", 1),
}),
new AttributeDefinition(Create(TokenKind.None, "signEd", 3), new MultipartToken
{
CreateToken(TokenKind.None, "five", 4),
CreateToken(TokenKind.None, "days", 5),
CreateToken(TokenKind.None, "ago", 6),
}),
},
};
Axiom.AssertAreEqual(expected, actual);
}
public void AssertParseMethod003()
{
// Arrange
const string text = @"Permits with title ""Some Title"" signed by evision and in state ""c""";
var sentences = SentenceParser.Parse(new Parser(text));
// Act
var actual = EvisionLanguageProcessor.Processor.Parse(sentences.First());
// Assert
var expected = new QueryDefinition
{
Target = "permit",
Properties = new List <AttributeDefinition>
{
new AttributeDefinition(Create(TokenKind.None, "title", 2), Create(TokenKind.None, "\"Some Title\"", 3)),
new AttributeDefinition(new MultipartToken
{
CreateToken(TokenKind.None, "signed", 4),
CreateToken(TokenKind.Owner, "by", 5),
}, Create(TokenKind.None, "evision", 6)),
new AttributeDefinition(Create(TokenKind.None, "state", 9), Create(TokenKind.None, "\"c\"", 10)),
},
};
Axiom.AssertAreEqual(expected, actual);
}
public void TestScore()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Blue, Number.Five, axiom),
new Card(Colour.Red, Number.Seven, axiom),
new Card(Colour.Red, Number.Six, axiom),
new Card(Colour.Red, Number.Two, axiom),
new Card(Colour.Green, Number.Seven, axiom),
new Card(Colour.Blue, Number.Two, axiom),
};
IRule greenRule = new GreenRule(axiom);
IPalette palette = new Palette(cards);
// ACT
IRuleScore ruleScore = greenRule.Score(palette);
// ASSERT
Assert.IsNotNull(ruleScore);
Assert.AreEqual(expected: 3, actual: ruleScore.NumberOfCards);
Assert.IsNotNull(ruleScore.TopCard);
Assert.AreEqual(Colour.Red, ruleScore.TopCard.Colour);
Assert.AreEqual(Number.Six, ruleScore.TopCard.Number);
}
public void TestScoringCards()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Blue, Number.Five, axiom),
new Card(Colour.Red, Number.Four, axiom),
new Card(Colour.Green, Number.Four, axiom),
new Card(Colour.Blue, Number.Two, axiom),
};
IList <ICard> expectedScoringCards = new List <ICard>
{
new Card(Colour.Red, Number.Four, axiom),
new Card(Colour.Green, Number.Four, axiom),
};
IRule orangeRule = new OrangeRule();
IPalette palette = new Palette(cards);
// ACT
IList <ICard> scoringCards = orangeRule.ScoringCards(palette);
// ASSERT
Assert.IsNotNull(scoringCards);
Assert.AreEqual(expected: 2, scoringCards.Count);
foreach (ICard card in expectedScoringCards)
{
Assert.IsTrue(scoringCards.Any(c => c.CompareTo(card) == 0), card.ToString());
}
}
private static void GenAxiom(Inference inference, List <Formula> formulas, HashSet <Formula> allFormulas,
Formula target, Axiom a)
{
foreach (var f1 in formulas)
{
foreach (var f2 in formulas)
{
foreach (var f3 in formulas)
{
var f = SubstituteInFormula(a, f1, f2, f3);
if (f.Equals(target))
{
continue;
}
bool ok;
lock (inference)
{
if (inference.Contains(target))
{
return;
}
ok = inference.Push(f);
}
lock (allFormulas)
{
if (ok)
{
ParseFormula(f, allFormulas);
}
}
}
}
}
}
public void TestAddDuplicateCardThrowsAnException()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Orange, Number.Three, axiom),
new Card(Colour.Blue, Number.Seven, axiom),
new Card(Colour.Red, Number.One, axiom)
};
ICard duplicateCard = new Card(Colour.Orange, Number.Three, axiom);
IPalette palette = new Palette(cards);
// ACT
ArgumentException argumentException = null;
try
{
palette.AddCard(duplicateCard);
}
catch (ArgumentException ex)
{
argumentException = ex;
}
// ASSERT
if (argumentException != null)
{
Console.WriteLine(argumentException.ToString());
}
Assert.IsNotNull(argumentException, "Expected exception not thrown");
}
public virtual Axiom VisitAxiom(Axiom node)
{
Contract.Requires(node != null);
Contract.Ensures(Contract.Result <Axiom>() != null);
node.Expr = this.VisitExpr(node.Expr);
return(node);
}
void Start()
{
vector = new Vector();
savedVectors = new List <Vector>();
allRules = new List <RuleSet>();
axiom = Rule.GetRulesFromString("I");
sizeLine = Random.Range(2f, 7.5f);
widthLine = Random.Range(sizeLine / 2, sizeLine * 2);
angle = Random.Range(40f, 80f);
widthScaleFactor = Random.Range(0.9f, 0.98f);
rules = new RuleSet();
rules.AddRule('I', "FS");
rules.AddRule('S', "[[F-F+&SF*]F&[^F+F-FS]]");
allRules.Add(rules);
rules = new RuleSet();
rules.AddRule('I', "FFS");
rules.AddRule('S', "F[+F&-F+F-F^F*][-^&F+[F-F^F&+^F*]*]");
allRules.Add(rules);
foreach (Rule r in axiom)
{
r.Run(this);
}
}
/// <summary>method <c>CacheGenerationalInstructions</c> Final generation string is calculated and cached globally in the script </summary>
void CacheGenerationalInstructions()
{
currentString = Axiom.ToString(); //start with the base axiom
StringBuilder sb = new StringBuilder();
for (int i = 0; i < CurrentIteration; i++)
{
foreach (char c in currentString)
{
if (isStochastic)
{
sb.Append(ApplyStochasticProbablity(c)); //append randomised character set
}
else
{
sb.Append(parcelableRules.ContainsKey(c) ? parcelableRules[c] : c.ToString()); //append default character
}
}
currentString = sb.ToString();
sb.Clear(); //temp string to add is cleared
}
preloadedInstructions = currentString; //instructions are updated
if (isStochastic)
{
isStochastic = false; //to stop continual generation this value is stopped until clicked from the HUD script
}
}
public void TestCompareToNullThrowsException()
{
// ARRANGE
IAxiom axiom = new Axiom();
ICard topCard = new Card(Colour.Green, Number.Four, axiom);
const int numberOfCards = 4;
IRuleScore ruleScore = new RuleScore(numberOfCards, topCard);
// ACT
ArgumentNullException argumentNullException = null;
int comparison = 99;
try
{
comparison = ruleScore.CompareTo(null);
}
catch (ArgumentNullException exception)
{
argumentNullException = exception;
}
// ASSERT
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
Assert.IsNotNull(argumentNullException);
Assert.AreEqual(expected: 99, actual: comparison);
}
public static Expr Extract(Expr expr, Program program, List <Axiom> axioms)
{
Contract.Requires(expr != null && program != null && !program.TopLevelDeclarationsAreFrozen && axioms != null);
if (expr is LiteralExpr)
{
return(expr);
}
var extractor = new FunctionExtractor();
var body = extractor.VisitExpr(expr);
var name = program.FreshExtractedFunctionName();
var originalVars = extractor.Substitutions.Keys.ToList();
var formalInArgs = originalVars.Select(v => new Formal(Token.NoToken, new TypedIdent(Token.NoToken, extractor.Substitutions[v].Name, extractor.Substitutions[v].TypedIdent.Type), true)).ToList <Variable>();
var formalOutArg = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, name + "$result$", expr.Type), false);
var func = new Function(Token.NoToken, name, formalInArgs, formalOutArg);
func.AddAttribute("never_pattern");
var boundVars = originalVars.Select(k => extractor.Substitutions[k]);
var axiomCall = new NAryExpr(Token.NoToken, new FunctionCall(func), boundVars.Select(b => new IdentifierExpr(Token.NoToken, b)).ToList <Expr>());
axiomCall.Type = expr.Type;
axiomCall.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
var eq = LiteralExpr.Eq(axiomCall, body);
eq.Type = body.Type;
eq.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
if (0 < formalInArgs.Count)
{
var forallExpr = new ForallExpr(Token.NoToken, boundVars.ToList <Variable>(), new Trigger(Token.NoToken, true, new List <Expr> {
axiomCall
}), eq);
body = forallExpr;
forallExpr.Attributes = new QKeyValue(Token.NoToken, "weight", new List <object> {
new LiteralExpr(Token.NoToken, Basetypes.BigNum.FromInt(30))
}, null);
body.Type = Type.Bool;
}
else
{
body = eq;
}
var axiom = new Axiom(Token.NoToken, body);
func.DefinitionAxiom = axiom;
program.AddTopLevelDeclaration(func);
program.AddTopLevelDeclaration(axiom);
axioms.Add(axiom);
var call = new NAryExpr(Token.NoToken, new FunctionCall(func), originalVars.Select(v => new IdentifierExpr(Token.NoToken, v)).ToList <Expr>());
call.Type = expr.Type;
call.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
return(call);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
axiom = LSystem.Iterate(axiom, this);
Debug.Log(axiom);
}
}
public void TestRunsAreOfCorrectLength(int index, int expectedLength)
{
// ACT
IAxiom axiom = new Axiom();
// ASSERT
Assert.IsTrue(index < axiom.Runs.Count);
Assert.AreEqual(expectedLength, axiom.Runs[index].Length);
}
void Input_KeyDown(object sender, Axiom.Input.KeyEventArgs e)
{
if (e.Key == KeyCodes.Escape)
{
Environment.Exit(Environment.ExitCode);
}
Core.BrowserManager[_browserId].KeyDown(CreateWebKeyboardEvent(e, WebKeyType.KeyDown));
}
public override void CheckMouseButtonPressed( Axiom.Input.MouseButtons button, out bool isPressed )
{
isPressed = false;
if ( button == Axiom.Input.MouseButtons.Left || _gpState.IsButtonDown( XInput.Buttons.A ) )
isPressed = true;
if ( button == Axiom.Input.MouseButtons.Right || _gpState.IsButtonDown( XInput.Buttons.B ) )
isPressed = true;
}
private Microsoft.Xna.Framework.Input.Keys Convert( Axiom.Input.KeyCodes key )
{
switch ( key )
{
case Axiom.Input.KeyCodes.G:
return Microsoft.Xna.Framework.Input.Keys.G;
default:
return Microsoft.Xna.Framework.Input.Keys.BrowserFavorites;
}
}
public override void CheckMouseButtonPressed( Axiom.Input.MouseButtons button, out bool isPressed )
{
isPressed = false;
if ( button == Axiom.Input.MouseButtons.Left && _mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed )
isPressed = true;
if ( button == Axiom.Input.MouseButtons.Right && _mouseState.RightButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed )
isPressed = true;
}
WebKeyboardEvent CreateWebKeyboardEvent(Axiom.Input.KeyEventArgs e, WebKeyType type)
{
return new WebKeyboardEvent()
{
IsSystemKey = false,
Type = type,
Modifiers = AwesomiumUtil.ConvertModifierKeys(e.Modifiers),
VirtualKeyCode = AwesomiumUtil.ConvertKeyCodesToVirtualKey(e.Key)
};
}
public void TestConstructor()
{
// ARRANGE
IAxiom axiom = new Axiom();
// ACT
ICanvas actualCanvas = new Canvas(axiom);
// ASSERT
Assert.IsNotNull(actualCanvas);
}
private FilterViewModel CreateFilterViewModel(string propertyName, string startValue, string endValue = "", Axiom.Common.Enumerations.FilterCondition condition = Axiom.Common.Enumerations.FilterCondition.Equals)
{
FilterViewModel filter = new FilterViewModel();
filter.PropertyName = propertyName;
filter.StartValue = startValue;
if (!string.IsNullOrEmpty(endValue))
filter.EndValue = endValue;
filter.WhereCondition = Axiom.Common.Enumerations.PredicateCondition.And;
filter.FilterCondition = condition;
return filter;
}
public void TestConstructor()
{
// ARRANGE
IAxiom axiom = new Axiom();
// ACT
IRule greenRule = new GreenRule(axiom);
// ASSERT
Assert.AreEqual("Most even cards wins", greenRule.Description);
Assert.AreEqual(Colour.Green, greenRule.Colour);
}
WebKeyboardEvent CreateWebKeyboardEvent(Axiom.Input.KeyEventArgs e)
{
return new WebKeyboardEvent()
{
IsSystemKey = false,
Text = new ushort[] { (ushort)e.KeyChar, 0, 0, 0 },
Type = WebKeyType.Char,
Modifiers = AwesomiumUtil.ConvertModifierKeys(e.Modifiers),
VirtualKeyCode = VirtualKey.UNKNOWN
};
}
public void TestConstructor()
{
// ARRANGE
IAxiom axiom = new Axiom();
// ACT
IRule indigoRule = new IndigoRule(axiom);
// ASSERT
Assert.AreEqual("Most cards in a run", indigoRule.Description);
Assert.AreEqual(Colour.Indigo, indigoRule.Colour);
}
protected void CompleteDefInfo( GLenum glType, Axiom.Graphics.GpuProgramParameters.GpuConstantDefinition defToUpdate )
{
//Decode unifrom size and type
//Note GLSL ES never packs rows into float4's (from an API perspective anyway)
//therefore all values are tight in the buffer
switch ( glType )
{
case GLenum.Float:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Float1;
break;
case GLenum.FloatVec2:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Float2;
break;
case GLenum.FloatVec3:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Float3;
break;
case GLenum.FloatVec4:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Float4;
break;
case GLenum.Sampler2D:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Sampler2D;
break;
case GLenum.SamplerCube:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.SamplerCube;
break;
case GLenum.Int:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Int1;
break;
case GLenum.IntVec2:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Int2;
break;
case GLenum.IntVec3:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Int3;
break;
case GLenum.IntVec4:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Int4;
break;
case GLenum.FloatMat2:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Matrix_2X2;
break;
case GLenum.FloatMat3:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Matrix_3X3;
break;
case GLenum.FloatMat4:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Unknown;
break;
default:
defToUpdate.ConstantType = GpuProgramParameters.GpuConstantType.Unknown;
break;
}
//GL doesn't pad
defToUpdate.ElementSize = Axiom.Graphics.GpuProgramParameters.GpuConstantDefinition.GetElementSize( defToUpdate.ConstantType, false );
}
public void TestRunsPopulated()
{
// ARRANGE
const int expectedRunCount = 21;
// ACT
IAxiom axiom = new Axiom();
// ASSERT
Assert.IsTrue(axiom.Runs.Any());
Assert.AreEqual(expectedRunCount, axiom.Runs.Count);
}
public void TestInitialNumberOfCardsInPalette()
{
// ASSERT
const int expectedInitialNumberOfCardsInPalette = 1;
// ACT
IAxiom axiom = new Axiom();
int actualInitialNumberOfCardsInPalette = axiom.InitialNumberOfCardsInPalette;
// ASSERT
Assert.AreEqual(expectedInitialNumberOfCardsInPalette, actualInitialNumberOfCardsInPalette);
}
public void TestForEachColourReturnsCorrectRule(Colour colour)
{
// ARRANGE
IAxiom axiom = new Axiom();
// ACT
IRule actualRule = axiom.GetRule(colour);
// ASSERT
Assert.IsNotNull(actualRule);
Assert.AreEqual(colour, actualRule.Colour);
}
public override void CheckKeyPressed( Axiom.Input.KeyCodes key, out bool isPressed )
{
isPressed = false;
if ( key == Axiom.Input.KeyCodes.Escape || ( _gpState.IsButtonDown( XInput.Buttons.Back ) ) )
{
isPressed = true;
return;
}
XFG.Input.Keys xnaKey = Convert( key );
isPressed = !_keyboardState.IsKeyUp( xnaKey );
}
///<summary>
/// Should be called by HardwareBufferManager
///</summary>
public HardwarePixelBuffer(int width, int height, int depth,
Axiom.Media.PixelFormat format, BufferUsage usage,
bool useSystemMemory, bool useShadowBuffer)
: base(usage, useSystemMemory, useShadowBuffer)
{
this.width = width;
this.height = height;
this.depth = depth;
this.format = format;
// Default
rowPitch = width;
slicePitch = height * width;
sizeInBytes = height * width * depth * PixelUtil.GetNumElemBytes(format);
}
void Input_KeyUp(object sender, Axiom.Input.KeyEventArgs e)
{
Core.BrowserManager[_browserId].KeyUp(CreateWebKeyboardEvent(e, WebKeyType.KeyUp));
Core.BrowserManager[_browserId].KeyPress(CreateWebKeyboardEvent(e));
if (e.Key == KeyCodes.A)
{
_sceneNode.Rotate(new Vector3(0, 1, 0), 10f);
}
if ( e.Key == KeyCodes.D)
{
_sceneNode.Rotate(new Vector3(0, 1, 0), -1f);
}
}
private Microsoft.Xna.Framework.Input.Keys Convert( Axiom.Input.KeyCodes key )
{
switch ( key )
{
case Axiom.Input.KeyCodes.Escape:
return Microsoft.Xna.Framework.Input.Keys.Escape;
case Axiom.Input.KeyCodes.G:
return Microsoft.Xna.Framework.Input.Keys.G;
case Axiom.Input.KeyCodes.A:
return Microsoft.Xna.Framework.Input.Keys.A;
case Axiom.Input.KeyCodes.S:
return Microsoft.Xna.Framework.Input.Keys.S;
case Axiom.Input.KeyCodes.D:
return Microsoft.Xna.Framework.Input.Keys.D;
case Axiom.Input.KeyCodes.W:
return Microsoft.Xna.Framework.Input.Keys.W;
default:
return Microsoft.Xna.Framework.Input.Keys.Execute;
}
}
/// <summary>
/// Resolve uniform auto constant parameter with associated real data of this program
/// </summary>
/// <param name="autoType"> The auto type of the desired parameter </param>
/// <param name="type"> The desried data type of the auto parameter </param>
/// <param name="data"> The data to associate with the auto parameter </param>
/// <param name="size"> number of elements in the parameter </param>
/// <returns> parameter instance in case of that resolve operation succeeded, otherwise null </returns>
public UniformParameter ResolveAutoParameterReal( GpuProgramParameters.AutoConstantType autoType,
Axiom.Graphics.GpuProgramParameters.GpuConstantType type,
Real data, int size )
{
UniformParameter param = null;
//check if parameter already exists
param = GetParameterByAutoType( autoType );
if ( param != null )
{
if ( param.IsAutoConstantRealParameter && param.AutoConstantRealData == data )
{
param.Size = Axiom.Math.Utility.Max( size, param.Size );
return param;
}
}
//Create new parameter
param = new UniformParameter( autoType, data, size, type );
AddParameter( param );
return param;
}
public void OnUpdateInput(Axiom.Input.InputReader inputReader)
{
}
public void Initialise(Axiom.Core.Root item)
{
_root = item;
}
public override void NotifyCurrentCamera( Axiom.Core.Camera camera )
{
// Do nothing
}
/** Updates the level of detail to be used for rendering this PagingLandScapeRenderable based on the passed in Camera
*/
public override void NotifyCurrentCamera( Axiom.Core.Camera cam )
{
PagingLandscape.Camera plsmcam = (PagingLandscape.Camera) (cam);
this.isVisible = (init && loaded && plsmcam.GetVisibility(tileSceneNode.WorldAABB));
// this.isVisible = (init && loaded );
}
public abstract void GetWorldTransforms(Axiom.MathLib.Matrix4[] matrices);
protected void _setProgramParameter( GpuProgramType type, String paramName, Axiom.Math.Vector3 value )
{
_setProgramParameter( type, paramName, value, sizeof( float ) * 3 );
}
public override void NotifyCurrentCamera(Axiom.Core.Camera cam)
{
Debug.Assert(inBoundary);
if (((Camera)(cam)).IsObjectVisible(this.worldAABB))
{
isVisible = true;
}
else
{
isVisible = false;
return;
}
}
protected override void SetPosition(Axiom.MathLib.Vector3 newposition)
{
threeDsound.Position = new Vector3(newposition.x, newposition.y, newposition.z);
}
protected override void SetConeDirection(Axiom.MathLib.Vector3 direction)
{
Axiom.MathLib.Vector3 vector = direction;
threeDsound.ConeOrientation = new Vector3(vector.x, vector.y, vector.z);
}
protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, Axiom.Collections.NameValuePairList createParams )
{
return new Mesh( this, name, handle, group, isManual, loader );
}
private void _getVertices( ref Vector3[] points, Axiom.Animating.Bone bone )
{
Vector3 boneBase = bone.DerivedPosition;
foreach ( Axiom.Animating.Bone childBone in bone.Children )
{
// The tip of the bone:
Vector3 boneTip = childBone.DerivedPosition;
// the base of the bone
Vector3 arm = boneTip - boneBase;
Vector3 perp1 = arm.Perpendicular();
Vector3 perp2 = arm.Cross( perp1 );
perp1.Normalize();
perp2.Normalize();
float boneLen = arm.Length;
int offset = 6 * childBone.Handle;
points[ offset + 0 ] = boneTip;
points[ offset + 1 ] = boneBase;
points[ offset + 2 ] = boneBase + boneLen / 10 * perp1;
points[ offset + 3 ] = boneBase + boneLen / 10 * perp2;
points[ offset + 4 ] = boneBase - boneLen / 10 * perp1;
points[ offset + 5 ] = boneBase - boneLen / 10 * perp2;
_getVertices( ref points, childBone );
}
}
/// <summary>
///
/// </summary>
/// <param name="terrain"></param>
private void InitBlendMaps( Axiom.Components.Terrain.Terrain terrain )
{
TerrainLayerBlendMap blendMap0 = terrain.GetLayerBlendMap( 1 );
TerrainLayerBlendMap blendMap1 = terrain.GetLayerBlendMap( 2 );
Real minHeight0 = 70;
Real fadeDist0 = 40;
Real minHeight1 = 70;
Real fadeDist1 = 15;
float[] pBlend1 = blendMap1.BlendPointer;
int blendIdx = 0;
for ( ushort y = 0; y < terrain.LayerBlendMapSize; y++ )
{
for ( ushort x = 0; x < terrain.LayerBlendMapSize; x++ )
{
float tx = 0;
float ty = 0;
blendMap0.ConvertImageToTerrainSpace( x, y, ref tx, ref ty );
Real height = terrain.GetHeightAtTerrainPosition( tx, ty );
Real val = ( height - minHeight0 ) / fadeDist0;
val = Utility.Clamp( val, 0, 1 );
val = ( height - minHeight1 ) / fadeDist1;
val = Utility.Clamp( val, 0, 1 );
pBlend1[ blendIdx++ ] = val;
}
}
blendMap0.Dirty();
blendMap1.Dirty();
blendMap0.Update();
blendMap1.Update();
}
public override void CheckKeyPressed( Axiom.Input.KeyCodes key, out bool isPressed )
{
isPressed = false;
XFG.Input.Keys xnaKey = Convert( key );
isPressed = _keyboardState.IsKeyDown( xnaKey );
}
public override float GetSquaredViewDepth(Axiom.Core.Camera camera)
{
// Use squared length to avoid square root
return (this.ParentNode.DerivedPosition - camera.DerivedPosition).LengthSquared;
}
public static bool GetReal( AbstractNode node, out Axiom.Math.Real retVal )
{
return Scripting.Compiler.ScriptCompiler.Translator.getReal( node, out retVal );
}
public override void GetWorldTransforms( Axiom.Math.Matrix4[] matrices )
{
// return identity matrix to prevent parent transforms
matrices[ 0 ] = Matrix4.Identity;
}
/// <summary>
/// Populate a list of uniforms based on GLSL ES source.
/// </summary>
/// <param name="src"> Reference to the source code </param>
/// <param name="constantDefs"> The defs to populate (will not be cleared before adding, clear it yourself before calling this if that's what you want). </param>
/// <param name="fileName"> The file name this came from, for logging errors </param>
public void ExtractConstantDefs( string src, Axiom.Graphics.GpuProgramParameters.GpuNamedConstants constantDefs, string fileName )
{
// Parse the output string and collect all uniforms
// NOTE this relies on the source already having been preprocessed
// which is done in GLSLESProgram::loadFromSource
string line;
int currPos = src.IndexOf( "uniform" );
while ( currPos != -1 )
{
var def = new GpuProgramParameters.GpuConstantDefinition();
string paramName = string.Empty;
//Now check for using the word 'uniform' in a larger string & ignore
bool inLargerString = false;
if ( currPos != 0 )
{
char prev = src[ currPos - 1 ];
if ( prev != ' ' && prev != '\t' && prev != '\r' && prev != '\n' && prev != ';' )
{
inLargerString = true;
}
}
if ( !inLargerString && currPos + 7 < src.Length )
{
char next = src[ currPos + 7 ];
if ( next != ' ' && next != '\t' && next != '\r' && next != '\n' )
{
inLargerString = true;
}
}
//skip uniform
currPos += 7;
if ( !inLargerString )
{
//find terminatiing semicolon
int endPos = -1;
for ( int i = 0; i < src.Length; i++ )
{
if ( src[ i ] == ';' )
{
endPos = i;
break;
}
}
if ( endPos == -1 )
{
//problem, missing semicolon, abort
break;
}
line = src.Substring( currPos, endPos - currPos );
//remove spaces before opening square braces, otherwise the following split() can split the line at inapppropriate
//places (e.g. "vec3 sometihng [3]" won't work).
for ( int sqp = line.IndexOf( "[" ); sqp != -1; sqp = line.IndexOf( " [" ) )
{
line.Remove( sqp, 1 );
}
string[] parts = line.Split( '\t', '\r', '\n' );
foreach ( string i in parts )
{
//Is this a type
if ( this.typeEnumMap.ContainsKey( i ) )
{
this.CompleteDefInfo( this.typeEnumMap[ i ], def );
}
else
{
//If this is not a type, and not empty, it should be a name
string trim = i.Trim();
if ( trim.Length == 0 )
{
continue;
}
//Skip over precision keywords
if ( trim == "lowp" || trim == "mediump" || trim == "highp" )
{
continue;
}
int arrayStart = -1;
for ( int j = 0; j < trim.Length; j++ )
{
if ( trim[ j ] == '[' )
{
arrayStart = j;
break;
}
}
if ( arrayStart != -1 )
{
//potential name (if butted up to array)
string name = trim.Substring( 0, arrayStart );
name = name.Trim();
if ( name.Length > 0 )
{
paramName = name;
}
int arrayEnd = -1;
for ( int k = 0; k < trim.Length; k++ )
{
if ( trim[ k ] == ']' )
{
arrayEnd = k;
break;
}
}
string arrayDimTerm = trim.Substring( arrayStart + 1, arrayEnd - arrayStart - 1 );
arrayDimTerm = arrayDimTerm.Trim();
// the array term might be a simple number or it might be
// an expression (e.g. 24*3) or refer to a constant expression
// we'd have to evaluate the expression which could get nasty
// Ogre TODO
def.ArraySize = int.Parse( arrayDimTerm );
}
else
{
paramName = trim;
def.ArraySize = 1;
}
//Name should be after the type, so complete def and add
//We do this now so that comma-seperated params will do
//this part once for each name mentioned
if ( def.ConstantType == GpuProgramParameters.GpuConstantType.Unknown )
{
Axiom.Core.LogManager.Instance.Write( "Problem parsing the following GLSL Uniform: " + line + " in file " + fileName );
//next uniform
break;
}
//Complete def and add
//increment physical buffer location
def.LogicalIndex = 0; // not valid in GLSL
if ( def.IsFloat )
{
def.PhysicalIndex = constantDefs.FloatBufferSize;
constantDefs.FloatBufferSize += def.ArraySize * def.ElementSize;
}
else
{
def.PhysicalIndex = constantDefs.IntBufferSize;
constantDefs.IntBufferSize += def.ArraySize * def.ElementSize;
}
constantDefs.Map.Add( paramName, def );
}
}
}
//Find next one
currPos = src.IndexOf( "uniform" );
}
}