Theme::Theme(NVGcontext *ctx) {
mStandardFontSize = 16;
mButtonFontSize = 20;
mTextBoxFontSize = 20;
mWindowCornerRadius = 2;
mWindowHeaderHeight = 30;
mWindowDropShadowSize = 10;
mButtonCornerRadius = 2;
mTabBorderWidth = 0.75f;
mTabInnerMargin = 5;
mTabMinButtonWidth = 20;
mTabMaxButtonWidth = 160;
mTabControlWidth = 20;
mTabButtonHorizontalPadding = 10;
mTabButtonVerticalPadding = 2;
mDropShadow = Color(0, 128);
mTransparent = Color(0, 0);
mBorderDark = Color(29, 255);
mBorderLight = Color(92, 255);
mBorderMedium = Color(35, 255);
mTextColor = Color(255, 160);
mDisabledTextColor = Color(255, 80);
mTextColorShadow = Color(0, 160);
mIconColor = mTextColor;
mButtonGradientTopFocused = Color(64, 255);
mButtonGradientBotFocused = Color(48, 255);
mButtonGradientTopUnfocused = Color(74, 255);
mButtonGradientBotUnfocused = Color(58, 255);
mButtonGradientTopPushed = Color(41, 255);
mButtonGradientBotPushed = Color(29, 255);
/* Window-related */
mWindowFillUnfocused = Color(43, 230);
mWindowFillFocused = Color(45, 230);
mWindowTitleUnfocused = Color(220, 160);
mWindowTitleFocused = Color(255, 190);
mWindowHeaderGradientTop = mButtonGradientTopUnfocused;
mWindowHeaderGradientBot = mButtonGradientBotUnfocused;
mWindowHeaderSepTop = mBorderLight;
mWindowHeaderSepBot = mBorderDark;
mWindowPopup = Color(50, 255);
mWindowPopupTransparent = Color(50, 0);
mFontNormal = nvgCreateFontMem(ctx, "sans", roboto_regular_ttf,
roboto_regular_ttf_size, 0);
mFontBold = nvgCreateFontMem(ctx, "sans-bold", roboto_bold_ttf,
roboto_bold_ttf_size, 0);
mFontIcons = nvgCreateFontMem(ctx, "icons", entypo_ttf,
entypo_ttf_size, 0);
if (mFontNormal == -1 || mFontBold == -1 || mFontIcons == -1)
throw std::runtime_error("Could not load fonts!");
}
int QNanoFont::getID(NVGcontext* nvg)
{
if (m_fontPropertiesChanged) {
nvgFontSize(nvg, m_size);
nvgFontBlur(nvg, m_blur);
nvgTextLetterSpacing(nvg, m_spacing);
nvgTextLineHeight(nvg, m_lineHeight);
}
if (m_filename.isEmpty()) {
// No font file set, so loading the default font
setFontId(QNanoFont::DEFAULT_FONT_NORMAL);
}
m_id = nvgFindFont(nvg,m_filename.toUtf8().constData());
if (m_id == -1) {
// Font is not yet in cache, so load and add it
QFile file(m_filename);
if (!file.open(QFile::ReadOnly))
{
qWarning() << "Could not open font file: " << m_filename;
} else {
qint64 length = file.bytesAvailable();
char * data = static_cast<char*>(malloc(length));
file.read(data,length);
m_id = nvgCreateFontMem(nvg, m_filename.toUtf8().constData(), reinterpret_cast<unsigned char*>(data), length, 1);
file.close();
}
}
return m_id;
}
NvgFont::NvgFont(NVGcontext * nvg, const std::string & name, std::vector<uint8_t> buffer)
{
this->buffer = std::move(buffer);
this->nvg = nvg;
id = nvgCreateFontMem(nvg, name.c_str(), this->buffer.data(), (int) this->buffer.size(), 0);
if (id < 0)
throw std::runtime_error("Failed to load font: " + name);
}
void Renderer2D::createFont2D( string_hash name , pointer_t<void> memory, uint32_t size)
{
const uint32_t index = _fonts.find( name );
if( index == Font2DMap::INVALID )
{
char buf[64];
sprintf(buf,"%u",name.hash());
//string64 hashedName = convert<string_hash, string64>(name);
Font2D font = nvgCreateFontMem( _context2D, buf, memory.as_uint8_t, size, 0 );
//Font2D font = crap::createFont2D( _context2D, name, memory, size );
_fonts.push_back( name, font );
}
}
// 表示の初期化
void caInit(int w, int h)
{
width = w;
height = h;
// Calculate pixel ration for hi-dpi devices.
pixelRatio = (float)width / (float)height;
vg = nvgCreate(NVG_ANTIALIAS);
//nvgCreateFont(vg, "sans-bold", CATGL_ASSETS("Roboto-Bold.ttf"));
nvgCreateFontMem(vg, "sans-bold", mplus1pregular, sizeof(mplus1pregular), 0);
nvgFontFace(vg, "sans-bold");
}
static void loadDefaultFontFace() {
lmLogWarn(gGFXVectorRendererLogGroup, "Warning: TextFormat font face not specified, using predefined default system font");
void* mem;
size_t size;
bool success = readDefaultFontFaceBytes(&mem, &size);
if (!success) {
defaultFontId = VectorTextFormat::FONT_DEFAULTMISSING;
return;
}
int handle = nvgCreateFontMem(nvg, "__default", (unsigned char*)mem, size, true);
if (handle == -1) {
customFree(mem);
defaultFontId = VectorTextFormat::FONT_DEFAULTMEMORY;
return;
}
defaultFontId = handle;
}
int NVGRenderer::createFontMem(const char* name, unsigned char* data, int ndata, int freeData)
{
return nvgCreateFontMem(m_context, name, data, ndata, freeData);
}
void init()
{
vf::skinned_geom_t::vao = createVAO(ARRAY_SIZE(vf::descSkinnedGeom), vf::descSkinnedGeom, 0, NULL);
vf::static_geom_t::vao = createVAO(ARRAY_SIZE(vf::descStaticGeom), vf::descStaticGeom, 0, NULL);
vf::p2_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2), vf::fmtdesc_p2, 0, NULL);
vf::p2uv2_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2uv2), vf::fmtdesc_p2uv2, 0, NULL);
vf::p2uv3_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2uv3), vf::fmtdesc_p2uv3, 0, NULL);
vf::p2cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2cu4), vf::fmtdesc_p2cu4, 0, NULL);
vf::p2uv2cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2uv2cu4), vf::fmtdesc_p2uv2cu4, 0, NULL);
vf::p3_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p3), vf::fmtdesc_p3, 0, NULL);
vf::p3cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p3cu4), vf::fmtdesc_p3cu4, 0, NULL);
vf::p3uv2cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p3uv2cu4), vf::fmtdesc_p3uv2cu4, 0, NULL);
glGenVertexArrays(1, &vf::empty_geom_t::vao);
prgUI = res::createProgramFromFiles("UI.vert", "UI.frag");
prgRasterCubic = res::createProgramFromFiles("VG.Cubic.vert", "VG.Mask.Cubic.frag");
prgRasterCubicAA = res::createProgramFromFiles("VG.Cubic.vert", "VG.Mask.Cubic.AA.frag");
prgPaintSolid = res::createProgramFromFiles("VG.Paint.vert", "VG.Paint.Solid.frag");
prgPaintLinGradient = res::createProgramFromFiles("VG.Paint.vert", "VG.Paint.LinearGradient.frag");
const char* version = "#version 430\n\n";
const char* enableColor = "#define ENABLE_COLOR\n";
const char* enableTexture = "#define ENABLE_TEXTURE\n";
const char* enableVGAA = "#define EDGE_AA 1\n";
const char* headers[3] = {version};
size_t numHeaders;
for (size_t i=0; i<STD_PROGRAM_COUNT; ++i)
{
numHeaders = 1;
if (i&gfx::STD_FEATURE_COLOR)
{
headers[numHeaders++] = enableColor;
}
if (i&gfx::STD_FEATURE_TEXTURE)
{
headers[numHeaders++] = enableTexture;
}
stdPrograms[i] = res::createProgramFromFiles("MESH.std.vert", "MESH.std.frag", numHeaders, headers);
}
headers[1] = enableColor;
prgLine = res::createProgramFromFiles("MESH.Line.vert", "MESH.std.frag", 2, headers);
prgPoint = res::createProgramFromFiles("MESH.Point.vert", "MESH.std.frag", 2, headers);
prgRect = res::createProgramFromFiles("MESH.Rect.vert", "MESH.std.frag", 2, headers);
headers[1] = enableVGAA;
prgNanoVG = res::createProgramFromFiles("NanoVG.vert", "NanoVG.frag", 1, headers);
prgNanoVGAA = res::createProgramFromFiles("NanoVG.vert", "NanoVG.frag", 2, headers);
gfx::vertex_element_t ve[2] = {
{0, 0, 0, GL_FLOAT, 4, GL_FALSE, GL_FALSE},
{1, 0, 1, GL_UNSIGNED_BYTE, 4, GL_FALSE, GL_TRUE },
};
GLuint divs[2] = {1, 1};
vaoRect = gfx::createVAO(2, ve, 2, divs);
vgGArena = etlsf_create(VG_BUFFER_SIZE, GFX_MAX_ALLOCS);
glGenBuffers(1, &buffer);
glNamedBufferStorageEXT(buffer, VG_BUFFER_SIZE, 0, GL_MAP_WRITE_BIT);
vg::defaultFont = vg::createFont(anonymousProBTTF, sizeof(anonymousProBTTF), 16);
vg::nvgDefFont = nvgCreateFontMem(vg::ctx, "default", anonymousProBTTF, sizeof(anonymousProBTTF), 0);
}
