Editing Resources/DvScene (section)

== Technical Info ==
All of the pointers in DvScene are 32-bit and relative to DvCommon.

This is a structure that's used throughout DvScene, it's an easy way to read an array.<syntaxhighlight lang="c++" start="0">
template<typename T>
struct DvObject{
    int count; // amount of items in the array
    int size; // the total size of of all the elements
    long long unknown; // no instance with data here has been found
    T items; // the array itself, not a pointer
};
</syntaxhighlight>

DvScene starts with two simple values, the pointers to DvCommon and DvResource<syntaxhighlight lang="c++">
struct DvScene{
    DvCommon* common; // 32-bit pointer relative to DvCommon
    DvObject<DvResource>* resources; // 32-bit pointer relative to DvCommon
};
</syntaxhighlight> 

Before going into DvCommon, we first need to define the structures that are used in DvCommon.

There's a fairly easy to use system for skipping frames for either translation issues or QTEs. They're called DvPages. <syntaxhighlight lang="c++">
struct DvCondition{
    int type; // the condition type
    uint parametersSize; // the size of condition dataa
    long unknown; // no instance with data here has been found
    char parameterData; // the data of the parameter, different for every condtion type
};

struct DvTransition{
    uint destinationPageID; // the page it should jump to
    uint conditionCount; // amount of conditions
    ulong conditionSize; // size of conditions
};

struct DvPage{
    uint unk0; // unknown
    uint unk1; // unknown
    uint frameStart; // the start tick of the page, it's in ticks meaning it's * 100
    uint frameEnd; // the end tick of the page, it's in ticks meaning it's * 100
    uint transitionCount; // amount of transitions
    uint transitionSize; // size of transitions
    uint skipFrame; // the tick the cutscene should skip to, it's in ticks meaning it's * 100
    uint index; // the pages index
    uint pageSize; // size of the pageData
    char empty[12];
    char name[32]; // the name of the page
    char pageData; // the data of the page, hasn't been researched
    DvTransition transitions;
};
</syntaxhighlight>The DvPages use ticks, or also could be called just a ''truncated float.''



The important part of DvScene's, the DvNode.<syntaxhighlight lang="c++">
struct DvNode{
    Guid guid; // unique identifier for the node, also used for connection with DvResource
    uint nodeCategory; // the type of node
    uint nodeSize; // size of the node data
    uint childCount; // amount of child nodes
    uint nodeFlags; // yet to be researched
    uint priority; // the priority of the node when reading
    char empty[12];
    char name[64]; // the name of the node
    char nodeData; // the data of the node, different for every node category
    DvNode childNodes; // the children of this node
};
</syntaxhighlight>The Node Data is different for every single Node Category, it's the parameters of the node itself.


Now the controller of DvScenes, DvCommon.<syntaxhighlight lang="c++">
struct DvDisableFrame{
    float start;
    float end;
};

struct DvCommon{
    long unknown; // no instance with data here has been found
    float frameStart; // the start frame of the cutscene
    float frameEnd; // the end frame of the cutscene
    uint drawNodeNumber; // amount of visual nodes (unconfirmed)
    DvObject<float>* cuts; // every camera cut in cutscene
    DvObject<DvPage>* pages; // pages, used for QTEs and such
    DvObject<DvDisableFrame>* disableFrames; // unknown purpose
    DvObject<float>* resourceCuts; // when the resource should deload, always has just one item
    DvObject<float>* soundCuts; // unknown purpose
    DvNode* node; // the main node of the cutscene
    float chainCameraIn; // leftover from yakuza?
    float chainCameraOut; // leftover from yakuza?
    int type; // unknown
    int skipPointTick; // unknown
};
</syntaxhighlight>All of the pointers are 32-bit and relative to DvCommon itself.

The second important part of DvScene, is the DvResource.<syntaxhighlight lang="c++">
struct DvResource{
    Guid guid; // unique identifier for the resource, used to connect with DvNodes
    uint type; // the file type this resource is trying to use
    uint unk0; // unknown, always 0
    uint unk1; // unknown, always 1
    char filename[192]; // the filename of the file it's loading
    char unk2[596]; // unknown, could still be just space for the filename
};
</syntaxhighlight>