ImageRef Scene::parallelRaytrace(CameraRef camera, RenderOption option)
{
Rect leftRect(0.0f, 0.0f, camera->width(), floor(camera->height() / 2.0f));
Rect rightRect(0.0f, leftRect.maxY(), camera->width(), camera->height() - leftRect.size.height);
p1.scene = this;
p1.camera = camera;
p1.rect = leftRect;
p1.option = option;
p1.image = new Image(leftRect.size.width, leftRect.size.height);
p2.scene = this;
p2.camera = camera;
p2.rect = rightRect;
p2.option = option;
p2.image = new Image(rightRect.size.width, rightRect.size.height);
pthread_t thread1, thread2;
int iret1, iret2;
std::cout << this;
iret1 = pthread_create(&thread1, NULL, raytraceThread, &p1);
iret2 = pthread_create(&thread2, NULL, raytraceThread, &p2);
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
ImageRef image = new Image(camera->width(), camera->height());
image->drawImageAtPoint(p1.image, p1.rect.origin);
image->drawImageAtPoint(p2.image, p2.rect.origin);
delete p1.image;
delete p2.image;
return image;
}
float getSSD( BasicImage<float> &templatePatch, BasicImage<float> &targetPatch, float matchThreshold )
{
#ifdef USE_ACCELERATE
float score = 0;
int N = templatePatch.size().x * templatePatch.size().y;
vDSP_vsub( templatePatch.data(), 1, targetPatch.data(), 1, targetPatch.data(), 1, N );
vDSP_svesq( targetPatch.data(), 1, &score, N );
return score;
#else
float score = 0;
ImageRef loc = ImageRef( 0, 0 );
do {
float templateVal = templatePatch[loc];
float targetVal = targetPatch[loc];
float diff = templateVal - targetVal;
score += diff * diff;
if ( score > matchThreshold ) break;
} while ( loc.next( templatePatch.size() ) );
return score;
#endif
}
ReplaceImage::ReplaceImage(Sprite* sprite, const ImageRef& oldImage, const ImageRef& newImage)
: WithSprite(sprite)
, m_oldImageId(oldImage->id())
, m_newImageId(newImage->id())
, m_newImage(newImage)
{
}
void ReplaceImage::onRedo()
{
ImageRef oldImage = sprite()->getImageRef(m_oldImageId);
ASSERT(oldImage);
ASSERT(!sprite()->getImageRef(m_newImageId));
m_copy->setId(m_newImageId);
replaceImage(m_oldImageId, m_copy);
m_copy.reset(Image::createCopy(oldImage.get()));
}
void CalibCornerPatch::MakeTemplateWithCurrentParams() {
double dBlurSigma = 2.0;
int nExtraPixels = (int)(dBlurSigma * 6.0) + 2;
Image<float> imToBlur(mimTemplate.size() +
ImageRef(nExtraPixels, nExtraPixels));
Image<float> imTwiceToBlur(imToBlur.size() * 2);
// Make actual template:
int nOffset;
{
Matrix<2> m2Warp = mParams.m2Warp();
CVD::transform(mimSharedSourceTemplate, imTwiceToBlur, M2Inverse(m2Warp),
vec(mimSharedSourceTemplate.size() - ImageRef(1, 1)) * 0.5,
vec(imTwiceToBlur.size() - ImageRef(1, 1)) * 0.5);
halfSample(imTwiceToBlur, imToBlur);
convolveGaussian(imToBlur, dBlurSigma);
nOffset = (imToBlur.size().x - mimTemplate.size().x) / 2;
copy(imToBlur, mimTemplate, mimTemplate.size(), ImageRef(nOffset, nOffset));
};
// Make numerical angle jac images:
for (int dof = 0; dof < 2; dof++) {
Matrix<2> m2Warp;
for (int i = 0; i < 2; i++) {
double dAngle = mParams.v2Angles[i];
if (dof == i)
dAngle += 0.01;
m2Warp[0][i] = cos(dAngle);
m2Warp[1][i] = sin(dAngle);
};
CVD::transform(mimSharedSourceTemplate, imTwiceToBlur, M2Inverse(m2Warp),
vec(mimSharedSourceTemplate.size() - ImageRef(1, 1)) * 0.5,
vec(imTwiceToBlur.size() - ImageRef(1, 1)) * 0.5);
halfSample(imTwiceToBlur, imToBlur);
convolveGaussian(imToBlur, dBlurSigma);
ImageRef ir;
do
mimAngleJacs[ir][dof] =
(imToBlur[ir + ImageRef(nOffset, nOffset)] - mimTemplate[ir]) / 0.01;
while (ir.next(mimTemplate.size()));
};
// Make the image of image gradients here too (while we have the bigger
// template to work from)
ImageRef ir;
do {
mimGradients[ir][0] = 0.5 * (imToBlur[ir + ImageRef(nOffset + 1, nOffset)] -
imToBlur[ir + ImageRef(nOffset - 1, nOffset)]);
mimGradients[ir][1] = 0.5 * (imToBlur[ir + ImageRef(nOffset, nOffset + 1)] -
imToBlur[ir + ImageRef(nOffset, nOffset - 1)]);
} while (ir.next(mimGradients.size()));
}
float FastCorner::shiTomasiScore_10(const ImageRef<unsigned char>& im, const Point2i& pos)
{
const unsigned char* p3 = &(im.data())[(pos.y - 3) * im.width()];
const unsigned char* p2 = &(im.data())[(pos.y - 2) * im.width()];
const unsigned char* p1 = &(im.data())[(pos.y - 1) * im.width()];
const unsigned char* s = &(im.data())[pos.y * im.width()];
const unsigned char* n1 = &(im.data())[(pos.y + 1) * im.width()];
const unsigned char* n2 = &(im.data())[(pos.y + 2) * im.width()];
const unsigned char* n3 = &(im.data())[(pos.y + 3) * im.width()];
float Dxx = 0.0f;
float Dxy = 0.0f;
float Dyy = 0.0f;
const int endx = pos.x + 3;
for (int x = pos.x - 3; x<=endx; ++x) {
float dx = (float)(p2[x+1] - p2[x-1]); float dy = (float)(p1[x] - p3[x]);
Dxx += dx * dx; Dyy += dy * dy; Dxy += dx * dy;
dx = (float)(p1[x+1] - p1[x-1]); dy = (float)(s[x] - p2[x]);
Dxx += dx * dx; Dyy += dy * dy; Dxy += dx * dy;
dx = (float)(s[x+1] - s[x-1]); dy = (float)(n1[x] - p1[x]);
Dxx += dx * dx; Dyy += dy * dy; Dxy += dx * dy;
dx = (float)(n1[x+1] - n1[x-1]); dy = (float)(n2[x] - s[x]);
Dxx += dx * dx; Dyy += dy * dy; Dxy += dx * dy;
dx = (float)(n2[x+1] - n2[x-1]); dy = (float)(n3[x] - n1[x]);
Dxx += dx * dx; Dyy += dy * dy; Dxy += dx * dy;
}
const float sum_Dxx_Dyy = Dxx + Dyy;
float r = 0.04f * 0.5f * (sum_Dxx_Dyy - std::sqrt(sum_Dxx_Dyy * sum_Dxx_Dyy - 4.0f * (Dxx * Dyy - Dxy * Dxy)));
return r;
}
void ReplaceImage::onExecute()
{
// Save old image in m_copy. We cannot keep an ImageRef to this
// image, because there are other undo branches that could try to
// modify/re-add this same image ID
ImageRef oldImage = sprite()->getImageRef(m_oldImageId);
ASSERT(oldImage);
m_copy.reset(Image::createCopy(oldImage.get()));
replaceImage(m_oldImageId, m_newImage);
m_newImage.reset();
}
ImageRef SubObjectsFromSprite::getImageRef(ObjectId imageId)
{
auto it = m_images.find(imageId);
if (it != m_images.end()) {
ImageRef image = it->second;
ASSERT(image->id() == imageId);
ASSERT(!m_sprite->getImageRef(imageId));
return image;
}
else
return m_sprite->getImageRef(imageId);
}
void CalibCornerPatch::MakeSharedTemplate() {
const int nSideSize = 100;
const int nHalf = nSideSize / 2;
mimSharedSourceTemplate.resize(ImageRef(nSideSize, nSideSize));
ImageRef ir;
do {
float fX = (ir.x < nHalf) ? 1.0 : -1.0;
float fY = (ir.y < nHalf) ? 1.0 : -1.0;
mimSharedSourceTemplate[ir] = fX * fY;
} while (ir.next(mimSharedSourceTemplate.size()));
}
ImageRef Scene::rasterize(CameraRef camera)
{
ImageRef image = new Image(camera->width(), camera->height());
for (unsigned int y = 0; y < camera->height(); y++) {
for (unsigned int x = 0; x < camera->width(); x++) {
float xPos = (float)x / (float) camera->width() - 0.5f;
float yPos = (float)y / (float) camera->height() - 0.5f;
Ray viewRay = camera->viewRay(xPos, yPos);
HitInfo hitInfo;
if (m_rootGroup->hit(viewRay, &hitInfo)) {
image->setPixelColor(x, y, hitInfo.material->color());
}
}
}
return image;
}
double CalibCornerPatch::Iterate(Image<byte>& im) {
Vector<2> v2TL =
mParams.v2Pos - vec(mimTemplate.size() - ImageRef(1, 1)) / 2.0;
if (!(v2TL[0] >= 0.0 && v2TL[1] >= 0.0))
return -1.0;
Vector<2> v2BR = v2TL + vec(mimTemplate.size() - ImageRef(1, 1));
if (!(v2BR[0] < (im.size().x - 1.0) && v2BR[1] < (im.size().y - 1.0)))
return -1.0;
image_interpolate<Interpolate::Bilinear, byte> imInterp(im);
Matrix<6> m6JTJ = Zeros;
Vector<6> v6JTD = Zeros;
ImageRef ir;
double dSum = 0.0;
do {
Vector<2> v2Pos_Template =
vec(ir) - vec(mimTemplate.size() - ImageRef(1, 1)) / 2.0;
Vector<2> v2Pos_Image = mParams.v2Pos + v2Pos_Template;
double dDiff = imInterp[v2Pos_Image] -
(mParams.dGain * mimTemplate[ir] + mParams.dMean);
dSum += fabs(dDiff);
Vector<6> v6Jac;
// Jac for center pos: Minus sign because +pos equates to sliding template -
v6Jac.slice<0, 2>() = -1.0 * mParams.dGain * mimGradients[ir];
// Jac for angles: dPos/dAngle needs finishing by multiplying by pos..
v6Jac[2] = mimAngleJacs[ir][0] * mParams.dGain;
v6Jac[3] = mimAngleJacs[ir][1] * mParams.dGain;
// Jac for mean:
v6Jac[4] = 1.0;
// Jac for gain:
v6Jac[5] = mimTemplate[ir];
m6JTJ += v6Jac.as_col() * v6Jac.as_row();
v6JTD += dDiff * v6Jac;
} while (ir.next(mimTemplate.size()));
Cholesky<6> chol(m6JTJ);
Vector<6> v6Update = 0.7 * chol.backsub(v6JTD);
mParams.v2Pos += v6Update.slice<0, 2>();
mParams.v2Angles += v6Update.slice<2, 2>();
mParams.dMean += v6Update[4];
mParams.dGain += v6Update[5];
mdLastError = dSum / mimTemplate.size().area();
return sqrt(v6Update.slice<0, 2>() * v6Update.slice<0, 2>());
}
DocRangeOps() {
black = rgba(0, 0, 0, 0);
white = rgba(255, 255, 255, 255);
doc.reset(static_cast<app::Document*>(ctx.documents().add(4, 4)));
sprite = doc->sprite();
layer1 = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer());
layer2 = new LayerImage(sprite);
layer3 = new LayerImage(sprite);
layer4 = new LayerImage(sprite);
sprite->folder()->addLayer(layer2);
sprite->folder()->addLayer(layer3);
sprite->folder()->addLayer(layer4);
EXPECT_LAYER_ORDER(layer1, layer2, layer3, layer4);
layer1->setName("layer1");
layer2->setName("layer2");
layer3->setName("layer3");
layer4->setName("layer4");
sprite->setTotalFrames(frame_t(4));
sprite->setFrameDuration(frame_t(0), 1); // These durations can be used to identify
sprite->setFrameDuration(frame_t(1), 2); // frames after a move operation
sprite->setFrameDuration(frame_t(2), 3);
sprite->setFrameDuration(frame_t(3), 4);
for (int i=0; i<4; i++) {
LayerImage* layer = static_cast<LayerImage*>(sprite->indexToLayer(LayerIndex(i)));
for (int j=0; j<4; j++) {
Cel* cel = layer->cel(frame_t(j));
ImageRef image;
if (cel)
image = cel->imageRef();
else {
image.reset(Image::create(IMAGE_RGB, 4, 4));
cel = new Cel(frame_t(j), image);
layer->addCel(cel);
}
clear_image(image.get(), black);
put_pixel(image.get(), i, j, white);
}
}
}
void PadTracker::makefromImg(Image<CVD::byte> &img)
{
mirSize = img.size();
mimSmall.resize(mirSize);
mimTemplate.resize(mirSize);
mimSmall = img;
ImageRef ir;
unsigned int nSum = 0;
do
nSum += mimSmall[ir];
while(ir.next(mirSize));
float fMean = ((float) nSum) / mirSize.area();
ir.home();
do
mimTemplate[ir] = mimSmall[ir] - fMean;
while(ir.next(mirSize));
}
void Scene::raytrace(CameraRef camera, Rect rect, RenderOption option, ImageRef image)
{
ASSERT(image->width() == rect.size.width && image->height() == rect.size.height);
for (unsigned int y = 0; y < rect.size.height; y++) {
for (unsigned int x = 0; x < rect.size.width; x++) {
float xPos = (float)(x + rect.origin.x) / (float) camera->width() - 0.5f;
float yPos = (float)(y + rect.origin.y) / (float) camera->height() - 0.5f;
Ray viewRay = camera->viewRay(xPos, yPos);
HitInfo hitInfo;
Color color;
if (traceRay(viewRay, option, 1.0f, 0, &color, &hitInfo)) {
image->setPixelColor(x, y, color);
} else {
// set Background ccolor
//image->setPixelColor(x, y, hitInfo.material->color());
}
}
}
}
void BrushPreview::generateBoundaries()
{
Brush* brush = getCurrentBrush();
if (m_brushBoundaries &&
m_brushGen == brush->gen())
return;
bool isFloodfill = m_editor->getCurrentEditorTool()->getPointShape(0)->isFloodFill();
Image* brushImage = brush->image();
int w = (isFloodfill ? 1: brushImage->width());
int h = (isFloodfill ? 1: brushImage->height());
m_brushGen = brush->gen();
m_brushWidth = w;
m_brushHeight = h;
ImageRef mask;
if (isFloodfill) {
mask.reset(Image::create(IMAGE_BITMAP, w, w));
mask->putPixel(0, 0, (color_t)1);
}
else if (brushImage->pixelFormat() != IMAGE_BITMAP) {
mask.reset(Image::create(IMAGE_BITMAP, w, h));
LockImageBits<BitmapTraits> bits(mask.get());
auto pos = bits.begin();
for (int v=0; v<h; ++v) {
for (int u=0; u<w; ++u) {
*pos = get_pixel(brushImage, u, v);
++pos;
}
}
}
m_brushBoundaries.reset(
new MaskBoundaries(
(mask ? mask.get(): brushImage)));
}
bool CalibImage::MakeFromImage(Image<byte>& im) {
static gvar3<int> gvnCornerPatchSize("CameraCalibrator.CornerPatchPixelSize",
20, SILENT);
mvCorners.clear();
mvGridCorners.clear();
mim = im;
mim.make_unique();
// Find potential corners..
// This works better on a blurred image, so make a blurred copy
// and run the corner finding on that.
{
Image<byte> imBlurred = mim;
imBlurred.make_unique();
convolveGaussian(imBlurred,
GV2.GetDouble("CameraCalibrator.BlurSigma", 1.0, SILENT));
ImageRef irTopLeft(5, 5);
ImageRef irBotRight = mim.size() - irTopLeft;
ImageRef ir = irTopLeft;
glPointSize(1);
glColor3f(1, 0, 1);
glBegin(GL_POINTS);
int nGate = GV2.GetInt("CameraCalibrator.MeanGate", 10, SILENT);
do
if (IsCorner(imBlurred, ir, nGate)) {
mvCorners.push_back(ir);
glVertex(ir);
}
while (ir.next(irTopLeft, irBotRight));
glEnd();
}
// If there's not enough corners, i.e. camera pointing somewhere random,
// abort.
if ((int)mvCorners.size() <
GV2.GetInt("CameraCalibrator.MinCornersForGrabbedImage", 20, SILENT))
return false;
// Pick a central corner point...
ImageRef irCenterOfImage = mim.size() / 2;
ImageRef irBestCenterPos;
unsigned int nBestDistSquared = 99999999;
for (unsigned int i = 0; i < mvCorners.size(); i++) {
unsigned int nDist = (mvCorners[i] - irCenterOfImage).mag_squared();
if (nDist < nBestDistSquared) {
nBestDistSquared = nDist;
irBestCenterPos = mvCorners[i];
}
}
// ... and try to fit a corner-patch to that.
CalibCornerPatch Patch(*gvnCornerPatchSize);
CalibCornerPatch::Params Params;
Params.v2Pos = vec(irBestCenterPos);
Params.v2Angles = GuessInitialAngles(mim, irBestCenterPos);
Params.dGain = 80.0;
Params.dMean = 120.0;
if (!Patch.IterateOnImageWithDrawing(Params, mim))
return false;
// The first found corner patch becomes the origin of the detected grid.
CalibGridCorner cFirst;
cFirst.Params = Params;
mvGridCorners.push_back(cFirst);
cFirst.Draw();
// Next, go in two compass directions from the origin patch, and see if
// neighbors can be found.
if (!(ExpandByAngle(0, 0) || ExpandByAngle(0, 2)))
return false;
if (!(ExpandByAngle(0, 1) || ExpandByAngle(0, 3)))
return false;
mvGridCorners[1].mInheritedSteps = mvGridCorners[2].mInheritedSteps =
mvGridCorners[0].GetSteps(mvGridCorners);
// The three initial grid elements are enough to find the rest of the grid.
int nNext;
int nSanityCounter = 0; // Stop it getting stuck in an infinite loop...
const int nSanityCounterLimit = 500;
while ((nNext = NextToExpand()) >= 0 &&
nSanityCounter < nSanityCounterLimit) {
ExpandByStep(nNext);
nSanityCounter++;
}
if (nSanityCounter == nSanityCounterLimit)
return false;
DrawImageGrid();
return true;
}
void AppBrushes::load(const std::string& filename)
{
XmlDocumentRef doc = app::open_xml(filename);
TiXmlHandle handle(doc.get());
TiXmlElement* brushElem = handle
.FirstChild("brushes")
.FirstChild("brush").ToElement();
while (brushElem) {
// flags
int flags = 0;
BrushRef brush;
app::Color fgColor;
app::Color bgColor;
tools::InkType inkType = tools::InkType::DEFAULT;
int inkOpacity = 255;
Shade shade;
bool pixelPerfect = false;
// Brush
const char* type = brushElem->Attribute("type");
const char* size = brushElem->Attribute("size");
const char* angle = brushElem->Attribute("angle");
if (type || size || angle) {
if (type) flags |= int(BrushSlot::Flags::BrushType);
if (size) flags |= int(BrushSlot::Flags::BrushSize);
if (angle) flags |= int(BrushSlot::Flags::BrushAngle);
brush.reset(
new Brush(
string_id_to_brush_type(type),
(size ? base::convert_to<int>(std::string(size)): 1),
(angle ? base::convert_to<int>(std::string(angle)): 0)));
}
// Brush image
if (TiXmlElement* imageElem = brushElem->FirstChildElement("image")) {
ImageRef image = load_xml_image(imageElem);
if (image) {
if (!brush)
brush.reset(new Brush());
brush->setImage(image.get());
}
}
// Colors
if (TiXmlElement* fgcolorElem = brushElem->FirstChildElement("fgcolor")) {
if (auto value = fgcolorElem->Attribute("value")) {
fgColor = app::Color::fromString(value);
flags |= int(BrushSlot::Flags::FgColor);
}
}
if (TiXmlElement* bgcolorElem = brushElem->FirstChildElement("bgcolor")) {
if (auto value = bgcolorElem->Attribute("value")) {
bgColor = app::Color::fromString(value);
flags |= int(BrushSlot::Flags::BgColor);
}
}
// Ink
if (TiXmlElement* inkTypeElem = brushElem->FirstChildElement("inktype")) {
if (auto value = inkTypeElem->Attribute("value")) {
inkType = app::tools::string_id_to_ink_type(value);
flags |= int(BrushSlot::Flags::InkType);
}
}
if (TiXmlElement* inkOpacityElem = brushElem->FirstChildElement("inkopacity")) {
if (auto value = inkOpacityElem->Attribute("value")) {
inkOpacity = base::convert_to<int>(std::string(value));
flags |= int(BrushSlot::Flags::InkOpacity);
}
}
// Shade
if (TiXmlElement* shadeElem = brushElem->FirstChildElement("shade")) {
if (auto value = shadeElem->Attribute("value")) {
shade = shade_from_string(value);
flags |= int(BrushSlot::Flags::Shade);
}
}
// Pixel-perfect
if (TiXmlElement* pixelPerfectElem = brushElem->FirstChildElement("pixelperfect")) {
pixelPerfect = bool_attr_is_true(pixelPerfectElem, "value");
flags |= int(BrushSlot::Flags::PixelPerfect);
}
if (flags != 0)
flags |= int(BrushSlot::Flags::Locked);
BrushSlot brushSlot(BrushSlot::Flags(flags),
brush, fgColor, bgColor,
inkType, inkOpacity, shade,
pixelPerfect);
m_slots.push_back(brushSlot);
brushElem = brushElem->NextSiblingElement();
}
}
void CelData::setImage(const ImageRef& image)
{
ASSERT(image.get());
m_image = image;
}
void SubObjectsFromSprite::addImageRef(const ImageRef& image)
{
ASSERT(image);
ASSERT(!getImageRef(image->id()));
m_images.insert(std::make_pair(image->id(), image));
}
void CopyCel::onExecute()
{
LayerImage* srcLayer = static_cast<LayerImage*>(m_srcLayer.layer());
LayerImage* dstLayer = static_cast<LayerImage*>(m_dstLayer.layer());
ASSERT(srcLayer);
ASSERT(dstLayer);
Sprite* srcSprite = srcLayer->sprite();
Sprite* dstSprite = dstLayer->sprite();
ASSERT(srcSprite);
ASSERT(dstSprite);
ASSERT(m_srcFrame >= 0 && m_srcFrame < srcSprite->totalFrames());
ASSERT(m_dstFrame >= 0);
(void)srcSprite; // To avoid unused variable warning on Release mode
Cel* srcCel = srcLayer->cel(m_srcFrame);
Cel* dstCel = dstLayer->cel(m_dstFrame);
// Clear destination cel if it does exist. It'll be overriden by the
// copy of srcCel.
if (dstCel) {
if (dstCel->links())
executeAndAdd(new cmd::UnlinkCel(dstCel));
executeAndAdd(new cmd::ClearCel(dstCel));
}
// Add empty frames until newFrame
while (dstSprite->totalFrames() <= m_dstFrame)
executeAndAdd(new cmd::AddFrame(dstSprite, dstSprite->totalFrames()));
Image* srcImage = (srcCel ? srcCel->image(): NULL);
ImageRef dstImage;
dstCel = dstLayer->cel(m_dstFrame);
if (dstCel)
dstImage = dstCel->imageRef();
bool createLink =
(srcLayer == dstLayer && dstLayer->isContinuous());
// For background layer
if (dstLayer->isBackground()) {
ASSERT(dstCel);
ASSERT(dstImage);
if (!dstCel || !dstImage ||
!srcCel || !srcImage)
return;
if (createLink) {
executeAndAdd(new cmd::SetCelData(dstCel, srcCel->dataRef()));
}
else {
BlendMode blend = (srcLayer->isBackground() ?
BlendMode::SRC:
BlendMode::NORMAL);
ImageRef tmp(Image::createCopy(dstImage.get()));
render::composite_image(tmp.get(), srcImage,
srcCel->x(), srcCel->y(), 255, blend);
executeAndAdd(new cmd::CopyRect(dstImage.get(), tmp.get(), gfx::Clip(tmp->bounds())));
}
}
// For transparent layers
else {
if (dstCel)
executeAndAdd(new cmd::RemoveCel(dstCel));
if (srcCel) {
if (createLink)
dstCel = Cel::createLink(srcCel);
else
dstCel = Cel::createCopy(srcCel);
dstCel->setFrame(m_dstFrame);
executeAndAdd(new cmd::AddCel(dstLayer, dstCel));
}
}
}
int main()
{
sf::RenderWindow window(sf::VideoMode(400, 400), "Jump Test");
ImageRef imageRef;
imageRef.loadTextures();
Path path;
StraightBlock b1;
b1.translate(200.0f, 200.0f)->scale(0.00000000001f, 0.0f);
path.smartAddBlock(&b1);
Player player(imageRef);
player.setPath(path);
player.go();
sf::Clock clock;
//
sf::Font font;
font.loadFromFile("arial.ttf");
sf::Text text;
text.setFont(font);
text.setCharacterSize(10);
ostringstream os;
player.GRAVITY = 0.00005f;
player.LOWGRAVITY = 0.00001f;
player.FRICTION = 0.0001f;
player.MOVESPEED = 60.0f;
player.JUMPSPEED = 100.0f;
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Return)
{
cout << "Gravity: ";
cin >> player.GRAVITY;
if (player.GRAVITY < 0.0f)
{
//set defaults
player.GRAVITY = 0.00005f;
player.LOWGRAVITY = 0.00001f;
player.FRICTION = 0.1f;
player.MOVESPEED = 60.0f;
player.JUMPSPEED = 200.0f;
}
else
{
cout << "LowGravity: ";
cin >> player.LOWGRAVITY;
cout << "Friction: ";
cin >> player.FRICTION;
cout << "MoveSpeed: ";
cin >> player.MOVESPEED;
cout << "JumpSpeed: ";
cin >> player.JUMPSPEED;
}
os << "Gravity: " << player.GRAVITY << endl;
os << "LowGravity: " << player.LOWGRAVITY << endl;
os << "Friction: " << player.FRICTION << endl;
os << "MoveSpeed: " << player.MOVESPEED << endl;
os << "JumpSpeed: " << player.JUMPSPEED << endl;
}
}
ostringstream gravStream;
gravStream << "player gravity: " << player.gravity << endl;
text.setString(os.str() + gravStream.str());
player.button(sf::Keyboard::isKeyPressed(sf::Keyboard::Space));
player.update(clock.restart());
window.clear(sf::Color(255, 100, 100, 255));
window.draw(player.sprite);
window.draw(text);
window.display();
}
