DDL Asset - Revision history

Therifboy at 13:42, 7 November 2015

2015-11-07T13:42:38Z

← Older revision		Revision as of 13:42, 7 November 2015
Line 4:		Line 4:
	[[Category:BO2]]		[[Category:BO2]]
	[[Category:BO3]]		[[Category:BO3]]
	The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops ~~1 and Black Ops 2~~. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.		The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in the Black Ops franchise. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	enum ddlPrimitiveTypes_e : unsigned int		enum ddlPrimitiveTypes_e : unsigned int

CraigChrist8239 at 06:58, 5 November 2015

2015-11-05T06:58:53Z

← Older revision		Revision as of 06:58, 5 November 2015
Line 3:		Line 3:
	[[Category:BO1]]		[[Category:BO1]]
	[[Category:BO2]]		[[Category:BO2]]
			[[Category:BO3]]
	The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.		The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
Line 17:		Line 18:
	DDL_STRING_TYPE = 0x7,		DDL_STRING_TYPE = 0x7,
	DDL_STRUCT_TYPE = 0x8,		DDL_STRUCT_TYPE = 0x8,
	DDL_ENUM_TYPE = 0x9		DDL_ENUM_TYPE = 0x9,
			#ifdef BO3
			DDL_PAD_TYPE = 0xA
			#endif
	};		};

	struct ddlHash_t		struct ddlHash_t
	{		{
			#ifdef BO3
			char * unknownData; //Size = unknownSize << 3
			int unknownSize;
			int unknown;
			#else
	int hash;		int hash;
	int index;		int index;
			#endif
	};		};

Line 31:		Line 41:
	int memberCount;		int memberCount;
	const char **members;		const char **members;
	#~~ifdef~~ BO2		#if defined(BO2) \|\| defined(BO3)
	ddlHash_t *hashTable;		ddlHash_t *hashTable;
	#endif		#endif
Line 39:		Line 49:
	{		{
	const char *name;		const char *name;
			#ifdef BO3
			int indexInParent;
			ddlStructDef_t * parent;
			char unknown2[0x4];
			#endif
	int size;		int size;
	int offset;		int offset;
Line 60:		Line 75:
	int memberCount;		int memberCount;
	ddlMemberDef_t *members;		ddlMemberDef_t *members;
	#~~ifdef~~ BO2		#if defined(BO2) \|\| defined(BO3)
	ddlHash_t *hashTable;		ddlHash_t *hashTable;
			#ifdef BO3
			ddlHash_t *hashTable2;
			#endif
	#endif		#endif
	};		};
Line 67:		Line 85:
	struct ddlDef_t		struct ddlDef_t
	{		{
			#ifdef BO3
			const char * name;
			short version;
			unsigned int checksum;
			char unknown1[0x4];
			int size;
			int unknown2;
			#else
	int version;		int version;
	int size;		int size;
			#endif
	ddlStructDef_t *structList;		ddlStructDef_t *structList;
	int structCount;		int structCount;
Line 74:		Line 101:
	int enumCount;		int enumCount;
	ddlDef_t *next;		ddlDef_t *next;
			#ifdef BO3
			char unknown3[0x14];
			#endif
	};		};

Red-EyeX32: /* Source Format */

2015-09-30T04:42:04Z

Source Format

← Older revision		Revision as of 04:42, 30 September 2015
Line 87:		Line 87:
	First enums must be dumped. These are very simple with each EnumEntry an individual enum and having a single string in the entries for each member of the enum.		First enums must be dumped. These are very simple with each EnumEntry an individual enum and having a single string in the entries for each member of the enum.

	Structures are the second and last item to be dumped. Each StructEntry is a structure to be used, and each MemberEntry is an item in the structure. Keep in mind that while IW's structureddatadef used normal lengths and byte offsets, the DDL uses bit offset/lengths and aligns almost nothing. Dumping the DDL should be fairly obvious when compared to the ~~structreddatadef~~.		Structures are the second and last item to be dumped. Each StructEntry is a structure to be used, and each MemberEntry is an item in the structure. Keep in mind that while IW's structureddatadef used normal lengths and byte offsets, the DDL uses bit offset/lengths and aligns almost nothing. Dumping the DDL should be fairly obvious when compared to the structureddatadef.

CraigChrist8239 at 21:19, 26 December 2014

2014-12-26T21:19:41Z

← Older revision		Revision as of 21:19, 26 December 2014
Line 5:		Line 5:
	The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.		The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	enum ddlPrimitiveTypes_e : int		enum ddlPrimitiveTypes_e : unsigned int
	{		{
	DDL_INVALID_TYPE = 0xFFFFFFFF,		DDL_INVALID_TYPE = 0xFFFFFFFF,
Line 17:		Line 17:
	DDL_STRING_TYPE = 0x7,		DDL_STRING_TYPE = 0x7,
	DDL_STRUCT_TYPE = 0x8,		DDL_STRUCT_TYPE = 0x8,
	DDL_ENUM_TYPE = 0x9,		DDL_ENUM_TYPE = 0x9
	};		};

CraigChrist8239 at 21:18, 26 December 2014

2014-12-26T21:18:34Z

← Older revision		Revision as of 21:18, 26 December 2014
Line 5:		Line 5:
	The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.		The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	enum ddlPrimitiveTypes_e		enum ddlPrimitiveTypes_e : int
	{		{
	DDL_INVALID_TYPE = 0xFFFFFFFF,		DDL_INVALID_TYPE = 0xFFFFFFFF,
Line 41:		Line 41:
	int size;		int size;
	int offset;		int offset;
	~~DataType~~ type;		ddlPrimitiveTypes_e type;
	int externalIndex;		int externalIndex;
	unsigned int rangeLimit;		unsigned int rangeLimit;

CraigChrist8239 at 21:13, 26 December 2014

2014-12-26T21:13:58Z

← Older revision		Revision as of 21:13, 26 December 2014
Line 5:		Line 5:
	The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.		The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	enum ~~DataType : int~~		enum ddlPrimitiveTypes_e
	{		{
	~~DT_INT8~~ = 0,		DDL_INVALID_TYPE = 0xFFFFFFFF,
	~~DT_INT16~~ = 1,		DDL_BYTE_TYPE = 0x0,
	~~DT_INT32~~ = 2,		DDL_SHORT_TYPE = 0x1,
	~~DT_U_INT32~~ = 3,		DDL_UINT_TYPE = 0x2,
	~~DT_INT64~~ = 4,		DDL_INT_TYPE = 0x3,
	~~DT_FLOAT~~ = 5,		DDL_INT64_TYPE = 0x4,
	~~DT_STRING~~ = 7,		DDL_FLOAT_TYPE = 0x5,
	~~DT_STRUCT~~ = 8		DDL_FIXEDPOINT_TYPE = 0x6,
			DDL_STRING_TYPE = 0x7,
			DDL_STRUCT_TYPE = 0x8,
			DDL_ENUM_TYPE = 0x9,
	};		};

CraigChrist8239 at 23:23, 20 December 2014

2014-12-20T23:23:56Z

← Older revision		Revision as of 23:23, 20 December 2014
Line 17:		Line 17:
	};		};

	struct ~~EntryData~~		struct ddlHash_t
	{		{
	int hash;		int hash;
	int ~~entryID~~;		int index;
	};		};

	struct ~~EnumEntry~~		struct ddlEnumDef_t
	{		{
	char *name;		const char *name;
	int ~~entryCount~~;		int memberCount;
	char **~~entries~~;		const char **members;
	#ifdef BO2 ~~//entryData only exists on Black Ops 2~~		#ifdef BO2
	~~EntryData~~ *~~entryData~~;		ddlHash_t *hashTable;
	#endif		#endif
	};		};

	struct ~~MemberEntry~~		struct ddlMemberDef_t
	{		{
	char *name;		const char *name;
	int ~~bitSize~~;		int size;
	int ~~bitOffset~~;		int offset;
	DataType ~~dataType~~;		DataType type;
	int ~~structType~~;		int externalIndex;
	int ~~unknown1[3]~~;		unsigned int rangeLimit;
	int ~~arrayCount~~;		unsigned int serverDelta;
			unsigned int clientDelta;
			int arraySize;
	int enumIndex;		int enumIndex;
	int ~~unknown2~~;		int permission;
	#ifdef BO1		#ifdef BO1
	int unknown3;		int unknown3;
Line 49:		Line 51:
	};		};

	struct ~~StructEntry~~		struct ddlStructDef_t
	{		{
	char *name;		const char *name;
	int ~~structSize~~;		int size;
	int ~~entryCount~~;		int memberCount;
	~~MemberEntry~~ *~~entries~~;		ddlMemberDef_t *members;
	#ifdef BO2		#ifdef BO2
	~~EntryData~~ *~~entryData~~;		ddlHash_t *hashTable;
	#endif		#endif
	};		};

	struct ~~DataDef~~		struct ddlDef_t
	{		{
	int ~~mainStructMemberCount~~;		int version;
	int ~~mainStructSize~~;		int size;
	~~StructEntry~~ *~~structEntries~~;		ddlStructDef_t *structList;
	int structCount;		int structCount;
	~~EnumEntry~~ *~~enumEntries~~;		ddlEnumDef_t *enumList;
	int enumCount;		int enumCount;
	~~DataDef~~ * next;		ddlDef_t *next;
	};		};

	struct ~~DataDefLanguage~~		struct ddlRoot_t
	{		{
	char *name;		const char *name;
	~~DataDef~~ *~~entires~~;		ddlDef_t *ddlDef;
	};		};
	</syntaxhighlight>		</syntaxhighlight>

CraigChrist8239 at 23:07, 13 January 2014

2014-01-13T23:07:19Z

← Older revision		Revision as of 23:07, 13 January 2014
Line 1:		Line 1:
			__NOTOC__
			[[Category:Assets]]
			[[Category:BO1]]
			[[Category:BO2]]
	The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.		The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">

CraigChrist8239: Created page with "The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The ..."

2014-01-13T23:06:37Z

Created page with "The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The ..."

New page

The DDL asset is Treyarch's equivalent to IW's structureddatadef asset and is used to store structure information. As such it only appears in Black Ops 1 and Black Ops 2. The acronym that "ddl" represents (Data Definition Language most likely, Data Definition Library, Dynamic Data Library?) is currently unknown.
<syntaxhighlight lang="cpp">
enum DataType : int
{
DT_INT8 = 0,
DT_INT16 = 1,
DT_INT32 = 2,
DT_U_INT32 = 3,
DT_INT64 = 4,
DT_FLOAT = 5,
DT_STRING = 7,
DT_STRUCT = 8
};

struct EntryData
{
int hash;
int entryID;
};

struct EnumEntry
{
char *name;
int entryCount;
char **entries;
#ifdef BO2 //entryData only exists on Black Ops 2
EntryData *entryData;
#endif
};

struct MemberEntry
{
char *name;
int bitSize;
int bitOffset;
DataType dataType;
int structType;
int unknown1[3];
int arrayCount;
int enumIndex;
int unknown2;
#ifdef BO1
int unknown3;
#endif
};

struct StructEntry
{
char *name;
int structSize;
int entryCount;
MemberEntry *entries;
#ifdef BO2
EntryData *entryData;
#endif
};

struct DataDef
{
int mainStructMemberCount;
int mainStructSize;
StructEntry *structEntries;
int structCount;
EnumEntry *enumEntries;
int enumCount;
DataDef * next;
};

struct DataDefLanguage
{
char *name;
DataDef *entires;
};
</syntaxhighlight>
== Source Format ==
The current public source format for DDLs is no good for the modding scene. It is similar to a string table with the name of the entries and their maximum and minimum values. A more useful format would be similar to the structureddatadefs with a structure and enums. DDLs are defined at "ddl/" for SP and shared DDLs, and at "ddl_mp/" for MP DDLs.

First enums must be dumped. These are very simple with each EnumEntry an individual enum and having a single string in the entries for each member of the enum.

Structures are the second and last item to be dumped. Each StructEntry is a structure to be used, and each MemberEntry is an item in the structure. Keep in mind that while IW's structureddatadef used normal lengths and byte offsets, the DDL uses bit offset/lengths and aligns almost nothing. Dumping the DDL should be fairly obvious when compared to the structreddatadef.