void CLockBox9::on_add_node_child(StateDataNode* parent, StateDataNode* child) {
if(child->get_id().name == NAME_LOCKBOX) {
/** @todo Perhaps it's necessary to copy volume DATA to lock DATA, depending on the flags.
Without this, if application only modifies a region of lock DATA
the contents of the surface DATA corresponding to a non modified regions
of lock DATA are overwritten with zeroes.
*/
// Calculate size of DATA node and resize it
D3DFORMAT format;
child->get_parent()->get_child(StateId(NAME_FORMAT))->read_data(&format);
UINT left, right, top, bottom, front, back;
child->get_child(StateId(NAME_LEFT))->read_data(&left);
child->get_child(StateId(NAME_RIGHT))->read_data(&right);
child->get_child(StateId(NAME_TOP))->read_data(&top);
child->get_child(StateId(NAME_BOTTOM))->read_data(&bottom);
child->get_child(StateId(NAME_TOP))->read_data(&front);
child->get_child(StateId(NAME_BOTTOM))->read_data(&back);
UINT width = right - left;
UINT height = bottom - top;
UINT depth = back - front;
// Change units for compressed formats
/// @note Depth is not affected
if(is_compressed(format)) {
width = width / 4 + (((width % 4) == 0) ? 0 : 1);
height = height / 4 + (((height % 4) == 0) ? 0 : 1);
}
UINT size = depth * width * height * texel_size(format);
child->get_child(StateId(NAME_DATA))->set_data_size(size);
D3D_DEBUG( cout << "CLOCKBOX9: Resizing SLOCKBOX DATA to " << (int)size << endl; )
void CAlphaBlending9::on_added_controller(StateDataNode* node) {
if(node->get_id().name == NAME_DEVICE_9) {
// Watch Alpha Blend state
node->get_child(StateId(NAME_ALPHA_BLEND_ENABLED))->add_controller(this);
node->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->add_controller(this);
node->get_child(StateId(NAME_BLEND_FACTOR))->add_controller(this);
node->get_child(StateId(NAME_SRC_BLEND))->add_controller(this);
node->get_child(StateId(NAME_DST_BLEND))->add_controller(this);
node->get_child(StateId(NAME_SRC_BLEND_ALPHA))->add_controller(this);
node->get_child(StateId(NAME_DST_BLEND_ALPHA))->add_controller(this);
node->get_child(StateId(NAME_BLEND_OP))->add_controller(this);
node->get_child(StateId(NAME_BLEND_OP_ALPHA))->add_controller(this);
}
}
void CIndexVertexBuffers9::on_added_controller(StateDataNode* node) {
if((node->get_id().name == NAME_INDEXBUFFER_9) ||
(node->get_id().name == NAME_VERTEXBUFFER_9)) {
UINT lenght;
node->get_child(StateId(NAME_LENGTH))->read_data(&lenght);
// Reserve storage in state
node->get_child(StateId(NAME_DATA))->set_data_size(lenght);
// Obtain GPU memory
u32bit md;
md = GPUProxy::get_instance()->obtainMemory(size_t(lenght));
/* GPU memory is assigned to resource, so add the assignation
to the assignation table */
ResourceAssignationTable* a_resource_memory;
a_resource_memory = AssignationsRegistry::get_table(NAME_IVBUFFER_MEMORY);
a_resource_memory->add_resource(ResourceId(NAME_MEMORY, ResourceIndex(md)));
a_resource_memory->assign( UsageId(NAME_IVBUFFER, node->get_id().index),
ResourceId(NAME_MEMORY, ResourceIndex(md)));
D3D_DEBUG( cout << "CINDEXVERTEXBUFFERS9: Memory descriptor is " << md << " size is " << lenght << endl; )
}
IVolumeImp9::IVolumeImp9(StateDataNode* s_parent, IDeviceImp9* _i_parent, UINT Width, UINT Height, UINT Depth,
DWORD Usage , D3DFORMAT Format, D3DPOOL Pool) {
i_parent = _i_parent;
// Create state
state = D3DState::create_volume_state_9(this);
// Fill state with parameters
D3DRESOURCETYPE type = D3DRTYPE_VOLUME;
state->get_child(StateId(NAME_TYPE))->write_data(&type);
state->get_child(StateId(NAME_WIDTH))->write_data(&Width);
state->get_child(StateId(NAME_HEIGHT))->write_data(&Height);
state->get_child(StateId(NAME_DEPTH))->write_data(&Depth);
state->get_child(StateId(NAME_FORMAT))->write_data(&Format);
state->get_child(StateId(NAME_USAGE))->write_data(&Usage);
state->get_child(StateId(NAME_POOL))->write_data(&Pool);
// Add state
s_parent->add_child(state);
}
// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpJavaData::CMMCScBkupStateArchiveOpJavaData()
//
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateArchiveOpJavaData::CMMCScBkupStateArchiveOpJavaData( MMMCScBkupDriver& aDriver )
: CMMCScBkupStateOpAware( aDriver ), iIndexValueCurrent( -1 )
{
__LOG1("CMMCScBkupStateArchiveOpJavaData::CMMCScBkupStateArchiveOpJavaData() - 0x%08x", StateId().iUid );
}
// ---------------------------------------------------------------------------
// CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace()
//
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace( MMMCScBkupDriver& aDriver )
: CMMCScBkupState( aDriver ), iCumulatedSize(0)
{
__LOG1("CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace() - 0x%08x", StateId().iUid );
}
// ---------------------------------------------------------------------------
// CMMCScBkupStateNotifyAllSnapshotsSupplied::CMMCScBkupStateNotifyAllSnapshotsSupplied()
//
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateNotifyAllSnapshotsSupplied::CMMCScBkupStateNotifyAllSnapshotsSupplied( MMMCScBkupDriver& aDriver )
: CMMCScBkupState( aDriver )
{
__LOG1("CMMCScBkupStateNotifyAllSnapshotsSupplied::CMMCScBkupStateNotifyAllSnapshotsSupplied() - 0x%08x", StateId().iUid );
}
// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles()
//
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles( MMMCScBkupDriver& aDriver )
: CMMCScBkupState( aDriver )
{
__LOG1("CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles() - 0x%08x", StateId().iUid );
}
// ---------------------------------------------------------------------------
// CMMCScBkupState::RunError()
//
//
// ---------------------------------------------------------------------------
TInt CMMCScBkupState::RunError(TInt aError)
{
#ifdef MMCSCBKUP_USE_BREAKPOINTS
__BREAKPOINT();
#endif
//
if ( aError == KErrNoMemory || aError == KErrDiskFull || aError == KErrNotReady || aError == KErrServerTerminated || aError == KErrWrite )
{
__LOGFILE2("CMMCScBkupState::RunError() - **** - FATAL ERROR - state: 0x%08x, aError: %d - Notifying Observer (Engine)", StateId().iUid, aError );
CompleteObserver( aError );
}
else
{
__LOGFILE2("CMMCScBkupState::RunError() - **** - ATTEMPT TO HANDLE ERROR - state: 0x%08x, aError: %d...", StateId().iUid, aError );
const TBool errorHandled = PerformAsynchronousErrorCleanup( aError );
__LOGFILE1("CMMCScBkupState::RunError() - **** - handle error result: %d", errorHandled );
// If the cleanup callback didn't set us active again, then
// assume the object didn't perform any recovery. Therefore
// inform our observer about the error and give up.
if (!errorHandled || !IsActive())
{
CompleteObserver( aError );
}
}
//
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMMCScBkupState::DoCancel()
//
//
// ---------------------------------------------------------------------------
void CMMCScBkupState::DoCancel()
{
__LOG3("CMMCScBkupState::DoCancel() - START - state: 0x%08x, IsActive: %d, status: %d", StateId().iUid, IsActive(), iStatus.Int() );
PerformAsynchronousCancellation();
CompleteObserver( KErrCancel );
__LOG3("CMMCScBkupState::DoCancel() - END - state: 0x%08x, IsActive: %d, status: %d", StateId().iUid, IsActive(), iStatus.Int() );
}
// ---------------------------------------------------------------------------
// CMMCScBkupState::PerformAsynchronousErrorCleanup()
//
//
// ---------------------------------------------------------------------------
TBool CMMCScBkupState::PerformAsynchronousErrorCleanup( TInt aError )
{
(void) aError;
__LOGFILE2("CMMCScBkupState::PerformAsynchronousErrorCleanup() - error: %d, state id: 0x%08x", aError, StateId().iUid );
return EFalse;
}
// ---------------------------------------------------------------------------
// CMMCScBkupState::PerformAsynchronousCancellation()
//
//
// ---------------------------------------------------------------------------
void CMMCScBkupState::PerformAsynchronousCancellation()
{
// Derived classes are expected to implement this if they have
// resources to free. For calls to CompleteSelf(), no action is needed.
__LOG3("CMMCScBkupState::PerformAsynchronousCancellation() - ERROR - cancellation not implemented for state: 0x%08x, IsActive: %d, status: %d", StateId().iUid, IsActive(), iStatus.Int() );
}
// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestSizeOfBackupData::CMMCScBkupStateRequestSizeOfBackupData()
//
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestSizeOfBackupData::CMMCScBkupStateRequestSizeOfBackupData( MMMCScBkupDriver& aDriver )
: CMMCScBkupState( aDriver )
{
__LOG1("CMMCScBkupStateRequestSizeOfBackupData::CMMCScBkupStateRequestSizeOfBackupData() - 0x%08x", StateId().iUid );
}
void CAlphaBlending9::on_write_node_data(StateDataNode* node, size_t size, unsigned int offset) {
if(node->get_id().name == NAME_ALPHA_BLEND_ENABLED) {
DWORD value;
node->read_data(&value);
GPURegData data;
data.booleanVal = (value == TRUE);
GPUProxy::get_instance()->writeGPURegister(GPU_COLOR_BLEND, data);
}
else if(node->get_id().name == NAME_SEPARATE_ALPHA_BLEND_ENABLED) {
DWORD value;
node->read_data(&value);
if(value == FALSE) {
// Propagate color functions to alpha functions
DWORD color;
node->get_parent()->get_child(StateId(NAME_SRC_BLEND))->read_data(&color);
update_blend_functions(D3DRS_SRCBLENDALPHA, color, false);
node->get_parent()->get_child(StateId(NAME_DST_BLEND))->read_data(&color);
update_blend_functions(D3DRS_DESTBLENDALPHA, color, false);
}
}
else if(node->get_id().name == NAME_BLEND_OP) {
DWORD value;
node->read_data(&value);
DWORD separate;
node->get_parent()->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->read_data(&separate);
bool sep = (separate == 0 ? false : true);
update_blend_op(D3DRS_BLENDOP, value, sep);
}
else if(node->get_id().name == NAME_BLEND_OP_ALPHA) {
DWORD value;
node->read_data(&value);
DWORD separate;
node->get_parent()->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->read_data(&separate);
bool sep = (separate == 0 ? false : true);
update_blend_op(D3DRS_BLENDOPALPHA, value, sep);
}
else if(node->get_id().name == NAME_SRC_BLEND) {
DWORD value;
node->read_data(&value);
DWORD separate;
node->get_parent()->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->read_data(&separate);
bool sep = (separate == 0 ? false : true);
update_blend_functions(D3DRS_SRCBLEND, value, sep);
}
else if(node->get_id().name == NAME_SRC_BLEND_ALPHA) {
DWORD value;
node->read_data(&value);
DWORD separate;
node->get_parent()->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->read_data(&separate);
bool sep = (separate == 0 ? false : true);
update_blend_functions(D3DRS_SRCBLENDALPHA, value, sep);
}
else if(node->get_id().name == NAME_DST_BLEND) {
DWORD value;
node->read_data(&value);
DWORD separate;
node->get_parent()->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->read_data(&separate);
bool sep = (separate == 0 ? false : true);
update_blend_functions(D3DRS_DESTBLEND, value, sep);
}
else if(node->get_id().name == NAME_DST_BLEND_ALPHA) {
DWORD value;
node->read_data(&value);
DWORD separate;
node->get_parent()->get_child(StateId(NAME_SEPARATE_ALPHA_BLEND_ENABLED))->read_data(&separate);
bool sep = (separate == 0 ? false : true);
update_blend_functions(D3DRS_DESTBLENDALPHA, value, sep);
}
else if(node->get_id().name == NAME_BLEND_FACTOR) {
DWORD value;
node->read_data(&value);
QuadFloat qf_value;
d3dcolor2quadfloat(value, &qf_value);
GPURegData data;
for(u32bit i = 0; i < 4; i++)
data.qfVal[i] = qf_value[i];
GPUProxy::get_instance()->writeGPURegister(GPU_BLEND_COLOR, data);
}
}
