#include "Runtime/World/CFluidPlaneGPU.hpp"

namespace metaforce {

CFluidPlaneGPU::CFluidPlaneGPU(CAssetId texPattern1, CAssetId texPattern2, CAssetId texColor, CAssetId bumpMap,
                               CAssetId envMap, CAssetId envBumpMap, CAssetId lightMap, float unitsPerLightmapTexel,
                               float tileSize, u32 tileSubdivisions, EFluidType fluidType, float alpha,
                               const zeus::CVector3f& bumpLightDir, float bumpScale, const CFluidUVMotion& mot,
                               float turbSpeed, float turbDistance, float turbFreqMax, float turbFreqMin,
                               float turbPhaseMax, float turbPhaseMin, float turbAmplitudeMax, float turbAmplitudeMin,
                               float specularMin, float specularMax, float reflectionBlend, float reflectionSize,
                               float rippleIntensity, u32 maxVertCount)
: CFluidPlaneCPU(texPattern1, texPattern2, texColor, bumpMap, envMap, envBumpMap, lightMap, unitsPerLightmapTexel,
                 tileSize, tileSubdivisions, fluidType, alpha, bumpLightDir, bumpScale, mot, turbSpeed, turbDistance,
                 turbFreqMax, turbFreqMin, turbPhaseMax, turbPhaseMin, turbAmplitudeMax, turbAmplitudeMin, specularMin,
                 specularMax, reflectionBlend, reflectionSize, rippleIntensity, maxVertCount) {
  m_tessellation = true;
}

// void CFluidPlaneGPU::RenderStripWithRipples(float curY, const Heights& heights, const Flags& flags, int startYDiv,
//                                             const CFluidPlaneRender::SPatchInfo& info,
//                                             std::vector<CFluidPlaneShader::Vertex>& vOut,
//                                             std::vector<CFluidPlaneShader::PatchVertex>& pvOut) {
//   m_shader->bindTessellation();
//
//   int yTile = (startYDiv + CFluidPlaneRender::numSubdivisionsInTile - 1) / CFluidPlaneRender::numSubdivisionsInTile;
//   int endXTile =
//       (info.x0_xSubdivs + CFluidPlaneRender::numSubdivisionsInTile - 4) / CFluidPlaneRender::numSubdivisionsInTile;
//
//   float yMin = curY;
//   float subdivF = CFluidPlaneRender::numSubdivisionsInTile;
//
//   float curX = info.x4_localMin.x();
//   int gridCell = info.x28_tileX + info.x2a_gridDimX * (info.x2e_tileY + yTile - 1);
//   int xTile = 1;
//   int tileSpan;
//   for (int i = 1; i < info.x0_xSubdivs - 2; i += CFluidPlaneRender::numSubdivisionsInTile * tileSpan,
//            gridCell += tileSpan, xTile += tileSpan, curX += info.x14_tileSize * tileSpan) {
//     tileSpan = 1;
//     if (info.x30_gridFlags && !info.x30_gridFlags[gridCell])
//       continue;
//
//     CFluidPlaneShader::PatchVertex pv;
//     size_t start = pvOut.size();
//
//     if ((flags[yTile][xTile] & 0x1f) == 0x1f) {
//       for (; xTile + tileSpan <= endXTile; ++tileSpan) {
//         if ((flags[yTile][xTile + tileSpan] & 0x1f) != 0x1f)
//           break;
//         if (info.x30_gridFlags && !info.x30_gridFlags[gridCell + tileSpan])
//           break;
//       }
//
//       pv.m_outerLevels.fill(subdivF);
//       pv.m_innerLevels.fill(subdivF);
//     } else {
//       const bool north = (flags[yTile + 1][xTile] & 0x2) != 0;
//       const bool west = (flags[yTile][xTile - 1] & 0x8) != 0;
//       const bool east = (flags[yTile][xTile + 1] & 0x4) != 0;
//       const bool south = (flags[yTile - 1][xTile] & 0x1) != 0;
//
//       pv.m_outerLevels[0] = west ? subdivF : 1.f;
//       pv.m_outerLevels[1] = south ? subdivF : 1.f;
//       pv.m_outerLevels[2] = east ? subdivF : 1.f;
//       pv.m_outerLevels[3] = north ? subdivF : 1.f;
//       pv.m_innerLevels.fill(subdivF);
//     }
//
//     float curTileY = yMin;
//     float curTileX = curX;
//     for (int t = 0; t < tileSpan; ++t) {
//       pv.m_pos = zeus::CVector4f(curTileX, curTileY, curTileX + info.x14_tileSize, curTileY + info.x14_tileSize);
//       pvOut.push_back(pv);
//       curTileX += info.x14_tileSize;
//     }
//
// //    CGraphics::DrawArray(start, pvOut.size() - start);
//   }
// }

} // namespace metaforce