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();
	}
Пример #2
0
	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* 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 ScriptResourceDragDropData::internal_CreateInstance(MonoObject* managedInstance, MonoArray* monoPaths)
	{
		ScriptArray pathsArray = ScriptArray(monoPaths);

		Vector<Path> paths(pathsArray.size());
		for (UINT32 i = 0; i < pathsArray.size(); i++)
		{
			MonoString* monoPath = pathsArray.get<MonoString*>(i);
			paths[i] = MonoUtil::monoToWString(monoPath);
		}

		new (bs_alloc<ScriptResourceDragDropData>()) ScriptResourceDragDropData(managedInstance, paths);
	}
Пример #6
0
	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();
	}
	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();
	}
	void ScriptSceneObjectDragDropData::internal_CreateInstance(MonoObject* managedInstance, MonoArray* objects)
	{
		ScriptArray objectsArray = ScriptArray(objects);

		Vector<HSceneObject> sceneObjects(objectsArray.size());
		for (UINT32 i = 0; i < objectsArray.size(); i++)
		{
			ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(objectsArray.get<MonoObject*>(i));
			if (scriptSO != nullptr)
				sceneObjects[i] = scriptSO->getNativeSceneObject();
		}

		new (bs_alloc<ScriptSceneObjectDragDropData>()) ScriptSceneObjectDragDropData(managedInstance, sceneObjects);
	}
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();
	}
Пример #11
0
	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();
	}
Пример #12
0
	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;
	}
Пример #15
0
	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();
	}
Пример #16
0
	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();
	}
Пример #17
0
	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();
	}
	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();
		}
	}
	void ScriptRenderTexture2D::internal_getColorSurfaces(ScriptRenderTexture2D* thisPtr, MonoArray** value)
	{
		SPtr<RenderTexture> tex = thisPtr->getRenderTexture();

		UINT32 numColorSurfaces = BS_MAX_MULTIPLE_RENDER_TARGETS;
		ScriptArray outArray = ScriptArray::create<ScriptTexture>(numColorSurfaces);

		for (UINT32 i = 0; i < numColorSurfaces; i++)
		{
			HTexture colorTex = tex->getColorTexture(i);

			if (colorTex != nullptr)
			{
				ScriptResourceBase* scriptSurface = ScriptResourceManager::instance().getScriptResource(colorTex, true);
				outArray.set<MonoObject*>(i, scriptSurface->getManagedInstance());
			}
			else
				outArray.set<MonoObject*>(i, nullptr);
		}

		*value = outArray.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;
	}
Пример #22
0
	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();
	}
Пример #23
0
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);
}
	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();
	}
Пример #25
0
	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();
	}