4ian/GDevelop
1
0
Fork 0
mirror of https://github.com/4ian/GDevelop.git synced 2026-10-12 02:01:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove the dependency to SFML (#3865)

Browse Source 
* This allows to run Core tests more easily.
This commit is contained in:
D8H
2022-05-13 13:27:41 +02:00
committed by GitHub
parent 67718a364b
commit 91a02d132f
41 changed files with 415 additions and 671 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.vscode/c_cpp_properties.json
Vendored
-3
View File
@@ -7,7 +7,6 @@
"${workspaceRoot}/GDJS",
"${workspaceRoot}/Extensions",
"${workspaceRoot}/Core",
"${workspaceRoot}/ExtLibs/SFML/include",
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
"/usr/local/include",
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
@@ -46,7 +45,6 @@
"${workspaceRoot}/GDJS",
"${workspaceRoot}/Extensions",
"${workspaceRoot}/Core",
"${workspaceRoot}/ExtLibs/SFML/include",
"/usr/include",
"/usr/local/include",
"${workspaceRoot}"
@@ -76,7 +74,6 @@
"${workspaceRoot}/GDJS",
"${workspaceRoot}/Extensions",
"${workspaceRoot}/Core",
"${workspaceRoot}/ExtLibs/SFML/include",
"${workspaceRoot}"
],
"defines": [
.vscode/settings.json
Vendored
-1
View File
@@ -115,7 +115,6 @@
"files.exclude": {
"Binaries/*build*": true,
"Binaries/Output": true,
"ExtLibs/SFML": true,
"GDJS/Runtime-dist": true,
"docs": true,
"newIDE/electron-app/dist": true,
Core/CMakeLists.txt
+1 -10
View File
@@ -14,7 +14,6 @@ set(GDCORE_lib_dir ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SY
#Dependencies on external libraries:
###
include_directories(${sfml_include_dir})
#Defines
###
@@ -68,14 +67,6 @@ set(LIBRARY_OUTPUT_PATH ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMA
set(ARCHIVE_OUTPUT_PATH ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SYSTEM_NAME})
set(RUNTIME_OUTPUT_PATH ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SYSTEM_NAME})
#Linker files
###
IF(EMSCRIPTEN)
#Nothing.
ELSE()
target_link_libraries(GDCore ${sfml_LIBRARIES})
ENDIF()
#Tests
###
if(BUILD_TESTS)
@@ -88,5 +79,5 @@ if(BUILD_TESTS)
add_executable(GDCore_tests ${test_source_files})
set_target_properties(GDCore_tests PROPERTIES BUILD_WITH_INSTALL_RPATH FALSE) #Allow finding dependencies directly from build path on Mac OS X.
target_link_libraries(GDCore_tests GDCore)
target_link_libraries(GDCore_tests ${sfml_LIBRARIES})
target_link_libraries(GDCore_tests ${CMAKE_DL_LIBS})
endif()
Core/GDCore/CommonTools.h
-1
View File
@@ -13,7 +13,6 @@
#include <string>
#include <vector>
#include "Utf8/utf8.h"
#include <SFML/System/String.hpp>
#ifdef __GNUC__
#define GD_DEPRECATED __attribute__((deprecated))
Core/GDCore/Extensions/Builtin/SpriteExtension/Direction.cpp
+1 -1
View File
@@ -121,7 +121,7 @@ void Direction::UnserializeFrom(const gd::SerializerElement& element) {
polygonElement.GetChild(k);
polygon.vertices.push_back(
sf::Vector2f(verticeElement.GetDoubleAttribute("x"),
gd::Vector2f(verticeElement.GetDoubleAttribute("x"),
verticeElement.GetDoubleAttribute("y")));
}
Core/GDCore/Extensions/Builtin/SpriteExtension/Polygon2d.cpp
+8 -8
View File
@@ -4,7 +4,7 @@
* reserved. This project is released under the MIT License.
*/
#include "Polygon2d.h"
#include <SFML/System/Vector2.hpp>
#include "GDCore/Vector2.h"
#include <cmath>
#include <iostream>
@@ -28,7 +28,7 @@ void Polygon2d::Move(float x, float y) {
}
void Polygon2d::ComputeEdges() const {
sf::Vector2f v1, v2;
gd::Vector2f v1, v2;
edges.clear();
for (std::size_t i = 0; i < vertices.size(); i++) {
@@ -62,8 +62,8 @@ bool Polygon2d::IsConvex() const {
return true;
}
sf::Vector2f Polygon2d::ComputeCenter() const {
sf::Vector2f center;
gd::Vector2f Polygon2d::ComputeCenter() const {
gd::Vector2f center;
for (std::size_t i = 0; i < vertices.size(); i++) {
center.x += vertices[i].x;
@@ -77,10 +77,10 @@ sf::Vector2f Polygon2d::ComputeCenter() const {
Polygon2d Polygon2d::CreateRectangle(float width, float height) {
Polygon2d rect;
rect.vertices.push_back(sf::Vector2f(-width / 2.0f, -height / 2.0f));
rect.vertices.push_back(sf::Vector2f(+width / 2.0f, -height / 2.0f));
rect.vertices.push_back(sf::Vector2f(+width / 2.0f, +height / 2.0f));
rect.vertices.push_back(sf::Vector2f(-width / 2.0f, +height / 2.0f));
rect.vertices.push_back(gd::Vector2f(-width / 2.0f, -height / 2.0f));
rect.vertices.push_back(gd::Vector2f(+width / 2.0f, -height / 2.0f));
rect.vertices.push_back(gd::Vector2f(+width / 2.0f, +height / 2.0f));
rect.vertices.push_back(gd::Vector2f(-width / 2.0f, +height / 2.0f));
return rect;
}
Core/GDCore/Extensions/Builtin/SpriteExtension/Polygon2d.h
+6 -6
View File
@@ -5,7 +5,7 @@
*/
#ifndef GDCORE_POLYGON_H
#define GDCORE_POLYGON_H
#include <SFML/System/Vector2.hpp>
#include "GDCore/Vector2.h"
#include <vector>
/**
@@ -22,19 +22,19 @@ class GD_CORE_API Polygon2d {
Polygon2d(){};
virtual ~Polygon2d(){};
std::vector<sf::Vector2f> vertices; ///< The vertices composing the polygon
mutable std::vector<sf::Vector2f>
std::vector<gd::Vector2f> vertices; ///< The vertices composing the polygon
mutable std::vector<gd::Vector2f>
edges; ///< Edges. Can be computed from vertices using ComputeEdges()
/**
* \brief Get the vertices composing the polygon.
*/
std::vector<sf::Vector2f>& GetVertices() { return vertices; }
std::vector<gd::Vector2f>& GetVertices() { return vertices; }
/**
* \brief Get the vertices composing the polygon.
*/
const std::vector<sf::Vector2f>& GetVertices() const { return vertices; }
const std::vector<gd::Vector2f>& GetVertices() const { return vertices; }
/**
* \brief Moves each vertices from the given amount.
@@ -68,7 +68,7 @@ class GD_CORE_API Polygon2d {
/**
* \brief Return the position of the center of the polygon
*/
sf::Vector2f ComputeCenter() const;
gd::Vector2f ComputeCenter() const;
/** \name Tools
* Tool functions
Core/GDCore/Extensions/Builtin/SpriteExtension/Sprite.cpp
-1
View File
@@ -4,7 +4,6 @@
* reserved. This project is released under the MIT License.
*/
#include "GDCore/Extensions/Builtin/SpriteExtension/Sprite.h"
#include <SFML/Graphics/Sprite.hpp>
#include <iostream>
#include "GDCore/Extensions/Builtin/SpriteExtension/Polygon2d.h"
Core/GDCore/Extensions/Builtin/SpriteExtension/Sprite.h
-1
View File
@@ -6,7 +6,6 @@
#ifndef SPRITE_H
#define SPRITE_H
#include <SFML/Graphics/Sprite.hpp>
#include <memory>
#include "GDCore/Extensions/Builtin/SpriteExtension/Point.h"
#include "GDCore/Extensions/Builtin/SpriteExtension/Polygon2d.h"
Core/GDCore/Extensions/Builtin/SpriteExtension/SpriteObject.cpp
-1
View File
@@ -6,7 +6,6 @@
#include "GDCore/Extensions/Builtin/SpriteExtension/SpriteObject.h"
#include <SFML/Graphics.hpp>
#include <algorithm>
#include "GDCore/CommonTools.h"
Core/GDCore/Extensions/Metadata/EffectMetadata.h
+1
View File
@@ -8,6 +8,7 @@
#include <functional>
#include <map>
#include <memory>
#include <algorithm>
#include "GDCore/Project/PropertyDescriptor.h"
#include "GDCore/String.h"
Core/GDCore/Extensions/Metadata/InstructionMetadata.h
+1
View File
@@ -9,6 +9,7 @@
#include <functional>
#include <map>
#include <memory>
#include <algorithm>
#include "GDCore/Events/Instruction.h"
#include "GDCore/String.h"
Core/GDCore/Project/EffectsContainer.h
+1
View File
@@ -7,6 +7,7 @@
#define GDCORE_EFFECTS_CONTAINER_H
#include <memory>
#include <vector>
#include <algorithm>
#include "GDCore/String.h"
Core/GDCore/Project/Object.h
+1 -1
View File
@@ -5,7 +5,7 @@
*/
#ifndef GDCORE_OBJECT_H
#define GDCORE_OBJECT_H
#include <SFML/System/Vector2.hpp>
#include "GDCore/Vector2.h"
#include <map>
#include <memory>
#include <vector>
Core/GDCore/Project/ObjectGroupsContainer.h
+1
View File
@@ -7,6 +7,7 @@
#ifndef GDCORE_OBJECTGROUPSCONTAINER_H
#define GDCORE_OBJECTGROUPSCONTAINER_H
#include <vector>
#include <algorithm>
#include "GDCore/Project/ObjectGroup.h"
#include "GDCore/String.h"
namespace gd {
Core/GDCore/Project/Project.cpp
-1
View File
@@ -9,7 +9,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <SFML/System/Utf.hpp>
#include <cctype>
#include <fstream>
#include <map>
Core/GDCore/String.cpp
+4 -49
View File
@@ -9,7 +9,6 @@
#include <algorithm>
#include <string.h>
#include <SFML/System/String.hpp>
#include "GDCore/CommonTools.h"
#include "GDCore/Utf8/utf8proc.h"
@@ -28,11 +27,6 @@ String::String(const char *characters) : m_string()
*this = characters;
}
String::String(const sf::String &string) : m_string()
{
*this = string;
}
String::String(const std::u32string &string) : m_string()
{
*this = string;
@@ -44,26 +38,6 @@ String& String::operator=(const char *characters)
return *this;
}
String& String::operator=(const sf::String &string)
{
m_string.clear();
//In theory, an UTF8 character can be up to 6 bytes (even if in the current Unicode standard,
//the last character is 4 bytes long when encoded in UTF8).
//So, reserve the maximum possible size to avoid reallocations.
m_string.reserve( string.getSize() * 6 );
//Push_back all characters inside the string.
for( sf::String::ConstIterator it = string.begin(); it != string.end(); ++it )
{
push_back( *it );
}
m_string.shrink_to_fit();
return *this;
}
String& String::operator=(const std::u32string &string)
{
m_string.clear();
@@ -112,7 +86,7 @@ String::const_iterator String::end() const
String String::FromLocale( const std::string &localizedString )
{
#if defined(WINDOWS)
return FromSfString(sf::String(localizedString)); //Don't need to use the current locale, on Windows, std::locale is always the C locale
return FromUTF8(localizedString); //Don't need to use the current locale, on Windows, std::locale is always the C locale
#elif defined(MACOS)
return FromUTF8(localizedString); //Assume UTF8 is the current locale
#elif defined(EMSCRIPTEN)
@@ -124,7 +98,7 @@ String String::FromLocale( const std::string &localizedString )
std::locale("").name().find("UTF8") != std::string::npos)
return FromUTF8(localizedString); //UTF8 is already the current locale
else
return FromSfString(sf::String(localizedString, std::locale(""))); //Use the current locale (std::locale("")) for conversion
return FromUTF8(localizedString); //Use the current locale (std::locale("")) for conversion
#endif
}
@@ -136,11 +110,6 @@ String String::FromUTF32( const std::u32string &string )
return str;
}
String String::FromSfString( const sf::String &sfString )
{
return String(sfString);
}
String String::FromUTF8( const std::string &utf8Str )
{
String str(utf8Str.c_str());
@@ -164,7 +133,7 @@ String String::FromWide( const std::wstring &wstr )
std::string String::ToLocale() const
{
#if defined(WINDOWS)
return ToSfString().toAnsiString();
return m_string;
#elif defined(MACOS)
return m_string;
#elif defined(EMSCRIPTEN)
@@ -176,7 +145,7 @@ std::string String::ToLocale() const
std::locale("").name().find("UTF8") != std::string::npos)
return m_string; //UTF8 is already the current locale on Linux
else
return ToSfString().toAnsiString(std::locale("")); //Use the current locale for conversion
return m_string; //Use the current locale for conversion
#endif
}
@@ -191,20 +160,6 @@ std::u32string String::ToUTF32() const
return u32str;
}
sf::String String::ToSfString() const
{
sf::String str;
for(const_iterator it = begin(); it != end(); ++it)
str += sf::String(static_cast<sf::Uint32>(*it));
return str;
}
String::operator sf::String() const
{
return ToSfString();
}
std::string String::ToUTF8() const
{
return m_string;
Core/GDCore/String.h
+1 -44
View File
@@ -13,12 +13,9 @@
#include <sstream>
#include <string>
#include <vector>
#include <SFML/System/String.hpp>
#include "GDCore/Utf8/utf8.h"
namespace sf {class String;};
namespace gd
{
@@ -121,11 +118,6 @@ public:
*/
String(const std::u32string &string);
/**
* Constructs a string from an sf::String.
*/
String(const sf::String &string);
/**
* \}
*/
@@ -146,8 +138,6 @@ public:
*/
String& operator=(const char *characters);
String& operator=(const sf::String &string);
String& operator=(const std::u32string &string);
/**
@@ -229,7 +219,6 @@ public:
static String From(T value)
{
static_assert(!std::is_same<T, std::string>::value, "Can't use gd::String::From with std::string.");
static_assert(!std::is_same<T, sf::String>::value, "Can't use gd::String::From with sf::String.");
std::ostringstream oss;
oss << value;
@@ -244,7 +233,6 @@ public:
T To() const
{
static_assert(!std::is_same<T, std::string>::value, "Can't use gd::String::To with std::string.");
static_assert(!std::is_same<T, sf::String>::value, "Can't use gd::String::To with sf::String.");
T value;
std::istringstream oss(m_string);
@@ -274,13 +262,6 @@ public:
*/
static String FromUTF32( const std::u32string &string );
/**
* \return a String created from a sf::String (UTF32).
*
* See \ref Conversions1 for more information.
*/
static String FromSfString( const sf::String &sfString );
/**
* \return a String created an UTF8 encoded std::string.
*/
@@ -312,20 +293,6 @@ public:
*/
std::u32string ToUTF32() const;
/**
* \return a sf::String from the current string.
*
* See \ref Conversions1 for more information.
*/
sf::String ToSfString() const;
/**
* Implicit conversion operator to sf::String.
*
* See \ref Conversions1 for more information.
*/
operator sf::String() const;
/**
* \return a UTF8 encoded std::string from the current string.
*/
@@ -885,7 +852,7 @@ namespace std
* on the string size and so is the operator[]().
*
* \section Conversion Conversions from/to other string types
* The String handles implicit conversion with sf::String (implicit constructor and implicit conversion
* The String handles implicit conversion with std::String (implicit constructor and implicit conversion
* operator).
*
* **However, this is not the case with std::string** as this conversion is not often lossless (mostly on Windows).
@@ -894,16 +861,6 @@ namespace std
* directly use the operator=() or the constructor as they are supporting const char* as argument (it assumes the string
* literal is encoded in UTF8, so you'll need to put the u8 prefix).
*
* \subsection Conversions1 Implicit conversion from/to sf::String
* \code
* //Get a String from sf::String
* sf::String sfmlStr("This is a test ! ");
* gd::String str1(sfmlStr); //Now contains "This is a test ! " encoded in UTF8
*
* //Get a sf::String from String
* sf::String anotherSfmlString = str; //anotherSfmlString now contains "Another test ! "
* \endcode
*
* \subsection Conversions2 Conversion from/to std::string
* \code
* //Get a String from a std::string encoded in the current locale
Core/GDCore/Tools/FileStream.cpp
-200
View File
@@ -1,200 +0,0 @@
#include "GDCore/Tools/FileStream.h"
#if defined(WINDOWS)
#if __GLIBCXX__
#include <ext/stdio_filebuf.h>
#endif
#endif
namespace gd {
namespace {
#if FSTREAM_WINDOWS_MINGW
#define MODE(in_val, out_val, trunc_val, app_val) \
((((mode & std::ios_base::in) != 0) == in_val) && \
(((mode & std::ios_base::out) != 0) == out_val) && \
(((mode & std::ios_base::trunc) != 0) == trunc_val) && \
(((mode & std::ios_base::app) != 0) == app_val))
std::wstring GetStdioMode(std::ios_base::openmode mode) {
std::wstring strMode;
/// Thanks to https://gcc.gnu.org/ml/libstdc++/2007-06/msg00013.html
if (MODE(false, true, false, false))
strMode += L"w";
else if (MODE(false, true, false, true))
strMode += L"a";
else if (MODE(true, true, false, true))
strMode += L"a+";
else if (MODE(false, true, true, false))
strMode += L"w";
else if (MODE(true, false, false, false))
strMode += L"r";
else if (MODE(true, true, false, false))
strMode += L"r+";
else if (MODE(true, true, true, false))
strMode += L"w+";
if ((mode & std::ios_base::binary) != 0) strMode += L"b";
return strMode;
}
#endif
/**
* Open the given file into a filebuf and return it.
* On Windows, return the associated FILE* inside the file argument.
*/
FileStream::InternalBufferType* OpenBuffer(const gd::String& path,
std::ios_base::openmode mode,
FILE** file) {
#if FSTREAM_WINDOWS_MINGW
*file = _wfopen(path.ToWide().c_str(), GetStdioMode(mode).c_str());
if (!(*file)) return nullptr;
return new __gnu_cxx::stdio_filebuf<char>(*file, mode);
#else
auto* filebuffer = new std::filebuf();
return filebuffer->open(path.ToLocale().c_str(), mode);
#endif
}
} // namespace
FileStream::FileStream() : std::iostream(nullptr) {}
FileStream::FileStream(const gd::String& path, std::ios_base::openmode mode)
: std::iostream(nullptr),
m_file(nullptr),
m_buffer(OpenBuffer(path, mode, &m_file)) {
setstate(ios_base::goodbit);
if (m_buffer) {
std::iostream::init(m_buffer.get());
if ((mode & std::ios_base::ate) != 0) seekg(0, end);
} else
setstate(ios_base::badbit);
}
FileStream::~FileStream() {
if (is_open()) close();
}
/*
WILL WORK with GCC>=5 (not 4.9 used on Windows)
FileStream::FileStream(FileStream && other) :
std::iostream(std::move(other)),
m_buffer(std::move(other.m_buffer))
{
}*/
/*FileStream& FileStream::operator=(FileStream && other)
{
std::iostream::operator=(std::move(other));
m_buffer = std::move(other.m_buffer);
}*/
void FileStream::open(const gd::String& path, std::ios_base::openmode mode) {
setstate(ios_base::goodbit);
if (is_open()) {
setstate(ios_base::failbit);
std::cout << "is_open true when trying to open!" << std::endl;
} else {
auto* newBuffer = OpenBuffer(path, mode, &m_file);
if (newBuffer) {
m_buffer.reset(newBuffer);
std::iostream::init(m_buffer.get());
if ((mode & std::ios_base::ate) != 0) seekg(0, end);
} else {
setstate(ios_base::badbit);
}
}
}
bool FileStream::is_open() const {
if (!m_buffer) return false;
return m_buffer->is_open();
}
void FileStream::close() {
#if FSTREAM_WINDOWS_MINGW
if (m_buffer) m_buffer->close();
if (m_file && fclose(m_file) != 0) {
setstate(ios_base::failbit);
}
m_buffer.reset(nullptr);
m_file = nullptr;
#else
if (!m_buffer || m_buffer->close() == nullptr) {
setstate(ios_base::failbit);
} else {
m_buffer.reset(nullptr);
}
#endif
}
/*void FileStream::swap(FileStream & other) //WILL WORK with GCC>=5 (not 4.9
used on Windows)
{
std::iostream::swap(other);
std::swap(m_buffer, other.m_buffer);
}*/
SFMLFileStream::SFMLFileStream() : m_file(nullptr) {}
SFMLFileStream::~SFMLFileStream() {
if (m_file) fclose(m_file);
}
bool SFMLFileStream::open(const gd::String& filename) {
if (m_file) fclose(m_file);
#if FSTREAM_WINDOWS_MINGW
m_file = _wfopen(filename.ToWide().c_str(), L"rb");
#else
m_file = fopen(filename.ToLocale().c_str(), "rb");
#endif
return m_file != NULL;
}
sf::Int64 SFMLFileStream::read(void* data, sf::Int64 size) {
if (m_file)
return fread(data, 1, static_cast<std::size_t>(size), m_file);
else
return -1;
}
sf::Int64 SFMLFileStream::seek(sf::Int64 position) {
if (m_file) {
fseek(m_file, static_cast<std::size_t>(position), SEEK_SET);
return tell();
} else {
return -1;
}
}
sf::Int64 SFMLFileStream::tell() {
if (m_file)
return ftell(m_file);
else
return -1;
}
sf::Int64 SFMLFileStream::getSize() {
if (m_file) {
sf::Int64 position = tell();
fseek(m_file, 0, SEEK_END);
sf::Int64 size = tell();
seek(position);
return size;
} else {
return -1;
}
}
} // namespace gd
Core/GDCore/Tools/FileStream.h
-82
View File
@@ -1,82 +0,0 @@
#ifndef GDCORE_FSTREAMTOOLS
#define GDCORE_FSTREAMTOOLS
#include <iostream>
#include <memory>
#include <SFML/System.hpp>
#include "GDCore/String.h"
#if defined(WINDOWS) && __GLIBCXX__
#include <ext/stdio_filebuf.h>
#else
#include <fstream> //for std::filebuf
#endif
namespace gd {
/**
* Similar to std::i/ofstream except that it can open file with
* gd::String paths (useful on Windows where fstream doesn't
* support wide paths).
*/
class GD_CORE_API FileStream : public std::iostream {
public:
#if defined(WINDOWS) && __GLIBCXX__
using InternalBufferType = std::basic_filebuf<char>;
#else
using InternalBufferType = std::filebuf;
#endif
FileStream();
FileStream(const gd::String& path, std::ios_base::openmode mode);
~FileStream();
FileStream(const FileStream& other) = delete;
FileStream(FileStream&& other) = delete; // HACK for GCC 4.9 (Windows)
// FileStream(FileStream && other); WILL WORK with GCC>=5 (not 4.9 used on
// Windows)
FileStream& operator=(const FileStream& other) = delete;
FileStream& operator=(FileStream&& other) =
delete; // HACK for GCC 4.9 (Windows)
// FileStream& operator=(FileStream && other); WILL WORK with GCC>=5 (not 4.9
// used on Windows)
void open(const gd::String& path, std::ios_base::openmode mode);
bool is_open() const;
void close();
// void swap(FileStream & other); //WILL WORK with GCC>=5 (not 4.9 used on
// Windows)
private:
FILE* m_file;
std::unique_ptr<InternalBufferType> m_buffer;
};
class GD_CORE_API SFMLFileStream : public sf::InputStream {
public:
SFMLFileStream();
~SFMLFileStream();
bool open(const gd::String& filename);
virtual sf::Int64 read(void* data, sf::Int64 size);
virtual sf::Int64 seek(sf::Int64 position);
virtual sf::Int64 tell();
virtual sf::Int64 getSize();
private:
FILE* m_file;
};
} // namespace gd
#endif
Core/GDCore/Tools/OpenGLTools.cpp
-19
View File
@@ -1,19 +0,0 @@
#include <SFML/OpenGL.hpp>
#include <cmath>
namespace OpenGLTools {
void GD_CORE_API PerspectiveGL(GLdouble fovY,
GLdouble aspect,
GLdouble zNear,
GLdouble zFar) {
const GLdouble pi = 3.1415926535897932384626433832795;
GLdouble fW, fH;
fH = std::tan(fovY / 360 * pi) * zNear;
fW = fH * aspect;
glFrustum(-fW, fW, -fH, fH, zNear, zFar);
}
} // namespace OpenGLTools
Core/GDCore/Tools/OpenGLTools.h
-9
View File
@@ -1,9 +0,0 @@
#include <SFML/OpenGL.hpp>
namespace OpenGLTools {
void GD_CORE_API PerspectiveGL(GLdouble fovY,
GLdouble aspect,
GLdouble zNear,
GLdouble zFar);
}
Core/GDCore/Vector2.h
+360
View File
@@ -0,0 +1,360 @@
// This is adapted from SFML (https://github.com/SFML/SFML).
#ifndef GDCORE_VECTOR2_H
#define GDCORE_VECTOR2_H
namespace gd
{
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2016 Laurent Gomila ([email protected])
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
/// \brief Utility template class for manipulating
/// 2-dimensional vectors
///
////////////////////////////////////////////////////////////
template <typename T>
class Vector2
{
public:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
/// Creates a Vector2(0, 0).
///
////////////////////////////////////////////////////////////
inline Vector2() :
x(0),
y(0)
{
}
////////////////////////////////////////////////////////////
/// \brief Construct the vector from its coordinates
///
/// \param X X coordinate
/// \param Y Y coordinate
///
////////////////////////////////////////////////////////////
inline Vector2(T X, T Y) :
x(X),
y(Y)
{
}
////////////////////////////////////////////////////////////
/// \brief Construct the vector from another type of vector
///
/// This constructor doesn't replace the copy constructor,
/// it's called only when U != T.
/// A call to this constructor will fail to compile if U
/// is not convertible to T.
///
/// \param vector Vector to convert
///
////////////////////////////////////////////////////////////
template <typename U>
inline explicit Vector2(const Vector2<U>& vector) :
x(static_cast<T>(vector.x)),
y(static_cast<T>(vector.y))
{
}
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
T x; ///< X coordinate of the vector
T y; ///< Y coordinate of the vector
};
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of unary operator -
///
/// \param right Vector to negate
///
/// \return Memberwise opposite of the vector
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T> operator -(const Vector2<T>& right)
{
return Vector2<T>(-right.x, -right.y);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator +=
///
/// This operator performs a memberwise addition of both vectors,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T>& operator +=(Vector2<T>& left, const Vector2<T>& right)
{
left.x += right.x;
left.y += right.y;
return left;
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator -=
///
/// This operator performs a memberwise subtraction of both vectors,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T>& operator -=(Vector2<T>& left, const Vector2<T>& right)
{
left.x -= right.x;
left.y -= right.y;
return left;
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator +
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Memberwise addition of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T> operator +(const Vector2<T>& left, const Vector2<T>& right)
{
return Vector2<T>(left.x + right.x, left.y + right.y);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator -
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Memberwise subtraction of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T> operator -(const Vector2<T>& left, const Vector2<T>& right)
{
return Vector2<T>(left.x - right.x, left.y - right.y);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator *
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Memberwise multiplication by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T> operator *(const Vector2<T>& left, T right)
{
return Vector2<T>(left.x * right, left.y * right);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator *
///
/// \param left Left operand (a scalar value)
/// \param right Right operand (a vector)
///
/// \return Memberwise multiplication by \a left
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T> operator *(T left, const Vector2<T>& right)
{
return Vector2<T>(right.x * left, right.y * left);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator *=
///
/// This operator performs a memberwise multiplication by \a right,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T>& operator *=(Vector2<T>& left, T right)
{
left.x *= right;
left.y *= right;
return left;
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator /
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Memberwise division by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T> operator /(const Vector2<T>& left, T right)
{
return Vector2<T>(left.x / right, left.y / right);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator /=
///
/// This operator performs a memberwise division by \a right,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
inline Vector2<T>& operator /=(Vector2<T>& left, T right)
{
left.x /= right;
left.y /= right;
return left;
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator ==
///
/// This operator compares strict equality between two vectors.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return True if \a left is equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
inline bool operator ==(const Vector2<T>& left, const Vector2<T>& right)
{
return (left.x == right.x) && (left.y == right.y);
}
////////////////////////////////////////////////////////////
/// \relates Vector2
/// \brief Overload of binary operator !=
///
/// This operator compares strict difference between two vectors.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return True if \a left is not equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
inline bool operator !=(const Vector2<T>& left, const Vector2<T>& right)
{
return (left.x != right.x) || (left.y != right.y);
}
// Define the most common types
typedef Vector2<int> Vector2i;
typedef Vector2<unsigned int> Vector2u;
typedef Vector2<float> Vector2f;
} // namespace gd
#endif // GDCORE_VECTOR2_H
////////////////////////////////////////////////////////////
/// \class gd::Vector2
/// \ingroup CommonProgrammingTools
///
/// gd::Vector2 is a simple class that defines a mathematical
/// vector with two coordinates (x and y). It can be used to
/// represent anything that has two dimensions: a size, a point,
/// a velocity, etc.
///
/// The template parameter T is the type of the coordinates. It
/// can be any type that supports arithmetic operations (+, -, /, *)
/// and comparisons (==, !=), for example int or float.
///
/// You generally don't have to care about the templated form (gd::Vector2<T>),
/// the most common specializations have special typedefs:
/// \li gd::Vector2<float> is gd::Vector2f
/// \li gd::Vector2<int> is gd::Vector2i
/// \li gd::Vector2<unsigned int> is gd::Vector2u
///
/// The gd::Vector2 class has a small and simple interface, its x and y members
/// can be accessed directly (there are no accessors like setX(), getX()) and it
/// contains no mathematical function like dot product, cross product, length, etc.
///
/// Usage example:
/// \code
/// gd::Vector2f v1(16.5f, 24.f);
/// v1.x = 18.2f;
/// float y = v1.y;
///
/// gd::Vector2f v2 = v1 * 5.f;
/// gd::Vector2f v3;
/// v3 = v1 + v2;
///
/// bool different = (v2 != v3);
/// \endcode
///
/// Note: for 3-dimensional vectors, see gd::Vector3.
///
////////////////////////////////////////////////////////////
Core/tests/Common.cpp
+5 -1
View File
@@ -75,7 +75,11 @@ TEST_CASE("EventsList", "[common][events]") {
size_t endMemory = gd::SystemStats::GetUsedVirtualMemory();
INFO("Memory used: " << endMemory - startMemory << "KB");
REQUIRE(1500 >= endMemory - startMemory);
#if defined(WINDOWS)
REQUIRE(3000 >= endMemory - startMemory);
#else
REQUIRE(1500 >= endMemory - startMemory);
#endif
}
}
Core/tests/FileStream.cpp
-90
View File
@@ -1,90 +0,0 @@
/*
* GDevelop Core
* Copyright 2008-2016 Florian Rival ([email protected]). All rights
* reserved. This project is released under the MIT License.
*/
/**
* @file Tests covering FileStream class of GDevelop Core.
*/
#include "GDCore/Tools/FileStream.h"
#include <fstream>
#include <memory>
#include "GDCore/CommonTools.h"
#include "catch.hpp"
TEST_CASE("FileStream", "[common][fstream]") {
// Creating the test file
std::ofstream testFile("FileStreamTest.test");
REQUIRE(testFile.is_open());
testFile << "this is the first line of the test file!\n";
testFile << "the last line!";
testFile.close();
SECTION("Input file") {
gd::FileStream f;
f.open("FileStreamTest.test", std::ios_base::in);
REQUIRE(f.is_open() == true);
REQUIRE(f.tellg() == 0);
std::string lineContent;
REQUIRE(f.eof() == false);
std::getline(f, lineContent);
REQUIRE(lineContent == "this is the first line of the test file!");
REQUIRE(f.eof() == false);
std::getline(f, lineContent);
REQUIRE(lineContent == "the last line!");
REQUIRE(f.eof() == true);
REQUIRE(f.fail() == false);
f.close();
REQUIRE(f.is_open() == false);
REQUIRE(f.fail() == false);
}
SECTION("Output/Input file with special characters in filepath") {
gd::FileStream output("\xEA\x88\xA1.txt", std::ios_base::out);
REQUIRE(output.is_open() == true);
output << "TEST";
output.close();
gd::FileStream input("\xEA\x88\xA1.txt", std::ios_base::in);
REQUIRE(input.is_open() == true);
std::string lineContent;
REQUIRE(input.eof() == false);
std::getline(input, lineContent);
REQUIRE(lineContent == "TEST");
REQUIRE(input.eof() == true);
input.close();
REQUIRE(input.is_open() == false);
REQUIRE(input.fail() == false);
}
SECTION("File opening failure") {
gd::FileStream f("\xE4\x84\xA2",
std::ios_base::in); // A file that doesn't exist
REQUIRE(f.is_open() == false);
REQUIRE(f.fail() ==
true); // As the opening failed, the "fail" flag should be set
f.close();
REQUIRE(f.bad() == true); // As no files are opened, this should set the
// "bad" flag of the stream
}
SECTION("std::ios_base::ate") { // As ate is "emulated", needs testing
gd::FileStream f;
f.open("FileStreamTest.test", std::ios_base::in | std::ios_base::ate);
REQUIRE(f.is_open() == true);
REQUIRE(f.tellg() > 0);
}
}
Core/tests/Utf8Tests.cpp
+15 -10
View File
@@ -7,7 +7,6 @@
* @file Tests covering utf8 features from GDevelop Core.
*/
#include <SFML/System/String.hpp>
#include <exception>
#include <iostream>
#include <string>
@@ -19,10 +18,8 @@ TEST_CASE("Utf8 String", "[common][utf8]") {
SECTION("ctor & conversions") {
gd::String str = u8"UTF8 a été testé !";
sf::String sfStr = str;
std::u32string u32str = str.ToUTF32();
REQUIRE(str == gd::String::FromSfString(sfStr));
REQUIRE(str == gd::String::FromUTF32(u32str));
}
@@ -42,8 +39,10 @@ TEST_CASE("Utf8 String", "[common][utf8]") {
REQUIRE(str.substr(5, 7) == u8"a été t");
REQUIRE(str.substr(5, gd::String::npos) == u8"a été testé !");
REQUIRE_THROWS_AS(str.substr(50, 5), std::out_of_range);
// Windows doesn't seems to like exceptions.
#if !defined(WINDOWS)
REQUIRE_THROWS_AS(str.substr(50, 5), std::out_of_range);
#endif
}
SECTION("insert") {
@@ -51,7 +50,9 @@ TEST_CASE("Utf8 String", "[common][utf8]") {
str.insert(25, u8"vraiment ");
REQUIRE(str == u8"Une fonctionnalité a été vraiment testée !");
REQUIRE_THROWS_AS(str.insert(150, u8"This gonna fail"), std::out_of_range);
#if !defined(WINDOWS)
REQUIRE_THROWS_AS(str.insert(150, u8"This gonna fail"), std::out_of_range);
#endif
}
SECTION("replace") {
@@ -62,8 +63,10 @@ TEST_CASE("Utf8 String", "[common][utf8]") {
REQUIRE(str.replace(11, gd::String::npos, u8"vraiment très testé !") ==
u8"UTF8 a été vraiment très testé !");
REQUIRE_THROWS_AS(str.replace(50, 5, u8"Cela va planter."),
std::out_of_range);
#if !defined(WINDOWS)
REQUIRE_THROWS_AS(str.replace(50, 5, u8"Cela va planter."),
std::out_of_range);
#endif
// Testing the iterator version of replace
gd::String str2 = u8"UTF8 a été testé !";
@@ -94,8 +97,10 @@ TEST_CASE("Utf8 String", "[common][utf8]") {
REQUIRE(str == "UTF8");
}
{
gd::String str = u8"UTF8 a été testé !";
REQUIRE_THROWS_AS(str.erase(100, 5), std::out_of_range);
#if !defined(WINDOWS)
gd::String str = u8"UTF8 a été testé !";
REQUIRE_THROWS_AS(str.erase(100, 5), std::out_of_range);
#endif
}
{
gd::String str = u8"UTF8 a été testé !";
ExtLibs/CMakeLists.txt
-54
View File
@@ -1,54 +0,0 @@
# Clone SFML from its official directory using Git. Only
# do it if not already cloned to avoid triggering a whole
# recompilation every time CMake is run.
find_package(Git)
if(GIT_FOUND)
if (NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/SFML/readme.txt")
message( "Cloning SFML in ExtLibs/SFML with Git..." )
execute_process(
COMMAND ${GIT_EXECUTABLE} clone "https://www.github.com/SFML/SFML.git" SFML
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/
OUTPUT_QUIET)
message( "Resetting SFML source code to version 2.4.1..." )
execute_process(
COMMAND ${GIT_EXECUTABLE} reset --hard 2.4.1
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/SFML
OUTPUT_QUIET)
message( "Applying the patches..." )
file(GLOB SFML_PATCHES
LIST_DIRECTORIES FALSE
${CMAKE_CURRENT_SOURCE_DIR}/SFML-patches/*.patch)
if(SFML_PATCHES)
list(SORT SFML_PATCHES)
foreach(SFML_PATCH ${SFML_PATCHES})
message( "Applying patch: ${SFML_PATCH}..." )
execute_process(
COMMAND ${GIT_EXECUTABLE} apply ${SFML_PATCH} --ignore-whitespace
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/SFML
OUTPUT_QUIET)
endforeach()
endif()
else()
message( "SFML already downloaded." )
endif()
else()
message( "Git not found, make sure you have SFML >= 2.4 in ExtLibs/SFML and you applied the needed patches (from ExtLibs/SFML-patches)!" )
endif()
#SFML:
IF(NOT EMSCRIPTEN) #Don't build SFML binaries when compiling with emscripten (but keep include files!)
add_subdirectory(SFML)
set(sfml_lib_dir ${CMAKE_BINARY_DIR}/ExtLibs/SFML/lib PARENT_SCOPE)
set(sfml_LIBRARIES sfml-audio sfml-graphics sfml-window sfml-network sfml-system)
IF(WIN32)
set(sfml_LIBRARIES "${sfml_LIBRARIES}" ws2_32 user32 opengl32 glu32 psapi)
ELSEIF(NOT APPLE)
set(sfml_LIBRARIES "${sfml_LIBRARIES}" GLU GL)
ENDIF()
set(sfml_LIBRARIES "${sfml_LIBRARIES}" PARENT_SCOPE)
ENDIF()
set(sfml_include_dir ${CMAKE_CURRENT_SOURCE_DIR}/SFML/include PARENT_SCOPE)
ExtLibs/SFML-patches/01_GCC_5_and_6_sse2.patch
-19
View File
@@ -1,19 +0,0 @@
diff --git a/extlibs/headers/stb_image/stb_image.h b/extlibs/headers/stb_image/stb_image.h
index c3945c2..5fe1050 100644
--- a/extlibs/headers/stb_image/stb_image.h
+++ b/extlibs/headers/stb_image/stb_image.h
@@ -671,14 +671,9 @@ static int stbi__sse2_available()
static int stbi__sse2_available()
{
-#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 // GCC 4.8 or later
- // GCC 4.8+ has a nice way to do this
- return __builtin_cpu_supports("sse2");
-#else
// portable way to do this, preferably without using GCC inline ASM?
// just bail for now.
return 0;
-#endif
}
#endif
#endif
ExtLibs/SFML-patches/02_workaround_OSX_crash_SFViewController.patch
-29
View File
@@ -1,29 +0,0 @@
From f55ee73a73398bb77ce9c63ff1a13d8053cb1d18 Mon Sep 17 00:00:00 2001
From: Florian Rival <[email protected]>
Date: Tue, 3 Jan 2017 21:15:11 +0100
Subject: [PATCH] Fix crash with SFML embeded in wxWidgets on OS X
---
src/SFML/Window/OSX/SFViewController.mm | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/SFML/Window/OSX/SFViewController.mm b/src/SFML/Window/OSX/SFViewController.mm
index 7d736e3..280ec2b 100644
--- a/src/SFML/Window/OSX/SFViewController.mm
+++ b/src/SFML/Window/OSX/SFViewController.mm
@@ -82,8 +82,12 @@ -(id)initWithView:(NSView *)view
////////////////////////////////////////////////////////
-(void)dealloc
{
+ NSLog(@"SFViewController::dealloc called on %@", self);
[self closeWindow];
+
+ // See https://github.com/SFML/SFML/issues/824
+ [[NSNotificationCenter defaultCenter] removeObserver:m_oglView];
[m_view release];
[m_oglView release];
--
2.7.4 (Apple Git-66)
ExtLibs/SFML-patches/03_recognize_emscripten_as_linux.patch
-13
View File
@@ -1,13 +0,0 @@
diff --git a/include/SFML/Config.hpp b/include/SFML/Config.hpp
index 9c68d84..2522d88 100644
--- a/include/SFML/Config.hpp
+++ b/include/SFML/Config.hpp
@@ -76,7 +76,7 @@
// Android
#define SFML_SYSTEM_ANDROID
- #elif defined(__linux__)
+ #elif defined(__linux__) || defined(EMSCRIPTEN)
// Linux
#define SFML_SYSTEM_LINUX
Extensions/CMakeUtils.txt
-2
View File
@@ -4,7 +4,6 @@
# consist in a few lines containing calls to these functions.
macro(gd_add_extension_includes)
include_directories(${sfml_include_dir})
include_directories(${GDCORE_include_dir})
endmacro()
@@ -81,7 +80,6 @@ function(gd_extension_link_libraries target_name)
#Nothing.
ELSE()
target_link_libraries(${target_name} GDCore)
target_link_libraries(${target_name} ${sfml_LIBRARIES})
ENDIF()
endfunction()
Extensions/DraggableBehavior/DraggableBehavior.h
+1 -1
View File
@@ -7,7 +7,7 @@ This project is released under the MIT License.
#ifndef DRAGGABLEBEHAVIOR_H
#define DRAGGABLEBEHAVIOR_H
#include <SFML/System/Vector2.hpp>
#include "GDCore/Vector2.h"
#include <map>
#include "GDCore/Project/Behavior.h"
#include "GDCore/Project/Object.h"
Extensions/PanelSpriteObject/PanelSpriteObject.cpp
-1
View File
@@ -5,7 +5,6 @@ Copyright (c) 2012-2016 Victor Levasseur ([email protected])
This project is released under the MIT License.
*/
#include <SFML/Graphics.hpp>
#include "GDCore/Tools/Localization.h"
#include "GDCore/CommonTools.h"
#include "GDCore/Project/InitialInstance.h"
Extensions/PathfindingBehavior/PathfindingBehavior.h
+1 -1
View File
@@ -7,7 +7,7 @@ This project is released under the MIT License.
#ifndef PATHFINDINGBEHAVIOR_H
#define PATHFINDINGBEHAVIOR_H
#include <SFML/System/Vector2.hpp>
#include "GDCore/Vector2.h"
#include <vector>
#include "GDCore/Project/Behavior.h"
#include "GDCore/Project/Object.h"
Extensions/PhysicsBehavior/PhysicsBehavior.cpp
+2 -2
View File
@@ -33,7 +33,7 @@ void PhysicsBehavior::InitializeContent(
behaviorContent.SetAttribute("polygonWidth", 200);
behaviorContent.SetAttribute("polygonHeight", 200);
std::vector<sf::Vector2f> polygonCoords;
std::vector<gd::Vector2f> polygonCoords;
behaviorContent.SetAttribute(
"coordsList",
PhysicsBehavior::GetStringFromCoordsVector(polygonCoords, '/', ';'));
@@ -128,7 +128,7 @@ bool PhysicsBehavior::UpdateProperty(gd::SerializerElement &behaviorContent,
#endif
gd::String PhysicsBehavior::GetStringFromCoordsVector(
const std::vector<sf::Vector2f> &vec,
const std::vector<gd::Vector2f> &vec,
char32_t coordsSep,
char32_t composantSep) {
gd::String coordsStr;
Extensions/PhysicsBehavior/PhysicsBehavior.h
+2 -2
View File
@@ -13,7 +13,7 @@ This project is released under the MIT License.
#include <vector>
#include "GDCore/Project/Behavior.h"
#include "GDCore/Project/Object.h"
#include "SFML/System/Vector2.hpp"
#include "GDCore/Vector2.h"
namespace gd {
class Project;
class SerializerElement;
@@ -43,7 +43,7 @@ class GD_EXTENSION_API PhysicsBehavior : public gd::Behavior {
gd::SerializerElement &behaviorContent) override;
private:
gd::String GetStringFromCoordsVector(const std::vector<sf::Vector2f> &vec,
gd::String GetStringFromCoordsVector(const std::vector<gd::Vector2f> &vec,
char32_t coordsSep,
char32_t composantSep);
enum ShapeType {
GDJS/CMakeLists.txt
-2
View File
@@ -4,7 +4,6 @@ cmake_policy(SET CMP0015 NEW)
project(GDJS)
#Dependencies on external libraries:
###
include_directories(${sfml_include_dir})
include_directories(${GDCORE_include_dir})
#Defines
@@ -75,5 +74,4 @@ IF(EMSCRIPTEN)
#Nothing.
ELSE()
target_link_libraries(GDJS GDCore)
target_link_libraries(GDJS ${sfml_LIBRARIES})
ENDIF()
GDevelop.js/Bindings/Bindings.idl
-1
View File
@@ -2540,7 +2540,6 @@ interface SpriteObject {
};
SpriteObject implements gdObject;
[Prefix="sf::"]
interface Vector2f {
void Vector2f();
GDevelop.js/Bindings/Wrapper.cpp
+3 -3
View File
@@ -338,11 +338,11 @@ void removeFromVectorPolygon2d(std::vector<Polygon2d> &vec, size_t pos) {
vec.erase(vec.begin() + pos);
}
void removeFromVectorVector2f(std::vector<sf::Vector2f> &vec, size_t pos) {
void removeFromVectorVector2f(std::vector<gd::Vector2f> &vec, size_t pos) {
vec.erase(vec.begin() + pos);
}
void moveVector2fInVector(std::vector<sf::Vector2f> &vec,
void moveVector2fInVector(std::vector<gd::Vector2f> &vec,
size_t oldIndex,
size_t newIndex) {
if (oldIndex >= vec.size() || newIndex >= vec.size()) return;
@@ -397,7 +397,7 @@ typedef std::set<gd::String> SetString;
typedef std::vector<std::size_t> VectorInt;
typedef std::vector<Point> VectorPoint;
typedef std::vector<Polygon2d> VectorPolygon2d;
typedef std::vector<sf::Vector2f> VectorVector2f;
typedef std::vector<gd::Vector2f> VectorVector2f;
typedef std::vector<EventsSearchResult> VectorEventsSearchResult;
typedef std::vector<gd::ParameterMetadata> VectorParameterMetadata;
typedef std::vector<gd::DependencyMetadata> VectorDependencyMetadata;
GDevelop.js/CMakeLists.txt
-1
View File
@@ -23,7 +23,6 @@ set(GDJS_lib_dir ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SYST
#Dependencies on external libraries:
###
include_directories(${sfml_include_dir})
include_directories(${GDCORE_include_dir})
include_directories(${GDJS_include_dir})
GDevelop.js/scripts/generate-types.js
-1
View File
@@ -18,7 +18,6 @@ const idlTempFolder = fs.mkdtempSync('gdevelopjs-cleaned-bindings-idl');
// are not supported by the webidl2.js parser used by "webidl-tools".
shell.cp('-f', 'Bindings/Bindings.idl', idlTempFolder);
const idlFile = path.join(idlTempFolder, 'Bindings.idl');
shell.sed('-i', /\[Prefix="sf::"\]/, '// Removed sf prefix', idlFile);
shell.sed('-i', /\[Prefix="gdjs::"\]/, '//Removed gdjs prefix', idlFile);
shell.sed(
'-i',