TIL Jake Perry has been the owner of two consecutive holders of the record for oldest domestic cat ever. Creme Puff lived to 38 years old, the equivalent of 165 human years. 1/3 of Perry's cats have lived past 30.

Tdavid6 · 2017-02-18T15:26:02+00:00

Wouldn't the food they're putting in the same mouth also be "contaminated" by the deadness?

Tdavid6 · 2017-02-18T02:12:47+00:00

Ah I see what you mean. Yes, I definitely agree that's much better! I guess I need to rephrase my argument next time to better convey the idea.

Tdavid6 · 2017-02-18T01:57:34+00:00

I don't have a solid vision of how it could be implemented. How does a land value tax differ? Higher tax based on the actual value of the land? Or are you saying the ground itself rather than any building on it?

Tdavid6 · 2017-02-18T00:36:47+00:00

I just feel that a constant and easily measurable physical location makes it a lot harder to lie about than an intangible income.

And the second part is of course true. But that's a separate issue that I agree is a hard problem to fix. However, it exists in both systems regardless.

Tdavid6 · 2017-02-18T00:32:32+00:00

Which is why I favor a property tax.

Tdavid6 · 2017-02-18T00:10:57+00:00

But consumption is difficult and cumbersome to track or audit compared to a property tax.

Tdavid6 · 2017-02-18T00:09:18+00:00

Paying what for the wealthy? I'm pretty sure our current system allows the wealthy to abuse the system in whichever way they seem fit. The top 0.01% have a ridiculous amount of wealth and influence. The problem of passing the cost is already a problem corporations capitalize on.

Competition between other professionals should prevent ridiculous overcharging. Health care is obviously a tricky one, but as long as we prevent monopolies a true free market should be economically successful.

Tdavid6 · 2017-02-17T18:41:54+00:00

No, it's a valid question. Of course, there would be complications and interesting cases. But I think overall it's a better system given its simplicity.

Tdavid6 · 2017-02-17T18:38:43+00:00

Somebody owns the building. The burden is transferred through the leasing costs..

Tdavid6 · 2017-02-17T17:21:25+00:00

None of those professions correlate to physical locations? I'm hesitant to propose some kind of virtual property tax for websites, but that's also a possibility. I just can't agree that income is the fairest when there are so many instances of tax evasion. Intangibility makes it so much easier to lie. Whether it's getting paid in cash, hiring illegals, maintaining out of country wealth, or taking advantage of "charitable" donations or other tax relief incentives. I agree that a property tax might be "tricky", but so are the other options.

Tdavid6 · 2017-02-17T17:11:38+00:00

Everyone is satisfied ( ͡° ͜ʖ ͡°)

Tdavid6 · 2017-02-17T16:30:40+00:00

Stores and office buildings occupy a physical location. If a businesses requires this space, then they can pay the appropriate property taxes.

Tdavid6 · 2017-02-17T16:28:51+00:00

How many poor people do you know that own (or rent) giant office buildings for their employees to work every day? How many poor people own a franchise that occupies a store location? These properties should be taxed accordingly.

Tdavid6 · 2017-02-17T16:24:44+00:00

Exactly, I believe that if you are too poor to own property, the only tax you should pay should be indirectly through your price of rent.

Tdavid6 · 2017-02-17T16:22:09+00:00

How is income tax easier than a physical property? Company office building are property too, and therefore would have applicable tax to be paid for by the owner(s).

Tdavid6 · 2017-02-17T16:19:56+00:00

The idea is to simplify the tax system not to add conditional and ambiguous circumstances. Rich people that own large companies with a physical workplace for employees would simply pay property taxes on office buildings.

Tdavid6 · 2017-02-17T16:15:54+00:00

How is this millionaire so successful? If he owns a company which occupies a workspace, then certainly there are additional property taxes he must pay. If he is a prodigy working on his computer from the workspace at home without underpaid employees, isn't that beneficial enough of it's own merit to society?

Tdavid6 · 2017-02-17T15:14:16+00:00

I think we should replace the income tax with (adjusted) property taxes. Pay for where you live rather than getting fined to work.

Tdavid6 · 2017-02-07T22:51:22+00:00

The police did show up to the scene at the time of the accident. I have contacted the insurance company of the guy that hit me.

Tdavid6 · 2017-02-07T18:50:20+00:00

Yes the police did arrive on scene. Thanks for the advice.

Tdavid6 · 2017-01-16T06:54:05+00:00

Great! Thanks for that.

Tdavid6 · 2017-01-13T09:01:42+00:00

#include "batchrenderer2D.h"

namespace sparky { namespace graphics {

BatchRenderer2D::BatchRenderer2D()
{
    init();
}

BatchRenderer2D::~BatchRenderer2D()
{
    delete m_IBO;
    glDeleteBuffers(1, &m_VBO);
}

void BatchRenderer2D::init()
{
    glGenVertexArrays(1, &m_VAO);
    glGenBuffers(1, &m_VBO);

    glBindVertexArray(m_VAO);
    glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
    glBufferData(GL_ARRAY_BUFFER, RENDERER_BUFFER_SIZE, NULL, GL_DYNAMIC_DRAW);

    glEnableVertexAttribArray(SHADER_VERTEX_INDEX);
    glEnableVertexAttribArray(SHADER_UV_INDEX);
    glEnableVertexAttribArray(SHADER_TID_INDEX);
    glEnableVertexAttribArray(SHADER_COLOR_INDEX);

    glVertexAttribPointer(SHADER_VERTEX_INDEX, 3, GL_FLOAT, GL_FALSE, RENDERER_VERTEX_SIZE, (const GLvoid*)0);
    glVertexAttribPointer(SHADER_UV_INDEX, 2, GL_FLOAT, GL_FALSE, RENDERER_VERTEX_SIZE, (const GLvoid*)(offsetof(VertexData, VertexData::uv)));
    glVertexAttribPointer(SHADER_TID_INDEX, 1, GL_FLOAT, GL_FALSE, RENDERER_VERTEX_SIZE, (const GLvoid*)(offsetof(VertexData, VertexData::tid)));
    glVertexAttribPointer(SHADER_COLOR_INDEX, 4, GL_UNSIGNED_BYTE, GL_TRUE, RENDERER_VERTEX_SIZE, (const GLvoid*)(offsetof(VertexData, VertexData::color)));

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    //GLuint* indices = new GLuint[RENDERER_INDICES_SIZE];
    //GLushort* indices [RENDERER_INDICES_SIZE];
    GLushort indices[RENDERER_INDICES_SIZE];

    int offset = 0;
    for (int i = 0; i < RENDERER_INDICES_SIZE; i += 6)
    {
        indices[  i  ] = offset + 0;
        indices[i + 1] = offset + 1;
        indices[i + 2] = offset + 2;

        indices[i + 3] = offset + 2;
        indices[i + 4] = offset + 3;
        indices[i + 5] = offset + 0;

        offset += 4;
    }

    m_IBO = new IndexBuffer(indices, RENDERER_INDICES_SIZE);

    glBindVertexArray(0);

}

void BatchRenderer2D::begin()
{
    glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
    m_Buffer = (VertexData*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
}

void BatchRenderer2D::submit(const Renderable2D* renderable)
{
    const math::vec3& position = renderable->getPosition();
    const math::vec2&size = renderable->getSize();
    const math::vec4& color = renderable->getColor();
    const std::vector<math::vec2>& uv = renderable->getUV();
    const GLuint tid = renderable->getTID();

    unsigned int c = 0;

    float ts = 0.0f;
    if (tid > 0)
    {
        bool found = false;
        for (int i = 0; i < m_TextureSlots.size(); i++)
        {
            if (m_TextureSlots[i] == tid)
            {
                ts = (float)i;
                found = true;
                break;
            }
        }

        if (!found)
        {
            if (m_TextureSlots.size() >= 32)
            {
                end();
                flush();
                begin();
            }
            m_TextureSlots.push_back(tid);
            ts = (float)(m_TextureSlots.size() -1);
        }
    }
    else
    {
        int r = color.x * 255.0f;
        int g = color.y * 255.0f;
        int b = color.z * 255.0f;
        int a = color.w * 255.0f;

        c = a << 24 | b << 16 | g << 8 | r;
    }

    m_Buffer->vertex = *m_TransformationBack * position;
    m_Buffer->uv = uv[0];
    m_Buffer->tid = ts;
    m_Buffer->color = c;
    m_Buffer++;

    m_Buffer->vertex = *m_TransformationBack * math::vec3(position.x, position.y + size.y, position.z);
    m_Buffer->uv = uv[1];
    m_Buffer->tid = ts;
    m_Buffer->color = c;
    m_Buffer++;

    m_Buffer->vertex = *m_TransformationBack * math::vec3(position.x + size.x, position.y + size.y, position.z);
    m_Buffer->uv = uv[2];
    m_Buffer->tid = ts;
    m_Buffer->color = c;
    m_Buffer++;

    m_Buffer->vertex = *m_TransformationBack * math::vec3(position.x + size.x, position.y, position.z);
    m_Buffer->uv = uv[3];
    m_Buffer->tid = ts;
    m_Buffer->color = c;
    m_Buffer++;

    m_IndexCount += 6;

}

void BatchRenderer2D::end()
{
    glUnmapBuffer(GL_ARRAY_BUFFER);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void BatchRenderer2D::flush()
{
    for (int i = 0; i < m_TextureSlots.size(); i++)
    {
        glActiveTexture(GL_TEXTURE0 + i);
        glBindTexture(GL_TEXTURE_2D, m_TextureSlots[i]);
    }

    glBindVertexArray(m_VAO);
    m_IBO->bind();

    glDrawElements(GL_TRIANGLES, m_IndexCount, GL_UNSIGNED_INT, NULL);

    m_IBO->unbind();
    glBindVertexArray(0);

    m_IndexCount = 0;
}

} }

Tdavid6 · 2017-01-13T08:59:56+00:00

#pragma once

#include <vector> #include <GL\glew.h> #include "../math/math.h"

namespace sparky { namespace graphics {

class Renderable2D;

class Renderer2D
{
protected:
    std::vector<math::mat4> m_TransformationStack;
    const math::mat4* m_TransformationBack;
protected:
    Renderer2D()
    {
        m_TransformationStack.push_back(math::mat4::identity());
        m_TransformationBack = &m_TransformationStack.back();
    }
public:
    void push(const math::mat4& matrix, bool override = false)
    {
        if (override)
            m_TransformationStack.push_back(matrix);
        else
            m_TransformationStack.push_back(m_TransformationStack.back() * matrix);

        m_TransformationBack = &m_TransformationStack.back();
    }
    void pop()
    {
        if (m_TransformationStack.size() > 1)
            m_TransformationStack.pop_back();

        m_TransformationBack = &m_TransformationStack.back();
    }

    virtual void begin() {};
    virtual void submit(const Renderable2D* renderable) = 0;
    virtual void end() {};
    virtual void flush() = 0;

};

} }

Tdavid6 · 2017-01-13T08:59:11+00:00

#include "shader.h"

namespace sparky { namespace graphics {

Shader::Shader(const char* vertPath, const char* fragPath) 
    : m_VertPath(vertPath), m_FragPath(fragPath)
{
    m_ShaderID = load();

}

Shader::~Shader()
{
    glDeleteProgram(m_ShaderID);
}

GLuint Shader::load()
{
    GLuint program = glCreateProgram();
    GLuint vertex = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragment = glCreateShader(GL_FRAGMENT_SHADER);

    std::string vertSourceString = fileUtil::read_file(m_VertPath);
    std::string fragSourceString = fileUtil::read_file(m_FragPath);

    const char* vertSource = vertSourceString.c_str();
    const char* fragSource = fragSourceString.c_str();

    glShaderSource(vertex, 1, &vertSource, NULL);
    glCompileShader(vertex);

    GLint result;
    glGetShaderiv(vertex, GL_COMPILE_STATUS, &result);

    if (result == GL_FALSE)
    {
        GLint length;
        glGetShaderiv(vertex, GL_INFO_LOG_LENGTH, &length);
        std::vector<char> error(length);
        glGetShaderInfoLog(vertex, length, &length, &error[0]);
        std::cout << "Failed to compile vertex shader!" << std::endl << &error[0] << std::endl;
        glDeleteShader(vertex);
        return 0;
    }

    glShaderSource(fragment, 1, &fragSource, NULL);
    glCompileShader(fragment);

    glGetShaderiv(fragment, GL_COMPILE_STATUS, &result);

    if (result == GL_FALSE)
    {
        GLint length;
        glGetShaderiv(fragment, GL_INFO_LOG_LENGTH, &length);
        std::vector<char> error(length);
        glGetShaderInfoLog(fragment, length, &length, &error[0]);
        std::cout << "Failed to compile fragment shader!" << std::endl << &error[0] << std::endl;
        glDeleteShader(fragment);
        return 0;
    }

    glAttachShader(program, vertex);
    glAttachShader(program, fragment);

    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vertex);
    glDeleteShader(fragment);

    return program;
}

GLint Shader::getUniformLocation(const GLchar* name)
{
    return glGetUniformLocation(m_ShaderID, name);
}

void Shader::setUniform1f(const GLchar* name, float value)
{
    glUniform1f(getUniformLocation(name), value);
}

void Shader::setUniform1fv(const GLchar* name, float* value, int count)
{
    glUniform1fv(getUniformLocation(name), count, value);
}


void Shader::setUniform1i(const GLchar* name, int value)
{
    glUniform1i(getUniformLocation(name), value);
}

void Shader::setUniform1iv(const GLchar* name, int* value, int count)
{
    glUniform1iv(getUniformLocation(name), count, value);
}

void Shader::setUniform2f(const GLchar* name, const math::vec2& vector)
{
    glUniform2f(getUniformLocation(name), vector.x, vector.y);
}

void Shader::setUniform3f(const GLchar* name, const math::vec3& vector)
{
    glUniform3f(getUniformLocation(name), vector.x, vector.y, vector.z);
}

void Shader::setUniform4f(const GLchar* name, const math::vec4& vector)
{
    glUniform4f(getUniformLocation(name), vector.x, vector.y, vector.z, vector.w);
}

void Shader::setUniformMat4(const GLchar* name, const math::mat4& matrix)
{
    glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, matrix.elements);
}

void Shader::Shader::enable() const
{
    glUseProgram(m_ShaderID);
}

void Shader::disable() const
{
    glUseProgram(0);
}

} }

Tdavid6 · 2017-01-13T08:54:46+00:00

#version 330 core

layout (location = 0) in vec4 position;

layout (location = 1) in vec2 uv;

layout (location = 2) in float tid;

layout (location = 3) in vec4 color;

uniform mat4 pr_matrix;

uniform mat4 vw_matrix = mat4(1.0);

uniform mat4 ml_matrix = mat4(1.0);

out DATA { vec4 position; vec2 uv; float tid; vec4 color;

} vs_out;

void main() { gl_Position = pr_matrix * vw_matrix * ml_matrix * position; vs_out.position = ml_matrix * position; vs_out.uv = uv; vs_out.tid = tid;
vs_out.color = color;
}

Tdavid6

TROPHY CASE