Jump to content

  • Log In with Google      Sign In   
  • Create Account

Kylotan's Developer Journal

Still alive

Posted by , 23 July 2009 - - - - - - · 270 views

Hi guys, just a quick note to remind you that I'm still writing (very occasional) blog entries over at http://www.ebonyfortress.com/blog, and would love to see some of you posting comments. :)


This journal is moribund

Posted by , 18 May 2009 - - - - - - · 354 views

As much as I like GameDev.net, I find the journal system here to be underpowered - no tags, no categories, posts disappear from the front page if they're too old, poor support for inline formatting, etc. This has made me hesitate to spend time putting entries here, and the last one was eight months ago.

So in future, I will be posting on my own blog at http://www.ebonyfortress.com/blog/. It's using Wordpress, which is your typical example of crap-code-good-functionality, but it's functionality that counts here. Hopefully I'll see some of you over there, as well as through my continued presence on the forums here of course.


AI in games

Posted by , 01 September 2008 - - - - - - · 378 views

Hello GD Journal, it's been a while. Mostly because the journals are still exceedingly well separated from the rest of the site. I have no idea whose journals are worth reading - any suggestions?

At work, our development cycle is coming to a close and I have lots of reflections on the development process to share; but that will wait until after release.

At home, I am very slowly working on a web-based game, but have changed direction with it quite significantly after not only did I hit a problem, but I stumbled upon a solution at about the same time. Unfortunately it left me questioning a fundamental approach to my game, which I'll come to shortly.

Earlier this year I started a couple of threads on an algorithm for grouping a set of actors together so that they could perform tasks, the idea being that they'd gather as many actors as necessary, but not too many (as the reward would be diluted), and that certain actors were better suited to some tasks than others.

As you might see from the threads, should you be bored enough to read them, finding a good algorithm for this is quite difficult, especially since my original specifications are not exactly fixed in stone. I just wanted something that looked right, and defining it was surprisingly tricky. It was easier to list situations that I didn't want to happen, than to specify precisely what I did want. Such is the nature of all AI problems really - the trick is in finding the correct representation of your problem. In the end, I got the feeling that this system was unworkable; I found ways of having the characters group up for tasks, but it was usually quite predictable, and trying to influence them through the size of the reward was too coarse a tool.

That was when I found the solution, in the form of the football (ie. soccer to North America) management game, Championship Manager. The problem you face there is much the same as my problem, in that you have tasks to perform (in this case, football matches), and you have a pool of characters of differing abilities which must be combined to achieve this goal. Instead of the AI grouping the characters for you, you pick the team yourself.

This removes my initial aim of the characters being largely autonomous entities that work together to achieve a goal. But it arguably makes for better gameplay, by moving more interesting choices into the human player's hands. And so I can now move the game design and prototype forward with some solid principles that have been tested in the field and have done well with players (over 85% on Metacritic for recent instalments in the series, ie. the Football Manager games). But now the AI component is no longer part of the game.

This leads me to think, just how useful is AI in games? Quite a few of us rue the fact that so many computer opponents are stupid, but that tends to be a feature of faster paced games where foes run into walls, or aim like Imperial stormtroopers instead of like real soldiers, or where monsters would rather stand still and be hacked to death than run away or call for help. When we ask for better AI, we could have all of these with virtually no code time at all. Is that really what we're asking for? Or is there something more? I have the first 3 AI Wisdom books, and although every single article in them impresses me in some way, virtually none of the games I play or consider making would make use of any of these. For example, listing 101 ways to generate pathfinding nodes is all well and good, but not terribly interesting unless reducing CPU usage for AI from 5% to 2% is of interest.

I'd like to hear what AI you'd like to see in games, and perhaps why you think it isn't there yet (eg. deliberate design decision, lack of raw computing power, difficult to represent well as an algorithm, etc).


Here's an idea

Posted by , 08 November 2007 - - - - - - · 385 views

For so long we've seen newbies come on these forums, and say something like "I have a great idea for a game - how do I get it made?" The slightly more optimistic, or dare I say mercenary, may actually ask how they sell it, but the underlying concept is the same, in that someone with no knowledge of how the industry works comes on here thinking that a vision is valuable. Not only that, but they believe that their vision is valuable.

Board and industry veterans, myself included, chuckle inwardly and decide how best to deflate this newbie's hopes. A couple of people will mention that ideas are a dime a dozen, and that games companies don't buy ideas because their employees have loads already. Some may mention that games are expensive products, that those who make them are highly paid professionals, and that therefore the value comes in what you can bring to that process, because implementation is the hard part. Some will point out that companies won't look at idea submissions for legal reasons. Tom Sloper will post a link to his wonderfully detailed Sloperama advice site. The newcomer eventually experiences one of three emotions, disappointment (and often a loss of interest), resolve (to learn the tools to get their game made), or bitterness (that nobody can understand just how great their idea is).

All the while, the industry churns out crap. Yes, it's polished, enjoyable crap, but it's crap nonetheless. What sold well last year?

On the PC: World of Warcraft (sequel, admittedly in new genre), The Sims 2: Open for Business (expansion/sequel), The Sims 2 (sequel), The Elder Scrolls IV: Oblivion (sequel), Star Wars: Empire at War (license), Age of Empires III (sequel), Civilization IV (sequel), The Sims 2: Nightlife (expansion/sequel), Guild Wars: Factions (sequel), Zoo Tycoon 2 (sequel).

How about the PS2: Madden NFL 07 (the mother of all sequels/license), Kingdom Hearts II (sequel), Guitar Hero, Final Fantasy XII (the father of all sequels), NCAA Football 07 (sequel/license), Guitar Hero II (sequel), MLB 06: The Show (license/sequel), Scarface: The World is Yours (license), LEGO Star Wars II: The Original Trilogy (double license/sequel), Fight Night Round 3 (sequel).

XBox 360: Tom Clancy's Ghost Recon Advanced Warfighter (license/sequel), Madden NFL 07 (sequel/license), Gears of War, The Elder Scrolls IV: Oblivion (sequel), Fight Night Round 3 (sequel), Saints Row, Dead Rising, NCAA Football 07 (sequel/license), Call of Duty 3 (sequel), Tom Clancy's Splinter Cell: Double Agent (sequel/license).

Come on guys... this isn't just unfortunate, it's embarrassing.

And every time we tell a newbie that ideas are currently worth nothing, we are helping to perpetuate that lack of worth. This in turn perpetuates the crap above, where gamers scramble over each other to get their hands on Halo 3, a sequel to a sequel set in a cliché setting and a highly derivative genre. (And it wouldn't be surprising if even the Bungie guys, although proud of their work, were quite aware of just how little they are giving to the world by delivering yet more of the same when they are capable of so much more, thus setting the stage for them parting ways with Microsoft.) This is surely part of why Nolan Bushnell, responsible for so much innovation in games during the 80s, considers modern games 'unadulterated trash'.

Is there a better way?

Well, I'm certainly not arguing that every newbie with a 'k3wl g4me 1dea' should be taken seriously and have their work published. But on the other hand, the highly trained human factories who churned out the cloned dross above are certainly not going to be producing much of real worth either. Perhaps someone needs to be going through these external ideas and looking for the diamond in the rough? If, as we often see on the forums, an idea is just another RPG with their own particular permutation of the typical elements, then sure, toss it out. But if their idea is the next Guitar Hero, or Tetris, or Civilization, or Donkey Kong, or Elite, or... hell, anything that doesn't have an ordinal number as a suffix and a pre-existing property as a prefix - then shouldn't there be someone who can step in and deliver that to us?

Let's be fair, game design is not about merely coming up with a cool idea and selling it to someone else - it's about systems, as designer Raph Koster points out in a recent blog entry. Games are active and the design must manage the flow of the players and the non-players through the game space. This is not usually something you can adequately predict before building any prototypes. But does that mean the original idea is worthless? A good script can be rewritten as a screenplay, often rewritten several times before it can be shot as a film. But it doesn't mean the original script was worthless. Sometimes the original writer might be retained for some duration while the script is worked into something usable, and other times it might just be purchased from them. There can be overlap and cooperation between the person who holds an overall vision, and the person or people who buy into that vision but who better understand the systems they're working with.

Sure, many people who write for films find themselves rejected time and time again, and 99% of the submissions are probably useless, but does that mean that we should discount the other 1% (or 0.1%, or 10%) out of hand, in favour of trying to produce the same old software, relying on branding and licenses to carry it in the market? Is it perhaps worth investing in trying to cultivate new ideas? Or do we continue to rely on the ideas grown in-house, which don't seem to be delivering the goods?

There have been plenty of great game ideas out in the independent sphere, things like Braid, Immortal Defense, Virtual Villagers, Democracy. Sure, as with most games, they owe much to their predecessors, but they do not just update the graphics, or add a couple of extra weapons, or add a replay feature, or tack on yet another multiplayer mode. They bring significant new twists to the gameplay and presentation, to give us a new way of seeing games. Some make us think, not just in the "work out this puzzle" sort of way, but in the "ponder the human condition" sort of way. Why can't we expect a typical game to do this? When will a mainstream game have the same emotional impact as a game like Photopia?

I'm pretty sure I don't have all the answers to the problem. But I refuse to believe that "the market" dictates that people only want sequels and licenses. As with film and books, something new and special quickly carves its own niche if it's good enough. All we have to do is give it a decent chance and not bury it under the sequels and licenses which should be the bottom layer of our industry, not the top layer. We need to encourage interesting ideas and interesting takes on old ideas, and much of that is not going to come from within.


Squirrel

Posted by , 19 June 2007 - - - - - - · 419 views

Imagine you are a squirrel. You're at the foot of a large oak tree, contemplating climbing it to feast upon the acorny goodness that it offers. You start climbing up the trunk, and it provides a single obvious and reliable route up the tree. Eventually you reach branches, where you can choose the one that seems most appealing to you, perhaps holding the most acorns, or bigger acorns, or other squirrels to play with. If you end up choosing the wrong branch, you can back up and choose another one, and sometimes you can jump across from one branch to another one nearby. As you continue to climb, the branches get thinner and start to bend under your weight. The further up the tree you go, the more they move in response to your presence and that of the other squirrels. Sometimes this makes it easier to get to the other branches and liberate the acorns they hold, and other times you end up dangling in the middle of the air, needing to go back before you can proceed. But once you leave the branch, eventually it reverts back to its original position, ready for the next intrepid squirrel.

The tree is a persistent online game. The squirrels are players. The branches are courses of action that players or groups of players can take. Most games provide these branches, but they don't bend. You pick quests, carry them out in largely the same way that the last person did, and nothing changes as a result. You climb up the steel branch, get the acorn, then climb back down to the welded join to take the next branch.

A better system would involve a degree of flexibility. A player should have an impact on the game that influences their future choices and which is noticeable to the other players. There wouldn't be so much at early levels; this is the 'trunk' and the largest branches, which barely budge under your weight, and which are designed to be rigid introductions to the game, with little scope for error. Later on you get to have a real influence on the world, that gives better opportunities to make a difference. But when you withdraw from that area of the gameplay, it slowly bends back into place, giving other players the same opportunities that you had.

So, how do we build this flexibility in place, while keeping the 'springiness' that makes a branch snap back when a player leaves it? Perhaps players gradually accumulate more and more skills that allow them to alter the game world, but none of those alterations would be permanent - houses crumble, forests regrow, goblins migrate to different lairs. A better understanding of feedback systems might help here, allowing us to create sub-environments that can absorb a certain degree of player action before springing back in response. Better exploitation of the middle ground between 'repetitive grunt work' and 'high fantasy quests' when creating tasks for players might be lucrative; defending outposts or making diplomatic representations are the sort of activities that can both make a difference and yet legitimately be carried out by player after player without breaking the fiction. A Tale In The Desert shows one possible direction with many of the activities being social in nature, the fact that many players are doing the same quest becoming a benefit rather than a fiction-breaking distraction.

I'm not sure we have all the answers just yet, but I am sure that we can do better than the relatively rigid structures that we currently have in most such games.


Ivory Towers

Posted by , 25 April 2007 - - - - - - · 221 views

It's funny when people appear to live in some parallel dimension where they don't have to contend with the details of real life. Take this quote from "Efficient C++ Programming" in 2002:

Quote:
The language extension never became part of the language, but the optimization itself has become nearly universal. It is called the name return value optimization.[...] (At the time of this writing, I am aware of only two compilers that do not provide the named return value optimization: the GNU compiler gcc and Visual C++.)


Just which universe did Stanley B. Lippman dwell in where you could exclude MSVC and gcc and still consider a C++ feature 'universal'?


Inefficiency

Posted by , 19 April 2007 - - - - - - · 283 views

My short time in the games industry - 8 months or so - has been marked by inefficiency. I now have a good idea why games take so long and why so many projects are cancelled. Setting aside human error and egos, which are a major problem on the publisher side it seems, the development side is just plain inefficient, often because problems are solved in such a way that other things become harder.

Examples:

- source control systems: it keeps source backed up, it allows for revertions, and stops people trampling on each others work. All good. But it also leads to a fair bit of hassle - exclusive check-outs often make you wait for a file, shared check-outs make you waste time merging and checking automated merges. It also holds up bug fixes because a one-liner fix may now have to go through the update/merge/commit cycle.

- exotic architectures: it's often quite cool to write extensive systems that make a certain complex idea possible. eg. Call a function, and have it executed on multiple servers and clients automatically, with all passed in data members correctly serialised and reconstructed. Grrrreat idea. Now try wrestling with the lengthy code needed to create such functions and the data, and the 48-page long template errors you get at the slightest typo.

- data backed by SQL databases: these give you automatic persistence, standardised querying facilities, easy ability to locate your data on a different computer to the program doing the querying, etc. All good. Now try to write a common interface for such SQL-enabled objects, get it to work across inheritance, and guarantee that the code stays in sync with the SQL statements required to create the database. I never knew adding two integers to a C++ class could take 3 weeks before, but now I do.

- using complex template libraries like Boost: as seen in recent threads on the forums, many people swear that Boost makes their life easier - and it does - but Boost also makes your compile times longer - which it does. Longer compile times can't be shrugged off as irrelevant, as the compiler is a valuable tool in checking your code correctness at the low level, freeing you to think of the high level tasks. Faster builds also facilitate running tests, whether of an informal nature or of the Test Driven Development variety. Using complex template types inevitably means inserting them into headers, and that means bigger build times, and probably a reluctance to refactor code due to this. People talk about using the pImpl idiom to help here, but let's not kid ourselves - the pImpl idiom is a workaround to sidestep problems with the language. It's extra work, no two ways about it.

All these facilities do Great Things. There's no denying it. But you pay a price. And I fear that all we're doing is shuffling the burden around rather than eliminating it.

I think the answer to some of these problem will look something like a word that starts with 'P' and ends with 'ython', but I'll go into that another time.


User-friendly error messages from MS Visual C++

Posted by , 01 April 2007 - - - - - - · 180 views

Compiling...

\Dev\GameProjects\FSProjects\FSLibs\ServerLogic\Source\Actor_ServerLogic.cpp(1435) : error C2679: binary '=' : no operator found which takes a right-hand operand of type 'double' (or there is no acceptable conversion)
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::G
enericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\ReferenceMetaProperty.h(75) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see ref
erence to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectMetaProperty.h(70) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
D:\Dev\CoreLibs\Reflection\DecoratedObjectSequenceMetaProperty.h(56) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=double
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericMetaProperty<TProperty>' being compiled
with
[
TProperty=std::string
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=bool
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint8
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint16
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=int32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=uint32
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class template instantiation 'Reflection::GenericDecoratedMetaProperty<TProperty>' being compiled
with
[
TProperty=float
]
d:\Dev\CoreLibs\Reflection\ObjectSequenceMetaProperty.h(51) : see reference to class Read Full Entry »
1 comments





Recent Entries

Recent Comments