GxPrimitiveContext.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//---------------------------------------------------------------------------
// 2D点
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DPoint(const GxVector3& position, const GxColor color, const GxPrimitiveMaterial& material)
{
    auto* GX_RESTRICT pVertex = draw2DLineStrip(2, material, position._z);
    
    if (pVertex)
    {
        pVertex[0]._position = position + LINE_PRIMITIVE_OFFSET_2D_XY;
        pVertex[0]._color = color;
        pVertex[1]._position = pVertex[0]._position + GxVector3(1.0f, 0.0f, 0.0);
        pVertex[1]._color = color;
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "2D POINT プリミティブは仮実装です。サポートまでご連絡ください。");
    }
}
 
//---------------------------------------------------------------------------
// 2Dライン(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DLineF(const GxVector3& position0, const GxVector3& position1, const GxColor color, const GxPrimitiveMaterial& material)
{
    draw2DLineG(position0, position1, color, color, material);
}
 
//---------------------------------------------------------------------------
// 2Dライン(Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DLineG(const GxVector3& position0, const GxVector3& position1, const GxColor color0, const GxColor color1, const GxPrimitiveMaterial& material)
{
    auto* GX_RESTRICT pVertex = draw2DLineStrip(2, material, position0._z);
    
    if (pVertex)
    {
        pVertex[0]._position = position0 + LINE_PRIMITIVE_OFFSET_2D_XY;
        pVertex[0]._color = color0;
        pVertex[1]._position = position1 + LINE_PRIMITIVE_OFFSET_2D_XY;
        pVertex[1]._color = color1;
    }
}
 
//---------------------------------------------------------------------------
// 2Dポリライン(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DPolyLineF(const GxVector3& position0, const GxVector3& position1, u32 width, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DPolyLineG(position0, position1, width, color, color, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 2D三角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DTriangleF(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DTriangleG(position0, position1, position2, color, color, color, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 2D四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectF(const GxRectF& rect, f32 z, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DRectG(rect, z, color, color, color, color, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 2D四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectF(const GxRectF& rect, f32 positionZ, f32 z, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DRectG(rect, positionZ, z, color, color, color, color, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 2D回転あり四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectF(const GxRectF& rect, f32 z, const GxVector2& rotateCenter, const f32 rotateRadian, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DRectG(rect, z, rotateCenter, rotateRadian, color, color, color, color, fillMode, material);
}
 
 
//---------------------------------------------------------------------------
// 2Dテクスチャ付き四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectTextureF(const GxRectF& rect, f32 z, const GxColor color, const GxFloat2& uv0, const GxFloat2& uv1, const GxPrimitiveMaterial& material, const GxFloat2& uvSecond0, const GxFloat2& uvSecond1)
{
    draw2DRectTextureG(rect, 0.0f, z, color, color, color, color, uv0, uv1, material, uvSecond0, uvSecond1);
}
 
//---------------------------------------------------------------------------
// 2Dテクスチャ付き回転あり四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectTextureF(const GxRectF& rect, f32 z, const GxVector2& rotateCenter, const f32 rotateRadian, const GxColor color, const GxFloat2& uv0, const GxFloat2& uv1, const GxPrimitiveMaterial& material, const GxFloat2& uvSecond0, const GxFloat2& uvSecond1)
{
    draw2DRectTextureG(rect, 0.0f, z, rotateCenter, rotateRadian, color, color, color, color, uv0, uv1, material, uvSecond0, uvSecond1);
}
 
//---------------------------------------------------------------------------
// 2Dテクスチャ付き四角形(Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectTextureG(const GxRectF& rect, f32 z, const GxColor color0, const GxColor color1, const GxColor color2, const GxColor color3, const GxFloat2& uv0, const GxFloat2& uv1, const GxPrimitiveMaterial& material, const GxFloat2& uvSecond0, const GxFloat2& uvSecond1)
{
    draw2DRectTextureG(rect, 0.0f, z, color0, color1, color2, color3, uv0, uv1, material, uvSecond0, uvSecond1);
}
 
//---------------------------------------------------------------------------
// 2Dテクスチャ付き四角形(Z値指定、Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectTextureG(const GxRectF& rect, f32 positionZ, f32 z, const GxColor color0, const GxColor color1, const GxColor color2, const GxColor color3, const GxFloat2& uv0, const GxFloat2& uv1, const GxPrimitiveMaterial& material, const GxFloat2& uvSecond0, const GxFloat2& uvSecond1)
{
    // ここの z はソートプライオリティ
    auto* GX_RESTRICT pVertex = draw2DTriangleFan(4, material, z);
    
    if (pVertex)
    {
        auto left = rect._left;
        auto top = rect._top;
        auto right = rect._right;
        auto bottom = rect._bottom;
 
        pVertex[0]._position = GxFloat3(left, top, positionZ);
        pVertex[0]._color = color0;
        pVertex[0]._texCoord = uv0;
        pVertex[0]._texCoordSecond = uvSecond0;
        pVertex[1]._position = GxFloat3(right, top, positionZ);
        pVertex[1]._color = color1;
        pVertex[1]._texCoord = GxFloat2(uv1._u, uv0._v);
        pVertex[1]._texCoordSecond = GxFloat2(uvSecond1._u, uvSecond0._v);
        pVertex[2]._position = GxFloat3(right, bottom, positionZ);
        pVertex[2]._color = color2;
        pVertex[2]._texCoord = uv1;
        pVertex[2]._texCoordSecond = uvSecond1;
        pVertex[3]._position = GxFloat3(left, bottom, positionZ);
        pVertex[3]._color = color3;
        pVertex[3]._texCoord = GxFloat2(uv0._u, uv1._v);
        pVertex[3]._texCoordSecond = GxFloat2(uvSecond0._u, uvSecond1._v);
    }
}
 
//---------------------------------------------------------------------------
// 2Dテクスチャ付き回転あり四角形(Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectTextureG(const GxRectF& rect, f32 z, const GxVector2& rotateCenter, const f32 rotateRadian, const GxColor color0, const GxColor color1, const GxColor color2, const GxColor color3, const GxFloat2& uv0, const GxFloat2& uv1, const GxPrimitiveMaterial& material, const GxFloat2& uvSecond0, const GxFloat2& uvSecond1)
{
    draw2DRectTextureG(rect, 0.0f, z, rotateCenter, rotateRadian, color0, color1, color2, color3, uv0, uv1, material, uvSecond0, uvSecond1);
}
 
//---------------------------------------------------------------------------
// 2Dテクスチャ付き回転あり四角形(Z値指定、Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DRectTextureG(const GxRectF& rect, f32 positionZ, f32 z, const GxVector2& rotateCenter, const f32 rotateRadian, const GxColor color0, const GxColor color1, const GxColor color2, const GxColor color3, const GxFloat2& uv0, const GxFloat2& uv1, const GxPrimitiveMaterial& material, const GxFloat2& uvSecond0, const GxFloat2& uvSecond1)
{
    auto* GX_RESTRICT pVertex = draw2DTriangleFan(4, material, z);
    
    if (pVertex)
    {
        auto left = rect._left - rotateCenter._x;
        auto top = rect._top - rotateCenter._y;
        auto right = rect._right - rotateCenter._x;
        auto bottom = rect._bottom - rotateCenter._y;
 
        auto leftTopX = (left * GxMath::getFastCos(rotateRadian) - top * GxMath::getFastSin(rotateRadian)) + rotateCenter._x;
        auto leftTopY = (left * GxMath::getFastSin(rotateRadian) + top * GxMath::getFastCos(rotateRadian)) + rotateCenter._y;
 
        auto leftBottomX = (left * GxMath::getFastCos(rotateRadian) - bottom * GxMath::getFastSin(rotateRadian)) + rotateCenter._x;
        auto leftBottomY = (left * GxMath::getFastSin(rotateRadian) + bottom * GxMath::getFastCos(rotateRadian)) + rotateCenter._y;
 
        auto rightTopX = (right * GxMath::getFastCos(rotateRadian) - top * GxMath::getFastSin(rotateRadian)) + rotateCenter._x;
        auto rightTopY = (right * GxMath::getFastSin(rotateRadian) + top * GxMath::getFastCos(rotateRadian)) + rotateCenter._y;
 
        auto rightBottomX = (right * GxMath::getFastCos(rotateRadian) - bottom * GxMath::getFastSin(rotateRadian)) + rotateCenter._x;
        auto rightBottomY = (right * GxMath::getFastSin(rotateRadian) + bottom * GxMath::getFastCos(rotateRadian)) + rotateCenter._y;
 
        pVertex[0]._position = GxFloat3(leftTopX, leftTopY, positionZ);
        pVertex[0]._color = color0;
        pVertex[0]._texCoord = uv0;
        pVertex[0]._texCoordSecond = uvSecond0;
        pVertex[1]._position = GxFloat3(rightTopX, rightTopY, positionZ);
        pVertex[1]._color = color1;
        pVertex[1]._texCoord = GxFloat2(uv1._u, uv0._v);
        pVertex[1]._texCoordSecond = GxFloat2(uvSecond1._u, uvSecond0._v);
        pVertex[2]._position = GxFloat3(rightBottomX, rightBottomY, positionZ);
        pVertex[2]._color = color2;
        pVertex[2]._texCoord = uv1;
        pVertex[2]._texCoordSecond = uvSecond1;
        pVertex[3]._position = GxFloat3(leftBottomX, leftBottomY, positionZ);
        pVertex[3]._color = color3;
        pVertex[3]._texCoord = GxFloat2(uv0._u, uv1._v);
        pVertex[3]._texCoordSecond = GxFloat2(uvSecond0._u, uvSecond1._v);
    }
}
 
//---------------------------------------------------------------------------
// 2D円(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DCircleF(const GxVector3& position, f32 radius, const GxColor color, u32 divide, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DCircleG(position, radius, color, color, divide, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 2D扇形(Flat)
//
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DFanF(const GxVector3& position, f32 radius, f32 startRadian, f32 deltaRadian, const GxColor color, u32 divide, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material)
{
    draw2DFanG(position, radius, startRadian, deltaRadian, color, color, divide, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 2Dベクトル(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DArrowF(const GxVector3& position0, const GxVector3& position1, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, f32 arrowRate, f32 arrowRadius)
{
    draw2DArrowG(position0, position1, color, color, fillMode, material, arrowRate, arrowRadius);
}
 
//---------------------------------------------------------------------------
// 2Dベクトル(Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw2DArrowG(const GxVector3& position0, const GxVector3& position1, const GxColor color0, const GxColor color1, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, f32 arrowRate, f32 arrowRadius)
{
    draw2DLineG(position0, position1, color0, color1, material);
 
    // 終点から arrowRate % の長さのベクトル
    GxVector3 v(position0 - position1);
    v *= arrowRate;
 
    // 左右に arrowRadius 開く
    arrowRadius *= 0.5f;
 
    GxVector3 vL;
    vL._x = v._x * GxMath::getFastCos( arrowRadius) - v._y * GxMath::getFastSin( arrowRadius);
    vL._y = v._x * GxMath::getFastSin( arrowRadius) + v._y * GxMath::getFastCos( arrowRadius);
    vL._z = 0.0f;
    vL += position1;
 
    GxVector3 vR;
    vR._x = v._x * GxMath::getFastCos(-arrowRadius) - v._y * GxMath::getFastSin(-arrowRadius);
    vR._y = v._x * GxMath::getFastSin(-arrowRadius) + v._y * GxMath::getFastCos(-arrowRadius);
    vR._z = 0.0f;
    vR += position1;
 
    // 色を作成
    auto color2 = GxColor::getLerp(color0, color1, arrowRate);
 
    draw2DTriangleG(position1, vL, vR, color1, color2, color2, fillMode, material);
}
 
//---------------------------------------------------------------------------
// 3D点
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DPoint(const GxVector3& position, const GxColor color, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    auto* GX_RESTRICT pVertex = draw3DLineStrip(1, material, position, viewFlag);
    
    if (pVertex)
    {
        pVertex[0]._position = position;
        pVertex[0]._color = color;
    }
}
 
//---------------------------------------------------------------------------
// 3Dライン(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DLineF(const GxVector3& position0, const GxVector3& position1, const GxColor color, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    draw3DLineG(position0, position1, color, color, material, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3Dライン(Gradation)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DLineG(const GxVector3& position0, const GxVector3& position1, const GxColor color0, const GxColor color1, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    auto* GX_RESTRICT pVertex = draw3DLineStrip(2, material, (position0 + position1) * 0.5f, viewFlag);
    
    if (pVertex)
    {
        pVertex[0]._position = position0;
        pVertex[0]._color = color0;
        pVertex[1]._position = position1;
        pVertex[1]._color = color1;
    }
}
 
//---------------------------------------------------------------------------
// 3D三角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DTriangleF(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    draw3DTriangleG(position0, position1, position2, color, color, color, fillMode, material, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3D四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DQuadF(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxVector3& position3, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    draw3DQuadG(position0, position1, position2, position3, color, color, color, color, fillMode, material, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3Dテクスチャ付き四角形(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DQuadTextureF(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxVector3& position3, const GxColor color, GxFloat2* pUvArray, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, GxFloat2* pUvArraySecond, u32 viewFlag)
{
    GxColor colorArray[4] = {color, color, color, color};
    draw3DQuadTextureG(position0, position1, position2, position3, colorArray, pUvArray, fillMode, material, pUvArraySecond, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3Dベクトル(Flat)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DArrowF(const GxVector3& position0, const GxVector3& position1, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, f32 arrowRate, f32 arrowRadian, u32 viewFlag)
{
    draw3DArrowG(position0, position1, color, color, fillMode, material, arrowRate, arrowRadian, viewFlag );
}
 
//---------------------------------------------------------------------------
// 3Dマトリクス
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DMatrix(const GxMatrixAffine& matrix, f32 size, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, f32 arrowRate, f32 arrowRadius, u32 viewFlag)
{
    GxVector3 axisX((GxVector3::AXIS_X * size).getTransform(matrix));
    GxVector3 axisY((GxVector3::AXIS_Y * size).getTransform(matrix));
    GxVector3 axisZ((GxVector3::AXIS_Z * size).getTransform(matrix));
 
    draw3DArrowG(matrix.getPosition(), axisX, GxColor::WHITE, GxColor::SYSTEM_AXIS_X, fillMode, material, arrowRate, arrowRadius, viewFlag);
    draw3DArrowG(matrix.getPosition(), axisY, GxColor::WHITE, GxColor::SYSTEM_AXIS_Y, fillMode, material, arrowRate, arrowRadius, viewFlag);
    draw3DArrowG(matrix.getPosition(), axisZ, GxColor::WHITE, GxColor::SYSTEM_AXIS_Z, fillMode, material, arrowRate, arrowRadius, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3Dマトリクス(ポジションのみ)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DMatrix(const GxVector3& position, f32 size, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, f32 arrowRate, f32 arrowRadius, u32 viewFlag)
{
    GxVector3 axisX((GxVector3::AXIS_X * size) + position);
    GxVector3 axisY((GxVector3::AXIS_Y * size) + position);
    GxVector3 axisZ((GxVector3::AXIS_Z * size) + position);
 
    draw3DArrowG(position, axisX, GxColor::WHITE, GxColor::SYSTEM_AXIS_X, fillMode, material, arrowRate, arrowRadius, viewFlag);
    draw3DArrowG(position, axisY, GxColor::WHITE, GxColor::SYSTEM_AXIS_Y, fillMode, material, arrowRate, arrowRadius, viewFlag);
    draw3DArrowG(position, axisZ, GxColor::WHITE, GxColor::SYSTEM_AXIS_Z, fillMode, material, arrowRate, arrowRadius, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3D球(形状指定)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DSphere(const GxShapeSphere& sphere, const GxColor color, u32 divide, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    draw3DSphere(GxMatrixAffine(sphere.getPosition()), sphere.getRadius(), color, divide, fillMode, material, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3D球(ポジション指定)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DSphere(const GxVector3& center, f32 radius, const GxColor color, u32 divide, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    draw3DSphere(GxMatrixAffine(center), radius, color, divide, fillMode, material, viewFlag);
}
 
//---------------------------------------------------------------------------
// 3D箱(形状指定)
//---------------------------------------------------------------------------
void GxPrimitiveContext::draw3DBox(const GxShapeBox& box, const GxColor color, PRIMITIVE_FILL_MODE fillMode, const GxPrimitiveMaterial& material, u32 viewFlag)
{
    draw3DBox(box.getMatrix(), box.getExtent(), color, fillMode, material, viewFlag);
}
 
//---------------------------------------------------------------------------
// パケットを確保
//---------------------------------------------------------------------------
GxPrimitiveManager::GxPacket* GxPrimitiveContext::allocatePacket(void)
{
    if( (GxPrimitiveManager::PACKET_BLOCK_SIZE / sizeof(GxPrimitiveManager::GxPacket)) - 1 <= _packetCountBlock )
    {
        // メモリが足りないので、マネージャからバッファを取得しなおす
 
        auto* pNewPacket = _pManager->allocatePacketBlock();
        if (pNewPacket)
        {
            if (!_pPacketTop)
            {
                _pPacketTop = pNewPacket;   // 先頭を記録
            }
            else
            {
                // 残り1個は残っているはず
                auto** ppNext = reinterpret_cast<GxPrimitiveManager::GxPacket**>(&(_pPacketBlock[_packetCountBlock]));
                *ppNext = pNewPacket;
 
                _packetCount++; // アドレス指定用の物もカウントする
            }
 
            _packetCountBlock = 0;
            _pPacketBlock = pNewPacket;
        }
        else
        {
            return nullptr; // メモリ確保に失敗
        }
    }
 
    _packetCount++;
    return &_pPacketBlock[_packetCountBlock++];
}
 
//---------------------------------------------------------------------------
// コマンドバッファを確保
//---------------------------------------------------------------------------
void* GxPrimitiveContext::allocateCommand(u32 size)
{
    // 16バイトアライメント
    size = GxMath::getRoundUpFast(size, GxMemory::ALIGNMENT::_16);
 
    if( GxPrimitiveManager::COMMAND_BLOCK_SIZE < _commandSizeBlock + size )
    {
        // メモリが足りないので、マネージャからバッファを取得しなおす
        auto* pBuffer = _pManager->allocateCommandBlock();
        if (pBuffer)
        {
            _pCommandBlock = pBuffer;
            _commandSizeBlock = 0;
        }
        else
        {
            return nullptr; // メモリ確保に失敗
        }
    }
 
    auto* pCommand = _pCommandBlock;
    _pCommandBlock = GX_POINTER_ADD(_pCommandBlock, size);
    _commandSizeBlock += size;
 
    return pCommand;
}
 
//---------------------------------------------------------------------------
// 頂点バッファを確保
//---------------------------------------------------------------------------
GxPrimitiveVertex* GxPrimitiveContext::allocateVertexBuffer(u32 vertexCount)
{
    static const u32 vertexCountLimit = GxPrimitiveManager::VERTEX_BLOCK_SIZE / sizeof(GxPrimitiveVertex);
 
    if( vertexCount > vertexCountLimit )
    {
        GX_ASSERT(vertexCount <= vertexCountLimit, "プリミティブの頂点数が最大値（%d）を超えています。最大値を超えないように分割して描画してください。", vertexCountLimit);
        return nullptr;
    }
 
    if( _vertexCountBlock + vertexCount > vertexCountLimit )
    {
        // メモリが足りないので、マネージャからバッファを取得しなおす
        auto* pBuffer = _pManager->allocateVertexBlock();
        if (pBuffer)
        {
            _pVertexBlock = pBuffer;
            _vertexCountBlock = 0;
        }
        else
        {
            return nullptr; // メモリ確保に失敗
        }
    }
 
    auto* pVertex = _pVertexBlock;
 
    _pVertexBlock       += vertexCount;
    _vertexCount        += vertexCount;
    _vertexCountBlock   += vertexCount;
 
    return pVertex;
}
 
GX_CORE_NAMESPACE_END()