void DiInstanceBatchHardware::Update(DiCamera* camera)
{
if (!mKeepStatic)
mAddToBatch = UpdateVertexBuffer(NULL) != 0;
else
mAddToBatch = true;
}
/**
* @brief Adds a point to the list of vertices
*
* Adds a point to the list of vertices and updates the data on the
* OpenGL context.
*
* @param x The x-coordinate (in OpenGL normalized space)
* @param y The y-coordinate (int OpenGL normalized space)
*/
void PolygonTool::AddPoint(float x, float y)
{
pointsList.push_back(Point(x, y));
++pointCount;
UpdateVertexBuffer();
UpdateIndexBuffer();
}
void ParticleEmitterInstance::Render(Camera* aCamera)
{
UpdateVertexBuffer();
myParticleEmitterData->myEffect->SetTexture(
Engine::GetInstance()->GetTextureContainer()->GetTexture(myParticleEmitterData->myTextureName.c_str()));
myParticleEmitterData->myEffect->SetWorldMatrix(myOrientation);
myParticleEmitterData->myEffect->SetViewMatrix(CU::InverseSimple(aCamera->GetOrientation()));
myParticleEmitterData->myEffect->SetProjectionMatrix(aCamera->GetProjection());
Engine::GetInstance()->GetContex()->IASetInputLayout(myParticleEmitterData->myInputLayout);
Engine::GetInstance()->GetContex()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
Engine::GetInstance()->GetContex()->IASetVertexBuffers(
myVertexWrapper->myStartSlot
, myVertexWrapper->myNumberOfBuffers
, &myVertexWrapper->myVertexBuffer
, &myVertexWrapper->myStride
, &myVertexWrapper->myByteOffset);
D3DX11_TECHNIQUE_DESC techDesc;
myParticleEmitterData->myEffect->GetTechnique()->GetDesc(&techDesc);
for (UINT i = 0; i < techDesc.Passes; ++i)
{
myParticleEmitterData->myEffect->GetTechnique()->GetPassByIndex(i)->Apply(0, Engine::GetInstance()->GetContex());
Engine::GetInstance()->GetContex()->Draw(myGraphicalParticles.Size(), 0);
}
}
void DxWidget::paintEvent(QPaintEvent* event)
{
if (m_nVertexCounter != 0)
{
UpdateVertexBuffer();
Render(); // return HRESULT
}
}
void DxWidget::resizeEvent(QResizeEvent* event)
{
if (m_nVertexCounter != 0)
{
UpdateVertexBuffer();
Render();
}
}
void Polygon::ResetPolygonData()
{
//Set the render mode
SetRenderMode(m_IsFilled ? GL_TRIANGLE_FAN : GL_LINE_LOOP);
//And update the vertex buffer
UpdateVertexBuffer();
}
void BillboardSet::UpdateGeometry(const FrameInfo& frame)
{
if (bufferSizeDirty_ || indexBuffer_->IsDataLost())
UpdateBufferSize();
if (bufferDirty_ || vertexBuffer_->IsDataLost())
UpdateVertexBuffer(frame);
}
n2dBufferImpl* n2dDynamicMeshDataImpl::GetVertexBuffer()
{
if (!m_pRenderDevice)
{
return 0u;
}
UpdateVertexBuffer();
return m_VB;
}
void DiInstanceBatchHardware::SetStaticAndUpdate( bool bStatic )
{
if( mKeepStatic && mBoundsDirty )
{
mCreator->AddDirtyBatch(std::dynamic_pointer_cast<DiInstanceBatch>(shared_from_this()));
}
mKeepStatic = bStatic;
if( mKeepStatic )
{
UpdateVertexBuffer( NULL );
}
}
void BillboardSet::UpdateGeometry(const FrameInfo& frame)
{
if (bufferSizeDirty_ || indexBuffer_->IsDataLost())
UpdateBufferSize();
if (bufferDirty_ || sortThisFrame_ || vertexBuffer_->IsDataLost())
UpdateVertexBuffer(frame);
// If using camera facing, re-update the rotation for the current view now
if (faceCameraMode_ != FC_NONE)
{
transforms_[1] = Matrix3x4(Vector3::ZERO, frame.camera_->GetFaceCameraRotation(node_->GetWorldPosition(),
node_->GetWorldRotation(), faceCameraMode_), Vector3::ONE);
}
}
void Point::ResetPolygonData()
{
//Clear the vertices vector
m_Vertices.clear();
//Clear the colors vector
m_Colors.clear();
//Add the vertices
AddVertex(vec2(0.0f, 0.0f));
//Set the render mode
SetRenderMode(GL_POINTS);
//Update the vertex buffer
UpdateVertexBuffer();
}
void FRenderD3D11::RenderFrame()
{
camera.CommitListener();
// ProcessInCPU();
float colorRGBA[4] = { 0.0f, 0.2f, 0.4f, 1.0f };
// clear the back buffer to a deep blue
m_pDeviceContext->ClearRenderTargetView(m_pBackbuffer, colorRGBA);
UpdateVertexBuffer();
UpdateIndexBuffer();
UpdateConstantBuffer();
// select which vertex buffer to display
UINT stride = sizeof(VERTEX);
UINT offset = 0;
m_pDeviceContext->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset);
m_pDeviceContext->IASetIndexBuffer(m_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
m_pDeviceContext->VSSetConstantBuffers(0, 1, &m_pCBuffer);
// select which primtive type we are using
m_pDeviceContext->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
D3D11_RASTERIZER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_RASTERIZER_DESC));
desc.CullMode = D3D11_CULL_BACK;
desc.FillMode = D3D11_FILL_WIREFRAME;
desc.FrontCounterClockwise = false;
desc.DepthClipEnable = true;
ID3D11RasterizerState* pRasterizerState = NULL;
m_pDevice->CreateRasterizerState(&desc, &pRasterizerState);
m_pDeviceContext->RSSetState(pRasterizerState);
// draw the vertex buffer to the back buffer
m_pDeviceContext->DrawIndexed(triCorn.indices.size(), 0, 0);
// switch the back buffer and the front buffer
m_pSwapchain->Present(0, 0);
}
void BillboardSet::UpdateGeometry(const FrameInfo& frame)
{
// If rendering from multiple views and fixed screen size is in use, re-update scale factors before each render
if (fixedScreenSize_ && viewCameras_.Size() > 1)
CalculateFixedScreenSize(frame);
// If using camera facing, re-update the rotation for the current view now
if (faceCameraMode_ != FC_NONE)
{
transforms_[1] = Matrix3x4(Vector3::ZERO, frame.camera_->GetFaceCameraRotation(node_->GetWorldPosition(),
node_->GetWorldRotation(), faceCameraMode_, minAngle_), Vector3::ONE);
}
if (bufferSizeDirty_ || indexBuffer_->IsDataLost())
UpdateBufferSize();
if (bufferDirty_ || sortThisFrame_ || vertexBuffer_->IsDataLost())
UpdateVertexBuffer(frame);
}
void Update(unsigned int elapsedMilliseconds)
{
RenderContext& rc = GlobalRenderContext;
static float theta = 0;
static float time = 0;
const float InitialPause = 0;
const bool LoopForever = true;
time += elapsedMilliseconds;
if (time > InitialPause && (LoopForever || theta < 360))
{
theta += elapsedMilliseconds * 0.1f;
}
mat4 rotation = mat4::Rotate(theta, vec3(0, 1, 0));
mat4 translation = mat4::Translate(0, 0, -7);
rc.Modelview = translation * rotation;
rc.NormalMatrix = rc.Modelview.ToMat3();
UpdateVertexBuffer();
}
// Fill the command list with all the render commands and dependent state and
// submit it to the command queue.
void D3D12HDR::RenderScene()
{
// Command list allocators can only be reset when the associated
// command lists have finished execution on the GPU; apps should use
// fences to determine GPU execution progress.
ThrowIfFailed(m_commandAllocators[m_frameIndex]->Reset());
// However, when ExecuteCommandList() is called on a particular command
// list, that command list can then be reset at any time and must be before
// re-recording.
ThrowIfFailed(m_commandList->Reset(m_commandAllocators[m_frameIndex].Get(), m_pipelineStates[GradientPSO].Get()));
if (m_updateVertexBuffer)
{
UpdateVertexBuffer();
m_updateVertexBuffer = false;
}
// Set necessary state.
m_commandList->SetGraphicsRootSignature(m_rootSignature.Get());
ID3D12DescriptorHeap* ppHeaps[] = { m_srvHeap.Get() };
m_commandList->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps);
m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
m_commandList->RSSetViewports(1, &m_viewport);
m_commandList->RSSetScissorRects(1, &m_scissorRect);
// Bind the root constants and the SRV table to the pipeline.
m_rootConstantsF[ReferenceWhiteNits] = m_referenceWhiteNits;
m_commandList->SetGraphicsRoot32BitConstants(0, RootConstantsCount, m_rootConstants, 0);
m_commandList->SetGraphicsRootDescriptorTable(1, m_srvHeap->GetGPUDescriptorHandleForHeapStart());
// Draw the scene into the intermediate render target.
{
PIXBeginEvent(m_commandList.Get(), 0, L"Draw scene content");
CD3DX12_CPU_DESCRIPTOR_HANDLE intermediateRtv(m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), FrameCount, m_rtvDescriptorSize);
m_commandList->OMSetRenderTargets(1, &intermediateRtv, FALSE, nullptr);
const float clearColor[] = { 0.0f, 0.0f, 0.0f, 0.0f };
m_commandList->ClearRenderTargetView(intermediateRtv, clearColor, 0, nullptr);
m_commandList->IASetVertexBuffers(0, 1, &m_gradientVertexBufferView);
PIXBeginEvent(m_commandList.Get(), 0, L"Standard Gradient");
m_commandList->DrawInstanced(4, 1, 0, 0);
PIXEndEvent(m_commandList.Get());
PIXBeginEvent(m_commandList.Get(), 0, L"Bright Gradient");
m_commandList->DrawInstanced(4, 1, 4, 0);
PIXEndEvent(m_commandList.Get());
m_commandList->SetPipelineState(m_pipelineStates[PalettePSO].Get());
m_commandList->IASetVertexBuffers(0, 1, &m_trianglesVertexBufferView);
m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
PIXBeginEvent(m_commandList.Get(), 0, L"Rec709 Triangles");
m_commandList->DrawInstanced(3, 1, 0, 0);
m_commandList->DrawInstanced(3, 1, 3, 0);
m_commandList->DrawInstanced(3, 1, 6, 0);
PIXEndEvent(m_commandList.Get());
m_commandList->SetPipelineState(m_pipelineStates[PalettePSO].Get());
PIXBeginEvent(m_commandList.Get(), 0, L"Rec2020 Triangles");
m_commandList->DrawInstanced(3, 1, 9, 0);
m_commandList->DrawInstanced(3, 1, 12, 0);
m_commandList->DrawInstanced(3, 1, 15, 0);
PIXEndEvent(m_commandList.Get());
PIXEndEvent(m_commandList.Get());
if (!m_enableUI)
{
intermediateRtv.Offset(1, m_rtvDescriptorSize);
m_commandList->OMSetRenderTargets(1, &intermediateRtv, FALSE, nullptr);
m_commandList->ClearRenderTargetView(intermediateRtv, clearColor, 0, nullptr);
}
}
// Indicate that the intermediates will be used as SRVs in the pixel shader
// and the back buffer will be used as a render target.
D3D12_RESOURCE_BARRIER barriers[] = {
CD3DX12_RESOURCE_BARRIER::Transition(m_intermediateRenderTarget.Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE),
CD3DX12_RESOURCE_BARRIER::Transition(m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET),
CD3DX12_RESOURCE_BARRIER::Transition(m_UIRenderTarget.Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE),
};
// Process the intermediate and draw into the swap chain render target.
{
PIXBeginEvent(m_commandList.Get(), 0, L"Apply HDR");
// If the UI is enabled, the 11on12 layer will do the state transition for us.
UINT barrierCount = m_enableUI ? 2 : _countof(barriers);
m_commandList->ResourceBarrier(barrierCount, barriers);
m_commandList->SetPipelineState(m_pipelineStates[Present8bitPSO + m_currentSwapChainBitDepth].Get());
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), m_frameIndex, m_rtvDescriptorSize);
m_commandList->OMSetRenderTargets(1, &rtvHandle, FALSE, nullptr);
m_commandList->ClearRenderTargetView(rtvHandle, ClearColor, 0, nullptr);
m_commandList->IASetVertexBuffers(0, 1, &m_presentVertexBufferView);
m_commandList->DrawInstanced(3, 1, 0, 0);
PIXEndEvent(m_commandList.Get());
}
// Indicate that the intermediates will be used as render targets and the swap chain
// back buffer will be used for presentation.
barriers[0].Transition.StateBefore = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barriers[0].Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
barriers[1].Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barriers[1].Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
barriers[2].Transition.StateBefore = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barriers[2].Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
m_commandList->ResourceBarrier(_countof(barriers), barriers);
ThrowIfFailed(m_commandList->Close());
// Execute the command list.
ID3D12CommandList* ppCommandLists[] = { m_commandList.Get() };
m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
}
void Polygon::SetPointSize(float aPointSize)
{
m_PointSize = aPointSize;
UpdateVertexBuffer();
}
//[-------------------------------------------------------]
//[ Public virtual SPK::Renderer functions ]
//[-------------------------------------------------------]
void SPK_PLQuadRendererShaders::render(const SPK::Group &group)
{
// Is there a valid m_pSPK_PLBuffer instance?
if (prepareBuffers(group) && m_pSPK_PLBuffer && m_pSPK_PLBuffer->GetVertexBuffer()) {
// Update the vertex buffer
UpdateVertexBuffer(group);
// Setup render states
InitBlending();
GetPLRenderer().SetRenderState(RenderState::ZEnable, isRenderingHintEnabled(SPK::DEPTH_TEST));
GetPLRenderer().SetRenderState(RenderState::ZWriteEnable, isRenderingHintEnabled(SPK::DEPTH_WRITE));
/*
// [TODO] Alpha test
if (isRenderingHintEnabled(SPK::ALPHA_TEST)) {
pFixedFunctions->SetRenderState(FixedFunctions::RenderState::AlphaTestEnable, true);
pFixedFunctions->SetRenderState(FixedFunctions::RenderState::AlphaTestFunction, Compare::GreaterEqual);
pFixedFunctions->SetRenderState(FixedFunctions::RenderState::AlphaTestReference, Tools::FloatToUInt32(getAlphaTestThreshold()));
} else {
pFixedFunctions->SetRenderState(FixedFunctions::RenderState::AlphaTestEnable, false);
}
*/
// Make our program to the current one
if (GetPLRenderer().SetProgram(m_pProgram)) {
// Set the "ObjectSpaceToClipSpaceMatrix" fragment shader parameter
if (m_pObjectSpaceToClipSpaceMatrixProgramUniform)
m_pObjectSpaceToClipSpaceMatrixProgramUniform->Set(m_mWorldViewProjection);
// Set "TextureMap" program uniform
if (m_pTextureMapProgramUniform) {
Texture *pTexture = m_pTextureHandler->GetTexture();
if (pTexture && pTexture->GetTextureBuffer()) {
const int nTextureUnit = m_pTextureMapProgramUniform->Set(pTexture->GetTextureBuffer());
if (nTextureUnit >= 0) {
GetPLRenderer().SetSamplerState(nTextureUnit, Sampler::AddressU, TextureAddressing::Wrap);
GetPLRenderer().SetSamplerState(nTextureUnit, Sampler::AddressV, TextureAddressing::Wrap);
GetPLRenderer().SetSamplerState(nTextureUnit, Sampler::MagFilter, TextureFiltering::Linear);
GetPLRenderer().SetSamplerState(nTextureUnit, Sampler::MinFilter, TextureFiltering::Linear);
GetPLRenderer().SetSamplerState(nTextureUnit, Sampler::MipFilter, TextureFiltering::Linear);
}
}
}
// Set program vertex attributes, this creates a connection between "Vertex Buffer Attribute" and "Vertex Shader Attribute"
VertexBuffer *pVertexBuffer = m_pSPK_PLBuffer->GetVertexBuffer();
if (m_pPositionProgramAttribute)
m_pPositionProgramAttribute->Set(pVertexBuffer, PLRenderer::VertexBuffer::Position);
if (m_pTexCoordProgramAttribute)
m_pTexCoordProgramAttribute->Set(pVertexBuffer, PLRenderer::VertexBuffer::TexCoord);
if (m_pColorProgramAttribute)
m_pColorProgramAttribute->Set(pVertexBuffer, PLRenderer::VertexBuffer::Color);
// Make the index buffer to the current renderer index buffer
IndexBuffer *pIndexBuffer = m_pSPK_PLBuffer->GetIndexBuffer();
if (pIndexBuffer)
GetPLRenderer().SetIndexBuffer(pIndexBuffer);
// Draw
GetPLRenderer().DrawIndexedPrimitives(Primitive::TriangleList, 0, static_cast<uint32>(group.getNbParticles()*NumOfVerticesPerParticle-1), 0, static_cast<uint32>(group.getNbParticles()*NumOfIndicesPerParticle));
}
}
}
void CSlideShowPic::Render(float *x, float *y, CBaseTexture* pTexture, color_t color)
{
#ifdef HAS_DX
static const DWORD FVF_VERTEX = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;
Vertex vertex[5];
for (int i = 0; i < 4; i++)
{
vertex[i].pos = XMFLOAT3( x[i], y[i], 0);
CD3DHelper::XMStoreColor(&vertex[i].color, color);
vertex[i].texCoord = XMFLOAT2(0.0f, 0.0f);
vertex[i].texCoord2 = XMFLOAT2(0.0f, 0.0f);
}
if (pTexture)
{
vertex[1].texCoord.x = vertex[2].texCoord.x = (float) pTexture->GetWidth() / pTexture->GetTextureWidth();
vertex[2].texCoord.y = vertex[3].texCoord.y = (float) pTexture->GetHeight() / pTexture->GetTextureHeight();
}
else
{
vertex[1].texCoord.x = vertex[2].texCoord.x = 1.0f;
vertex[2].texCoord.y = vertex[3].texCoord.y = 1.0f;
}
vertex[4] = vertex[0]; // Not used when pTexture != NULL
CGUIShaderDX* pGUIShader = g_Windowing.GetGUIShader();
pGUIShader->Begin(SHADER_METHOD_RENDER_TEXTURE_BLEND);
// Set state to render the image
if (pTexture)
{
pTexture->LoadToGPU();
CDXTexture* dxTexture = reinterpret_cast<CDXTexture*>(pTexture);
ID3D11ShaderResourceView* shaderRes = dxTexture->GetShaderResource();
pGUIShader->SetShaderViews(1, &shaderRes);
pGUIShader->DrawQuad(vertex[0], vertex[1], vertex[2], vertex[3]);
}
else
{
if (!UpdateVertexBuffer(vertex))
return;
ID3D11DeviceContext* pContext = g_Windowing.Get3D11Context();
unsigned stride = sizeof(Vertex);
unsigned offset = 0;
pContext->IASetVertexBuffers(0, 1, &m_vb, &stride, &offset);
pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP);
pGUIShader->Draw(5, 0);
pGUIShader->RestoreBuffers();
}
#elif defined(HAS_GL)
if (pTexture)
{
int unit = 0;
pTexture->LoadToGPU();
pTexture->BindToUnit(unit++);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
// diffuse coloring
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
if(g_Windowing.UseLimitedColor())
{
// compress range
pTexture->BindToUnit(unit++); // dummy bind
const GLfloat rgba1[4] = {(235.0 - 16.0f) / 255.0f, (235.0 - 16.0f) / 255.0f, (235.0 - 16.0f) / 255.0f, 1.0f};
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba1);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_MODULATE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS);
// transition
pTexture->BindToUnit(unit++); // dummy bind
const GLfloat rgba2[4] = {16.0f / 255.0f, 16.0f / 255.0f, 16.0f / 255.0f, 0.0f};
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba2);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_ADD);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS);
}
}
else
glDisable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, pTexture ? GL_FILL : GL_LINE);
glBegin(GL_QUADS);
float u1 = 0, u2 = 1, v1 = 0, v2 = 1;
if (pTexture)
{
u2 = (float)pTexture->GetWidth() / pTexture->GetTextureWidth();
v2 = (float)pTexture->GetHeight() / pTexture->GetTextureHeight();
}
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u1, v1);
glVertex3f(x[0], y[0], 0);
// Bottom-left vertex (corner)
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u2, v1);
glVertex3f(x[1], y[1], 0);
// Bottom-right vertex (corner)
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u2, v2);
glVertex3f(x[2], y[2], 0);
// Top-right vertex (corner)
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u1, v2);
glVertex3f(x[3], y[3], 0);
glEnd();
#elif defined(HAS_GLES)
if (pTexture)
{
pTexture->LoadToGPU();
pTexture->BindToUnit(0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
g_Windowing.EnableGUIShader(SM_TEXTURE);
}
else
{
glDisable(GL_TEXTURE_2D);
g_Windowing.EnableGUIShader(SM_DEFAULT);
}
float u1 = 0, u2 = 1, v1 = 0, v2 = 1;
if (pTexture)
{
u2 = (float)pTexture->GetWidth() / pTexture->GetTextureWidth();
v2 = (float)pTexture->GetHeight() / pTexture->GetTextureHeight();
}
GLubyte col[4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
GLint uniColLoc= g_Windowing.GUIShaderGetUniCol();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
glEnableVertexAttribArray(tex0Loc);
// Setup Colour values
col[0] = (GLubyte)GET_R(color);
col[1] = (GLubyte)GET_G(color);
col[2] = (GLubyte)GET_B(color);
col[3] = (GLubyte)GET_A(color);
for (int i=0; i<4; i++)
{
// Setup vertex position values
ver[i][0] = x[i];
ver[i][1] = y[i];
ver[i][2] = 0.0f;
}
// Setup texture coordinates
tex[0][0] = tex[3][0] = u1;
tex[0][1] = tex[1][1] = v1;
tex[1][0] = tex[2][0] = u2;
tex[2][1] = tex[3][1] = v2;
glUniform4f(uniColLoc,(col[0] / 255.0f), (col[1] / 255.0f), (col[2] / 255.0f), (col[3] / 255.0f));
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
#else
// SDL render
g_Windowing.BlitToScreen(m_pImage, NULL, NULL);
#endif
}
//----------------------------------------------------------------------------
bool Fluids3D::OnKeyDown (unsigned char key, int x, int y)
{
if (WindowApplication3::OnKeyDown(key, x, y))
{
return true;
}
switch (key)
{
case '0':
mSmoke->Initialize();
UpdateVertexBuffer();
return true;
case ' ':
if (mSingleStep)
{
PhysicsTick();
}
return true;
case 's':
case 'S':
mSingleStep = !mSingleStep;
return true;
case 'c':
case 'C':
mUseColor = !mUseColor;
UpdateVertexBuffer();
return true;
case '+':
case '=':
{
int numActive = mSmoke->GetNumActiveVortices();
if (numActive < mSmoke->GetNumVortices())
{
mSmoke->SetNumActiveVortices(numActive + 1);
}
return true;
}
case '-':
case '_':
{
int numActive = mSmoke->GetNumActiveVortices();
if (numActive > 0)
{
mSmoke->SetNumActiveVortices(numActive - 1);
}
return true;
}
case 'g':
{
float gravity = mSmoke->GetGravity() - 0.5f;
if (gravity < 0.0f)
{
gravity = 0.0f;
}
mSmoke->SetGravity(gravity);
return true;
}
case 'G':
mSmoke->SetGravity(mSmoke->GetGravity() + 0.5f);
return true;
}
return false;
}
//----------------------------------------------------------------------------
void Fluids3D::PhysicsTick ()
{
mSmoke->DoSimulationStep();
UpdateVertexBuffer();
UpdateIndexBuffer();
}
//----------------------------------------------------------------------------
bool Fluids3D::OnInitialize ()
{
if (!WindowApplication3::OnInitialize())
{
return false;
}
// Create the pseudocoloring for display.
Vector3f key[9] =
{
Vector3f( 0.0f/255.0f, 0.0f/255.0f, 0.0f/255.0f), // black
Vector3f(128.0f/255.0f, 64.0f/255.0f, 64.0f/255.0f), // brown
Vector3f(128.0f/255.0f, 0.0f/255.0f, 255.0f/255.0f), // violet
Vector3f( 0.0f/255.0f, 0.0f/255.0f, 255.0f/255.0f), // blue
Vector3f( 0.0f/255.0f, 255.0f/255.0f, 0.0f/255.0f), // green
Vector3f(255.0f/255.0f, 255.0f/255.0f, 0.0f/255.0f), // yellow
Vector3f(255.0f/255.0f, 128.0f/255.0f, 0.0f/255.0f), // orange
Vector3f(255.0f/255.0f, 0.0f/255.0f, 0.0f/255.0f), // red
Vector3f(255.0f/255.0f, 255.0f/255.0f, 255.0f/255.0f) // white
};
for (int i = 0, j = 0; i < 8; ++i)
{
for (int k = 0; k < 32; ++k, ++j)
{
float t = k/32.0f;
float omt = 1.0f - t;
mColor[j][0] = omt*key[i][0] + t*key[i+1][0];
mColor[j][1] = omt*key[i][1] + t*key[i+1][1];
mColor[j][2] = omt*key[i][2] + t*key[i+1][2];
}
}
// Create the fluid solver.
float x0 = -0.5f, y0 = -0.5f, z0 = -0.5f;
float x1 = 0.5f, y1 = 0.5f, z1 = 0.5f;
float dt = 0.001f;
float denViscosity = 0.0001f, velViscosity = 0.0001f;
int imax = 23, jmax = 23, kmax = 23;
int numGaussSeidelIterations = 16;
bool densityDirichlet = true;
int numVortices = 8;
mSmoke = new0 Smoke3D<float>(x0, y0, z0, x1, y1, z1, dt, denViscosity,
velViscosity, imax, jmax, kmax, numGaussSeidelIterations,
densityDirichlet, numVortices);
mSmoke->Initialize();
// Set up the camera.
mCamera->SetFrustum(60.0f, GetAspectRatio(), 0.1f, 100.0f);
APoint camPosition(1.0f, 0.0f, 0.0f);
AVector camDVector(-1.0f, 0.0f, 0.0f);
AVector camUVector(0.0f, 0.0f, 1.0f);
AVector camRVector = camDVector.Cross(camUVector);
mCamera->SetFrame(camPosition, camDVector, camUVector, camRVector);
// Create the scene.
CreateScene();
mScene->Update();
#ifdef USE_PARTICLES
mCube->GenerateParticles(mCamera);
#endif
UpdateVertexBuffer();
UpdateIndexBuffer();
// The scene is controlled by a virtual trackball.
InitializeCameraMotion(0.01f, 0.01f);
InitializeObjectMotion(mScene);
return true;
}
//----------------------------------------------------------------------------
void Fluids3D::CreateScene ()
{
// Get fluid solver parameters.
const int bound0M1 = mSmoke->GetIMax();
const int bound1M1 = mSmoke->GetJMax();
const int bound2M1 = mSmoke->GetKMax();
const int bound0 = bound0M1 + 1;
const int bound1 = bound1M1 + 1;
const int bound2 = bound2M1 + 1;
const int quantity = bound0*bound1*bound2;
const float* x = mSmoke->GetX();
const float* y = mSmoke->GetY();
const float* z = mSmoke->GetZ();
#ifdef USE_PARTICLES
// Create the vertex format.
VertexFormat* vformat = VertexFormat::Create(3,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT4, 0);
#else
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT4, 0);
#endif
// Create the vertex buffer for the cube.
#ifdef USE_PARTICLES
const int numVertices = 4*quantity;
#else
const int numVertices = quantity;
#endif
int vstride = vformat->GetStride();
VertexBuffer* vbuffer = new0 VertexBuffer(numVertices, vstride);
int i0, i1, i2, index;
#ifdef USE_PARTICLES
const float delta = mSmoke->GetDx();
Float4* posSize = new1<Float4>(quantity);
for (i2 = 0, index = 0; i2 < bound2; ++i2)
{
for (i1 = 0; i1 < bound1; ++i1)
{
for (i0 = 0; i0 < bound0; ++i0, ++index)
{
posSize[index] = Float4(x[i0], y[i1], z[i2], delta);
}
}
}
mCube = new0 Particles(vformat, vbuffer, 4, posSize, 1.0f);
UpdateVertexBuffer();
IndexBuffer* ibuffer = mCube->GetIndexBuffer();
#else
VertexBufferAccessor vba(vformat, vbuffer);
for (i2 = 0, index = 0; i2 < bound2; ++i2)
{
for (i1 = 0; i1 < bound1; ++i1)
{
for (i0 = 0; i0 < bound0; ++i0, ++index)
{
vba.Position<Float3>(index) = Float3(x[i0], y[i1], z[i2]);
}
}
}
// Create the index buffer for the cube.
const int numIndices =
6*bound0M1*bound1M1*bound2 +
6*bound0M1*bound1*bound2M1 +
6*bound0*bound1M1*bound2M1;
IndexBuffer* ibuffer = new0 IndexBuffer(numIndices, sizeof(int));
int* indices = (int*)ibuffer->GetData();
const int bound01 = bound0*bound1;
int j0, j1, j2, j3;
for (i2 = 0; i2 < bound2; ++i2)
{
for (i1 = 0; i1 < bound1M1; ++i1)
{
for (i0 = 0; i0 < bound0M1; ++i0)
{
j0 = i0 + bound0*(i1 + bound1*i2);
j1 = j0 + 1;
j2 = j1 + bound0;
j3 = j2 - 1;
*indices++ = j0;
*indices++ = j1;
*indices++ = j2;
*indices++ = j0;
*indices++ = j2;
*indices++ = j3;
}
}
}
for (i1 = 0; i1 < bound1; ++i1)
{
for (i2 = 0; i2 < bound2M1; ++i2)
{
for (i0 = 0; i0 < bound0M1; ++i0)
{
j0 = i0 + bound0*(i1 + bound1*i2);
j1 = j0 + 1;
j2 = j1 + bound01;
j3 = j2 - 1;
*indices++ = j0;
*indices++ = j1;
*indices++ = j2;
*indices++ = j0;
*indices++ = j2;
*indices++ = j3;
}
}
}
for (i0 = 0; i0 < bound0; ++i0)
{
for (i1 = 0; i1 < bound1M1; ++i1)
{
for (i2 = 0; i2 < bound2M1; ++i2)
{
j0 = i0 + bound0*(i1 + bound1*i2);
j1 = j0 + bound0;
j2 = j1 + bound01;
j3 = j2 - bound0;
*indices++ = j0;
*indices++ = j1;
*indices++ = j2;
*indices++ = j0;
*indices++ = j2;
*indices++ = j3;
}
}
}
mCube = new0 TriMesh(vformat, vbuffer, ibuffer);
UpdateVertexBuffer();
#endif
mNumIndices = ibuffer->GetNumElements();
mIndices = new1<int>(mNumIndices);
memcpy(mIndices, ibuffer->GetData(), mNumIndices*sizeof(int));
// Create the cube effect.
#ifdef USE_PARTICLES
std::string path = Environment::GetPathR("Disk.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
VisualEffectInstance* instance =
VertexColor4TextureEffect::CreateUniqueInstance(texture,
Shader::SF_NEAREST, Shader::SC_CLAMP_EDGE, Shader::SC_CLAMP_EDGE);
#else
VertexColor4Effect* effect = new0 VertexColor4Effect();
VisualEffectInstance* instance = effect->CreateInstance();
#endif
const VisualPass* pass = instance->GetPass(0);
AlphaState* astate = pass->GetAlphaState();
astate->BlendEnabled = true;
CullState* cstate = pass->GetCullState();
cstate->Enabled = false;
DepthState* dstate = pass->GetDepthState();
dstate->Enabled = false;
dstate->Writable = false;
mCube->SetEffectInstance(instance);
mScene = new0 Node();
mScene->AttachChild(mCube);
}
