// is an element of a specified type? it does include inheritance inspection GBool GElement::IsOfType(const GClassID& Class_ID) const { // trivial case if ((Class_ID == ClassID()) || (Class_ID == DerivedClassID())) return G_TRUE; return IsTypeOfType(ClassID(), Class_ID); }
void STARTUP_pore() { GenesisObject* object; GenesisObject tobject; char* slotnames[50]; char* argv[50]; /* Definition of object Napores */ BZERO(&tobject,sizeof(GenesisObject)); tobject.name = "Napores"; tobject.type = "Na_pore_type"; tobject.size = sizeof(struct Na_pore_type); { extern int NaPorePop(); tobject.function = NaPorePop; HashFunc("NaPorePop", NaPorePop, "int"); } ObjectAddClass(&tobject,ClassID("segment"),CLASS_PERMANENT); AddDefaultFieldList(&tobject); tobject.defaults = (Element*) calloc(1, tobject.size); AddObject(&tobject); object = GetObject("Napores"); object->defaults->object = object; object->defaults->name = CopyString("Napores"); { extern int NaPorePop(); AddActionToObject(object, "INIT", NaPorePop, 0) ? 0 : (Error(), printf("adding action 'INIT' to object 'Napores'\n")); HashFunc("NaPorePop", NaPorePop, "int"); } { extern int NaPorePop(); AddActionToObject(object, "PROCESS", NaPorePop, 0) ? 0 : (Error(), printf("adding action 'PROCESS' to object 'Napores'\n")); HashFunc("NaPorePop", NaPorePop, "int"); } { extern int NaPorePop(); AddActionToObject(object, "RESET", NaPorePop, 0) ? 0 : (Error(), printf("adding action 'RESET' to object 'Napores'\n")); HashFunc("NaPorePop", NaPorePop, "int"); } { extern int NaPorePop(); AddActionToObject(object, "CHECK", NaPorePop, 0) ? 0 : (Error(), printf("adding action 'CHECK' to object 'Napores'\n")); HashFunc("NaPorePop", NaPorePop, "int"); } slotnames[0] = "Vm"; MsgListAdd(object, "VOLTAGE", Napores_VOLTAGE, slotnames, 1); object->author = "Adam Strassberg"; object->description = "Sodium pore population represented through eight state Markov kinetic scheme (see Strassberg and DeFelice, 1992).\n"; FieldListMakePermanent(object); MsgListMakePermanent(object); /* Definition of object Kpores */ BZERO(&tobject,sizeof(GenesisObject)); tobject.name = "Kpores"; tobject.type = "K_pore_type"; tobject.size = sizeof(struct K_pore_type); { extern int KPorePop(); tobject.function = KPorePop; HashFunc("KPorePop", KPorePop, "int"); } ObjectAddClass(&tobject,ClassID("segment"),CLASS_PERMANENT); AddDefaultFieldList(&tobject); tobject.defaults = (Element*) calloc(1, tobject.size); AddObject(&tobject); object = GetObject("Kpores"); object->defaults->object = object; object->defaults->name = CopyString("Kpores"); { extern int KPorePop(); AddActionToObject(object, "INIT", KPorePop, 0) ? 0 : (Error(), printf("adding action 'INIT' to object 'Kpores'\n")); HashFunc("KPorePop", KPorePop, "int"); } { extern int KPorePop(); AddActionToObject(object, "PROCESS", KPorePop, 0) ? 0 : (Error(), printf("adding action 'PROCESS' to object 'Kpores'\n")); HashFunc("KPorePop", KPorePop, "int"); } { extern int KPorePop(); AddActionToObject(object, "RESET", KPorePop, 0) ? 0 : (Error(), printf("adding action 'RESET' to object 'Kpores'\n")); HashFunc("KPorePop", KPorePop, "int"); } { extern int KPorePop(); AddActionToObject(object, "CHECK", KPorePop, 0) ? 0 : (Error(), printf("adding action 'CHECK' to object 'Kpores'\n")); HashFunc("KPorePop", KPorePop, "int"); } slotnames[0] = "Vm"; MsgListAdd(object, "VOLTAGE", Kpores_VOLTAGE, slotnames, 1); object->author = "Adam Strassberg"; object->description = "Potassium pore population represented through five state Markov kinetic scheme (see Strassberg and DeFelice, 1992).\n"; FieldListMakePermanent(object); MsgListMakePermanent(object); /* Script variables */ } /* STARTUP_pore */
//SETUPPROPERTIES // Tests if IPB2 pointers are healthy and sets up the MaxNode Data bool plArmatureComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg) { // Global issues node->SetMovable(true); node->SetForceLocal(true); #ifndef BOB_SORT_AVATAR_FACES ISetupAvatarRenderPropsRecurse(node); #endif // float mass, friction, restitution; // if(ClassID() == AVATAR_CLASS_ID || ClassID() == LOD_AVATAR_CLASS_ID) // { // mass = 12; // *** good number from old physical player // restitution = 0.5f; // friction = 0.1f; // } plMaxNode *animRoot = nil; if(ClassID() == AVATAR_CLASS_ID) animRoot = (plMaxNode *)fCompPB->GetINode(plAvatarComponent::kRootNode); else if (ClassID() == LOD_AVATAR_CLASS_ID) animRoot = (plMaxNode *)fCompPB->GetINode(plLODAvatarComponent::kRootNodeAddBtn); if(animRoot) { const char *nodeName = animRoot->GetName(); animRoot->SetDrawable(false); // make sure our root bone is invisible } // Ignore all of the old physicals, so old scenes can export if (ClassID() == AVATAR_CLASS_ID || ClassID() == LOD_AVATAR_CLASS_ID) { bool isLOD = ((ClassID() == LOD_AVATAR_CLASS_ID) != 0); plMaxNode* ignoreNode = (plMaxNode*)fCompPB->GetINode(isLOD ? plLODAvatarComponent::kPhysicsProxyFeet_DEAD : plAvatarComponent::kPhysicsProxyFeet_DEAD); if (ignoreNode) ignoreNode->SetCanConvert(false); ignoreNode = (plMaxNode*)fCompPB->GetINode(isLOD ? plLODAvatarComponent::kPhysicsProxyTorso_DEAD : plAvatarComponent::kPhysicsProxyTorso_DEAD); if (ignoreNode) ignoreNode->SetCanConvert(false); ignoreNode = (plMaxNode*)fCompPB->GetINode(isLOD ? plLODAvatarComponent::kPhysicsProxyHead_DEAD : plAvatarComponent::kPhysicsProxyHead_DEAD); if (ignoreNode) ignoreNode->SetCanConvert(false); } return true; }
/*! \param Class_Name a string containing the class name that we wanna know the descriptor of \param OutID a class descriptor that will be returned in case of successful operation. \return If operation will succeed G_NO_ERROR constant, else an error code. \note Class name comparison is case-insensitive.\n A return value of G_UNSUPPORTED_CLASSID means that specified Class_Name does not correspond to any registered proxies, so the class descriptor cannot be "resolved". */ GError GElement::ClassIDFromClassName(const GString& Class_Name, GClassID& OutID) const { // first lets see if class name match my class name if (StrUtils::SameText(Class_Name, ClassID().IDName())) { OutID = ClassID(); return G_NO_ERROR; } // now try with owner if (gOwner) { G_ASSERT(gOwner->IsOfType(G_KERNEL_CLASSID) == G_TRUE); GKernel *kernel = (GKernel *)gOwner; return kernel->ClassIDFromClassName(Class_Name, OutID); } return G_UNSUPPORTED_CLASSID; }
GrFillRRectOp::GrFillRRectOp( GrAAType aaType, const SkRRect& rrect, Flags flags, const SkMatrix& totalShapeMatrix, GrPaint&& paint, const SkRect& devBounds) : GrDrawOp(ClassID()) , fAAType(aaType) , fOriginalColor(paint.getColor4f()) , fLocalRect(rrect.rect()) , fFlags(flags) , fProcessors(std::move(paint)) { SkASSERT((fFlags & Flags::kHasPerspective) == totalShapeMatrix.hasPerspective()); this->setBounds(devBounds, GrOp::HasAABloat::kYes, GrOp::IsZeroArea::kNo); // Write the matrix attribs. const SkMatrix& m = totalShapeMatrix; if (!(fFlags & Flags::kHasPerspective)) { // Affine 2D transformation (float2x2 plus float2 translate). SkASSERT(!m.hasPerspective()); this->writeInstanceData(m.getScaleX(), m.getSkewX(), m.getSkewY(), m.getScaleY()); this->writeInstanceData(m.getTranslateX(), m.getTranslateY()); } else { // Perspective float3x3 transformation matrix. SkASSERT(m.hasPerspective()); m.get9(this->appendInstanceData<float>(9)); } // Convert the radii to [-1, -1, +1, +1] space and write their attribs. Sk4f radiiX, radiiY; Sk4f::Load2(SkRRectPriv::GetRadiiArray(rrect), &radiiX, &radiiY); (radiiX * (2/rrect.width())).store(this->appendInstanceData<float>(4)); (radiiY * (2/rrect.height())).store(this->appendInstanceData<float>(4)); // We will write the color and local rect attribs during finalize(). }
Op(GrRecordingContext* ctx, GrProxyProvider* proxyProvider, LazyProxyTest* test, bool nullTexture) : GrDrawOp(ClassID()), fTest(test) { const GrBackendFormat format = ctx->priv().caps()->getBackendFormatFromColorType(kRGB_565_SkColorType); fProxy = GrProxyProvider::MakeFullyLazyProxy( [this, nullTexture]( GrResourceProvider* rp) -> GrSurfaceProxy::LazyInstantiationResult { REPORTER_ASSERT(fTest->fReporter, !fTest->fHasOpTexture); fTest->fHasOpTexture = true; if (nullTexture) { return {}; } else { GrSurfaceDesc desc; desc.fWidth = 1234; desc.fHeight = 567; desc.fConfig = kRGB_565_GrPixelConfig; sk_sp<GrTexture> texture = rp->createTexture( desc, SkBudgeted::kYes, GrResourceProvider::Flags::kNoPendingIO); REPORTER_ASSERT(fTest->fReporter, texture); return std::move(texture); } }, format, GrProxyProvider::Renderable::kNo, kTopLeft_GrSurfaceOrigin, kRGB_565_GrPixelConfig, *proxyProvider->caps()); this->setBounds(SkRectPriv::MakeLargest(), GrOp::HasAABloat::kNo, GrOp::IsZeroArea::kNo); }
GrDrawPathRangeBatch::GrDrawPathRangeBatch(const SkMatrix& viewMatrix, const SkMatrix& localMatrix, GrColor color, GrPathRange* range, GrPathRangeDraw* draw) : INHERITED(ClassID(), viewMatrix, color) , fPathRange(range) , fDraws(4) , fLocalMatrix(localMatrix) { SkDEBUGCODE(draw->fUsedInBatch = true;)
PLSPathBatch(const Geometry& geometry) : INHERITED(ClassID()) { fGeoData.push_back(geometry); // compute bounds fBounds = geometry.fPath.getBounds(); geometry.fViewMatrix.mapRect(&fBounds); }
DEFINE_OP_CLASS_ID Op(GrProxyProvider* proxyProvider, LazyProxyTest* test, bool nullTexture) : GrDrawOp(ClassID()), fTest(test) { fProxy = proxyProvider->createFullyLazyProxy([this, nullTexture]( GrResourceProvider* rp) { if (!rp) { return sk_sp<GrTexture>(); } REPORTER_ASSERT(fTest->fReporter, !fTest->fHasOpTexture); fTest->fHasOpTexture = true; if (nullTexture) { return sk_sp<GrTexture>(); } else { GrSurfaceDesc desc; desc.fWidth = 1234; desc.fHeight = 567; desc.fOrigin = kTopLeft_GrSurfaceOrigin; desc.fConfig = kRGB_565_GrPixelConfig; sk_sp<GrTexture> texture = rp->createTexture(desc, SkBudgeted::kYes); REPORTER_ASSERT(fTest->fReporter, texture); return texture; } }, GrProxyProvider::Renderable::kNo, kTopLeft_GrSurfaceOrigin, kRGB_565_GrPixelConfig); this->setBounds(SkRectPriv::MakeLargest(), GrOp::HasAABloat::kNo, GrOp::IsZeroArea::kNo); }
void OrientConstRotation::Copy(Control *from) { if(GetLocked()==false) { Quat fvalRot; if (from->ClassID()==ClassID()) { OrientConstRotation *ctrl = (OrientConstRotation*)from; // a copy will construct its own pblock to keep the pblock-to-owner 1-to-1. ReplaceReference(ORIENT_ROT_PBLOCK_REF, CloneRefHierarchy(ctrl->pblock)); curRot = ctrl->curRot; baseRotQuatLocal = ctrl->baseRotQuatLocal; baseRotQuatWorld = ctrl->baseRotQuatWorld; flags = ctrl->flags; mLocked = ctrl->mLocked; } else { if(from&&GetLockedTrackInterface(from)) mLocked = GetLockedTrackInterface(from)->GetLocked(); from->GetValue(GetCOREInterface()->GetTime(), &fvalRot, Interval(0, 0)); // to know the object orientation before the firstTimeFlag = 1; baseRotQuatLocal = fvalRot; baseRotQuatLocal.Normalize(); // current controller was active } ivalid.SetEmpty(); NotifyDependents(FOREVER,PART_ALL,REFMSG_CHANGE); } }
DEFINE_OP_CLASS_ID GrPipelineDynamicStateTestOp(ScissorState scissorState, sk_sp<const GrBuffer> vbuff) : INHERITED(ClassID()) , fScissorState(scissorState) , fVertexBuffer(std::move(vbuff)) { this->setBounds(SkRect::MakeIWH(kScreenSize, kScreenSize), HasAABloat::kNo, IsZeroArea::kNo); }
// this is a little gross...the armature component shouldn't know that the subclasses // actually exist....it's a hard-to-detect implementation detail that breaks new subclasses.... bool plArmatureComponent::Convert(plMaxNode* node, plErrorMsg *pErrMsg) { // plHKPhysical *physical = plHKPhysical::ConvertToPhysical(node->GetSceneObject()); // physical->SetProperty(plSimulationInterface::kUpright, true); IAttachModifiers(node, pErrMsg); ISetupClothes(node, fArmMod, pErrMsg); // ArmatureEffects plArmatureEffectsMgr *effects = new plArmatureEffectsMgr(); hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), effects, node->GetLocation()); plGenRefMsg *msg = new plGenRefMsg(fArmMod->GetKey(), plRefMsg::kOnCreate, -1, -1); hsgResMgr::ResMgr()->AddViaNotify(effects->GetKey(), msg, plRefFlags::kActiveRef); // Attach effects plSceneObject *obj = node->GetSceneObject(); node->MakeCharacterHierarchy(pErrMsg); const plAGModifier *temp = static_cast<const plAGModifier *>(FindModifierByClass(obj, plAGModifier::Index())); plAGModifier *agMod = const_cast<plAGModifier *>(temp); hsAssert(agMod, "Armature root didn't get a agmod. I'll make one for you."); if( ! agMod) { // MakeCharacterHierarchy will attach agmodifiers to all the bones in the hierarchy; // have to manually add any for non-bone objects... agMod = new plAGModifier("Handle"); // the player root is known as the handle node->AddModifier(agMod, IGetUniqueName(node)); } agMod->SetChannelName("Handle"); // Get the position and radius of the head and torso physicals if (ClassID() == AVATAR_CLASS_ID || ClassID() == LOD_AVATAR_CLASS_ID) { bool isLOD = ((ClassID() == LOD_AVATAR_CLASS_ID) != 0); float height = fCompPB->GetFloat(isLOD ? plLODAvatarComponent::kPhysicsHeight : plAvatarComponent::kPhysicsHeight); float width = fCompPB->GetFloat(isLOD ? plLODAvatarComponent::kPhysicsWidth : plAvatarComponent::kPhysicsWidth); fArmMod->SetPhysicalDims(height, width); } // node->SetupBonesAliasesRecur(node->GetKey()->GetName()); return true; }
static std::string Help() { return ClassID() + "\n" "Output scatter data which emits all superfluous points. These points \n" "are defined by all points where, if emitted, a line graph would remain \n" "unchanged. In practice, this routine will determine if points lie along\n" " a minimum angle, which is passed as an argument. \n" "OPTIONS \n" " MinAngle=double; # Threshold angle for point to be printed \n" ; };
static std::string Help() { return ClassID()+"\n" "Generates a separate file each time AppendToFileImpl is called,\n" "and outputs x_i and y_i as two columns in to each file. \n" "The i-th data-point is omitted if the angle calculated between \n" "the line-segment connecting and the i-th and (i+1)-st gridpoint \n" "is less than some user-specifiable minimum angle. \n" "OPTIONS: \n" " MinAngle = double\n"; };
DEFINE_BATCH_CLASS_ID PLSPathBatch(GrColor color, const SkPath& path, const SkMatrix& viewMatrix) : INHERITED(ClassID()) , fColor(color) , fPath(path) , fViewMatrix(viewMatrix) { // compute bounds fBounds = path.getBounds(); fViewMatrix.mapRect(&fBounds); }
ClassID ClassDictionary::lookup(const std::string &class_name) { auto it = store.find(class_name); if (it == store.end()) { // Insert the class name into the store. ClassID id = ClassID(uint32_t(ClassID::Named) + offset++); store.emplace(class_name, id); return id; } else { return it->second; } }
void EulerExposeControl::Copy(Control *from) { if (from->ClassID()==ClassID()) { exposeTransform = ((EulerExposeControl*)from)->exposeTransform; paramID = ((EulerExposeControl*)from)->paramID; ivalid = ((EulerExposeControl*)from)->ivalid; curVal = ((EulerExposeControl*)from)->curVal; NotifyDependents(FOREVER,PART_ALL,REFMSG_CHANGE); } }
GrDrawPathRangeBatch::GrDrawPathRangeBatch(const SkMatrix& viewMatrix, SkScalar scale, SkScalar x, SkScalar y, GrColor color, GrPathRendering::FillType fill, GrPathRange* range, const InstanceData* instanceData, const SkRect& bounds) : INHERITED(ClassID(), viewMatrix, color, fill) , fPathRange(range) , fTotalPathCount(instanceData->count()) , fScale(scale) { fDraws.addToHead()->set(instanceData, x, y); this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo); }
IOResult RigidBodyWorldDesc::Save(ISave* isave) { IOResult ret = ClassDesc2::Save(isave); ULONG retVal; isave->BeginChunk(USHORT (ClassID().PartB())); isave->Write((const char*)&m_gravity, sizeof (m_gravity), &retVal); isave->Write((const char*)&m_minFps, sizeof (m_minFps), &retVal); isave->EndChunk(); return ret; }
bool SkeletalExporterBase::isBone(INode* node) { // Root node is never a bone if (node->IsRootNode()) return false; // Check for standard Max bone class auto os = node->EvalWorldState(0); if (os.obj->ClassID() == Class_ID(BONE_CLASS_ID, 0) || os.obj->ClassID() == Class_ID(BONE_OBJ_CLASSID) || node->GetBoneNodeOnOff()) return true; // Ignore dummy objects if (os.obj->ClassID() == Class_ID(DUMMY_CLASS_ID, 0)) return false; auto c = node->GetTMController(); // Check for Character Studio bone classes return c->ClassID() == BIPSLAVE_CONTROL_CLASS_ID || c->ClassID() == BIPBODY_CONTROL_CLASS_ID; }
void AudioPositionControl::Copy(Control* from) { Point3 fval; if (from->ClassID() == ClassID()) { basePoint = ((AudioPositionControl*)from)->basePoint; targetPoint = ((AudioPositionControl*)from)->targetPoint; } else { from->GetValue(0, &fval, Interval(0,0)); basePoint = fval; targetPoint = fval; } }
GBool GElement::IsTypeOfType(const GClassID& InspectedType, const GClassID& Class_ID) const { // trivial case if (Class_ID == InspectedType) return G_TRUE; // as an element, i can just say that my ClassID is of DerivedClassID type if ((InspectedType == ClassID()) && (Class_ID == DerivedClassID())) return G_TRUE; // try with owner if (gOwner) return gOwner->IsTypeOfType(InspectedType, Class_ID); // no more chances left return G_FALSE; }
static std::string Help() { return ClassID() + "\n" "Raises 1st index of a rank 2 Tensor<DataMesh>. \n" " T^i_j = g^{ik} T_kj \n" "OPTIONS: \n" " Input = string; # T_{kj} \n" " Output = string; # T^i_j \n" " InvMetric = string; # g^{ik} \n" "REQUIRES in DataBox: \n" " Tensor<DataMesh> [Input,InvMetric] \n" "PRESENTS to the DataBox \n" " Tensor<DataMesh> [Output] \n" ; };
static std::string Help() { return ClassID()+"\n" " Adds Strahlkorper Surface, Mesh, and SurfaceWithMesh \n" " so that routines can have exact copies. \n" "Options: \n" " SurfaceName = string; # name of Surface in DataBox \n" " MeshName = string; # name of Mesh in DataBox \n" " L = int; # spherical harmonic \n" " M = int; # spherical harmonic \n" " Radius = double; # radius of spherical surface \n" " Center = MyVector<double>; # location of center \n" " \n" "Output quantities: \n" " StrahlkorperSurface [SurfaceName] \n" " StrahlkorperMesh [MeshName] \n"; };
AADistanceFieldPathBatch(GrColor color, const GrShape& shape, bool antiAlias, const SkMatrix& viewMatrix, GrBatchAtlas* atlas, ShapeCache* shapeCache, ShapeDataList* shapeList, bool gammaCorrect) : INHERITED(ClassID()) { SkASSERT(shape.hasUnstyledKey()); fBatch.fViewMatrix = viewMatrix; fGeoData.emplace_back(Geometry{color, shape, antiAlias}); fAtlas = atlas; fShapeCache = shapeCache; fShapeList = shapeList; fGammaCorrect = gammaCorrect; // Compute bounds this->setTransformedBounds(shape.bounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo); }
/*! If copy can't be done an error code is returned, else G_NO_ERROR. The copy schema is subdivided into 3 steps: -# If Source is the same object pointed by 'this' pointer, just exit with a G_NO_ERROR code. -# If Source is not of the same type of this element, use owner (kernel) to do the copy (using Copy() function).\n The kernel will try to do a (physical) type conversion (using registered converters plugins), and then do the conversion. For further details see GKernel::Copy(). -# If Source is of the same type of this element, then it is safe to call BaseClone(). \note If as Source parameter will be passed a 'this' reference the function just returns a G_NO_ERROR without doing nothing. So a call like element->CopyFrom(*element) is not dangerous. */ GError GElement::CopyFrom(const GElement& Source) { const GElement *ptr = &Source; // check for a self to self copy if (ptr == this) return G_NO_ERROR; // check for a valid (compatible) source if (!Source.IsOfType(ClassID())) { if (gOwner) { G_ASSERT(gOwner->IsOfType(G_KERNEL_CLASSID) == G_TRUE); GKernel *kernel = (GKernel *)gOwner; return kernel->Copy(Source, *this); } else return G_UNSUPPORTED_CLASSID; } // now is safe to do a clone return BaseClone(Source); }
Modifier* SkeletalExporterBase::findModifier(INode* node, const Class_ID& classID) { auto object = node->GetObjectRef(); while (object && object->SuperClassID() == GEN_DERIVOB_CLASS_ID) { auto derivedObject = static_cast<IDerivedObject*>(object); // Iterate over all entries of the modifier stack. for (auto i = 0; i < derivedObject->NumModifiers(); i++) { // If this modifier is a physique then return it auto modifier = derivedObject->GetModifier(i); if (modifier->ClassID() == classID) return modifier; } object = derivedObject->GetObjRef(); } return nullptr; }
void OrientConstRotation::EndEditParams( IObjParam *ip, ULONG flags,Animatable *next ) { if(editCont!=NULL) { editCont = NULL; IParamMap2* pmap = pblock->GetMap(); if (pmap != NULL) { if (next && next->ClassID() == ClassID() && ((OrientConstRotation*)next)->pblock&&((OrientConstRotation*)next)->GetLocked()==false) { pmap->SetParamBlock(((OrientConstRotation*)next)->pblock); ip->ClearPickMode(); } else orientCD.EndEditParams(ip, this, flags | END_EDIT_REMOVEUI, next); } else { int index = aprops.FindProperty(PROPID_INTERPUI); if (index>=0) { InterpCtrlUI *ui = (InterpCtrlUI*)aprops[index]; if (ui->hParams) { ip->UnRegisterDlgWnd(ui->hParams); ip->DeleteRollupPage(ui->hParams); } index = aprops.FindProperty(PROPID_INTERPUI); if (index>=0) { delete aprops[index]; aprops.Delete(index,1); } } } ip->UnRegisterTimeChangeCallback(&orientConstTimeChangeCallback); ip->ClearPickMode(); // need this, otherwise will crash on undo, while pickmode is active. this->ip = NULL; hWnd = NULL; } }
LoadedModel_SemSceneNode::LoadedModel_SemSceneNode() : ISemanticSceneNode(ClassID()) { // initialise variables m_sFilename = std::string(); m_bEnvironmentMapping = false; }
DEFINE_BATCH_CLASS_ID GLBatch(GLInstancedRendering* instRendering) : INHERITED(ClassID(), instRendering) {}