WaterPhysicsSystem::Edge::EdgeType WaterPhysicsSystem::Edge::getEdgeType()
{
if (aPosition().y < bPosition().y)
{ /// Downwards pointing
if (aPosition().x < bPosition().x)
{
return eLeftFloor;
}
else
{
return eLeftRoof;
}
}
else
{ /// Upwards pointing
if (aPosition().x < bPosition().x)
{
return eRightFloor;
}
else
{
return eRightRoof;
}
}
}
GrGLuint GLCpuPosInstancedArraysBench::setupShader(const GrGLContext* ctx) {
const GrGLSLCaps* glslCaps = ctx->caps()->glslCaps();
const char* version = glslCaps->versionDeclString();
// setup vertex shader
GrGLSLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLSLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLSLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
"gl_Position = vec4(a_position, 0.f, 1.f);\n"
"o_color = a_color;\n"
"}\n");
const GrGLInterface* gl = ctx->interface();
// setup fragment shader
GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *glslCaps, &fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
oColor.appendDecl(glslCaps, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (glslCaps->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(glslCaps, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "gl_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
"%s = vec4(o_color, 1.0f);\n"
"}\n", fsOutName);
return CreateProgram(gl, vshaderTxt.c_str(), fshaderTxt.c_str());
}
QPointF translate( const TernaryPoint& point )
{
if ( point.isValid() ) {
// the position is calculated by
// - first moving along the B-C line to the function that b
// selects
// - then traversing the selected function until we meet with
// the function that A selects (which is a parallel of the B-C
// line)
QPointF bPosition( 1.0 - point.b(), 0.0 );
QPointF aPosition( point.a() * AxisVector_C_A );
QPointF result( bPosition + aPosition );
return result;
} else {
qWarning() << "TernaryPoint::translate(TernaryPoint): cannot translate invalid ternary points:"
<< point;
return QPointF();
}
}
FullPN::FullPN( String const& fullpropertynamestring )
: theFullID( fullpropertynamestring )
{
String::size_type aPosition( 0 );
for( int i( 0 ) ; i < 3 ; ++i )
{
aPosition = fullpropertynamestring.
find_first_of( FullID::DELIMITER, aPosition );
if( aPosition == String::npos )
{
THROW_EXCEPTION( BadID, "not enough fields in FullPN string [" +
fullpropertynamestring + "]" );
}
++aPosition;
}
thePropertyName = fullpropertynamestring.substr( aPosition, String::npos );
eraseWhiteSpaces( thePropertyName );
}
static GrGLuint compile_shader(const GrGLContext* ctx) {
const char* version = GrGLGetGLSLVersionDecl(*ctx);
// setup vertex shader
GrGLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
"gl_Position = vec4(a_position, 0.f, 1.f);\n"
"o_color = a_color;\n"
"}\n");
const GrGLInterface* gl = ctx->interface();
GrGLuint vertexShader = load_shader(gl, vshaderTxt.c_str(), GR_GL_VERTEX_SHADER);
// setup fragment shader
GrGLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLAppendGLSLDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, gl->fStandard,
&fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
oColor.appendDecl(*ctx, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (ctx->caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(*ctx, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "gl_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
"%s = vec4(o_color, 1.0f);\n"
"}\n", fsOutName);
GrGLuint fragmentShader = load_shader(gl, fshaderTxt.c_str(), GR_GL_FRAGMENT_SHADER);
GrGLint shaderProgram;
GR_GL_CALL_RET(gl, shaderProgram, CreateProgram());
GR_GL_CALL(gl, AttachShader(shaderProgram, vertexShader));
GR_GL_CALL(gl, AttachShader(shaderProgram, fragmentShader));
GR_GL_CALL(gl, LinkProgram(shaderProgram));
// Check for linking errors
GrGLint success;
GrGLchar infoLog[512];
GR_GL_CALL(gl, GetProgramiv(shaderProgram, GR_GL_LINK_STATUS, &success));
if (!success) {
GR_GL_CALL(gl, GetProgramInfoLog(shaderProgram, 512, NULL, infoLog));
SkDebugf("Linker Error: %s\n", infoLog);
}
GR_GL_CALL(gl, DeleteShader(vertexShader));
GR_GL_CALL(gl, DeleteShader(fragmentShader));
return shaderProgram;
}
TerrainProcessor::TerrainProcessor(b2World* m_world, char* path,float epsilon, int scale,int waterLevel)
{
this->rangeTerrainOverWater= new list<pair<int,int>>();
b2Body* m_attachment;
TerrainImg* aBmpFile;
this->aListOfPolygons= new list< list< pair<float,float> > > ();
try
{
aBmpFile = new TerrainImg(path);
}
catch (int e)
{
makeDefaultTerrain(m_world,waterLevel);
return;
}
ContourBmp* aContourBmp = new ContourBmp(aBmpFile);
this->height =aBmpFile->getHeight();
this->width =aBmpFile->getWidth();
list< list<Position* > *>* cc =aContourBmp->getContour();
this->maxPointTerrain=aContourBmp->getMaxPointTerrain();
rangeTerrainOverWater =aContourBmp->getConnectedComponentsOptimized(waterLevel);
list< list<Position* >* >::iterator itComponente = cc->begin();
while(itComponente != cc->end() )
{
vector<b2Vec2> lista;
vector<vector<b2Vec2>> result;
list<Position*>::iterator itPosition = (*itComponente)->end();
while(itPosition != (*itComponente)->begin()){
--itPosition;
lista.push_back(b2Vec2((float)(*itPosition)->getX(), (float)(*itPosition)->getY()));
}
try{
result = this->getPolygonConvex(lista, epsilon, scale, height, width,waterLevel);
}
catch(ContourExp e){
throw e;
}
for(int nroDePoligono=0; nroDePoligono< result.size(); nroDePoligono++)
{
vector<b2Vec2> aPolygon= result[nroDePoligono];
int cantDeVerticesDelPoligono = aPolygon.size();
b2Vec2 vertices[8];
list< pair<float,float> > aListOfPoints;
for(int nroVertice=0; nroVertice < cantDeVerticesDelPoligono; nroVertice++)
{
b2Vec2 unVertice = aPolygon[nroVertice];
vertices[nroVertice] = this->transformBmpToBox2D(unVertice,height ,width );
pair<float,float> aPosition(vertices[nroVertice].x,vertices[nroVertice].y);
aListOfPoints.push_back(aPosition);
}
aListOfPolygons->push_back(aListOfPoints);
//
// AGREGAR POLIGONO A BOX2D
//Creo el poligono en Box2D
b2FixtureDef myFixtureDef;
b2BodyDef myBodyDef;
myBodyDef.type = b2_staticBody; //this will be a static body
myBodyDef.position.Set(0, 0); //in the middle
myFixtureDef.friction=0.999;
myFixtureDef.filter.categoryBits = TERRAIN_CAT;
myFixtureDef.filter.maskBits = WORM_CAT | MISSIL_CAT | TERRAIN_CAT;
myFixtureDef.userData = ( (void*) UD_TERRAIN );
m_attachment = m_world->CreateBody(&myBodyDef);
b2PolygonShape polygonShape;
polygonShape.Set(vertices, cantDeVerticesDelPoligono); //pass array to the shape
myFixtureDef.shape = &polygonShape; //change the shape of the fixture
m_attachment->CreateFixture(&myFixtureDef); //add a fixture to the body
int* st= 0;
m_attachment->SetUserData(st);
}
itComponente++;
}
ContourBmp::deleteListOfListPositions(cc);
delete aContourBmp;
}
GrGLuint GLVec4ScalarBench::setupShader(const GrGLContext* ctx) {
const GrShaderCaps* shaderCaps = ctx->caps()->shaderCaps();
const char* version = shaderCaps->versionDeclString();
// this shader draws fNumStages overlapping circles of increasing opacity (coverage) and
// decreasing size, with the center of each subsequent circle closer to the bottom-right
// corner of the screen than the previous circle.
// set up vertex shader; this is a trivial vertex shader that passes through position and color
GrShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
GrShaderVar oPosition("o_position", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier);
GrShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kIn_TypeModifier);
GrShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oPosition.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
" gl_Position = vec4(a_position, 0.0, 1.0);\n"
" o_position = a_position;\n"
" o_color = a_color;\n"
"}\n");
// set up fragment shader; this fragment shader will have fNumStages coverage stages plus an
// XP stage at the end. Each coverage stage computes the pixel's distance from some hard-
// coded center and compare that to some hard-coded circle radius to compute a coverage.
// Then, this coverage is mixed with the coverage from the previous stage and passed to the
// next stage.
GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps, &fshaderTxt);
oPosition.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oPosition.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
oColor.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (shaderCaps->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "sk_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
" vec4 outputColor;\n"
" %s outputCoverage;\n"
" outputColor = vec4(%s, 1.0);\n"
" outputCoverage = %s;\n",
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4" : "float",
oColor.getName().c_str(),
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(1.0)" : "1.0"
);
float radius = 1.0f;
for (uint32_t i = 0; i < fNumStages; i++) {
float centerX = 1.0f - radius;
float centerY = 1.0f - radius;
fshaderTxt.appendf(
" {\n"
" float d = length(%s - vec2(%f, %f));\n"
" float edgeAlpha = clamp(100.0 * (%f - d), 0.0, 1.0);\n"
" outputCoverage = 0.5 * outputCoverage + 0.5 * %s;\n"
" }\n",
oPosition.getName().c_str(), centerX, centerY,
radius,
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(edgeAlpha)" : "edgeAlpha"
);
radius *= 0.8f;
}
fshaderTxt.appendf(
" {\n"
" %s = outputColor * outputCoverage;\n"
" }\n"
"}\n",
fsOutName);
return CreateProgram(ctx, vshaderTxt.c_str(), fshaderTxt.c_str());
}
