void ScriptRenderTexture2D::internal_getColorSurfaces(ScriptRenderTexture2D* thisPtr, MonoArray** value) { if (thisPtr->mIsMulti) { SPtr<MultiRenderTexture> tex = thisPtr->getMultiRenderTexture(); UINT32 numColorSurfaces = tex->getColorSurfaceCount(); ScriptArray outArray = ScriptArray::create<ScriptTexture2D>(numColorSurfaces); for (UINT32 i = 0; i < numColorSurfaces; i++) { HTexture colorTex = tex->getBindableColorTexture(i); ScriptTexture2D* scriptSurface; ScriptResourceManager::instance().getScriptResource(colorTex, &scriptSurface, true); outArray.set(i, scriptSurface->getManagedInstance()); *value = outArray.getInternal(); } } else { SPtr<RenderTexture> tex = thisPtr->getRenderTexture(); ScriptArray outArray = ScriptArray::create<ScriptTexture2D>(1); HTexture colorTex = tex->getBindableColorTexture(); ScriptTexture2D* scriptSurface; ScriptResourceManager::instance().getScriptResource(colorTex, &scriptSurface, true); outArray.set(0, scriptSurface->getManagedInstance()); *value = outArray.getInternal(); } }
MonoArray* ScriptAnimationCurve::internal_GetKeyFrames(ScriptAnimationCurve* thisPtr) { UINT32 numKeyframes = thisPtr->mCurve->getNumKeyFrames(); ScriptArray output = ScriptArray::create<ScriptKeyFrame>(numKeyframes); for (UINT32 i = 0; i < numKeyframes; i++) output.set(i, thisPtr->mCurve->getKeyFrame(i)); return output.getInternal(); }
MonoArray* ScriptFontImportOptions::internal_GetFontSizes(ScriptFontImportOptions* thisPtr) { Vector<UINT32> fontSizes = thisPtr->getFontImportOptions()->getFontSizes(); ScriptArray outArray = ScriptArray::create<UINT32>((UINT32)fontSizes.size()); for (UINT32 i = 0; i < fontSizes.size(); i++) outArray.set(i, fontSizes[i]); return outArray.getInternal(); }
void ScriptSelection::onSelectionChanged(const Vector<HSceneObject>& sceneObjects, const Vector<Path>& resPaths) { UINT32 numObjects = (UINT32)sceneObjects.size(); ScriptArray scriptObjects = ScriptArray::create<ScriptSceneObject>(numObjects); for (UINT32 i = 0; i < numObjects; i++) { ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(sceneObjects[i]); scriptObjects.set(i, scriptSceneObject->getManagedInstance()); } UINT32 numPaths = (UINT32)resPaths.size(); ScriptArray scriptPaths = ScriptArray::create<String>(numPaths); for (UINT32 i = 0; i < numPaths; i++) scriptPaths.set(i, resPaths[i].toString()); MonoArray* monoObjects = scriptObjects.getInternal(); MonoArray* monoPaths = scriptPaths.getInternal(); MonoUtil::invokeThunk(OnSelectionChangedThunk, monoObjects, monoPaths); }
MonoArray* ScriptEditorWindow::internal_getAllWindows() { UINT32 numWindows = (UINT32)OpenScriptEditorWindows.size(); ScriptArray output = ScriptArray::create<ScriptEditorWindow>(numWindows); UINT32 idx = 0; for (auto& entry : OpenScriptEditorWindows) output.set(idx++, entry.second->mEditorWidget->getManagedInstance()); return output.getInternal(); }
MonoArray* ScriptAnimationClip::internal_GetAnimationEvents(ScriptAnimationClip* thisPtr) { const Vector<AnimationEvent>& events = thisPtr->getHandle()->getEvents(); UINT32 numEvents = (UINT32)events.size(); ScriptArray eventsArray = ScriptArray::create<ScriptAnimationEvent>(numEvents); for (UINT32 i = 0; i < numEvents; i++) eventsArray.set(i, ScriptAnimationEvent::toManaged(events[i])); return eventsArray.getInternal(); }
void ScriptEditorSettings::internal_GetRecentProjects(MonoArray** paths, MonoArray** timeStamps) { SPtr<EditorSettings> settings = gEditorApplication().getEditorSettings(); const Vector<RecentProject>& recentProjects = settings->getRecentProjects(); UINT32 numEntries = (UINT32)recentProjects.size(); ScriptArray outputPaths = ScriptArray::create<WString>(numEntries); ScriptArray outputTimeStamps = ScriptArray::create<UINT64>(numEntries); for (UINT32 i = 0; i < numEntries; i++) { WString projectPath = recentProjects[i].path.toWString(); MonoString* monoPath = MonoUtil::wstringToMono(projectPath); outputPaths.set(i, monoPath); outputTimeStamps.set(i, recentProjects[i].accessTimestamp); } *paths = outputPaths.getInternal(); *timeStamps = outputPaths.getInternal(); }
MonoArray* ScriptSceneObjectDragDropData::internal_GetObjects(ScriptSceneObjectDragDropData* instance) { ScriptArray objectsArray = ScriptArray::create<ScriptSceneObject>((UINT32)instance->mSceneObjects.size()); for (UINT32 i = 0; i < (UINT32)instance->mSceneObjects.size(); i++) { ScriptSceneObject* scriptSO = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(instance->mSceneObjects[i]); if (scriptSO != nullptr) objectsArray.set(i, scriptSO->getManagedInstance()); } return objectsArray.getInternal(); }
MonoArray* ScriptGUISkin::internal_GetStyleNames(ScriptGUISkin* thisPtr) { HGUISkin skin = thisPtr->getHandle(); Vector<String> styleNames = skin->getStyleNames(); UINT32 numNames = (UINT32)styleNames.size(); ScriptArray output = ScriptArray::create<String>(numNames); for (UINT32 i = 0; i < numNames; i++) output.set(i, styleNames[i]); return output.getInternal(); }
void InspectorBackend::getDatabaseTableNames(long callId, long databaseId) { if (InspectorFrontend* frontend = inspectorFrontend()) { ScriptArray result = frontend->newScriptArray(); Database* database = m_inspectorController->databaseForId(databaseId); if (database) { Vector<String> tableNames = database->tableNames(); unsigned length = tableNames.size(); for (unsigned i = 0; i < length; ++i) result.set(i, tableNames[i]); } frontend->didGetDatabaseTableNames(callId, result); } }
MonoArray* ScriptFontImportOptions::internal_GetCharRanges(ScriptFontImportOptions* thisPtr) { Vector<std::pair<UINT32, UINT32>> charRanges = thisPtr->getFontImportOptions()->getCharIndexRanges(); ScriptArray outArray = ScriptArray::create<ScriptCharRange>((UINT32)charRanges.size()); for (UINT32 i = 0; i < (UINT32)charRanges.size(); i++) { CharRange range; range.start = charRanges[i].first; range.end = charRanges[i].second; outArray.set(i, range); } return outArray.getInternal(); }
MonoArray* ScriptStringTable::internal_GetIdentifiers(ScriptStringTable* thisPtr) { const UnorderedSet<WString>& identifiers = thisPtr->getHandle()->getIdentifiers(); UINT32 numIdentifiers = (UINT32)identifiers.size(); ScriptArray outArray = ScriptArray::create<WString>(numIdentifiers); UINT32 idx = 0; for (auto identifier : identifiers) { outArray.set(idx, identifier); idx++; } return outArray.getInternal(); }
MonoArray* ScriptDebug::internal_getMessages() { Vector<LogEntry> entries = gDebug().getLog().getEntries(); UINT32 numEntries = (UINT32)entries.size(); ScriptArray output = ScriptArray::create<ScriptLogEntry>(numEntries); for (UINT32 i = 0; i < numEntries; i++) { MonoString* message = MonoUtil::stringToMono(entries[i].getMessage()); ScriptLogEntryData scriptEntry = { entries[i].getChannel(), message }; output.set(i, scriptEntry); } return output.getInternal(); }
void ScriptGUISceneTreeView::resourceDropped(const HSceneObject& parent, const Vector<Path>& resourcePaths) { MonoObject* sceneMonoObject = nullptr; if (parent != nullptr) { ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(parent); sceneMonoObject = scriptSceneObject->getManagedInstance(); } UINT32 numPaths = (UINT32)resourcePaths.size(); ScriptArray array = ScriptArray::create<WString>(numPaths); for (UINT32 i = 0; i < numPaths; i++) array.set(i, resourcePaths[i].toWString()); MonoUtil::invokeThunk(onResourceDroppedThunk, getManagedInstance(), sceneMonoObject, array.getInternal()); }
MonoObject* ScriptSceneObjectDragDropData::create(const Vector<HSceneObject>& sceneObjects) { ScriptArray arrSceneObjects = ScriptArray::create<ScriptSceneObject>((UINT32)sceneObjects.size()); UINT32 idx = 0; for (auto& so : sceneObjects) { ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(so); arrSceneObjects.set(idx, scriptSceneObject->getManagedInstance()); idx++; } void* params[1] = { arrSceneObjects.getInternal() }; MonoObject* instance = metaData.scriptClass->createInstance(params, 1); return instance; }
MonoArray* ScriptUndoRedo::internal_CloneSOMulti(MonoArray* soPtrs, MonoString* description) { WString nativeDescription = MonoUtil::monoToWString(description); ScriptArray input(soPtrs); ScriptArray output = ScriptArray::create<ScriptSceneObject>(input.size()); for (UINT32 i = 0; i < input.size(); i++) { ScriptSceneObject* soPtr = input.get<ScriptSceneObject*>(i); HSceneObject clone = CmdCloneSO::execute(soPtr->getNativeSceneObject(), nativeDescription); ScriptSceneObject* cloneSoPtr = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(clone); output.set(i, cloneSoPtr->getManagedInstance()); } return output.getInternal(); }
MonoArray* ScriptOSDropTarget::internal_GetFilePaths(ScriptOSDropTarget* nativeInstance) { OSDropTarget* dropTarget = nativeInstance->mDropTarget; if (nativeInstance->mIsDestroyed || dropTarget == nullptr || dropTarget->getDropType() != OSDropType::FileList) return ScriptArray::create<String>(0).getInternal(); Vector<WString> fileList = dropTarget->getFileList(); ScriptArray output = ScriptArray::create<WString>((UINT32)fileList.size()); UINT32 idx = 0; for (auto& path : fileList) { output.set(idx, path); idx++; } return output.getInternal(); }
MonoArray* ScriptMesh::internal_GetSubMeshes(ScriptMesh* thisPtr) { HMesh mesh = thisPtr->getHandle(); UINT32 numSubMeshes = mesh->getProperties().getNumSubMeshes(); ScriptArray subMeshArray = ScriptArray::create<ScriptSubMesh>(numSubMeshes); for (UINT32 i = 0; i < numSubMeshes; i++) { SubMesh curSubMesh = mesh->getProperties().getSubMesh(i); SubMeshData data; data.indexOffset = curSubMesh.indexOffset; data.indexCount = curSubMesh.indexCount; data.topology = drawOpToMeshTopology(curSubMesh.drawOp); subMeshArray.set(i, data); } return subMeshArray.getInternal(); }
MonoArray* ScriptEditorUtility::internal_FindDependencies(MonoObject* resource, bool recursive) { ScriptResource* srcResource = ScriptResource::toNative(resource); if (srcResource == nullptr) { ScriptArray emptyArray = ScriptArray::create<ScriptResource>(0); return emptyArray.getInternal(); } HResource srcHandle = srcResource->getGenericHandle(); Vector<ResourceDependency> dependencies = Utility::findResourceDependencies(srcHandle, recursive); UINT32 numEntries = (UINT32)dependencies.size(); ScriptArray output = ScriptArray::create<ScriptResource>(numEntries); for (UINT32 i = 0; i < numEntries; i++) { ScriptResourceBase* dependency = ScriptResourceManager::instance().getScriptResource(dependencies[i].resource, true); output.set(i, dependency->getManagedInstance()); } return output.getInternal(); }
ScriptCollisionData ScriptCollisionDataHelper::create(const CollisionData& data) { ScriptCollisionData output; if (data.collidersRaw[0] != nullptr) output.colliderA = (MonoObject*)data.collidersRaw[0]->_getOwner(PhysicsOwnerType::Script); else output.colliderA = nullptr; if (data.collidersRaw[1] != nullptr) output.colliderB = (MonoObject*)data.collidersRaw[1]->_getOwner(PhysicsOwnerType::Script); else output.colliderB = nullptr; UINT32 numContactPoints = (UINT32)data.contactPoints.size(); ScriptArray contactPoints = ScriptArray::create<ScriptContactPointHelper>(numContactPoints); for (UINT32 i = 0; i < numContactPoints; i++) contactPoints.set(i, ScriptContactPointHelper::box(data.contactPoints[i])); output.contactPoints = contactPoints.getInternal(); return output; }
MonoArray* ScriptSceneObject::internal_findChildren(ScriptSceneObject* nativeInstance, MonoString* name, bool recursive) { if (checkIfDestroyed(nativeInstance)) { ScriptArray emptyArray = ScriptArray::create<ScriptSceneObject>(0); return emptyArray.getInternal(); } String nativeName = MonoUtil::monoToString(name); Vector<HSceneObject> children = nativeInstance->getNativeSceneObject()->findChildren(nativeName, recursive); UINT32 numChildren = (UINT32)children.size(); ScriptArray output = ScriptArray::create<ScriptSceneObject>(numChildren); for (UINT32 i = 0; i < numChildren; i++) { HSceneObject child = children[i]; ScriptSceneObject* scriptChild = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(child); output.set(i, scriptChild->getManagedInstance()); } return output.getInternal(); }
void ScriptShader::internal_GetShaderParameters(ScriptShader* nativeInstance, MonoArray** outNames, MonoArray** outTypes, MonoArray** outVisibility) { HShader shader = nativeInstance->getHandle(); if (!shader.isLoaded()) { ScriptArray names = ScriptArray::create<String>(0); ScriptArray types = ScriptArray::create<UINT32>(0); ScriptArray visibility = ScriptArray::create<bool>(0); *outNames = names.getInternal(); *outTypes = types.getInternal(); *outVisibility = visibility.getInternal(); return; } const Map<String, SHADER_DATA_PARAM_DESC>& dataParams = shader->getDataParams(); const Map<String, SHADER_OBJECT_PARAM_DESC>& textureParams = shader->getTextureParams(); const Map<String, SHADER_OBJECT_PARAM_DESC>& samplerParams = shader->getSamplerParams(); struct ParamInfo { String name; ShaderParameterType type; bool internal; }; Vector<ParamInfo> paramInfos; // TODO - Ignoring int, bool, struct and non-square matrices // TODO - Ignoring buffers and load/store textures for (auto& param : dataParams) { ShaderParameterType type; bool isValidType = false; bool isInternal = !param.second.rendererSemantic.empty(); switch (param.second.type) { case GPDT_FLOAT1: type = ShaderParameterType::Float; isValidType = true; break; case GPDT_FLOAT2: type = ShaderParameterType::Vector2; isValidType = true; break; case GPDT_FLOAT3: type = ShaderParameterType::Vector3; isValidType = true; break; case GPDT_FLOAT4: type = ShaderParameterType::Vector4; isValidType = true; break; case GPDT_MATRIX_3X3: type = ShaderParameterType::Matrix3; isValidType = true; break; case GPDT_MATRIX_4X4: type = ShaderParameterType::Matrix4; isValidType = true; break; case GPDT_COLOR: type = ShaderParameterType::Color; isValidType = true; break; default: break; } if (isValidType) paramInfos.push_back({ param.first, type, isInternal }); } for (auto& param : textureParams) { ShaderParameterType type; bool isValidType = false; bool isInternal = !param.second.rendererSemantic.empty(); switch (param.second.type) { case GPOT_TEXTURE2D: case GPOT_TEXTURE2DMS: type = ShaderParameterType::Texture2D; isValidType = true; break; case GPOT_TEXTURE3D: type = ShaderParameterType::Texture3D; isValidType = true; break; case GPOT_TEXTURECUBE: type = ShaderParameterType::TextureCube; isValidType = true; break; default: break; } if (isValidType) paramInfos.push_back({ param.first, type, isInternal }); } for (auto& param : samplerParams) { ShaderParameterType type = ShaderParameterType::Sampler; bool isInternal = !param.second.rendererSemantic.empty(); paramInfos.push_back({ param.first, type, isInternal }); } UINT32 totalNumParams = (UINT32)paramInfos.size(); ScriptArray names = ScriptArray::create<String>(totalNumParams); ScriptArray types = ScriptArray::create<UINT32>(totalNumParams); ScriptArray visibility = ScriptArray::create<bool>(totalNumParams); UINT32 idx = 0; for (auto& param : paramInfos) { names.set(idx, param.name); types.set(idx, param.type); visibility.set(idx, param.internal); idx++; } *outNames = names.getInternal(); *outTypes = types.getInternal(); *outVisibility = visibility.getInternal(); }