void CargoBody::Init()
{
m_hitpoints = 1.0f;
SetLabel(Equip::types[m_type].name);
SetMassDistributionFromModel();
std::vector<Color4ub> colors;
//metallic blue-orangeish color scheme
colors.push_back(Color4ub(255, 198, 64));
colors.push_back(Color4ub(0, 222, 255));
colors.push_back(Color4ub(255, 255, 255));
GetModel()->SetColors(colors);
}
void runTests(bool write,BinaryDataHandler &pMem)
{
runTest (write,pMem, std::string("Hallo") );
runTest1 (write,pMem, Time(222.22) );
runTest (write,pMem, Color3f(1.1,2.2,3.3) );
runTest (write,pMem, Color4f(1.1,2.2,3.3,4.4) );
runTest (write,pMem, Color3ub(1,2,3) );
runTest (write,pMem, Color4ub(1,2,3,4) );
runTest (write,pMem, DynamicVolume(DynamicVolume::BOX_VOLUME) );
runTest (write,pMem, DynamicVolume(DynamicVolume::SPHERE_VOLUME) );
runTest1 (write,pMem, BitVector(0xabcd) );
runTest (write,pMem, Plane(Vec3f(1.0,0),0.222) );
runTest (write,pMem, Matrix(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) );
runTest (write,pMem, Quaternion(Vec3f(1,2,3),22) );
runTest2<bool>(write,pMem, true );
runTest (write,pMem, Int8(-22) );
runTest (write,pMem, UInt8(11) );
runTest (write,pMem, Int16(-10233) );
runTest (write,pMem, UInt16(20233) );
runTest (write,pMem, Int32(-222320233) );
runTest (write,pMem, UInt32(522320233) );
runTest<Int64> (write,pMem, Int64(-522323334) );
runTest (write,pMem, UInt64(44523423) );
runTest (write,pMem, Real32(22.333224) );
runTest (write,pMem, Real64(52.334534533224) );
runTest (write,pMem, Vec2f(1.1,2.2) );
runTest (write,pMem, Vec3f(1.1,2.2,3.3) );
runTest (write,pMem, Vec4f(1.1,2.2,3.3,4.4) );
runTest (write,pMem, Pnt2f(1.1,2.2) );
runTest (write,pMem, Pnt2d(1.1,2.2) );
runTest (write,pMem, Pnt3f(1.1,2.2,3.3) );
runTest (write,pMem, Pnt3d(1.1,2.2,3.3) );
runTest (write,pMem, Pnt4f(1.1,2.2,3.3,4.4) );
runTest (write,pMem, Pnt4d(1.1,2.2,3.3,4.4) );
}
GalaxyMap *GalaxyMap::AddPointLabel(const vector2f &at, const std::string &text)
{
const vector3f at3(at, 0.0f);
LabelOverlay::Marker *m = m_labelOverlay->AddMarker(text, at3);
m->color = Color4ub(0,255,0,255);
m->style = LabelOverlay::MARKER_DOT;
m->textAnchor = UI::Align::LEFT;
return this;
}
GalaxyMap *GalaxyMap::AddAreaLabel(const vector2f &at, const std::string &text)
{
const vector3f at3(at, 0.0f);
LabelOverlay::Marker *m = m_labelOverlay->AddMarker(text, at3);
m->color = Color4ub(255,255,255,255);
m->style = LabelOverlay::MARKER_NONE;
m->textAnchor = UI::Align::MIDDLE;
return this;
}
Color4ub Color4ub::FromLuaTable(lua_State *l, int idx)
{
const int table = lua_absindex(l, idx);
assert(lua_istable(l, table));
LUA_DEBUG_START(l);
float r, g, b, a;
_get_number(l, table, "r", r);
_get_number(l, table, "g", g);
_get_number(l, table, "b", b);
if (!_get_number(l, table, "a", a)) a = 1.0f;
LUA_DEBUG_END(l, 0);
return Color4ub(r*255, g*255, b*255, a*255);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool ScalarMapperRangeBased::updateTexture(TextureImage* image) const
{
CVF_ASSERT(image);
image->allocate(m_textureSize, 1);
// For now fill with white so we can see any errors more easily
image->fill(Color4ub(Color3::WHITE));
uint ic;
for (ic = 0; ic < m_textureSize; ic++)
{
const Color4ub clr(mapToColor(domainValue(((double)ic)/(m_textureSize-1))), 255);
image->setPixel(ic, 0, clr);
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool ScalarMapperContinuousLog::updateTexture(TextureImage* image) const
{
CVF_ASSERT(image);
image->allocate(m_textureSize, 1);
// For now fill with white so we can see any errors more easily
image->fill(Color4ub(Color3::WHITE));
uint ic;
for (ic = 0; ic < m_textureSize; ic++)
{
const Color4ub clr(m_colors[ic], 255);
image->setPixel(ic, 0, clr);
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool CategoryMapper::updateTexture(TextureImage* image) const
{
CVF_ASSERT(image);
image->allocate(m_textureSize, 1);
// For now fill with white so we can see any errors more easily
image->fill(Color4ub(Color3::WHITE));
const uint numColors = static_cast<uint>(m_colors.size());
if (numColors < 1)
{
return false;
}
const uint numPixelsPerColor = m_textureSize / numColors;
CVF_ASSERT(numPixelsPerColor >= 1);
uint ic;
for (ic = 0; ic < numColors; ic++)
{
const Color4ub clr(m_colors[ic], 255);
uint ip;
for (ip = 0; ip < numPixelsPerColor; ip++)
{
image->setPixel(ic*numPixelsPerColor + ip, 0, clr);
}
}
// In cases where we're not using the entire texture we might get into problems with texture coordinate precision on the graphics hardware.
// Therefore we set one extra pixel with the 'highest' color in the color table
if (numColors*numPixelsPerColor < m_textureSize)
{
const Color4ub topClr(m_colors[numColors - 1], 255);
image->setPixel(numColors*numPixelsPerColor, 0, topClr);
}
return true;
}
Color4ub operator + (const Color4ub & a, const Color4ub & b){
return Color4ub((unsigned char)(a.m_R + b.m_R),
(unsigned char)(a.m_G + b.m_G),
(unsigned char)(a.m_B + b.m_B),
(unsigned char)(a.m_A + b.m_A));
}
Color4ub operator - (const Color4ub & a, const Color4ub & b){
return Color4ub((unsigned char)(a.m_R - b.m_R),
(unsigned char)(a.m_G - b.m_G),
(unsigned char)(a.m_B - b.m_B),
(unsigned char)(a.m_A - b.m_A));
}
Color4ub operator * (float value, const Color4ub & a){
return Color4ub((unsigned char)(a.m_R * value),
(unsigned char)(a.m_G * value),
(unsigned char)(a.m_B * value),
(unsigned char)(a.m_A * value));
}
void FramebufferGLTest::read() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::framebuffer_object>())
CORRADE_SKIP(Extensions::GL::ARB::framebuffer_object::string() + std::string(" is not available."));
#endif
Renderbuffer color;
#ifndef MAGNUM_TARGET_GLES2
color.setStorage(RenderbufferFormat::RGBA8, Vector2i(128));
#else
color.setStorage(RenderbufferFormat::RGBA4, Vector2i(128));
#endif
/* Separate depth and stencil renderbuffers are not supported (or at least
on my NVidia, thus we need to do this juggling with one renderbuffer */
Renderbuffer depthStencil;
#ifdef MAGNUM_TARGET_GLES2
if(Context::current()->isExtensionSupported<Extensions::GL::OES::packed_depth_stencil>())
#endif
{
#ifdef MAGNUM_TARGET_GLES2
Debug() << "Using" << Extensions::GL::OES::packed_depth_stencil::string();
#endif
depthStencil.setStorage(RenderbufferFormat::Depth24Stencil8, Vector2i(128));
}
#ifdef MAGNUM_TARGET_GLES2
else depthStencil.setStorage(RenderbufferFormat::DepthComponent16, Vector2i(128));
#endif
Framebuffer framebuffer({{}, Vector2i(128)});
framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment(0), color)
.attachRenderbuffer(Framebuffer::BufferAttachment::Depth, depthStencil);
#ifdef MAGNUM_TARGET_GLES2
if(Context::current()->isExtensionSupported<Extensions::GL::OES::packed_depth_stencil>())
#endif
{
framebuffer.attachRenderbuffer(Framebuffer::BufferAttachment::Stencil, depthStencil);
}
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(framebuffer.checkStatus(FramebufferTarget::ReadDraw), Framebuffer::Status::Complete);
Renderer::setClearColor(Math::normalize<Color4>(Color4ub(128, 64, 32, 17)));
Renderer::setClearDepth(Math::normalize<Float, UnsignedShort>(48352));
Renderer::setClearStencil(67);
framebuffer.clear(FramebufferClear::Color|FramebufferClear::Depth|FramebufferClear::Stencil);
Image2D colorImage(ColorFormat::RGBA, ColorType::UnsignedByte);
framebuffer.read({16, 8}, {8, 16}, colorImage);
CORRADE_COMPARE(colorImage.size(), Vector2i(8, 16));
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(colorImage.data<Color4ub>()[0], Color4ub(128, 64, 32, 17));
#ifdef MAGNUM_TARGET_GLES
if(Context::current()->isExtensionSupported<Extensions::GL::NV::read_depth>())
#endif
{
#ifdef MAGNUM_TARGET_GLES
Debug() << "Using" << Extensions::GL::NV::read_depth::string();
#endif
Image2D depthImage(ColorFormat::DepthComponent, ColorType::UnsignedShort);
framebuffer.read({}, Vector2i(1), depthImage);
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(depthImage.data<UnsignedShort>()[0], 48352);
}
#ifdef MAGNUM_TARGET_GLES
if(Context::current()->isExtensionSupported<Extensions::GL::NV::read_stencil>())
#endif
{
#ifdef MAGNUM_TARGET_GLES
Debug() << "Using" << Extensions::GL::NV::read_stencil::string();
#endif
Image2D stencilImage(ColorFormat::StencilIndex, ColorType::UnsignedByte);
framebuffer.read({}, Vector2i(1), stencilImage);
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(stencilImage.data<UnsignedByte>()[0], 67);
}
#ifdef MAGNUM_TARGET_GLES
if(Context::current()->isExtensionSupported<Extensions::GL::NV::read_depth_stencil>())
#endif
{
#ifdef MAGNUM_TARGET_GLES
Debug() << "Using" << Extensions::GL::NV::read_depth_stencil::string();
#endif
Image2D depthStencilImage(ColorFormat::DepthStencil, ColorType::UnsignedInt248);
framebuffer.read({}, Vector2i(1), depthStencilImage);
MAGNUM_VERIFY_NO_ERROR();
/** @todo This will probably fail on different systems */
CORRADE_COMPARE(depthStencilImage.data<UnsignedInt>()[0] >> 8, 12378300);
CORRADE_COMPARE(depthStencilImage.data<UnsignedByte>()[0], 67);
}
// Copyright © 2008-2013 Pioneer Developers. See AUTHORS.txt for details
// Licensed under the terms of the GPL v3. See licenses/GPL-3.txt
#include "Color.h"
#include "LuaUtils.h"
const Color4f Color::BLACK = Color(0.0f,0.0f,0.0f,1.0f);
const Color4f Color::WHITE = Color(1.0f,1.0f,1.0f,1.0f);
const Color4f Color::RED = Color(1.0f,0.0f,0.0f,1.0f);
const Color4f Color::GREEN = Color(0.0f,1.0f,0.0f,1.0f);
const Color4f Color::BLUE = Color(0.0f,0.0f,1.0f,1.0f);
const Color4f Color::YELLOW = Color(1.0f,1.0f,0.0f,1.0f);
const Color4ub Color4ub::BLACK = Color4ub(0, 0, 0, 255);
const Color4ub Color4ub::WHITE = Color4ub(255, 255, 255, 255);
const Color4ub Color4ub::RED = Color4ub(255, 0, 0, 255);
const Color4ub Color4ub::GREEN = Color4ub(0, 255, 0, 255);
const Color4ub Color4ub::BLUE = Color4ub(0, 0, 255, 255);
const Color4ub Color4ub::YELLOW = Color4ub(255, 255, 0, 255);
float Color4f::GetLuminance() const
{
return (0.299f * r) + (0.587f * g) + (0.114f * b);
}
void Color4f::ToLuaTable(lua_State *l)
{
lua_newtable(l);
pi_lua_settable(l, "r", r);
pi_lua_settable(l, "g", g);
pi_lua_settable(l, "b", b);
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
ref<Texture> PointSprites::createTexture()
{
ref<TextureImage> textureImage = new TextureImage;
// Create a simple 4x4 texture
{
ref<Color4ubArray> textureData = new Color4ubArray;
textureData->reserve(16);
textureData->add(Color4ub(Color3::RED));
textureData->add(Color4ub(Color3::GREEN));
textureData->add(Color4ub(Color3::BLUE));
textureData->add(Color4ub(Color3::YELLOW));
textureData->add(Color4ub(Color3::CYAN));
textureData->add(Color4ub(Color3::MAGENTA));
textureData->add(Color4ub(Color3::INDIGO));
textureData->add(Color4ub(Color3::OLIVE));
textureData->add(Color4ub(Color3::LIGHT_GRAY));
textureData->add(Color4ub(Color3::BROWN));
textureData->add(Color4ub(Color3::CRIMSON));
textureData->add(Color4ub(Color3::DARK_BLUE));
textureData->add(Color4ub(Color3::DARK_CYAN));
textureData->add(Color4ub(Color3::DARK_GREEN));
textureData->add(Color4ub(Color3::DARK_MAGENTA));
textureData->add(Color4ub(Color3::DARK_ORANGE));
textureImage->setData(textureData->ptr()->ptr(), 4, 4);
}
// {
// textureImage = cvfu::ImageJpeg::loadImage(m_testDataDir + "Turbine.jpg");
// }
ref<Texture> texture = new Texture(textureImage.p());
return texture;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software)
{
CVF_CALLSITE_OPENGL(oglContext);
Camera projCam;
projCam.setViewport(position.x(), position.y(), size.x(), size.y());
projCam.setProjectionAsPixelExact2D();
projCam.setViewMatrix(Mat4d::IDENTITY);
// Turn off depth test
RenderStateDepth depth(false, RenderStateDepth::LESS, false);
depth.applyOpenGL(oglContext);
float vertexArray[12];
float textureCoords[] = {0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f};
projCam.viewport()->applyOpenGL(oglContext, Viewport::DO_NOT_CLEAR);
if (software)
{
// Create a POW2 texture for software rendering if needed
if (m_image.notNull() && m_pow2Image.isNull() && (!Math::isPow2(m_image->width()) || !Math::isPow2(m_image->height())))
{
m_pow2Image = new TextureImage;
m_pow2Image->allocate(Math::roundUpPow2(m_image->width()), Math::roundUpPow2(m_image->height()));
m_pow2Image->fill(Color4ub(Color3::BLACK));
for (uint y = 0; y < m_image->height(); ++y)
{
for (uint x = 0; x < m_image->width(); ++x)
{
m_pow2Image->setPixel(x, y, m_image->pixel(x, y));
}
}
}
if (ShaderProgram::supportedOpenGL(oglContext))
{
ShaderProgram::useNoProgram(oglContext);
}
#ifndef CVF_OPENGL_ES
RenderStateMaterial_FF mat;
mat.enableColorMaterial(true);
mat.applyOpenGL(oglContext);
RenderStateLighting_FF light(false);
light.applyOpenGL(oglContext);
if (m_textureBindings.isNull())
{
// Use fixed function texture setup
ref<Texture2D_FF> texture = new Texture2D_FF(m_pow2Image.notNull() ? m_pow2Image.p() : m_image.p());
texture->setWrapMode(Texture2D_FF::CLAMP);
texture->setMinFilter(Texture2D_FF::NEAREST);
texture->setMagFilter(Texture2D_FF::NEAREST);
texture->setupTexture(oglContext);
texture->setupTextureParams(oglContext);
ref<RenderStateTextureMapping_FF> textureMapping = new RenderStateTextureMapping_FF(texture.p());
textureMapping->setTextureFunction(m_blendMode == TEXTURE_ALPHA ? RenderStateTextureMapping_FF::MODULATE : RenderStateTextureMapping_FF::DECAL);
m_textureBindings = textureMapping;
}
#endif
// Adjust texture coordinates
if (m_pow2Image.notNull())
{
float xMax = static_cast<float>(m_image->width())/static_cast<float>(m_pow2Image->width());
float yMax = static_cast<float>(m_image->height())/static_cast<float>(m_pow2Image->height());
textureCoords[2] = xMax;
textureCoords[4] = xMax;
textureCoords[5] = yMax;
textureCoords[7] = yMax;
}
projCam.applyOpenGL();
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
if (m_shaderProgram.isNull())
{
ShaderProgramGenerator gen("OverlayImage_Shader", ShaderSourceProvider::instance());
gen.addVertexCode(ShaderSourceRepository::vs_MinimalTexture);
if (m_blendMode == GLOBAL_ALPHA)
{
gen.addFragmentCode(ShaderSourceRepository::src_TextureGlobalAlpha);
}
else
{
gen.addFragmentCode(ShaderSourceRepository::src_Texture);
}
gen.addFragmentCode(ShaderSourceRepository::fs_Unlit);
m_shaderProgram = gen.generate();
m_shaderProgram->linkProgram(oglContext);
}
if (m_shaderProgram->useProgram(oglContext))
{
MatrixState projMatrixState(projCam);
m_shaderProgram->clearUniformApplyTracking();
m_shaderProgram->applyFixedUniforms(oglContext, projMatrixState);
}
if (m_texture->textureOglId() == 0)
{
m_texture->setupTexture(oglContext);
}
if (m_textureBindings.isNull())
{
cvf::RenderStateTextureBindings* textureBindings = new cvf::RenderStateTextureBindings;
textureBindings->addBinding(m_texture.p(), m_sampler.p(), "u_texture2D");
m_textureBindings = textureBindings;
}
}
float offset = 0.0f;
Vec3f min(offset, offset, 0.0f);
Vec3f max(static_cast<float>(size.x()) + offset, static_cast<float>(size.y()) + offset, 0.0f);
// Setup the vertex array
float* v1 = &vertexArray[0];
float* v2 = &vertexArray[3];
float* v3 = &vertexArray[6];
float* v4 = &vertexArray[9];
v1[0] = min.x(); v1[1] = min.y(); v1[2] = 0.0f;
v2[0] = max.x(); v2[1] = min.y(); v2[2] = 0.0f;
v3[0] = max.x(); v3[1] = max.y(); v3[2] = 0.0f;
v4[0] = min.x(); v4[1] = max.y(); v4[2] = 0.0f;
if (m_blendMode != NO_BLENDING)
{
RenderStateBlending blend;
blend.configureTransparencyBlending();
blend.applyOpenGL(oglContext);
}
m_textureBindings->applyOpenGL(oglContext);
if (software)
{
#ifndef CVF_OPENGL_ES
glColor4f(1.0f, 1.0f, 1.0f, m_blendMode == GLOBAL_ALPHA ? m_alpha : 1.0f);
glBegin(GL_TRIANGLE_FAN);
glTexCoord2f(textureCoords[0], textureCoords[1]);
glVertex3fv(v1);
glTexCoord2f(textureCoords[2], textureCoords[3]);
glVertex3fv(v2);
glTexCoord2f(textureCoords[4], textureCoords[5]);
glVertex3fv(v3);
glTexCoord2f(textureCoords[6], textureCoords[7]);
glVertex3fv(v4);
glEnd();
#endif
}
else
{
if (m_blendMode == GLOBAL_ALPHA)
{
UniformFloat alphaUniform("u_alpha", m_alpha);
m_shaderProgram->applyUniform(oglContext, alphaUniform);
}
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
if (m_blendMode != NO_BLENDING)
{
RenderStateBlending blend;
blend.applyOpenGL(oglContext);
}
RenderStateDepth resetDepth;
resetDepth.applyOpenGL(oglContext);
if (software)
{
#ifndef CVF_OPENGL_ES
RenderStateTextureMapping_FF resetTextureMapping;
resetTextureMapping.applyOpenGL(oglContext);
#endif
}
if (!software)
{
glDisableVertexAttribArray(ShaderProgram::VERTEX);
glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
}
}
#include "Color.h"
const Color4f Color::BLACK = Color(0.0f,0.0f,0.0f,1.0f);
const Color4f Color::WHITE = Color(1.0f,1.0f,1.0f,1.0f);
const Color4ub Color4ub::BLACK = Color4ub(0, 0, 0, 255);
const Color4ub Color4ub::WHITE = Color4ub(255, 255, 255, 255);
float Color4f::GetLuminance() const
{
return (0.299f * r) + (0.587f * g) + (0.114f * b);
}
bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) {
bool usingTextures[kNumStages];
for (int s = 0; s < kNumStages; ++s) {
usingTextures[s] = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
if (usingTextures[s] && fCurrDrawState.fSamplerStates[s].isGradient()) {
unimpl("Fixed pipe doesn't support radial/sweep gradients");
return false;
}
}
if (GR_GL_SUPPORT_ES1) {
if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) ||
BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) {
unimpl("ES1 doesn't support blend constant");
return false;
}
}
if (!flushGLStateCommon(type)) {
return false;
}
if (fDirtyFlags.fRenderTargetChanged) {
flushProjectionMatrix();
}
for (int s = 0; s < kNumStages; ++s) {
bool wasUsingTexture = VertexUsesStage(s, fHWGeometryState.fVertexLayout);
if (usingTextures[s] != wasUsingTexture) {
setTextureUnit(s);
if (usingTextures[s]) {
GR_GL(Enable(GR_GL_TEXTURE_2D));
} else {
GR_GL(Disable(GR_GL_TEXTURE_2D));
}
}
}
uint32_t vertColor = (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit);
uint32_t prevVertColor = (fHWGeometryState.fVertexLayout &
kColor_VertexLayoutBit);
if (vertColor != prevVertColor) {
if (vertColor) {
GR_GL(ShadeModel(GR_GL_SMOOTH));
// invalidate the immediate mode color
fHWDrawState.fColor = GrColor_ILLEGAL;
} else {
GR_GL(ShadeModel(GR_GL_FLAT));
}
}
if (!vertColor && fHWDrawState.fColor != fCurrDrawState.fColor) {
GR_GL(Color4ub(GrColorUnpackR(fCurrDrawState.fColor),
GrColorUnpackG(fCurrDrawState.fColor),
GrColorUnpackB(fCurrDrawState.fColor),
GrColorUnpackA(fCurrDrawState.fColor)));
fHWDrawState.fColor = fCurrDrawState.fColor;
}
// set texture environment, decide whether we are modulating by RGB or A.
for (int s = 0; s < kNumStages; ++s) {
if (usingTextures[s]) {
GrGLTexture* texture = (GrGLTexture*)fCurrDrawState.fTextures[s];
if (NULL != texture) {
TextureEnvRGBOperands nextRGBOperand0 =
(GrPixelConfigIsAlphaOnly(texture->config())) ?
kAlpha_TextureEnvRGBOperand :
kColor_TextureEnvRGBOperand;
if (fHWRGBOperand0[s] != nextRGBOperand0) {
setTextureUnit(s);
GR_GL(TexEnvi(GR_GL_TEXTURE_ENV,
GR_GL_OPERAND0_RGB,
(nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ?
GR_GL_SRC_ALPHA :
GR_GL_SRC_COLOR));
fHWRGBOperand0[s] = nextRGBOperand0;
}
if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
(fHWDrawState.fSamplerStates[s].getMatrix() !=
getSamplerMatrix(s))) {
GrMatrix texMat = getSamplerMatrix(s);
AdjustTextureMatrix(texture,
GrSamplerState::kNormal_SampleMode,
&texMat);
GrGpuMatrix glm;
glm.set(texMat);
setTextureUnit(s);
GR_GL(MatrixMode(GR_GL_TEXTURE));
GR_GL(LoadMatrixf(glm.fMat));
recordHWSamplerMatrix(s, getSamplerMatrix(s));
}
} else {
GrAssert(!"Rendering with texture vert flag set but no bound texture");
return false;
}
}
}
if (fHWDrawState.fViewMatrix != fCurrDrawState.fViewMatrix) {
GrGpuMatrix glm;
glm.set(fCurrDrawState.fViewMatrix);
GR_GL(MatrixMode(GR_GL_MODELVIEW));
GR_GL(LoadMatrixf(glm.fMat));
fHWDrawState.fViewMatrix =
fCurrDrawState.fViewMatrix;
}
resetDirtyFlags();
return true;
}
//--------------------------------------------------------------------------------------------------
/// Setup and bind texture
//--------------------------------------------------------------------------------------------------
void Glyph::setupAndBindTexture(OpenGLContext* oglContext, bool software)
{
// Short path first if everything is in place
if (m_textureBindings.notNull())
{
RenderState::Type renderStateType = m_textureBindings->type();
if (software)
{
#ifndef CVF_OPENGL_ES
if (renderStateType == RenderState::TEXTURE_MAPPING_FF)
{
RenderStateTextureMapping_FF* texMapping = static_cast<RenderStateTextureMapping_FF*>(m_textureBindings.p());
texMapping->setupTexture(oglContext);
texMapping->applyOpenGL(oglContext);
return;
}
#else
CVF_FAIL_MSG("Not supported on OpenGL ES");
#endif
}
else
{
if (renderStateType == RenderState::TEXTURE_BINDINGS)
{
RenderStateTextureBindings* texBindings = static_cast<RenderStateTextureBindings*>(m_textureBindings.p());
texBindings->setupTextures(oglContext);
texBindings->applyOpenGL(oglContext);
return;
}
}
}
m_textureBindings = NULL;
if (m_textureBindings.isNull())
{
// TODO
// Revisit the code that sets up the texture image
// The code below ends up modifying the stored texture image
// Is this intentional - there is an external getter for the image!!
CVF_TIGHT_ASSERT(0 < m_textureImage->width());
CVF_TIGHT_ASSERT(0 < m_textureImage->height());
uint pow2Width = Math::roundUpPow2(m_width);
uint pow2Height = Math::roundUpPow2(m_height);
TextureImage* pow2Image = new TextureImage;
pow2Image->allocate(pow2Width, pow2Height);
pow2Image->fill(Color4ub(255, 255, 255, 0));
uint i, j;
for (j = 0; j < m_height; j++)
{
for (i = 0; i < m_width; i++)
{
pow2Image->setPixel(i, j, m_textureImage->pixel(i, j));
}
}
float textureCoordinateMaxX = static_cast<float>(m_width) / static_cast<float>(pow2Width);
float textureCoordinateMaxY = static_cast<float>(m_height) / static_cast<float>(pow2Height);
// Lower left
m_textureCoordinates->set(0, 0.0f);
m_textureCoordinates->set(1, 0.0f);
// Lower right
m_textureCoordinates->set(2, textureCoordinateMaxX);
m_textureCoordinates->set(3, 0.0f);
// Upper right
m_textureCoordinates->set(4, textureCoordinateMaxX);
m_textureCoordinates->set(5, textureCoordinateMaxY);
// Upper left
m_textureCoordinates->set(6, 0.0f);
m_textureCoordinates->set(7, textureCoordinateMaxY);
m_textureImage = pow2Image;
if (software)
{
#ifdef CVF_OPENGL_ES
CVF_FAIL_MSG("Not supported on OpenGL ES");
#else
// Use fixed function texture setup
ref<Texture2D_FF> texture = new Texture2D_FF(m_textureImage.p());
texture->setWrapMode(Texture2D_FF::CLAMP);
if (m_minFilter == NEAREST)
{
texture->setMinFilter(Texture2D_FF::NEAREST);
}
else
{
texture->setMinFilter(Texture2D_FF::LINEAR);
}
if (m_magFilter == NEAREST)
{
texture->setMagFilter(Texture2D_FF::NEAREST);
}
else
{
texture->setMagFilter(Texture2D_FF::LINEAR);
}
ref<RenderStateTextureMapping_FF> textureMapping = new RenderStateTextureMapping_FF(texture.p());
textureMapping->setTextureFunction(RenderStateTextureMapping_FF::MODULATE);
textureMapping->setupTexture(oglContext);
m_textureBindings = textureMapping;
#endif
}
else
{
ref<Sampler> sampler = new Sampler;
sampler->setWrapMode(Sampler::CLAMP_TO_EDGE);
if (m_minFilter == NEAREST)
{
sampler->setMinFilter(Sampler::NEAREST);
}
else
{
sampler->setMinFilter(Sampler::LINEAR);
}
if (m_magFilter == NEAREST)
{
sampler->setMagFilter(Sampler::NEAREST);
}
else
{
sampler->setMagFilter(Sampler::LINEAR);
}
ref<Texture> texture = new Texture(m_textureImage.p());
RenderStateTextureBindings* textureBindings = new RenderStateTextureBindings(texture.p(), sampler.p(), "dummy");
textureBindings->setupTextures(oglContext);
m_textureBindings = textureBindings;
}
}
if (m_textureBindings.notNull())
{
m_textureBindings->applyOpenGL(oglContext);
}
}
/*! @note very important: color cubes of the children must already exist, otherwise there will be a segmentation fault */
void ColorCubeGenerator::processColorCube(FrameContext& context, Node * node, deque<Node*>& children) {
const Geometry::Box box = node->getWorldBB();
ColorCube cc;
// 1. case: current node's color cube should be processed by drawing Geometry < see processColorCubes(...) >
if (children.empty()) {
context.getRenderingContext().pushAndSetLighting(Rendering::LightingParameters(true));
context.getRenderingContext().applyChanges();
// render the six sides
context.getRenderingContext().pushAndSetFBO(fbo.get());
for (uint8_t _side = 0; _side < 6; ++_side) { // determine the color for each of the 6 faces
const Geometry::side_t side = static_cast<Geometry::side_t> (_side);
if (!prepareCamera(context, box, side))
continue;
context.getRenderingContext().clearScreen(Util::Color4f(0.0f, 0.0f, 0.0f, 0.0f));
context.displayNode(node, USE_WORLD_MATRIX);
}
context.getRenderingContext().popFBO();
colorTexture->downloadGLTexture(context.getRenderingContext());
//////////// debug
// static uint32_t counter=0;
// stringstream ss;
// ss << "screens/colorcube_" << counter++ << ".png";
// Util::FileName filename(ss.str());
// Rendering::Serialization::saveTexture(context.getRenderingContext(), colorTexture.get(), filename);
//////////// end debug
// determine the color for each of the 6 faces
for (uint8_t _side = 0; _side < 6; ++_side) {
const Geometry::side_t side = static_cast<Geometry::side_t> (_side);
if (prepareCamera(context, box, side)){
const Color4ub c = calculateColor(colorTexture.get(), camera->getViewport()); //calculate color from texture
cc.colors[static_cast<uint8_t> (side)] = c;
} else {
cc.colors[static_cast<uint8_t> (side)] = Color4ub(0, 0, 0, 0);
}
}
context.getRenderingContext().popLighting();
}
else{
context.getRenderingContext().pushAndSetFBO(fbo.get()); // enable the fbo
// 2. case: the node is not a closed GroupNode (inner node)
for (uint8_t _side = 0; _side < 6; ++_side) { // for each of the six faces
Geometry::side_t side = static_cast<Geometry::side_t> (_side);
if (!prepareCamera(context, box, side))
continue;
context.getRenderingContext().clearScreen(Util::Color4f(0.0f, 0.0f, 0.0f, 0.0f));
context.getRenderingContext().pushAndSetMatrix_modelToCamera( context.getRenderingContext().getMatrix_worldToCamera() );
// draw faces using blending
context.getRenderingContext().pushAndSetBlending(Rendering::BlendingParameters(Rendering::BlendingParameters::ONE, Rendering::BlendingParameters::ONE_MINUS_SRC_ALPHA));
context.getRenderingContext().pushAndSetCullFace(Rendering::CullFaceParameters(Rendering::CullFaceParameters::CULL_BACK));
context.getRenderingContext().pushAndSetDepthBuffer(Rendering::DepthBufferParameters(true, false, Rendering::Comparison::LESS));
context.getRenderingContext().pushAndSetLighting(Rendering::LightingParameters(false));
context.getRenderingContext().applyChanges();
distanceQueue_t nodes(side); // distance queue used for sorting the children with color cubes
// sort (back-to-front order) the children according to distance of current side to the camera
for(const auto & child : children) {
nodes.push(child);
}
// draw the faces in back-to-front order
while (!nodes.empty()) {
Node* child = nodes.top();
nodes.pop();
const ColorCube & childsColorCube = ColorCube::getColorCube(child);
//cerr << "before drawing colored box " << endl;
childsColorCube.drawColoredBox(context, child->getWorldBB());
//cerr << "after drawing colored box" << endl;
}
context.getRenderingContext().popLighting();
context.getRenderingContext().popDepthBuffer();
context.getRenderingContext().popCullFace();
context.getRenderingContext().popBlending();
context.getRenderingContext().popMatrix_modelToCamera();
}
context.getRenderingContext().popFBO();
colorTexture->downloadGLTexture(context.getRenderingContext());
// determine the color for each of the 6 faces
for (uint8_t _side = 0; _side < 6; ++_side) {
Geometry::side_t side = static_cast<Geometry::side_t> (_side);
if (!prepareCamera(context, box, side))
continue;
//calculate color from texture
cc.colors[static_cast<uint8_t> (side)] = calculateColor(colorTexture.get(), camera->getViewport());
}
}
ColorCube::attachColorCube(node, cc);
}
