void Dialog::draw(GraphicsDevice *gfxDevice, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState){
drawSoftBorderQuad(gfxDevice, linearClamp, blendSrcAlpha, depthState, xPos, yPos, xPos + width, yPos + height, borderWidth, 1, 1);
vec4 black(0, 0, 0, 1);
vec4 blue(0.3f, 0.4f, 1.0f, 0.65f);
float x = xPos + 2 * borderWidth;
float y = yPos + 2 * borderWidth;
for (uint i = 0; i < tabs.getCount(); i++){
float tabWidth = 0.75f * tabHeight;
float cw = gfxDevice->getTextWidth(defaultFont, tabs[i]->caption);
float newX = x + tabWidth * cw + 6;
if (i == currTab){
vec2 quad[] = { MAKEQUAD(x, y, newX, y + tabHeight, 2) };
gfxDevice->drawPlain(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), blendSrcAlpha, depthState, &blue);
}
vec2 rect[] = { MAKERECT(x, y, newX, y + tabHeight, 2) };
gfxDevice->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
gfxDevice->drawText(tabs[i]->caption, x + 3, y, tabWidth, tabHeight, defaultFont, linearClamp, blendSrcAlpha, depthState);
tabs[i]->rightX = x = newX;
}
vec2 line[] = { MAKEQUAD(xPos + 2 * borderWidth, y + tabHeight - 1, xPos + width - 2 * borderWidth, y + tabHeight + 1, 0) };
gfxDevice->drawPlain(PRIM_TRIANGLE_STRIP, line, elementsOf(line), BS_NONE, depthState, &black);
closeButton->draw(gfxDevice, defaultFont, linearClamp, blendSrcAlpha, depthState);
if (currTab < tabs.getCount()){
DialogTab *tab = tabs[currTab];
if (tab->widgets.goToLast()){
do {
Widget *widget = tab->widgets.getCurrent().widget;
if (widget->isVisible()) widget->draw(gfxDevice, defaultFont, linearClamp, blendSrcAlpha, depthState);
} while (tab->widgets.goToPrev());
}
if (showSelection){
if (tab->widgets.goToFirst()){
Widget *w = tab->widgets.getCurrent().widget;
float x = w->getX();
float y = w->getY();
vec2 rect[] = { MAKERECT(x - 5, y - 5, x + w->getWidth() + 5, y + w->getHeight() + 5, 1) };
gfxDevice->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
}
}
}
}
void Slider::draw(Renderer *renderer, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState){
vec4 black(0, 0, 0, 1);
vec2 quad[] = { MAKEQUAD(xPos, yPos, xPos + width, yPos + height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), blendSrcAlpha, depthState, &color);
vec2 rect[] = { MAKERECT(xPos, yPos, xPos + width, yPos + height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
vec2 line[] = { MAKEQUAD(xPos + 0.5f * height, yPos + 0.5f * height - 1, xPos + width - 0.5f * height, yPos + 0.5f * height + 1, 0) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, line, elementsOf(line), BS_NONE, depthState, &black);
float x = lerp(xPos + 0.5f * height, xPos + width - 0.5f * height, (value - minValue) / (maxValue - minValue));
vec2 marker[] = { MAKEQUAD(x - 0.2f * height, yPos + 0.2f * height, x + 0.2f * height, yPos + 0.8f * height, 0) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, marker, elementsOf(marker), BS_NONE, depthState, &black);
}
void CheckBox::draw(Renderer *renderer, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState){
if (check == TEXTURE_NONE){
uint32 checkPic[] = {
0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xf5ffffff,0x9744619d,0xffffffff,0xffffffff,
0x25d8ffff,0xce1a0000,0xffffffff,0xffffffff,0x001adeff,0xffd81a00,0xffffffff,0xffffffff,0x00002aef,0xffffd81a,
0xffffffff,0xfcffffff,0x1000004a,0xffffffd5,0xffffffff,0x7cffffff,0xc9090000,0xffffffff,0xffffffff,0x01b3ffff,
0xffb30400,0xffffffff,0xf6d6f5ff,0x0011deff,0xffff9300,0xffffffff,0x6b000fa8,0x000035f6,0xffffff67,0xffffffff,
0x0c00004b,0x39000055,0xfffffff9,0xffffffff,0x00000075,0xe0130000,0xffffffff,0xffffffff,0x000000c9,0xffaf0000,
0xffffffff,0xffffffff,0x000034ff,0xffff5c00,0xffffffff,0xffffffff,0x4b5bdaff,0xfffff575,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
};
Image img;
img.loadFromMemory(checkPic, FORMAT_I8, 16, 16, 1, 1, false);
img.convert(FORMAT_RGBA8); // For DX10
check = renderer->addTexture(img, false, linearClamp);
}
if (checked){
TexVertex quad[] = { MAKETEXQUAD(xPos, yPos + 0.2f * height, xPos + 0.6f * height, yPos + 0.8f * height, 3) };
renderer->drawTextured(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), check, linearClamp, BS_NONE, depthState);
} else {
vec2 quad[] = { MAKEQUAD(xPos, yPos + 0.2f * height, xPos + 0.6f * height, yPos + 0.8f * height, 3) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), BS_NONE, depthState);
}
vec2 rect[] = { MAKERECT(xPos, yPos + 0.2f * height, xPos + 0.6f * height, yPos + 0.8f * height, 3) };
vec4 black(0, 0, 0, 1);
renderer->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
float textWidth = 0.75f * height;
float w = width - 0.7f * height;
float tw = renderer->getTextWidth(defaultFont, text);
float maxW = w / tw;
if (textWidth > maxW) textWidth = maxW;
float x = 0.7f * height;
renderer->drawText(text, xPos + x, yPos, textWidth, height, defaultFont, linearClamp, blendSrcAlpha, depthState);
}
void PushButton::drawButton(Renderer *renderer, const char *text, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState){
vec4 black(0, 0, 0, 1);
vec4 col = color;
if (pushed) col *= vec4(0.5f, 0.5f, 0.5f, 1);
vec2 quad[] = { MAKEQUAD(xPos, yPos, xPos + width, yPos + height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), blendSrcAlpha, depthState, &col);
vec2 rect[] = { MAKERECT(xPos, yPos, xPos + width, yPos + height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
float textWidth = 0.75f * height;
float tw = renderer->getTextWidth(defaultFont, text);
float maxW = width / tw;
if (textWidth > maxW) textWidth = maxW;
float x = 0.5f * (width - textWidth * tw);
renderer->drawText(text, xPos + x, yPos, textWidth, height, defaultFont, linearClamp, blendSrcAlpha, depthState);
}
VertexFormatID FW3ShadersFactory::GetVertexFormat(tShape aShape, const ShaderID shd)
{
VertexFormatID newvf;
std::map<tShape, VertexFormatID>::iterator it;
it = m_FW3ShadersFactory_VertexFormatcache.find(tShape(aShape));
if (it != m_FW3ShadersFactory_VertexFormatcache.end())
newvf=it->second;
else
{
switch(aShape)
{
case eTexturedBox:
{
FormatDesc format[] =
{
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_NORMAL, FORMAT_FLOAT, 3,
0, TYPE_TEXCOORD, FORMAT_FLOAT, 2
};
newvf = IRenderer::GetRendererInstance()->addVertexFormat(format, elementsOf(format), shd);
break;
}
case eBox:
case eSphere:
case eCylinder:
{
FormatDesc format[] =
{
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_NORMAL, FORMAT_FLOAT, 3
};
newvf = IRenderer::GetRendererInstance()->addVertexFormat(format, elementsOf(format), shd);
break;
}
};
m_FW3ShadersFactory_VertexFormatcache.insert ( std::pair<tShape,VertexFormatID>(tShape(aShape),newvf) );
}
return newvf;
}
void PortalArea::CreateBuffers()
{
FormatDesc vbFmt[] = {
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_NORMAL, FORMAT_FLOAT, 3,
0, TYPE_TANGENT, FORMAT_FLOAT, 3,
0, TYPE_BINORMAL,FORMAT_FLOAT, 3,
0, TYPE_TEXCOORD, FORMAT_FLOAT, 2,
//0, TYPE_COLOR, FORMAT_FLOAT, 4,
};
m_shader = gColor;
m_vf = gRenderer->addVertexFormat(vbFmt, elementsOf(vbFmt), m_shader);
/*rd.vf = gRenderer->addVertexFormat(vbFmt, elementsOf(vbFmt), rd.shader);
rd.vb = gRenderer->addVertexBuffer(sizeof(GridVertex) * numVertices , STATIC, pVerts);
rd.ib = gRenderer->addIndexBuffer(numIndices, sizeof(WORD), STATIC, pIndices);*/
std::vector<VertexPNTBUV> vertices;
std::vector<uint16> indices;
VertexPNTBUV temp;
int index = 0;
int baseIndex = 0;
std::map<const idMaterial*, std::vector<BatchGeom*> >::iterator itr = mBatches.begin();
for (; itr != mBatches.end(); itr++) {
std::vector<BatchGeom*> Batches = itr->second;
vertices.clear();
indices.clear();
baseIndex = 0;
for(size_t i=0; i < Batches.size(); i++) {
for (size_t j=0; j < Batches.at(i)->get_vertex_count(); j++) {
temp.pos = Batches.at(i)->get_vertex(j);
temp.norm = Batches.at(i)->get_normal(j);
temp.uv = Batches.at(i)->get_texcoord(j);
temp.tangent = Batches.at(i)->get_tangent_s(j);
temp.binormal = Batches.at(i)->get_tangent_t(j);
vertices.push_back(temp);
}
uint16* index = Batches.at(i)->get_indices();
for ( int k=0; k < Batches.at(i)->get_index_count(); k++) {
indices.push_back(baseIndex + index[k]);
}
baseIndex += Batches.at(i)->get_index_count();
}
if (vertices.size() > 0) {
m_vb = gRenderer->addVertexBuffer(sizeof(VertexPNTBUV) * vertices.size(), STATIC, &vertices[0]);
m_ib = gRenderer->addIndexBuffer(baseIndex, sizeof(WORD), STATIC, &indices[0]);
}
}
}
void DropDownList::draw(Renderer *renderer, const FontID defaultFont, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState){
vec4 col = enabled? color : vec4(color.xyz() * 0.5f, 1);
vec4 black(0, 0, 0, 1);
vec2 quad[] = { MAKEQUAD(xPos, yPos, xPos + width, yPos + height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), blendSrcAlpha, depthState, &col);
vec2 rect[] = { MAKERECT(xPos, yPos, xPos + width, yPos + height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
vec2 line0[] = { MAKEQUAD(xPos + width - height, yPos + 2, xPos + width - height + 2, yPos + height - 2, 0) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, line0, elementsOf(line0), BS_NONE, depthState, &black);
vec2 line1[] = { MAKEQUAD(xPos + width - height + 1, yPos + 0.5f * height - 1, xPos + width - 2, yPos + 0.5f * height + 1, 0) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, line1, elementsOf(line1), BS_NONE, depthState, &black);
vec2 triangles[] = {
vec2(xPos + width - 0.5f * height, yPos + 0.1f * height),
vec2(xPos + width - 0.2f * height, yPos + 0.4f * height),
vec2(xPos + width - 0.8f * height, yPos + 0.4f * height),
vec2(xPos + width - 0.5f * height, yPos + 0.9f * height),
vec2(xPos + width - 0.8f * height, yPos + 0.6f * height),
vec2(xPos + width - 0.2f * height, yPos + 0.6f * height),
};
renderer->drawPlain(PRIM_TRIANGLES, triangles, elementsOf(triangles), BS_NONE, depthState, &black);
float textWidth = 0.75f * height;
float w = width - 1.3f * height;
if (selectedItem >= 0){
float tw = renderer->getTextWidth(defaultFont, items[selectedItem]);
float maxW = w / tw;
if (textWidth > maxW) textWidth = maxW;
renderer->drawText(items[selectedItem], xPos + 0.15f * height, yPos, textWidth, height, defaultFont, linearClamp, blendSrcAlpha, depthState);
}
if (isDroppedDown){
vec2 quad[] = { MAKEQUAD(xPos, yPos - selectedItem * height, xPos + width - height + 2, yPos + (items.getCount() - selectedItem) * height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, quad, elementsOf(quad), blendSrcAlpha, depthState, &col);
vec2 rect[] = { MAKERECT(xPos, yPos - selectedItem * height, xPos + width - height + 2, yPos + (items.getCount() - selectedItem) * height, 2) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, rect, elementsOf(rect), BS_NONE, depthState, &black);
for (uint i = 0; i < items.getCount(); i++){
float tw = renderer->getTextWidth(defaultFont, items[i]);
float maxW = w / tw;
if (textWidth > maxW) textWidth = maxW;
renderer->drawText(items[i], xPos + 0.15f * height, yPos + (int(i) - selectedItem) * height, textWidth, height, defaultFont, linearClamp, blendSrcAlpha, depthState);
}
}
}
void InitCUSTOMVERTEX2DW(ShaderID& s, VertexFormatID& vf)
{
if(vf==-1)
{
const char *texSHD = IndieLibShadersFactory::GetShader("texSHD3");
s = IRenderer::GetRendererInstance()->addHLSLShader(texSHD, "main", "main");
FormatDesc format[] =
{
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_TEXCOORD, FORMAT_FLOAT, 2,
}
;
vf = IRenderer::GetRendererInstance()->addVertexFormat(format, elementsOf(format), s);
}
}
void VCloudSkySystem::create()
{
if (mCreated)
{
return;
}
linearWarp = GetRenderer()->addSamplerState(TRILINEAR_ANISO, WRAP, WRAP, WRAP);
// Load Skydom Shader
mSkydomeShader = GetApp()->getRenderer()->addShader("Data/Shaders/SkyDome.hlsl");
mCloudShader = GetApp()->getRenderer()->addShader("Data/Shaders/Clouds.hlsl");
FormatDesc vf_format[] = {
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_TEXCOORD, FORMAT_FLOAT, 3,
};
mCloudVF = GetRenderer()->addVertexFormat(vf_format, elementsOf(vf_format), mCloudShader);
mDiffuseTex = GetRenderer()->addTexture("Textures/Clouds.png", true);
mNormalTex = GetRenderer()->addTexture("Textures/CloudsNormal.png", true);
mTileTex = GetRenderer()->addTexture("Textures/CloudsTile.png", true);
mStarfieldTex = GetRenderer()->addTexture("Textures/Starfield.png", true);
mMeshManager->setMaterial(mSkydomeShader);
mMeshManager->create();
mAtmosphereManager->_update(mAtmosphereManager->getOptions(), true);
mMoonManager->create();
setVisible(mVisible);
mLastCameraPosition = noVec3(0,0,0);
mLastCameraFarClipDistance = -1;
//mVCloudsManager->create(-1);
mCreated = true;
}
bool D3D11App::Create()
{
// If the sample didn't create a context already, the framework creates a default one
if (m_context == NULL)
{
m_context = new D3D11Context();
if (!m_context->Create(_T("Sample"), DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D16_UNORM, 1280, 720, 1, false)) return false;
}
// Load the font
if (FAILED(m_mainFont.LoadFont(m_context->GetDevice(), FONT_PATH _T("Future.dds"), FONT_PATH _T("Future.font")))) return false;
// Tool resources
if ((m_toolsEffect = m_context->LoadEffect(SHADER_PATH _T("Tools.fx"))) == NULL) return false;
if ((m_toolsVsCB = m_context->CreateEffectConstantBuffer(m_toolsEffect, "MainVS")) == NULL) return false;
if ((m_toolsPsCB = m_context->CreateEffectConstantBuffer(m_toolsEffect, "MainPS")) == NULL) return false;
D3D11_INPUT_ELEMENT_DESC layout0[] =
{
{ "SV_Position", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
if ((m_pos3Layout = m_context->CreateInputLayout(m_toolsEffect->GetTechniqueByIndex(0)->GetPassByIndex(0), layout0, elementsOf(layout0))) == NULL) return false;
D3D11_INPUT_ELEMENT_DESC layout1[] =
{
{ "SV_Position", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TexCoord", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
if ((m_pos2Tex3Layout = m_context->CreateInputLayout(m_toolsEffect->GetTechniqueByIndex(2)->GetPassByIndex(0), layout1, elementsOf(layout1))) == NULL) return false;
ResetCamera();
return true;
}
static void collectMonitorInfo()
{
DISPLAY_DEVICEW adapter;
adapter.cb = sizeof(adapter);
int found = 0;
int size = 0;
for (int adapterIndex = 0;; ++adapterIndex)
{
if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
break;
if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
continue;
for (int displayIndex = 0; ; displayIndex++)
{
DISPLAY_DEVICEW display;
HDC dc;
display.cb = sizeof(display);
if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
break;
dc = CreateDCW(L"DISPLAY", adapter.DeviceName, NULL, NULL);
MonitorDesc desc;
desc.modesPruned = (adapter.StateFlags & DISPLAY_DEVICE_MODESPRUNED) != 0;
wcsncpy_s(desc.adapterName, adapter.DeviceName, elementsOf(adapter.DeviceName));
wcsncpy_s(desc.publicAdapterName, adapter.DeviceName, elementsOf(adapter.DeviceName));
wcsncpy_s(desc.displayName, display.DeviceName, elementsOf(display.DeviceName));
wcsncpy_s(desc.publicDisplayName, display.DeviceName, elementsOf(display.DeviceName));
gMonitors.push_back(desc);
EnumDisplayMonitors(NULL, NULL, monitorCallback, gMonitors.size() - 1);
DeleteDC(dc);
if ((adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) && displayIndex == 0)
{
MonitorDesc desc = gMonitors[0];
gMonitors[0] = gMonitors[found];
gMonitors[found] = desc;
}
found++;
}
}
for (uint32_t monitor = 0; monitor < (uint32_t)gMonitors.size(); ++monitor)
{
MonitorDesc* pMonitor = &gMonitors[monitor];
DEVMODEW devMode = {};
devMode.dmSize = sizeof(DEVMODEW);
devMode.dmFields = DM_PELSHEIGHT | DM_PELSWIDTH;
EnumDisplaySettingsW(pMonitor->adapterName, ENUM_CURRENT_SETTINGS, &devMode);
pMonitor->defaultResolution.mHeight = devMode.dmPelsHeight;
pMonitor->defaultResolution.mWidth = devMode.dmPelsWidth;
tinystl::vector<Resolution> displays;
DWORD current = 0;
while (EnumDisplaySettingsW(pMonitor->adapterName, current++, &devMode))
{
bool duplicate = false;
for (uint32_t i = 0; i < (uint32_t)displays.size(); ++i)
{
if (displays[i].mWidth == (uint32_t)devMode.dmPelsWidth && displays[i].mHeight == (uint32_t)devMode.dmPelsHeight)
{
duplicate = true;
break;
}
}
if (duplicate)
continue;
Resolution videoMode = {};
videoMode.mHeight = devMode.dmPelsHeight;
videoMode.mWidth = devMode.dmPelsWidth;
displays.emplace_back(videoMode);
}
qsort(displays.data(), displays.size(), sizeof(Resolution), [](const void* lhs, const void* rhs) {
Resolution* pLhs = (Resolution*)lhs;
Resolution* pRhs = (Resolution*)rhs;
if (pLhs->mHeight == pRhs->mHeight)
return (int)(pLhs->mWidth - pRhs->mWidth);
return (int)(pLhs->mHeight - pRhs->mHeight);
});
pMonitor->resolutionCount = (uint32_t)displays.size();
pMonitor->resolutions = (Resolution*)conf_calloc(pMonitor->resolutionCount, sizeof(Resolution));
memcpy(pMonitor->resolutions, displays.data(), pMonitor->resolutionCount * sizeof(Resolution));
}
}
bool BaseApp::onKey(const uint key, const bool pressed){
//#if defined(DEBUG) && defined(WIN32)
#ifdef WIN32
if (pressed && key == KEY_F12){
if (OpenClipboard(hwnd)){
EmptyClipboard();
char str[256];
int len = sprintf(str, "camPos = vec3(%.15ff, %.15ff, %.15ff);\r\nwx = %.15ff;\r\nwy = %.15ff;\r\n", camPos.x, camPos.y, camPos.z, wx, wy);
HGLOBAL handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 1);
char *mem = (char *) GlobalLock(handle);
if (mem != NULL){
strcpy(mem, str);
GlobalUnlock(handle);
SetClipboardData(CF_TEXT, handle);
}
CloseClipboard();
}
}
#endif
if (pressed && key == screenshotKey){
if (!saveScreenshot()){
ErrorMsg("Couldn't save screenshot");
}
return true;
}
if (pressed && key == benchmarkKey){
if (benchMarkFile){
fclose(benchMarkFile);
benchMarkFile = NULL;
} else {
benchMarkFile = fopen("Benchmark.xls", "w");
fprintf(benchMarkFile, "Frames/s\n");
}
return true;
}
bool processed = false;
if (!mouseCaptured){
if (widgets.goToFirst()){
do {
Widget *widget = widgets.getCurrent();
if (widget->isVisible() || widget->isCapturing()){
widgets.moveCurrentToTop();
processed = widget->onKey(key, pressed);
break;
}
} while (widgets.goToNext());
}
}
if (!processed){
if (pressed){
processed = true;
if (key == KEY_ESCAPE){
if (!mouseCaptured || (fullscreen && mouseCaptured)){
closeWindow(true, true);
} else {
captureMouse(false);
}
} else if (key == fpsKey){
showFPS = !showFPS;
} else if (key == resetKey){
resetCamera();
} else if (key == optionsKey){
if (configDialog->isVisible()){
configDialog->setVisible(false);
if (keysDialog) keysDialog->setVisible(false);
if (joystickDialog) joystickDialog->setVisible(false);
} else {
captureMouse(false);
configDialog->setVisible(true);
if (keysDialog) keysDialog->setVisible(true);
if (joystickDialog) joystickDialog->setVisible(true);
}
} else {
processed = false;
}
}
}
if (key < elementsOf(keys)) keys[key] = pressed;
return processed;
}
bool OpenGLApp::initAPI(){
if (screen >= GetSystemMetrics(SM_CMONITORS)) screen = 0;
int monitorCounter = screen;
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM) &monitorCounter);
// TODO: Use this when saving out position?
// HMONITOR hMonitor = MonitorFromWindow(m_handle->hWnd, MONITOR_DEFAULTTOPRIMARY);
DWORD flags = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
int x, y;
x = monInfo.rcMonitor.left;
y = monInfo.rcMonitor.top;
device.cb = sizeof(device);
//TODO: Monitor count is not equal to device count?
EnumDisplayDevices(NULL, 0/*screen*/, &device, 0);
DEVMODE dm, tdm;
memset(&dm, 0, sizeof(dm));
dm.dmSize = sizeof(dm);
dm.dmBitsPerPel = colorBits;
dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
dm.dmPelsWidth = fullscreenWidth;
dm.dmPelsHeight = fullscreenHeight;
dm.dmDisplayFrequency = 60;
// Find a suitable fullscreen format
int i = 0;
int targetHz = 85;
char str[128];
resolution->clear();
while (EnumDisplaySettings((const char *) device.DeviceName, i, &tdm)){
if (int(tdm.dmBitsPerPel) == colorBits && tdm.dmPelsWidth >= 640 && tdm.dmPelsHeight >= 480){
sprintf(str, "%dx%d", tdm.dmPelsWidth, tdm.dmPelsHeight);
int index = resolution->addItemUnique(str);
if (int(tdm.dmPelsWidth) == fullscreenWidth && int(tdm.dmPelsHeight) == fullscreenHeight){
if (abs(int(tdm.dmDisplayFrequency) - targetHz) < abs(int(dm.dmDisplayFrequency) - targetHz)){
dm = tdm;
}
resolution->selectItem(index);
}
}
i++;
}
if (fullscreen){
//TODO: Select correct monitor?
//dm.dmFields |= DM_POSITION ;
//dm.dmPosition.x = x;
//dm.dmPosition.y = y;
if (ChangeDisplaySettingsEx((const char *) device.DeviceName, &dm, NULL, CDS_FULLSCREEN, NULL) == DISP_CHANGE_SUCCESSFUL){
flags |= WS_POPUP;
captureMouse(!configDialog->isVisible());
} else {
ErrorMsg("Couldn't set fullscreen mode");
fullscreen = false;
}
}
sprintf(str, "%s (%dx%d)", getTitle(), width, height);
if (!fullscreen){
flags |= WS_OVERLAPPEDWINDOW;
RECT wRect;
wRect.left = 0;
wRect.right = width;
wRect.top = 0;
wRect.bottom = height;
AdjustWindowRect(&wRect, flags, FALSE);
width = min(wRect.right - wRect.left, monInfo.rcWork.right - monInfo.rcWork.left);
height = min(wRect.bottom - wRect.top, monInfo.rcWork.bottom - monInfo.rcWork.top);
x = (monInfo.rcWork.left + monInfo.rcWork.right - width ) / 2;
y = (monInfo.rcWork.top + monInfo.rcWork.bottom - height) / 2;
}
hwnd = CreateWindow("Humus", str, flags, x, y, width, height, HWND_DESKTOP, NULL, hInstance, NULL);
PIXELFORMATDESCRIPTOR pfd = {
sizeof (PIXELFORMATDESCRIPTOR), 1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, colorBits,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
depthBits, stencilBits,
0, PFD_MAIN_PLANE, 0, 0, 0, 0
};
hdc = GetDC(hwnd);
int iAttribs[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_RED_BITS_ARB, 8,
WGL_GREEN_BITS_ARB, 8,
WGL_BLUE_BITS_ARB, 8,
WGL_ALPHA_BITS_ARB, (colorBits > 24)? 8 : 0,
WGL_DEPTH_BITS_ARB, depthBits,
WGL_STENCIL_BITS_ARB, stencilBits,
0
};
int pixelFormats[256];
int bestFormat = 0;
int bestSamples = 0;
uint nPFormats;
if (wgl_ext_ARB_pixel_format && wglChoosePixelFormatARB(hdc, iAttribs, NULL, elementsOf(pixelFormats), pixelFormats, &nPFormats) && nPFormats > 0){
int minDiff = 0x7FFFFFFF;
int attrib = WGL_SAMPLES_ARB;
int samples;
// Find a multisample format as close as possible to the requested
for (uint i = 0; i < nPFormats; i++){
wglGetPixelFormatAttribivARB(hdc, pixelFormats[i], 0, 1, &attrib, &samples);
int diff = abs(antiAliasSamples - samples);
if (diff < minDiff){
minDiff = diff;
bestFormat = i;
bestSamples = samples;
}
}
} else {
pixelFormats[0] = ChoosePixelFormat(hdc, &pfd);
}
antiAliasSamples = bestSamples;
SetPixelFormat(hdc, pixelFormats[bestFormat], &pfd);
if(wgl_ext_ARB_create_context)
{
glContext = wglCreateContextAttribsARB(hdc, 0, 0);
}
else
{
glContext = wglCreateContext(hdc);
}
wglMakeCurrent(hdc, glContext);
ogl_LoadFunctions();
wgl_LoadFunctions(hdc);
if (wgl_ext_ARB_multisample && antiAliasSamples > 0){
glEnable(GL_MULTISAMPLE);
}
if (fullscreen) captureMouse(!configDialog->isVisible());
renderer = new OpenGLRenderer(hdc, glContext);
renderer->setViewport(width, height);
antiAlias->selectItem(antiAliasSamples / 2);
linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP);
defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp);
blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA);
noDepthTest = renderer->addDepthState(false, false);
noDepthWrite = renderer->addDepthState(true, false);
cullNone = renderer->addRasterizerState(CULL_NONE);
cullBack = renderer->addRasterizerState(CULL_BACK);
cullFront = renderer->addRasterizerState(CULL_FRONT);
return true;
}
void M2Object::LoadModelData()
{
if (animGeom)
{
/*char def[256];
sprintf(def, "#define MATRIX_PALETTE_SIZE_DEFAULT %d\n", header.nBones);
render_data[0].shader = renderer->addShader("Data/Shaders/skinnedShader.hlsl", def);*/
//render_data[0].shader = renderer->addShader("Data/Shaders/SkinColorPSSM.hlsl", def);
switch (AppSettings::ShadowModeEnum)
{
case SHADOW_PSSM:
render_data[0].shader = gSkinnedColorPssm;
break;
case SHADOW_NONE:
render_data[0].shader = gSkinned;
break;
case SHADOW_SSAO:
render_data[0].shader = gSkinnedColorSsao;
break;
}
FormatDesc vbFmt[] = {
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_NORMAL, FORMAT_FLOAT, 3,
0, TYPE_TEXCOORD, FORMAT_FLOAT, 2,
0, TYPE_BONES, FORMAT_FLOAT, 4,
0, TYPE_WEIGHTS, FORMAT_FLOAT, 4,
};
for (int i = 0; i < elementsOf(vbFmt); ++i)
{
vertexStride +=vbFmt[i].size * renderer->getFormatSize(vbFmt[i].format);
}
if ((render_data[0].vf = renderer->addVertexFormat(vbFmt, elementsOf(vbFmt), render_data[0].shader)) == VF_NONE) return;
if ((render_data[0].diffuseSampler = renderer->addSamplerState(LINEAR, WRAP, WRAP, WRAP)) == SS_NONE) return;
int32 numVerts = this->numVertices;
SkinnedVertexPNT* pVerts = new SkinnedVertexPNT[numVerts];
for (uint32 i = 0; i < this->numVertices; ++i)
{
pVerts[i].position = vertDatas[i].pos;
float y = vertDatas[i].texcoords.y;
if (modelType != MT_CHAR)
y = 1.0f - vertDatas[i].texcoords.y;;
pVerts[i].texcoord0 = noVec2(vertDatas[i].texcoords.x, y);
pVerts[i].normal = vertDatas[i].normal;
for (uint32 x = 0; x < 4; ++x)
{
pVerts[i].bones[x] = vertDatas[i].bones[x];
pVerts[i].weights[x] = vertDatas[i].weights[x] / 255.f;
}
}
render_data[0].vb = renderer->addVertexBuffer(sizeof(SkinnedVertexPNT) * this->numVertices , STATIC, pVerts);
render_data[0].ib = renderer->addIndexBuffer(this->nIndices, sizeof(WORD), STATIC, this->indices);
//SkinnedVertex
delete [] pVerts;
}
else
{
switch (AppSettings::ShadowModeEnum)
{
case SHADOW_PSSM:
render_data[0].shader = gColorPssm;
break;
case SHADOW_NONE:
render_data[0].shader = gColor;
break;
case SHADOW_SSAO:
render_data[0].shader = gColorSsao;
break;
}
FormatDesc vbFmt[] = {
0, TYPE_VERTEX, FORMAT_FLOAT, 3,
0, TYPE_NORMAL, FORMAT_FLOAT, 3,
0, TYPE_TEXCOORD, FORMAT_FLOAT, 2,
};
for (int i = 0; i < elementsOf(vbFmt); ++i)
{
vertexStride +=vbFmt[i].size * renderer->getFormatSize(vbFmt[i].format);
}
if ((render_data[0].vf = renderer->addVertexFormat(vbFmt, elementsOf(vbFmt), render_data[0].shader)) == VF_NONE) return;
if ((render_data[0].diffuseSampler = renderer->addSamplerState(LINEAR, WRAP, WRAP, WRAP)) == SS_NONE) return;
/*for (size_t i=0; i < this->TextureList.size(); i++)
{
std::string texturename = this->TextureList.at(i) + ".tga";
render_data[0].baseTex.push_back(renderer->addTexture(texturename.c_str(), true, render_data[0].linear));
}*/
int32 numVerts = this->numVertices;
RenderVertexPNUV* pVerts = new RenderVertexPNUV[numVerts];
for (uint32 i = 0; i < this->numVertices; ++i)
{
pVerts[i].position = vertDatas[i].pos;//this->vertices[i];
pVerts[i].normal = vertDatas[i].normal;
pVerts[i].texcoord0 = noVec2(this->texCoords[i].x, 1.f - this->texCoords[i].y);
}
render_data[0].vb = renderer->addVertexBuffer(sizeof(RenderVertexPNUV) * this->numVertices , STATIC, pVerts);
render_data[0].ib = renderer->addIndexBuffer(this->nIndices, sizeof(WORD), STATIC, this->indices);
render_data[0].vertexStart = 0;
render_data[0].vertexEnd = numVerts;
render_data[0].startIndex = 0;
render_data[0].endIndex = this->nIndices;
delete [] pVerts;
}
}
void App::drawFrame(){
const float near_plane = 20.0f;
const float far_plane = 4000.0f;
// Reversed depth
float4x4 projection = toD3DProjection(perspectiveMatrixY(1.2f, width, height, far_plane, near_plane));
float4x4 view = rotateXY(-wx, -wy);
view.translate(-camPos);
float4x4 viewProj = projection * view;
// Pre-scale-bias the matrix so I can use the screen position directly
float4x4 viewProjInv = (!viewProj) * (translate(-1.0f, 1.0f, 0.0f) * scale(2.0f / width, -2.0f / height, 1.0f));
TextureID bufferRTs[] = { baseRT, normalRT };
renderer->changeRenderTargets(bufferRTs, elementsOf(bufferRTs), depthRT);
renderer->clear(false, true, false, NULL, 0.0f);
/*
Main scene pass.
This is where the buffers are filled for the later deferred passes.
*/
renderer->reset();
renderer->setRasterizerState(cullBack);
renderer->setShader(fillBuffers);
renderer->setShaderConstant4x4f("viewProj", viewProj);
renderer->setShaderConstant3f("camPos", camPos);
renderer->setSamplerState("baseFilter", trilinearAniso);
renderer->setDepthState(depthTest);
renderer->apply();
for (uint i = 0; i < map->getBatchCount(); i++){
renderer->setTexture("Base", base[i]);
renderer->setTexture("Bump", bump[i]);
renderer->applyTextures();
map->drawBatch(renderer, i);
}
renderer->changeToMainFramebuffer();
int mode = renderMode->getSelectedItem();
/*
Deferred ambient pass
*/
renderer->reset();
renderer->setRasterizerState(cullNone);
renderer->setShader(ambient);
renderer->setShaderConstant2f("factors", float2((mode == 3)? 0.0f : 0.1f, (mode == 3)? 1.0f : 0.0f));
renderer->setTexture("Base", baseRT);
if (antiAliasSamples == 1)
renderer->setSamplerState("filter", pointClamp);
renderer->setDepthState(noDepthTest);
renderer->apply();
context->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
context->Draw(3, 0);
if (mode == 3)
return;
renderer->changeRenderTargets(NULL, 0, stencilMask);
renderer->clear(false, true, true, NULL, 0.0f, 0);
/*
Create the stencil mask
*/
renderer->reset();
renderer->setRasterizerState(cullNone);
renderer->setShader(createMask);
renderer->setTexture("BackBuffer", backBufferTexture);
renderer->setSamplerState("filter", pointClamp);
renderer->setDepthState(stencilSet, 0x1);
renderer->apply();
context->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
context->Draw(3, 0);
renderer->changeRenderTarget(FB_COLOR, stencilMask);
/*
Deferred lighting pass.
Draw twice, using stencil to separate pixels for single or multiple sample evaluation.
*/
float2 zw = projection.rows[2].zw();
int passCount = (mode == 0 && antiAliasSamples > 1)? 2 : 1;
for (int p = 0; p < passCount; p++){
renderer->reset();
if (mode == 0 && antiAliasSamples > 1){
renderer->setDepthState(stencilTest, (p == 0)? 0x1 : 0x0);
renderer->setShader(lighting[p]);
} else {
renderer->setDepthState(noDepthTest);
if (mode == 1){
renderer->setShader(lighting[0]);
} else {
renderer->setShader(lighting[1]);
}
}
renderer->setRasterizerState(cullFront);
renderer->setBlendState(blendAdd);
renderer->setShaderConstant4x4f("viewProj", viewProj);
renderer->setShaderConstant4x4f("viewProjInv", viewProjInv);
renderer->setShaderConstant3f("camPos", camPos);
renderer->setTexture("Base", baseRT);
renderer->setTexture("Normal", normalRT);
renderer->setTexture("Depth", depthRT);
renderer->apply();
for (uint i = 0; i < LIGHT_COUNT; i++){
float3 lightPos = lights[i].position;
float radius = lights[i].radius;
float invRadius = 1.0f / radius;
// Compute z-bounds
float4 lPos = view * float4(lightPos, 1.0f);
float z1 = lPos.z + radius;
if (z1 > near_plane){
float z0 = max(lPos.z - radius, near_plane);
float2 zBounds;
zBounds.y = saturate(zw.x + zw.y / z0);
zBounds.x = saturate(zw.x + zw.y / z1);
renderer->setShaderConstant3f("lightPos", lightPos);
renderer->setShaderConstant1f("radius", radius);
renderer->setShaderConstant1f("invRadius", invRadius);
renderer->setShaderConstant2f("zBounds", zBounds);
renderer->applyConstants();
sphere->draw(renderer);
}
}
}
// Display help text
static float displayTime = 5.0f;
if (displayTime > 0 && antiAliasSamples <= 1){
if (configDialog->isVisible()){
displayTime = 0;
} else {
displayTime -= min(frameTime, 0.1f);
renderer->drawText("Press F1 to select\na multisampled mode", width * 0.5f - 140, height * 0.5f - 38, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest);
}
}
}
void Widget::drawSoftBorderQuad(Renderer *renderer, const SamplerStateID linearClamp, const BlendStateID blendSrcAlpha, const DepthStateID depthState, const float x0, const float y0, const float x1, const float y1, const float borderWidth, const float colScale, const float transScale){
if (corner == TEXTURE_NONE){
ubyte pixels[32][32][4];
for (int y = 0; y < 32; y++){
for (int x = 0; x < 32; x++){
int r = 255 - int(powf(sqrtf(float(x * x + y * y)) * (255.0f / 31.0f), 1.0f));
if (r < 0) r = 0;
pixels[y][x][0] = r;
pixels[y][x][1] = r;
pixels[y][x][2] = r;
pixels[y][x][3] = r;
}
}
Image img;
img.loadFromMemory(pixels, FORMAT_RGBA8, 32, 32, 1, 1, false);
corner = renderer->addTexture(img, false, linearClamp);
}
float x0bw = x0 + borderWidth;
float y0bw = y0 + borderWidth;
float x1bw = x1 - borderWidth;
float y1bw = y1 - borderWidth;
TexVertex border[] = {
TexVertex(vec2(x0, y0bw), vec2(1, 0)),
TexVertex(vec2(x0, y0 ), vec2(1, 1)),
TexVertex(vec2(x0bw, y0bw), vec2(0, 0)),
TexVertex(vec2(x0bw, y0 ), vec2(0, 1)),
TexVertex(vec2(x1bw, y0bw), vec2(0, 0)),
TexVertex(vec2(x1bw, y0 ), vec2(0, 1)),
TexVertex(vec2(x1bw, y0 ), vec2(0, 1)),
TexVertex(vec2(x1, y0 ), vec2(1, 1)),
TexVertex(vec2(x1bw, y0bw), vec2(0, 0)),
TexVertex(vec2(x1, y0bw), vec2(1, 0)),
TexVertex(vec2(x1bw, y1bw), vec2(0, 0)),
TexVertex(vec2(x1, y1bw), vec2(1, 0)),
TexVertex(vec2(x1, y1bw), vec2(1, 0)),
TexVertex(vec2(x1, y1 ), vec2(1, 1)),
TexVertex(vec2(x1bw, y1bw), vec2(0, 0)),
TexVertex(vec2(x1bw, y1 ), vec2(0, 1)),
TexVertex(vec2(x0bw, y1bw), vec2(0, 0)),
TexVertex(vec2(x0bw, y1 ), vec2(0, 1)),
TexVertex(vec2(x0bw, y1 ), vec2(0, 1)),
TexVertex(vec2(x0, y1 ), vec2(1, 1)),
TexVertex(vec2(x0bw, y1bw), vec2(0, 0)),
TexVertex(vec2(x0, y1bw), vec2(1, 0)),
TexVertex(vec2(x0bw, y0bw), vec2(0, 0)),
TexVertex(vec2(x0, y0bw), vec2(1, 0)),
};
vec4 col = color * vec4(colScale, colScale, colScale, transScale);
renderer->drawTextured(PRIM_TRIANGLE_STRIP, border, elementsOf(border), corner, linearClamp, blendSrcAlpha, depthState, &col);
// Center
vec2 center[] = { vec2(x0bw, y0bw), vec2(x1bw, y0bw), vec2(x0bw, y1bw), vec2(x1bw, y1bw) };
renderer->drawPlain(PRIM_TRIANGLE_STRIP, center, 4, blendSrcAlpha, depthState, &col);
}
