//+------------------------------------------------------------------+
//|                                                       DXMesh.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2000-2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#include "DXObject.mqh"
#include "DXDispatcher.mqh"
#include "DXData.mqh"
#include "DXUtils.mqh"
//+------------------------------------------------------------------+
//| DX simple mesh object with default shader                        |
//+------------------------------------------------------------------+
class CDXMesh : public CDXObject
  {
protected:
   //--- DX resources
   CDXVertexBuffer*  m_buffer_vertex;
   CDXIndexBuffer*   m_buffer_index;
   CDXInput*         m_buffer_object;
   CDXInput*         m_buffer_scene;
   CDXShader*        m_shader_vertex;
   CDXShader*        m_shader_pixel;
   CDXTexture*       m_texture;
   //--- object data
   DXMatrix          m_transform_matrix;
   DXColor           m_diffuse_color;
   DXColor           m_emission_color;
   DXColor           m_specular_color;
   float             m_specular_power;

   ENUM_DX_PRIMITIVE_TOPOLOGY m_topology;

public:
   //+------------------------------------------------------------------+
   //| Constructor                                                      |
   //+------------------------------------------------------------------+
                     CDXMesh(void):m_buffer_vertex(NULL),m_buffer_index(NULL),m_buffer_object(NULL),m_buffer_scene(NULL),m_shader_vertex(NULL),m_shader_pixel(NULL),m_topology(WRONG_VALUE)
     {
     }
   //+------------------------------------------------------------------+
   //| Destructor                                                       |
   //+------------------------------------------------------------------+
                    ~CDXMesh(void)
     {
      Shutdown();
     }
   //+------------------------------------------------------------------+
   //| Create mesh object from vertices and indices list                |
   //+------------------------------------------------------------------+
   bool              Create(CDXDispatcher &dispatcher,CDXInput* buffer_scene,const DXVertex &vertices[],const uint &indices[],ENUM_DX_PRIMITIVE_TOPOLOGY topology=DX_PRIMITIVE_TOPOLOGY_TRIANGLELIST)
     {
      Shutdown();
      //--- check data
      if(buffer_scene==NULL || buffer_scene.Handle()==INVALID_HANDLE ||
         ArraySize(vertices)<1 || ArraySize(indices)<1)
         return(false);
      //--- update context
      m_context=dispatcher.DXContext();
      //--- initialize default parameters
      DXMatrixIdentity(m_transform_matrix);
      m_diffuse_color =DXColor(1.0,1.0,1.0,1.0);
      m_emission_color=DXColor(0.0,0.0,0.0,0.0);
      m_specular_color=DXColor(0.0,0.0,0.0,0.0);
      m_specular_power=16.0f;
      //--- create object input
      m_buffer_object=dispatcher.InputCreate<DXInputObject>();
      if(m_buffer_object!=NULL)
        {
         m_buffer_object.AddRef();
         //--- use default vertex shader
         m_shader_vertex=dispatcher.ShaderCreateDefault(DX_SHADER_VERTEX);
         if(m_shader_vertex!=NULL)
           {
            m_shader_vertex.AddRef();
            //--- use default pixel shader
            m_shader_pixel=dispatcher.ShaderCreateDefault(DX_SHADER_PIXEL);
            if(m_shader_pixel!=NULL)
              {
               m_shader_pixel.AddRef();
               //--- create vertex buffer
               m_buffer_vertex=dispatcher.VertexBufferCreate(vertices);
               if(m_buffer_vertex!=NULL)
                 {
                  m_buffer_vertex.AddRef();
                  //--- create index buffer
                  m_buffer_index=dispatcher.IndexBufferCreate(indices);
                  if(m_buffer_index!=NULL)
                     m_buffer_index.AddRef();
                 }
              }
           }
        }
      //--- set object buffer to shaders
      if(m_buffer_object==NULL || m_shader_vertex==NULL || m_shader_pixel==NULL || m_buffer_vertex==NULL || m_buffer_index==NULL)
        {
         Shutdown();
         return(false);
        }
      //--- save scene buffer
      m_buffer_scene=buffer_scene;
      m_buffer_scene.AddRef();
      //--- save topology
      m_topology=topology;
      //---
      return(true);
     }
   //+------------------------------------------------------------------+
   //| Create mesh object from OBJ mesh file                            |
   //+------------------------------------------------------------------+
   bool              Create(CDXDispatcher &dispatcher,CDXInput* buffer_scene,string obj_path,float scale=1.0f,bool inverse_winding=false)
     {
      DXVertex vertices[];
      uint     indices[];
      //--- load model
      if(!DXLoadObjModel(obj_path,vertices,indices,scale))
         return(false);
      //--- set white vertices color
      DXColor white=DXColor(1.0f,1.0f,1.0f,1.0f);
      int count=ArraySize(vertices);
      for(int i=0; i<count; i++)
         vertices[i].vcolor=white;
      //--- inverse winding
      if(inverse_winding)
         DXInverseWinding(vertices,indices);
      //--- create mesh
      return(Create(dispatcher,buffer_scene,vertices,indices));
     }
   //+------------------------------------------------------------------+
   //| Update vertices                                                  |
   //+------------------------------------------------------------------+
   bool              VerticesSet(const DXVertex &vertices[])
     {
      //--- check size
      if(ArraySize(vertices)<1)
         return(false);
      //--- create new vertex buffer
      if(!m_buffer_vertex.Create(m_context,vertices))
        {
         Shutdown();
         return(false);
        }
      //---
      return(true);
     }
   //+------------------------------------------------------------------+
   //| Update indices                                                   |
   //+------------------------------------------------------------------+
   bool              IndicesSet(const uint &indices[])
     {
      //--- check size
      if(ArraySize(indices)<1)
         return(false);
      //--- create new index buffer
      if(!m_buffer_index.Create(m_context,indices))
        {
         Shutdown();
         return(false);
        }
      //---
      return(true);
     }
   //+------------------------------------------------------------------+
   //| Update indices                                                   |
   //+------------------------------------------------------------------+
   bool              TopologySet(ENUM_DX_PRIMITIVE_TOPOLOGY topology)
     {
      m_topology=topology;
      //---
      return(true);
     }
   //+------------------------------------------------------------------+
   //| Get transform matrix                                             |
   //+------------------------------------------------------------------+
   void              TransformMatrixGet(DXMatrix &mat) const
     {
      mat=m_transform_matrix;
     }
   //+------------------------------------------------------------------+
   //| Set transform matrix                                             |
   //+------------------------------------------------------------------+
   void              TransformMatrixSet(const DXMatrix &mat)
     {
      m_transform_matrix=mat;
     }
   //+------------------------------------------------------------------+
   //| Get diffuse color                                                |
   //+------------------------------------------------------------------+
   void              DiffuseColorGet(DXColor &clr) const
     {
      clr=m_diffuse_color;
     }
   //+------------------------------------------------------------------+
   //| Set diffuse color                                                |
   //+------------------------------------------------------------------+
   void              DiffuseColorSet(const DXColor &clr)
     {
      m_diffuse_color=clr;
     }
   //+------------------------------------------------------------------+
   //| Get specular color                                               |
   //+------------------------------------------------------------------+
   void              SpecularColorGet(DXColor &clr) const
     {
      clr=m_specular_color;
     }
   //+------------------------------------------------------------------+
   //| Set specular color                                               |
   //+------------------------------------------------------------------+
   void              SpecularColorSet(const DXColor &clr)
     {
      m_specular_color=clr;
     }
   //+------------------------------------------------------------------+
   //| Get specular power                                               |
   //+------------------------------------------------------------------+
   void              SpecularPowerGet(float &power) const
     {
      power=m_specular_power;
     }
   //+------------------------------------------------------------------+
   //| Set specular power                                               |
   //+------------------------------------------------------------------+
   void              SpecularPowerSet(float power)
     {
      m_specular_power=power;
     }
   //+------------------------------------------------------------------+
   //| Get emission color                                               |
   //+------------------------------------------------------------------+
   void              EmissionColorGet(DXColor &clr) const
     {
      clr=m_emission_color;
     }
   //+------------------------------------------------------------------+
   //| Set emission color                                               |
   //+------------------------------------------------------------------+
   void              EmissionColorSet(const DXColor &clr)
     {
      m_emission_color=clr;
     }
   //+------------------------------------------------------------------+
   //| Render mesh                                                      |
   //+------------------------------------------------------------------+
   virtual bool      Render(void) override
     {
      //--- update object buffer
      DXInputObject input_data;
      DXMatrixTranspose(input_data.transform,m_transform_matrix);
      input_data.diffuse_color =m_diffuse_color;
      input_data.emission_color=m_emission_color;
      input_data.specular_color=m_specular_color;
      input_data.specular_power=m_specular_power;
      //--- clear shader textures
      m_shader_pixel.TexturesClear();
      //--- set buffers, shaders, topology and render
      if(m_buffer_object.InputSet(input_data))
         if(m_buffer_vertex.Render())
            if(m_buffer_index.Render())
               if(m_shader_vertex.InputSet(0,m_buffer_scene) && m_shader_vertex.InputSet(1,m_buffer_object))
                  if(m_shader_pixel.InputSet(0,m_buffer_scene) && m_shader_pixel.InputSet(1,m_buffer_object))
                     if(CheckPointer(m_texture)==POINTER_INVALID || m_shader_pixel.TextureSet(0,m_texture))
                        if(m_shader_vertex.Render())
                           if(m_shader_pixel.Render())
                              if(DXPrimiveTopologySet(m_context,m_topology))
                                 return(DXDrawIndexed(m_context));
      //---
      return(false);
     }
   //+------------------------------------------------------------------+
   //| Set texture from image file                                      |
   //+------------------------------------------------------------------+
   bool              TextureSet(CDXDispatcher &dispatcher,string path,uint data_x=0,uint data_y=0,uint data_width=0,uint data_height=0)
     {
      //--- check if texture already exist
      if(CheckPointer(m_texture)==POINTER_INVALID)
        {
         m_texture=dispatcher.TextureCreateFromFile(path,data_x,data_y,data_width,data_height);
         if(m_texture==NULL)
            return(false);
         m_texture.AddRef();
         return(true);
        }
      //--- update texture data
      if(!m_texture.Create(m_context,path,data_x,data_y,data_width,data_height))
        {
         m_texture.Release();
         m_texture=NULL;
         return(false);
        }
      //---
      return(true);
     }
   //+------------------------------------------------------------------+
   //| Set texture from image data                                      |
   //+------------------------------------------------------------------+
   bool              TextureSet(CDXDispatcher &dispatcher,ENUM_DX_FORMAT format,uint width,uint height,const uint &data[],uint data_x=0,uint data_y=0,uint data_width=0,uint data_height=0)
     {
      //--- check if texture already exist
      if(CheckPointer(m_texture)==POINTER_INVALID)
        {
         m_texture=dispatcher.TextureCreateFromData(format,width,height,data,data_x,data_y,data_width,data_height);
         if(m_texture==NULL)
            return(false);
         m_texture.AddRef();
         return(true);
        }
      //--- update texture data
      if(!m_texture.Create(m_context,format,width,height,data,data_x,data_y,data_width,data_height))
        {
         m_texture.Release();
         m_texture=NULL;
         return(false);
        }
      //---
      return(true);
     }
   //+------------------------------------------------------------------+
   //| Delete used texture                                              |
   //+------------------------------------------------------------------+
   void              TextureDelete()
     {
      //--- release texture
      if(CheckPointer(m_texture)!=POINTER_INVALID)
        {
         m_texture.Release();
         m_texture=NULL;
        }
     }
   //+------------------------------------------------------------------+
   //| Shutdown                                                         |
   //+------------------------------------------------------------------+
   virtual void      Shutdown(void)
     {
      //--- release all dx resources
      if(CheckPointer(m_buffer_vertex)!=POINTER_INVALID)
        {
         m_buffer_vertex.Release();
         m_buffer_vertex=NULL;
        }
      if(CheckPointer(m_buffer_index)!=POINTER_INVALID)
        {
         m_buffer_index.Release();
         m_buffer_index=NULL;
        }
      if(CheckPointer(m_buffer_object)!=POINTER_INVALID)
        {
         m_buffer_object.Release();
         m_buffer_object=NULL;
        }
      if(CheckPointer(m_texture)!=POINTER_INVALID)
        {
         m_texture.Release();
         m_texture=NULL;
        }
      if(CheckPointer(m_buffer_scene)!=POINTER_INVALID)
        {
         m_buffer_scene.Release();
         m_buffer_scene=NULL;
        }
      if(CheckPointer(m_shader_pixel)!=POINTER_INVALID)
        {
         m_shader_pixel.Release();
         m_shader_pixel=NULL;
        }
      if(CheckPointer(m_shader_vertex)!=POINTER_INVALID)
        {
         m_shader_vertex.Release();
         m_shader_vertex=NULL;
        }
      m_topology =WRONG_VALUE;
     }
  };
//+------------------------------------------------------------------+