Using triggers data the pc data field_bg.xml attributes are now equal to the psx data

QGearsMain/include/data/QGearsTriggersFile.h

@@ -37,12 +37,8 @@ namespace QGears
             Ogre::ManualResourceLoader* loader = nullptr);
         virtual ~TriggersFile();
         static const String RESOURCE_TYPE;
-    protected:
-        virtual void loadImpl(void) override;
-        virtual void unloadImpl(void) override;
-        virtual size_t calculateSize(void) const override;
-    private:
-        struct Range 
+       
+        struct Range
         {
             s16 left;
             s16 top;
@@ -50,6 +46,17 @@ namespace QGears
             s16 bottom;
         };
 
+        const Range& getCameraRange() const
+        {
+            return mData->camera_range;
+        }
+
+    protected:
+        virtual void loadImpl(void) override;
+        virtual void unloadImpl(void) override;
+        virtual size_t calculateSize(void) const override;
+    private:
+
         struct Vertex_s 
         {
             u16 x;

QGearsMain/src/data/QGearsCameraMatrixFileSerializer.cpp

@@ -45,30 +45,57 @@ namespace QGears
     void
     CameraMatrixFileSerializer::importCameraMatrixFile( Ogre::DataStreamPtr &stream, CameraMatrixFile* pDest )
     {
+        // Read matrix
         sint16 matrix_sint16[CAMERA_MATRIX_ROW_COUNT][CAMERA_MATRIX_COL_COUNT];
-        readShorts( stream, reinterpret_cast< uint16* >( matrix_sint16 ), CAMERA_MATRIX_ENTRY_COUNT  );
+        readInt16(stream, matrix_sint16[0][0]);
+        readInt16(stream, matrix_sint16[1][0]);
+        readInt16(stream, matrix_sint16[2][0]);
+        readInt16(stream, matrix_sint16[0][1]);
+        readInt16(stream, matrix_sint16[1][1]);
+        readInt16(stream, matrix_sint16[2][1]);
+        readInt16(stream, matrix_sint16[0][2]);
+        readInt16(stream, matrix_sint16[1][2]);
+        readInt16(stream, matrix_sint16[2][2]);
         stream->skip( 2 ); // unused
+    
+        // Array to matrix
+        Ogre::Matrix3 camera_matrix;
+        camera_matrix[0][0] = static_cast<float>(matrix_sint16[0][0]) / 4096.0f;
+        camera_matrix[1][0] = static_cast<float>(matrix_sint16[1][0]) / 4096.0f;
+        camera_matrix[2][0] = static_cast<float>(matrix_sint16[2][0]) / 4096.0f;
+        camera_matrix[0][1] = static_cast<float>(matrix_sint16[0][1]) / 4096.0f;
+        camera_matrix[1][1] = static_cast<float>(matrix_sint16[1][1]) / 4096.0f;
+        camera_matrix[2][1] = static_cast<float>(matrix_sint16[2][1]) / 4096.0f;
+        camera_matrix[0][2] = static_cast<float>(matrix_sint16[0][2]) / 4096.0f;
+        camera_matrix[1][2] = static_cast<float>(matrix_sint16[1][2]) / 4096.0f;
+        camera_matrix[2][2] = static_cast<float>(matrix_sint16[2][2]) / 4096.0f;
 
+        // Read POS
         sint32 pos[CAMERA_MATRIX_ROW_COUNT];
-        readInts( stream, reinterpret_cast< uint32* >( pos ), CAMERA_MATRIX_ROW_COUNT );
+        readInts(stream, reinterpret_cast<uint32*>(pos), CAMERA_MATRIX_ROW_COUNT);
 
-        Ogre::Matrix3 camera_matrix;
+        // Array to vector
         Ogre::Vector3 position;
-        for( size_t i(0); i < CAMERA_MATRIX_ROW_COUNT; ++i )
+        for (int i = 0; i < 3; i++)
         {
-            position[i] = Ogre::Real(pos[i]);
-            for( size_t j(0); j < CAMERA_MATRIX_COL_COUNT; ++j )
-            {
-                camera_matrix[j][i] = matrix_sint16[i][j] / 4096.0f;
-            }
+            position[i] = -Ogre::Real(pos[i]);
         }
-        position = camera_matrix * position;
-        camera_matrix[0][1] *= -1;
-        camera_matrix[1][1] *= -1;
-        camera_matrix[2][1] *= -1;
-        camera_matrix[0][2] *= -1;
-        camera_matrix[1][2] *= -1;
-        camera_matrix[2][2] *= -1;
+
+        Ogre::Quaternion orientation;
+        orientation.FromRotationMatrix(camera_matrix);
+        position = orientation * (position / 128.0f);
+
+        // Matrix fix up
+        camera_matrix[0][0] = camera_matrix[0][0];
+        camera_matrix[1][0] = camera_matrix[1][0];
+        camera_matrix[2][0] = camera_matrix[2][0];
+        camera_matrix[0][1] = -camera_matrix[0][1];
+        camera_matrix[1][1] = -camera_matrix[1][1];
+        camera_matrix[2][1] = -camera_matrix[2][1];
+        camera_matrix[0][2] = -camera_matrix[0][2];
+        camera_matrix[1][2] = -camera_matrix[1][2];
+        camera_matrix[2][2] = -camera_matrix[2][2];
+
         pDest->setMatrix( camera_matrix );
         pDest->setPosition( position );
 

utilities/q-gears-launcher/src/ff7DataInstaller.cpp

@@ -153,7 +153,6 @@ static void FF7PcFieldToQGearsField(QGears::FLevelFilePtr& field, const std::str
 {
     // Save out the tiles as a PNG image
     
-    const QGears::BackgroundFilePtr& bg = field->getBackground();
 
     try
     {
@@ -170,8 +169,13 @@ static void FF7PcFieldToQGearsField(QGears::FLevelFilePtr& field, const std::str
         std::cerr << "InternalDecompilerError: " << ex.what() << std::endl;
     }
 
-    
+
+    //const QGears::ModelListFilePtr& models = field->getModelList();
+    //const QGears::ModelListFile::ModelDescription& desc = models->getModels().at(0);
+
+
     const QGears::PaletteFilePtr& pal = field->getPalette();
+    const QGears::BackgroundFilePtr& bg = field->getBackground();
     std::unique_ptr<Ogre::Image> bgImage(bg->createImage(pal));
     bgImage->save(outDir + "/" + field->getName() + ".png");
 
@@ -179,44 +183,35 @@ static void FF7PcFieldToQGearsField(QGears::FLevelFilePtr& field, const std::str
         TiXmlDocument doc;
         std::unique_ptr<TiXmlElement> element(new TiXmlElement("background2d"));
 
-        // TODO: Write out the required attributes: image, position, orientation, fov, range and clip
-        auto& layers = bg->getLayers();
-        const QGears::CameraMatrixFilePtr& camMatrix = field->getCameraMatrix();
-
-       
-
-        // TODO: Should be the width/height of the actual field image, not the texture atlas
-        int width = bgImage->getWidth();
-        int height = bgImage->getHeight();
-
-        // set camera for depth calculation
-        Ogre::Vector3 position = camMatrix->getPosition();
-        Ogre::Quaternion orientation = camMatrix->getOrientation();
-        Ogre::Degree fov = camMatrix->getFov(90);
-
+        // Magic constants
+        const int kScaleUpFactor = 3;
+        const int kPsxScreenWidth = 320;
+        const int kPsxScreenHeight = 240;
 
-        // TODO: Needs to be loaded from "doors and gateways" section
-        int min_x = 0;
-        int min_y = 0;
-        int max_x = 0;
-        int max_y = 0;
-        //GetScreenRange(min_x, min_y, max_x, max_y);
+        // Get texture atlas size
+        const int width = bgImage->getWidth();
+        const int height = bgImage->getHeight();
 
-        // <background2d image="md1_2.png" position="-4990.38 -29075.1 -3384.11" orientation="0.887914 0.381507 0.101529 0.23619" fov="90" range="0 0 0 0" clip="960 720">
+        const QGears::CameraMatrixFilePtr& camMatrix = field->getCameraMatrix();
+        const Ogre::Vector3 position = camMatrix->getPosition();
+        const Ogre::Quaternion orientation = camMatrix->getOrientation();
+        const Ogre::Degree fov = camMatrix->getFov(static_cast<float>(kPsxScreenHeight));
 
-        // <background2d image="maps/ffvii/field/md1_2.png" position="39.027 227.173 26.4208" orientation="0.887914 0.381507 0.101529 0.23619" fov="14.3239" range="-768 -768 768 768" clip="960 720">
+        const QGears::TriggersFilePtr& triggers = field->getTriggers();
+        const int min_x = triggers->getCameraRange().left * kScaleUpFactor;
+        const int min_y = triggers->getCameraRange().top * kScaleUpFactor;
+        const int max_x = triggers->getCameraRange().right * kScaleUpFactor;
+        const int max_y = triggers->getCameraRange().bottom * kScaleUpFactor;
 
-        // TODO: These are not fully correct yet, some need to be scaled down etc
-        element->SetAttribute("image", (outDir + "/" + field->getName() + ".png"));
+        element->SetAttribute("image", field->getName() + ".png");
         element->SetAttribute("position", Ogre::StringConverter::toString(position));
         element->SetAttribute("orientation", Ogre::StringConverter::toString(orientation));
         element->SetAttribute("fov", Ogre::StringConverter::toString(fov));
         element->SetAttribute("range", std::to_string(min_x) + " " + std::to_string(min_y) + " " + std::to_string(max_x) + " " + std::to_string(max_y));
-        element->SetAttribute("clip", std::to_string(320 * 3) + " " + std::to_string(240 * 3));
+        element->SetAttribute("clip", std::to_string(kPsxScreenWidth * kScaleUpFactor) + " " + std::to_string(kPsxScreenHeight * kScaleUpFactor));
    
-
-
         // Write out the *_BG.XML data
+        auto& layers = bg->getLayers();
         for (const auto& layer : layers)
         {
             // TODO: Should we only output tiles to construct enabled layers?
@@ -227,13 +222,12 @@ static void FF7PcFieldToQGearsField(QGears::FLevelFilePtr& field, const std::str
                 {
                     std::unique_ptr<TiXmlElement> xmlElement(new TiXmlElement("tile"));
 
-                    // Not sure why it needs to be * 3
                     xmlElement->SetAttribute("destination",
-                        Ogre::StringConverter::toString(sprite.dst.x * 3) + " " + 
-                        Ogre::StringConverter::toString(sprite.dst.y * 3));
+                        Ogre::StringConverter::toString(sprite.dst.x * kScaleUpFactor) + " " +
+                        Ogre::StringConverter::toString(sprite.dst.y * kScaleUpFactor));
 
-                    xmlElement->SetAttribute("width", Ogre::StringConverter::toString(sprite.width * 3));
-                    xmlElement->SetAttribute("height", Ogre::StringConverter::toString(sprite.height * 3));
+                    xmlElement->SetAttribute("width", Ogre::StringConverter::toString(sprite.width * kScaleUpFactor));
+                    xmlElement->SetAttribute("height", Ogre::StringConverter::toString(sprite.height * kScaleUpFactor));
 
                     // Each tile is added to a big texture atlas with hard coded size of 1024x1024, convert UV's to the 0.0f to 1.0f range
                     const float u0 = static_cast<float>(sprite.src.x) / bgImage->getWidth();