void VLightClippingVolumeRenderer::PatchReadDepthStencilState(const VStateGroupDepthStencil& inputState, VStateGroupDepthStencil* pOutputStates, bool bEnableStencil)
{
VASSERT(pOutputStates != NULL);
for (unsigned int i=0;i<2;i++)
{
pOutputStates[i] = inputState;
if (bEnableStencil)
pOutputStates[i].m_bStencilTestEnabled = true;
if (i == 0)
pOutputStates[i].m_iStencilRef |= V_BIT(V_LIGHT_CLIPPING_STENCIL_BIT);
pOutputStates[i].m_iStencilReadMask |= V_BIT(V_LIGHT_CLIPPING_STENCIL_BIT);
pOutputStates[i].m_cStencilComparisonFunc[0] = COMPARISON_EQUAL;
}
}
void VLightClippingVolumeRenderer::Init()
{
m_LightClippingStencilStateWrite = *VisRenderStates_cl::GetDepthStencilDefaultState();
m_LightClippingStencilStateWrite.m_bDepthTestEnabled = true;
m_LightClippingStencilStateWrite.m_bDepthWriteEnabled = false;
m_LightClippingStencilStateWrite.m_bStencilTestEnabled = true;
m_LightClippingStencilStateWrite.m_bTwoSidedStencil = false;
m_LightClippingStencilStateWrite.m_cStencilComparisonFunc[0] =
m_LightClippingStencilStateWrite.m_cStencilComparisonFunc[1] = COMPARISON_ALWAYS;
m_LightClippingStencilStateWrite.m_cDepthComparisonFunc = COMPARISON_GREATER;
//Front face depth pass (because of inverse test function)
m_LightClippingStencilStateWrite.m_cStencilPassOp[1] =
m_LightClippingStencilStateWrite.m_cStencilPassOp[0] = STENCIL_OP_INVERT;
m_LightClippingStencilStateWrite.m_iStencilReadMask =
m_LightClippingStencilStateWrite.m_iStencilWriteMask = V_BIT(V_LIGHT_CLIPPING_STENCIL_BIT);
m_LightClippingStencilStateWrite.ComputeHash();
m_LightClippingStencilStateClear = *VisRenderStates_cl::GetDepthStencilDefaultState();
m_LightClippingStencilStateClear.m_bDepthTestEnabled = false;
m_LightClippingStencilStateClear.m_bDepthWriteEnabled = false;
m_LightClippingStencilStateClear.m_bStencilTestEnabled = true;
m_LightClippingStencilStateClear.m_bTwoSidedStencil = false;
m_LightClippingStencilStateClear.m_cStencilComparisonFunc[0] =
m_LightClippingStencilStateClear.m_cStencilComparisonFunc[1] = COMPARISON_ALWAYS;
m_LightClippingStencilStateClear.m_cDepthComparisonFunc = COMPARISON_GREATER;
m_LightClippingStencilStateClear.m_cStencilPassOp[1] =
m_LightClippingStencilStateClear.m_cStencilPassOp[0] = STENCIL_OP_REPLACE;
m_LightClippingStencilStateClear.m_iStencilWriteMask = V_BIT(V_LIGHT_CLIPPING_STENCIL_BIT);
m_LightClippingStencilStateClear.m_iStencilRef = 0;
m_LightClippingStencilStateClear.ComputeHash();
if (!Vision::Shaders.LoadShaderLibrary("\\Shaders/LightClippingVolumes.ShaderLib", SHADERLIBFLAG_HIDDEN))
{
hkvLog::Warning("Shader lib file for light clipping volumes could not be loaded!");
return;
}
VCompiledEffectPtr effect = Vision::Shaders.CreateEffect("LightClippingVolumesStencilFill", NULL);
if(effect)
{
m_spLightClippingVolumeStencilFill = effect->GetDefaultTechnique();
VASSERT_MSG( m_spLightClippingVolumeStencilFill.GetPtr() != NULL, "Unable to retrieve default technique for LightClippingVolumesStencilFill shader!" );
m_spLightClippingVolumeStencilFill->GetShader(0)->DisablePixelShader();
int iStateGroupMask = STATEGROUP_ALL & ~STATEGROUP_DEPTHSTENCIL;
m_spLightClippingVolumeStencilFill->GetShader(0)->m_cStateGroupMask = iStateGroupMask;
}
}
*/
/// \file VCoronaManager.hpp
#ifndef CORONAEMANAGER_HPP_INCLUDED
#define CORONAEMANAGER_HPP_INCLUDED
#include <Vision/Runtime/EnginePlugins/VisionEnginePlugin/Rendering/Effects/VCoronaComponent.hpp>
typedef VRefCountedCollection<VCoronaComponent> VCoronaCollection;
/// \brief
/// Defines what should be done in a call to VCoronaManager::UpdateCoronas.
enum VCoronaUpdateFlags_e
{
VCUF_ADD = V_BIT(0),
VCUF_REMOVE = V_BIT(1),
VCUF_UPDATE = V_BIT(2),
VCUF_FORCE_SCHEDULE = V_BIT(3),
VCUF_FORCE_FETCH = V_BIT(4),
VCUF_USE_OC_CONTEXT = V_BIT(5),
};
/// \brief
/// Manager for coronas. The global instance is accessible via VCoronaManager::GlobalManager()
///
/// This class manages a collection of coronas and hooks into an existing renderloop to render the them.
class VCoronaManager : public IVisCallbackHandler_cl
{
public:
#include <typeinfo>
#endif
class VCallback;
///////////////////////////////////////////////////////////////////////////////
// Variable management
///////////////////////////////////////////////////////////////////////////////
/// \brief
/// Optional flags for a VType variable list
enum VVARIABLELIST_FLAGS_e
{
VVARIABLELIST_FLAGS_NONE = 0,
VFORGE_HIDECLASS = V_BIT(0), ///< don't enum this class in vForge
VCOMPONENT_ALLOW_MULTIPLE = V_BIT(1), ///< components use this flag to determine whether multiple instances of the same type can be attached to one object
VFORGE_USE_NATIVE_PARENTING = V_BIT(2) ///< entities can use this flag to enforce scene graph update through native parenting functions inside vForge. No effect on the runtime side
};
/// \brief
/// Return options for the VTypedObject::OnVariableValueChanging callback
enum VVarChangeRes_e
{
VCHANGE_IS_REDUNDANT, ///< the variable is already set to the specified value, OnVariableValueChanged will not occur, set is successful
VCHANGE_IS_CANCELLED, ///< the variable cannot be changed to the specified value, OnVariableValueChanged will not occur, set is unsuccessful
VCHANGE_IS_ALLOWED, ///< the variable can be changed to the specified value, OnVariableValueChanged will occur, set is successful
};
/// \brief
/// Structure that gets passed to virtual VTypedObject::GetVariableAttributes function to modify per instance variable attributes in the editor
/// \brief
/// This function is called for every vertex in the list. Vertex data must be converted to target format and written to the out stream. The amount of bytes written must match the m_iStride member filled out in GetVertexFormat
virtual void ConvertToOutputFormat(const VGVertexList &list, int iVertex, IVFileOutStream *pOut) = 0;
};
/// \brief
/// .vmesh, .model, .anim, .vcolmesh reader/writer helper class
///
/// Helper class used by reader/writer processors.
class VGEOM2_IMPEXP_CLASS VGVisionImporterExporter
{
public:
enum DataFormat // Values can be used as a mask, although not intended when used with VGProcessor_Vision??porter::SetDataFormat() functions. DON'T change the values.
{
VDF_MESH = V_BIT(0),
VDF_MODEL = V_BIT(1), // Usually like a mesh but with bones, etc. (vision slang).
VDF_COLLISION_MESH = V_BIT(2),
VDF_ANIM = V_BIT(3),
VDF_PREFAB = V_BIT(4),
VDF_VISIBILITY_INFO = V_BIT(5),
VDF_MATERIAL = V_BIT(6),
VDF_MATERIAL_LIB = V_BIT(7),
VDF_PREFAB_LAYER = V_BIT(8),
VDFMASK_FULL = VDF_MESH|VDF_MODEL|VDF_COLLISION_MESH|VDF_ANIM|VDF_PREFAB|VDF_VISIBILITY_INFO|VDF_MATERIAL|VDF_MATERIAL_LIB|VDF_PREFAB_LAYER
};
enum CollisionType
{
VCT_NONE = 0, // Mesh/model should not be used as a collider.
/// \brief
/// Physics info class
///
/// Describes and sets up additional physics properties to be referenced on a per triangle level.
class VGEOM2_IMPEXP_CLASS VGPhysicsInfo : public VGNameable
{
public:
/// \brief
/// Physics flags
///
/// Stores physics specific flags.
enum PhysicsFlags
{
VGPF_NOTHING = 0,
VGPF_USE_ANISOTROPIC_FRICTION = V_BIT(0)
};
public:
VGPhysicsInfo();
virtual ~VGPhysicsInfo();
/// \brief
/// Gets flags
///
/// \return
/// Flags
inline PhysicsFlags GetFlags() const throw() { return m_flags; }
/// \brief
/// Triangle list class
///
/// Stores triangle specific data, e.g. indices, material reference, etc.
class VGEOM2_IMPEXP_CLASS VGTriangleList
{
public:
/// \brief
/// Triangle flags
///
/// Stores triangle specific flags, e.g. if the triangle casts a shadow, etc.
enum TriangleFlags
{
VGTF_NOTHING = 0,
VGTF_SHADOWCASTER = V_BIT(0), // @@@ do away with this flag???
VGTF_COLLIDER = V_BIT(1), // @@@ write testcode that checks whether these triangles get exported to .vcolmesh
VGTF_VISIBLE = V_BIT(2), // @@@ write testcode that checks whether these triangles get exported to .model and .vmesh
VGTF_DEFAULT = VGTF_COLLIDER|VGTF_VISIBLE
};
/// \brief
/// Triangle properties
struct TriangleProperties
{
int materialIndex; // Index into scene's materials (-1 means no material).
int geomInfoIndex; // Index into scene's geometry meta information (-1 means "use defaults").
int groupIndex; // Index that can be used for custom grouping (user defined).
int visibilityID; // Visibility classification ID (can be set manually or generated with VGProcessor_VisibilityInfoGenerator).
TriangleFlags triangleFlags; // Combination of VGTriangleList::TriangleFlags.
int physicsInfoIndex; // Index into scene's geometry physics properties (such as friction, etc.; -1 means "use defaults").
* Product and Trade Secret source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2013 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
/// \file VisApiEditorManager.hpp
#ifndef VIS_API_EDITOR_MANAGER_HPP
#define VIS_API_EDITOR_MANAGER_HPP
#include <Vision/Runtime/Engine/System/VisApiCallbacks.hpp>
/// \brief
/// Enum that defines bitflags for the IVisSceneExporter_cl::StartVSceneExport function
enum VSceneExportFlags_e
{
VExport_Plugins = V_BIT(0), ///< write out the required plugins
VExport_SceneScript = V_BIT(1), ///< export the scene script reference
VExport_Sky = V_BIT(2), ///< export the sky object
VExport_RendererNode = V_BIT(3), ///< export the renderer node
VExport_TimeOfDay = V_BIT(4), ///< export time of day handler
VExport_Fog = V_BIT(5), ///< export fog settings
VExport_View = V_BIT(6), ///< export view related settings (FOV)
VExport_ZoneRefs = V_BIT(7), ///< export zone references
VExport_TimeStepping = V_BIT(8), ///< export time stepping settings
VExport_All = 0xffffffff ///< export everything
};
/// \brief
/// Internal data object class used by the OnTriggerSetVariable callback
/// \brief
/// Sets whether the default shader of this material will use texture clamping.
VISION_APIFUNC void SetUseTextureClamping(bool bClampU, bool bClampV)
{
m_iClampUV = (bClampU ? V_BIT(0) : 0) | (bClampV ? V_BIT(1) : 0);
}
class VManagedResource;
DECLARE_LIST(VResourceList,VManagedResource,VBASE_IMPEXP)
class VResourceSnapshotEntry;
class VResourceManager;
class IVResourcePreview;
class VConnection;
/// \brief
/// This enum defines the different memory pool types as used by VManagedResource::SetNewMemSize for instance
///
/// \sa VManagedResource::SetNewMemSize
/// \sa VManagedResource::GetNewMemSize
enum VResourceMemoryType_e
{
VRESOURCEMEMORY_SYSTEM = V_BIT(0), ///< Unique system memory used by the resource
VRESOURCEMEMORY_GPU = V_BIT(1), ///< Unique GPU memory used by the resource
VRESOURCEMEMORY_DEPENDENT_SYSTEM = V_BIT(2), ///< System memory of other resources that this resource depends on
VRESOURCEMEMORY_DEPENDENT_GPU = V_BIT(3), ///< GPU memory of other resources that this resource depends on
VRESOURCEMEMORY_GPU_DOUBLEBUFFERED = VRESOURCEMEMORY_SYSTEM|VRESOURCEMEMORY_GPU, ///< Bitflag combinations for both unique memory types
VRESOURCEMEMORY_ALLTYPES = VRESOURCEMEMORY_SYSTEM|VRESOURCEMEMORY_GPU|VRESOURCEMEMORY_DEPENDENT_SYSTEM|VRESOURCEMEMORY_DEPENDENT_GPU ///< Bitflag combinations for all memory types
};
/// \brief options for unloading and reloading resources
enum VUnloadReloadOptions_e
{
VURO_HOT_RELOAD, ///< unloads and reloads the resource trying to maintain existing runtime data
VURO_COLD_RELOAD, ///< unloads and relaods the resource throwing away all existing runtime data
VURO_ONLY_UNLOAD ///< only unloads the resource
};
/// \file
#ifndef DEFINE_VISAPIPROFILING
#define DEFINE_VISAPIPROFILING
#include <string.h>
#include <stdlib.h>
#include <Vision/Runtime/Engine/Profiling/VisApiProfElements.hpp>
/// \brief
/// Flags for the VisProfiling_cl::SetDebugRenderFlags function
enum VDebugRenderFlags
{
DEBUGRENDERFLAG_VISION_VERSION = V_BIT(0), ///< Displays the vision version.
DEBUGRENDERFLAG_OBJECT_TRIANGLECOUNT = V_BIT(1), ///< Displays the object triangle count.
DEBUGRENDERFLAG_OBJECT_VISBBOX = V_BIT(2), ///< Renders the current visibility bounding box for each entity.
DEBUGRENDERFLAG_OBJECT_VISIBILITYZONES = V_BIT(3), ///< Displays a list of visibility zones each entity is assigned to.
DEBUGRENDERFLAG_VISIBILITYOBJECTS = V_BIT(4), ///< Renders all visibility objects (bounding box). Same as settings VISTESTFLAGS_DEBUG_RENDER flag per visibility object, but easier to toggle.
DEBUGRENDERFLAG_VISIBILITYZONES = V_BIT(5), ///< Renders the visibility zones.
DEBUGRENDERFLAG_PORTALS = V_BIT(6), ///< Renders the portals.
DEBUGRENDERFLAG_LIGHT_INFLUENCEBOX = V_BIT(7), ///< Renders each light's box of influence.
DEBUGRENDERFLAG_TRACELINES = V_BIT(8), ///< Renders all trace-lines as red lines (performed in that frame, thus also just visible one frame).
DEBUGRENDERFLAG_POLYGONCOUNT = V_BIT(9), ///< Displays the overall polygon count.
DEBUGRENDERFLAG_FRAMERATE = V_BIT(10), ///< Displays the current frame rate.
DEBUGRENDERFLAG_PERFORMANCECOUNTERS = V_BIT(11), ///< Displays performance counters, e.g. number of draw calls etc.
DEBUGRENDERFLAG_SCRIPTSTATISTICS = V_BIT(12), ///< Display script manager status. This is implementation specific.
DEBUGRENDERFLAG_OBJECTRENDERORDER = V_BIT(13), ///< Display the index of objects inside the render queues. Useful to debug sorting criteria.
DEBUGRENDERFLAG_THREADWORKLOAD = V_BIT(14), ///< Displays the workload of all CPU threads of the ThreadManager.
DEBUGRENDERFLAG_ZONES = V_BIT(15), ///< Displays streaming zone specific output.
/// Stores data for a single vertex in a convenient way - not that this class makes working with single
/// vertices pretty easy, whereas it might be unefficient to store a large number of VGVertex instances.
/// Usually, this class helps in setting up vertices and hand the data over to VGVertexlist instances,
/// which store the data more efficiently.
class VGEOM2_IMPEXP_CLASS VGVertex
{
public:
/// \brief
/// Vertex component mask
///
/// Bits to be used to specify which vertex components should be used when working with
/// vertices. We speak of 'compatible' vertex masks if two or more masks are identical.
enum VertexMask
{
VGVM_NOTHING = 0 ,
VGVM_POSITION = V_BIT( 0),
VGVM_NORMAL = V_BIT( 1),
VGVM_TANGENT = V_BIT( 2),
VGVM_WEIGHT = V_BIT( 3),
VGVM_COLOR_1 = V_BIT( 4),
VGVM_COLOR_2 = V_BIT( 5),
VGVM_TEXCOORD_01 = V_BIT( 8), // Used by Vision import/export processor as diffuse channel.
VGVM_TEXCOORD_02 = V_BIT( 9), // Used by Vision import/export processor as lightmap channel.
VGVM_TEXCOORD_03 = V_BIT(10),
VGVM_TEXCOORD_04 = V_BIT(11),
VGVM_TEXCOORD_05 = V_BIT(12),
VGVM_TEXCOORD_06 = V_BIT(13),
VGVM_TEXCOORD_07 = V_BIT(14),
VGVM_TEXCOORD_08 = V_BIT(15)
};
enum MaterialLighting
{
VGML_FULLBRIGHT,
VGML_LIGHTMAP,
VGML_LIGHTGRID,
VGML_DYNAMIC_ONLY
};
/// \brief
/// Material flags
///
/// Stores material specific flags, e.g. if maps should be clamped, etc.
enum MaterialFlags
{
VGMF_NOTHING = 0,
VGMF_DOUBLESIDED = V_BIT(0),
VGMF_CLAMP_U = V_BIT(1),
VGMF_CLAMP_V = V_BIT(2),
VGMF_FORCE_PRIMARYOPAQUEPASS = V_BIT(3),
VGMF_FORCE_TRANSPARENTPASS = V_BIT(4),
VGMF_FORCE_SECONDARYOPAQUEPASS = V_BIT(5),
VGMF_DISABLE_CAST_STATIC_SHADOWS = V_BIT(6),
VGMF_DISABLE_DEPTH_WRITE = V_BIT(7),
VGMF_DATA_DIR_RELATIVE_PATHS = V_BIT(8)
};
/// \brief
/// UV mapping transformation order (don't change values)
///
/// S = scale, R = rotation, T = translation/offset
enum UVMappingAlgorithm
*
*/
/// \file VResource.hpp
#ifndef _VRESOURCE_HPP_INCLUDED
#define _VRESOURCE_HPP_INCLUDED
#include <Vision/Runtime/Base/System/IO/Serialization/VSerializationProxy.hpp>
#include <Vision/Runtime/Base/System/Resource/VResourceManager.hpp>
/// \brief Flags for resources.
enum VResourceFlag
{
VRESOURCEFLAG_NONE = 0,
VRESOURCEFLAG_ISLOADED = V_BIT(0),
VRESOURCEFLAG_ISLOADING = V_BIT(1),
VRESOURCEFLAG_ISQUEUED = V_BIT(2),
VRESOURCEFLAG_ISMISSING = V_BIT(3),
VRESOURCEFLAG_DESTROYING = V_BIT(4),
VRESOURCEFLAG_ISREPLACEMENT = V_BIT(5),
VRESOURCEFLAG_FIRSTTIME = V_BIT(6),
VRESOURCEFLAG_ALLOWHANDLEBACKGROUNDING = V_BIT(7),
VRESOURCEFLAG_ALLOWUNLOAD = V_BIT(8),
VRESOURCEFLAG_AUTODELETE = V_BIT(9),
VRESOURCEFLAG_AUTOUNLOAD = V_BIT(10),
VRESOURCEFLAG_IGNORE_SURVIVING = V_BIT(11),
VRESOURCEFLAG_MODIFIABLEFLAGS = (VRESOURCEFLAG_IGNORE_SURVIVING | VRESOURCEFLAG_AUTOUNLOAD | VRESOURCEFLAG_AUTODELETE | VRESOURCEFLAG_ALLOWUNLOAD),
VRESOURCEFLAG_NOPURGING = V_BIT(12),
VRESOURCEFLAG_VIEWER_WANTSINFO = V_BIT(13),
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Product and Trade Secret source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2014 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
/// \file VWindowBase.hpp
#ifndef VWINDOW_HPP_INCLUDED
#define VWINDOW_HPP_INCLUDED
/// \brief
/// Status flags for UI items
enum VItemStatus
{
ITEMSTATUS_VISIBLE = V_BIT(0), ///< Whether a UI item is visible at all
ITEMSTATUS_ENABLED = V_BIT(1), ///< Whether a UI item is enabled and can be interacted with
ITEMSTATUS_HASFOCUS = V_BIT(3), ///< Whether a UI item has the focus for keyboard input
ITEMSTATUS_SELECTED = V_BIT(5), ///< Whether a UI item is supposed to stay selected
ITEMSTATUS_MOUSEOVER_USER0 = V_BIT(8), ///< Whether user 0 is hovering over the item
ITEMSTATUS_MOUSEOVER_USER1 = V_BIT(9), ///< Whether user 1 is hovering over the item
ITEMSTATUS_MOUSEOVER_USER2 = V_BIT(10), ///< Whether user 2 is hovering over the item
ITEMSTATUS_MOUSEOVER_USER3 = V_BIT(11), ///< Whether user 3 is hovering over the item
ITEMSTATUS_MOUSEOVER = (ITEMSTATUS_MOUSEOVER_USER0 | ITEMSTATUS_MOUSEOVER_USER1 | ITEMSTATUS_MOUSEOVER_USER2 | ITEMSTATUS_MOUSEOVER_USER3), ///< Whether any user is hovering over the item
ITEMSTATUS_VALIDPOSITION = V_BIT(16), ///< Whether a UI item has a valid position
ITEMSTATUS_VALIDSIZE = V_BIT(17), ///< Whether a UI item has a valid size
};
#define PARENTCHANGED_POSITION V_BIT(0)
#define PARENTCHANGED_SIZE V_BIT(1)
/// \brief Sets the lock owner name.
inline void SetLockOwner(const char* szOwner) {m_sOwner = szOwner;}
/// \brief Sets the workspace name in which the file is locked.
inline void SetLockWorkspace(const char* szWorkspace) {m_sWorkspace = szWorkspace;}
VString m_sOwner;
VString m_sWorkspace;
unsigned int m_iMode; ///< VRCSFileStatus::eMode flags
};
/// \brief
/// Revision Control Actions
enum VRevisionControlActions
{
RCS_UPDATE = V_BIT(0), ///< Update the file (ie. get the latest revision)
RCS_EDIT = V_BIT(1), ///< Check out the file to make it editable.
RCS_ADD = V_BIT(2), ///< Add the file to the RCS.
RCS_REMOVE = V_BIT(3), ///< Remove the file from the RCS.
RCS_LOCK = V_BIT(4), ///< Lock the file for exclusive access by this user.
RCS_UNLOCK = V_BIT(5), ///< Unlock the file to give other users access.
RCS_FILE_MODE_TEXT = V_BIT(6) ///< The file is supposed to be used in text mode.
};
/// \brief
/// Revision Control System Interface.
class IVRevisionControlSystem : public VRefCounter
{
public:
IVRevisionControlSystem() {}
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Product and Trade Secret source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2013 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
/// \file VisApiObjectComponent.hpp
#ifndef VISAPIOBJECTCOMPONENT_HPP_INCLUDED
#define VISAPIOBJECTCOMPONENT_HPP_INCLUDED
/// \brief Object Component Flags
enum VObjectComponentFlags_e
{
VIS_OBJECTCOMPONENTFLAG_NONE = 0, ///< no flag
VIS_OBJECTCOMPONENTFLAG_NOSERIALIZE = V_BIT(0), ///< don't serialize
VIS_OBJECTCOMPONENTFLAG_STATICMEMBER = V_BIT(1), ///<
VIS_OBJECTCOMPONENTFLAG_SERIALIZEWHENRELEVANT = V_BIT(2), ///< serialize this component if it is relevant
VIS_OBJECTCOMPONENTFLAG_EXPOSETOEDITOR = V_BIT(3), ///< expose this component to the editor
VIS_OBJECTCOMPONENTFLAG_INTERNALBUSYSERIALIZING = V_BIT(16) ///< serialization currently in progress
};
#include <Vision/Runtime/Engine/System/VisApiBase.hpp>
class VTypedObject;
class VisTypedEngineObject_cl;
/// \brief
/// Base class for an object component
