You could add a constant buffer in your vertex shader with a transform matrix. Something like this :

cbuffer TransformBuffer
{
	float4x4 Transform;
};

And still in the vertex shader, you multiply the intput vertex position with the transform matrix.

Now all you have to do is to update that constant buffer before the draw call with the transformation that you want (a translation in your case).

https://docs.microsoft.com/en-us/windows/desktop/direct3d11/overviews-direct3d-11-resources-buffers-constant-how-to

If you only have squares you might want to use instancing to provide a matrix per square, or even just rewrite the vertex buffer cause a square is such an extremely simple mesh with a tiny amount of vertices to rewrite.

4 hours ago, JWColeman said:

So, first of all, for best practice, should I use the same cbuffer I use for my world projection? I should be able to create another without any trouble. 

Second of all, in order to update an already created constant buffer, which functions do I need to call?

I'm guessing that I need to update the memory in the buffer like this:

InitData.pSysMem = &cbuffer;

Do I need to do anything else?

Well as a general rule for constant buffers it's preferable to group them based on update frequency. For example your projection matrix/view matrix along with few other future parameters may be updated once per frame. The world matrix however may be updated once per object to draw. So don't hesitate to split those.

Refer to this page to know how to update the data : https://bell0bytes.eu/shader-data/ there's a section called "Updating Constant Buffers" that show you how to use UpdateSubresource.

I'd also like to suggest using a template for your constant buffers as you'll end up having multiple cbuffers whether due to multiple shaders, different update intervals, etc.

Note: The following code is for DirectX 11.

I don't remember where I had found this resource from, but I use something like this

#ifndef ConstantBuffer_h__
#define ConstantBuffer_h__
#include <d3d11.h>
#include <wrl/client.h>

template<class T>
class ConstantBuffer
{
private:
	ConstantBuffer(const ConstantBuffer<T>& rhs);

private:

	Microsoft::WRL::ComPtr<ID3D11Buffer> buffer;
	bool mInitialized;

public:
	ConstantBuffer() {}

	T Data;

	ID3D11Buffer* Buffer()const
	{
		return buffer.Get();
	}

	HRESULT Initialize(Microsoft::WRL::ComPtr<ID3D11Device> &device)
	{
		HRESULT hr = S_OK;
		D3D11_BUFFER_DESC desc;
		desc.Usage = D3D11_USAGE_DYNAMIC;
		desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
		desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		desc.MiscFlags = 0;
		desc.ByteWidth = static_cast<UINT>(sizeof(T) + (16 - (sizeof(T) % 16)));
		desc.StructureByteStride = 0;

		hr = device->CreateBuffer(&desc, 0, buffer.GetAddressOf());
		mInitialized = true;
		return hr;
	}

	void ApplyChanges(Microsoft::WRL::ComPtr<ID3D11DeviceContext> &dc)
	{
		D3D11_MAPPED_SUBRESOURCE mappedResource;
		HRESULT hr = dc->Map(buffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
		CopyMemory(mappedResource.pData, &Data, sizeof(T));
		dc->Unmap(buffer.Get(), 0);
	}
};

#endif // ConstantBuffer_h__

Then I could define a structure for my cbuffer layout like this (In this example this is a constant buffer for my vertex shader for my 2d UI elements

struct CB_VS_UI
{
	XMFLOAT4 position;
};

In my graphics class, I am declaring the constant buffer of this type with

ConstantBuffer<CB_VS_UI> cb_vs_ui;

To initialize this constant buffer, I am doing

//create constant buffer for ui elements
HRESULT hr = this->cb_vs_ui.Initialize(this->d3d11Device); //<--Pass in the ComPtr<ID3D11Device> 
if (hr != S_OK)
{
	LogError("Failed Initialize Constant Buffer for UI Elements Vertex Shader. Error Code: " + std::to_string(hr)); 
	return false;
}

Then, before the Draw call, I am updating the constant buffer with this (note d3d11DeviceContext is type ComPtr<ID3D11DeviceContext> )

//constant buffer for ui vertex shader
this->cb_vs_ui.Data.position.x = xPosition;
this->cb_vs_ui.Data.position.y = yPosition;
this->cb_vs_ui.Data.position.z = 0;
this->cb_vs_ui.Data.position.w = 0;
auto vsbuffer = this->cb_vs_ui.Buffer();
this->d3d11DeviceContext->VSSetConstantBuffers(0, 1, &vsbuffer); //set the constant buffer for the vertex shader
this->cb_vs_ui.ApplyChanges(this->d3d11DeviceContext);

For reference, here is the basic vertex shader I am using for this example.

cbuffer cbPerUI : register(b0)
{
    float4 uipos;
};

struct UI_VS_OUTPUT    //output structure for skymap vertex shader
{
    float4 Pos : SV_POSITION;
    float2 texCoord : TEXCOORD;
};

UI_VS_OUTPUT main(float4 inPos : POSITION, float2 inTexCoord : TEXCOORD)
{
    UI_VS_OUTPUT output;
    output.Pos = inPos.xyzz + uipos;
    output.texCoord = inTexCoord;
    return output;
}

Sorry for wall of text, just trying to put some info out there that might be helpful.

Hopefully I didn't forget to include anything.

If you want to make your life even easier you could deal with a matrix instead of a float3. A matrix allow you to perform any combination of translation, rotation and scaling.

Which involves changing this :

cbuffer PositionConstantBuffer : register (b1)
{
	float3 xyz;
}

to this :

cbuffer PositionConstantBuffer : register (b1)
{
	float4x4 world;
}

And adjusting the shader a little bit to something like this :

VOut VShader(float4 position : POSITION, float4 color : COLOR)
{
	VOut output;
	output.position = mul(position, world);
        //output.position = mul(output.position, view); // you'll very soon want a view matrix there
	output.position = mul(output.position, projection); // Apply ortho projection matrix
	output.color = color; // Apply color from vertex input
	return output;
}

I'm assuming that you are already using a math library that provides common matrix operations such as Translate/Rotate/Scale.